Struct Proxy

pkg/agent/proxy/proxy.go:113–284

}

type Proxy struct {
	logger *zap.Logger

	IP4               string
	IP6               string
	Port              uint32
	IncomingProxyPort uint16
	DNSPort           uint32

	DestInfo     agent.DestInfo
	Integrations map[integrations.IntegrationType]integrations.Integrations

	integrationsPriority []ParserPriority
	errChannel           chan error

	// activeTestErrors accumulates mock-not-found errors during active test
	// execution. The continuous drain goroutine routes errors here when non-nil.
	// When nil (no window), mock-not-found errors fall to pendingMockErrors and
	// only non-mock noise (OTel, health checks) is discarded — keeping the
	// errChannel drained either way.
	activeTestErrors atomic.Pointer[testErrorAccumulator]
	// captureMu serializes the drain goroutine's routing decision (read
	// activeTestErrors, then add) against BeginTestErrorCapture / GetMockErrors
	// opening or closing the window. Without it, the goroutine could add a miss
	// to an accumulator that GetMockErrors has just swapped away, losing it.
	captureMu sync.Mutex
	// errDrainActive is true while the StartErrorDrain goroutine is running. It
	// gates the GetMockErrors flush-marker rendezvous (which needs that single
	// owner to consume the marker); when false we use the legacy direct sweep.
	errDrainActive atomic.Bool
	errDrainOnce   sync.Once
	// pendingMockErrors retains mock-not-found errors that arrive while no test
	// capture window is active (activeTestErrors is nil) — e.g. between tests,
	// or when the replayer/agent predates the BeginTestErrorCapture wiring. The
	// replayer normally opens a window per test (so misses route to
	// activeTestErrors), but this remains the fallback so a miss is never
	// silently dropped before GetMockErrors reads it. Only mock-not-found errors
	// are retained (background noise — OTel, health checks — is still
	// discarded), and the buffer is bounded so it can't grow unboundedly.
	pendingMockErrors testErrorAccumulator
	// session holds the single active session for this proxy.
	// Previously this was a sync.Map keyed by appID (always 0), which is
	// no longer needed since the proxy serves a single client-app.
	sessionMu   sync.RWMutex
	session     *agent.Session
	mockManager *MockManager

	// sessionResolver, when set, maps a connection's owning TGID to the
	// session that should handle it. It is the seam by which an external
	// composer (the enterprise multi-app agent) routes per-app traffic
	// without this package knowing what an "app" is. nil ⇒ single-session
	// mode: GetSessionFor falls back to the single session field above.
	// Guarded by sessionMu.
	sessionResolver func(tgid uint32) *agent.Session

	synchronous bool

	connMutex *sync.Mutex