proxy

type CaptureHandle ¶

type CaptureHandle struct {
	// contains filtered or unexported fields
}

CaptureHandle is an opaque handle to a previously-attached response capture sink. ModifyResponse-style hooks that need to mutate the response body call DetachResponseCapture to remove the tee from resp.Body (so they can read upstream bytes without those bytes landing in the capture sink), then call RewrapBody on whatever they hand back to ReverseProxy so the captured stream reflects what the CLIENT receives — not what upstream emitted.

A zero CaptureHandle is the "no-op" value: DetachResponseCapture returns it when resp.Body wasn't a teeReadCloser (e.g. capture was never wired). RewrapBody on a zero handle returns its argument unchanged.

func DetachResponseCapture(resp *http.Response) CaptureHandle

func (h CaptureHandle) RewrapBody(rc io.ReadCloser) io.ReadCloser

type CaptureTransport ¶

type CaptureTransport struct {
	// Inner is the underlying transport (typically a configured
	// *http.Transport with DisableCompression=true).
	Inner http.RoundTripper
	// Sinks looks up the per-trace sinks at RoundTrip time.
	Sinks SinkLookup
	// Meta receives request/response metadata callbacks. Optional;
	// when nil, the Transport only does body tee.
	Meta MetaCapture
	// OnDialError is invoked when the inner transport returned a
	// non-HTTP error (DNS / TLS / connection refused). Lets the
	// caller bump a counter without leaking the counters dependency
	// into this package. Optional.
	OnDialError func()
}

CaptureTransport wraps an inner http.RoundTripper and tees req.Body / resp.Body to per-trace capture sinks.

Critically: this transport does NOT consume req.Body itself — it wraps req.Body in a teeing ReadCloser so the inner Transport's read drives the tee. Calling req.Write/req.WriteProxy here would consume the body to EOF and the inner RoundTrip would forward an empty body upstream.

func (t *CaptureTransport) RoundTrip(req *http.Request) (*http.Response, error)

type MetaCapture ¶

type MetaCapture interface {
	OnReqHeaders(traceID string, h http.Header)
	OnRespMeta(traceID string, statusCode int, h http.Header)
}

MetaCapture is an optional hook that receives the outbound request headers (post-Director) and the upstream response status + headers as soon as they are known. Headers are passed as clones; callers may retain them safely. Used by the forwarding handler to populate the trace.Body objects at finalize.

type SinkLookup ¶

type SinkLookup interface {
	// SinksFor returns the req/resp capture sinks for traceID. Both are
	// non-nil when the trace is active; both are nil if the trace has
	// been finalized (in which case the Transport silently drops capture).
	SinksFor(traceID string) (req, resp *capture.Sink)
}

SinkLookup is how the custom Transport finds the right sinks for a given trace. The forwarding handler registers sinks at request start and removes them at finalize.

type StreamWatchdog ¶

type StreamWatchdog struct {
	// contains filtered or unexported fields
}

StreamWatchdog implements the per-stream idle timeout described in ARCHITECTURE § 10.7. A timer is reset on each forwarded chunk via Pulse(); if no chunk arrives for `timeout`, the watchdog cancels the request context. That unblocks the ReverseProxy body copy (which sees ctx cancellation), bubbles up an error to ServeHTTP, and lets finalize set disconnected: true.

The watchdog is "one shot": once it fires, further Pulse calls are no-ops. After finalize, callers should Stop() to release the underlying timer.

func NewStreamWatchdog(cancel context.CancelFunc, timeout time.Duration) *StreamWatchdog

func (w *StreamWatchdog) Fired() bool

func (w *StreamWatchdog) Pulse()

func (w *StreamWatchdog) Stop()