httpcapture

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

type Body struct {
	Prefix        []byte // raw, at most cap+1; a later owner applies disclosure policy
	End           BodyEnd
	ObservedBytes int64                 // counts source reads, never replay reads
	MeasuredBytes value.Nullable[int64] // known only after observed EOF
	ReadFailure   ReadFailure
}

type BodyCapture struct {
	// Bytes is an owned tap buffer or, for a request Bytes body within the
	// limit, the body's immutable copy.
	Bytes []byte
	// Declared is the Content-Length; null when unknown.
	Declared value.Nullable[int64]
	// Transferred counts bytes the transport sent or the caller read.
	Transferred int64
	// Complete means the end of the body was observed: the transport
	// consumed the whole request body, or the caller read the whole response.
	Complete bool
	// Offered means Bytes is a request body the client held whole in memory,
	// so it is the whole body even when the transport consumed less.
	Offered bool
	// Over means more than the capture limit passed.
	Over            bool
	Skip            Skip
	ContentType     string
	ContentEncoding string
}

type BodyEnd uint8

type Cause struct {
	RequestID attribution.RequestID
	Trace     tracing.TraceID
	// Route is the matched inbound route's declared name.
	Route string
}

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

type Completion struct {
	Route                                 string
	Result                                observability.Result
	Status                                value.Nullable[uint16] // actual committed status; absent on precommit abort/hijack
	ResponseHead                          []byte
	ResponseHeaders                       []Field // the handler's header map at commit, before net/http adds transport headers
	ResponseContentType, ResponseEncoding string
	ResponseMetadataTruncated             bool
	ResponseTruncated                     bool
	ResponseBytes                         int64 // accepted by the HTTP writer, not proof of delivery
	Hijacked                              bool
	Aborted                               bool
	WriteFailed                           bool
	Duration                              time.Duration
}

type Config struct {
	// BodyBytes bounds one captured body.
	BodyBytes     int
	RetainedBytes int64
	QueueSize     int
	// Rate and Burst admit captures per lane.
	Rate  int
	Burst int
	// LaneShare divides QueueSize and RetainedBytes among lanes: one lane may
	// hold at most 1/LaneShare of either (at least one row). Zero means one.
	LaneShare int
}

type DropReason uint8

type Exchange struct {
	ID, Operation      [16]byte
	Client             string
	Attempt            uint8
	Retried, Full      bool
	StartedAt          time.Time
	HeadersAfter       value.Nullable[time.Duration]
	Duration           time.Duration
	Cause              Cause
	Method             string
	Scheme, Host       string
	EscapedPath        string
	RawQuery           string
	PathCut, QueryCut  bool
	RequestHeaders     []Field
	RequestHeadersCut  bool
	Request            BodyCapture
	Status             value.Nullable[uint16]
	Protocol           string
	RemoteIP           netip.Addr
	Reused             value.Nullable[bool]
	ResponseHeaders    []Field
	ResponseHeadersCut bool
	Response           BodyCapture
	Result             Result
}

type Field struct {
	Name   string   `json:"name"`
	Values []string `json:"values"`
}

type Lane[S any] struct {
	// contains filtered or unexported fields
}

type Metadata struct {
	RequestID                                                       attribution.RequestID
	ReceivedAt                                                      time.Time
	Prefix                                                          string
	Full                                                            bool
	Method                                                          string
	EscapedPath                                                     string
	RawQuery                                                        string
	ClientIP                                                        netip.Addr
	Headers                                                         []Field
	ContentType                                                     string
	ContentEncoding                                                 string
	DeclaredBytes                                                   value.Nullable[int64]
	PathTruncated, QueryTruncated, HeadersTruncated                 bool
	MethodTruncated, ContentTypeTruncated, ContentEncodingTruncated bool
}

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

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

type OutboundConfig struct {
	Limits Config
	// Full names the clients whose bodies are stored exactly.
	Full  []string
	Rules []Rule
	// Inspect decides from Content-Type and Content-Encoding whether redacted
	// mode can store a body; the disclosure owner supplies it.
	Inspect func(contentType, contentEncoding string) Skip
}

type ReadFailure string

type Record[S any] struct {
	Snapshot      S
	DroppedBefore uint64
	// contains filtered or unexported fields
}

type Recorder[S any] struct {
	// contains filtered or unexported fields
}

type RequestFacts struct {
	Method  string
	URL     *url.URL
	Headers http.Header
	// Data is a Bytes body's private, immutable copy; nil for no body or a stream.
	Data     []byte
	Stream   bool
	Length   int64
	Declined bool
}

type Reservation[S any] struct {
	// contains filtered or unexported fields
}

type Result uint8

type Rule struct {
	Client string
	// Host is lowercase; "*.x" matches any subdomain of x, not x itself.
	Host   string
	Method string
	// PathPrefix is a normalized decoded prefix without a trailing slash; it
	// matches segment by segment.
	PathPrefix string
}

type Skip uint8

type Snapshot struct {
	Metadata   Metadata
	Body       Body
	Completion Completion
}

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

type TapEnd uint8