traces

type Capabilities struct {
	Live       bool `json:"live,omitempty"`
	Historical bool `json:"historical,omitempty"`
	Follow     bool `json:"follow,omitempty"`
}

type Emitter[R any] interface {
	// Emit waits while the session's buffer is full, and returns ctx's error
	// once it is done.
	Emit(ctx context.Context, record R) error
	// TryEmit never waits: a record a full buffer cannot take is dropped and
	// counted, so a handler called on someone else's goroutine never stalls it.
	TryEmit(record R) bool
}

type Handler[P, R any] struct {
	// contains filtered or unexported fields
}

type KindInfo struct {
	Name         string             `json:"name"`
	Title        string             `json:"title"`
	Capabilities Capabilities       `json:"capabilities"`
	Params       *rpc.OpenAPISchema `json:"params"`
	Columns      []query.ColumnDef  `json:"columns"`
}

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

type Preparer[P, R any] interface {
	Prepare(ctx dbcontext.Context, params P, records Emitter[R]) (prepared dbcontext.Context, release func() error, err error)
}

type Records[R any] interface {
	Scan(ctx context.Context, afterSeq int64, fn func(seq int64, record R) error) error
}

type Runtime struct {
	Kinds    *Kinds
	Sessions *query.SessionRegistry
	Probes   *probe.Manager
	// Results is the store the captures' records are committed to, opened
	// with Kinds.RegisterResultTypes.
	Results *recordresults.Results

	// PollEvery is how often a running capture's records are committed.
	// Zero is a second.
	PollEvery time.Duration
	// BufferRows caps the records a capture holds before they are committed.
	// Zero is 10,000; it is never more than one sample of the probe commits.
	BufferRows int
	// BufferBytes caps the bytes of records a capture holds before they are
	// committed, measured by their keys and text. Zero is 64MiB.
	BufferBytes int
}

type StartRequest struct {
	Kind   string
	Params json.RawMessage
	// StopAt ends the capture; nil runs it for the registry's longest duration.
	StopAt    *time.Time
	Labels    map[string]string
	Principal string
	RestartOf string
}

type Summary struct {
	Emitted      int64 `json:"emitted"`
	Deduplicated int64 `json:"deduplicated,omitempty"`
	Dropped      int64 `json:"dropped,omitempty"`
	Unencodable  int64 `json:"unencodable,omitempty"`
	Collapsed    int64 `json:"collapsed,omitempty"`
}

type TraceHandler[P, R any] interface {
	// Params are the defaults a session starts from; P's type is the params
	// form a client renders.
	Params() P
	// Schema declares how R's records are stored and read: its title, time
	// and key columns, indexes. R's own columns are reflected from its fields.
	Schema() recordresults.ResultType[R]
	// Handle captures until ctx is done, or until its source is exhausted,
	// emitting each record. It may read back the records it already emitted.
	Handle(ctx dbcontext.Context, params P, records Emitter[R], store Records[R]) error
}

type TracePlugin interface {
	// Title is the kind's human name.
	Title() string
	// Params is the JSON schema of the kind's params, with their defaults: the
	// form a client renders to start a capture.
	Params() (*rpc.OpenAPISchema, error)
	// Schema is the record-store schema the kind's records are stored under
	// when it is registered as kind.
	Schema(kind string) (recordstore.KindSchema, error)
	Capabilities() Capabilities
	// ValidateParams decodes params as a session start would, refusing what
	// the session would refuse.
	ValidateParams(params json.RawMessage) error
	// contains filtered or unexported methods
}

type Truncation struct {
	Truncated []string `json:"truncated,omitempty" pretty:"label=Truncated"`
}

type Validator interface {
	Validate() error
}