observability

type Alert struct {
	TenantID string
	Level    string // LevelWarning | LevelCritical
	Message  string
	BurnRate float64
	P95ms    float64
	// New-error fields (Kind == KindNewError / KindStorm).
	Kind    string
	Route   string
	TraceID string
	Count   int
}

type Alerter interface {
	Send(ctx context.Context, a Alert) error
}

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

type AnomalyEvent struct {
	TS        int64   `json:"ts"`         // unix microseconds (matches trace TS)
	LatencyUS float64 `json:"latency_us"` // request latency in microseconds
	ZScore    float64 `json:"z_score"`
}

type Attribution string

type AttributionThresholds struct {
	HighP99Ms         float64 // absolute "slow" floor (default 50 ms)
	BaselineRise      float64 // p99 ≥ BaselineRise × healthy baseline is "slow" too (default 3×), if ≥ MinRiseMs
	MinRiseMs         float64 // (default 10 ms)
	MinRPS            float64 // below this the window is idle → healthy (default 1)
	ThrottledFraction float64 // throttled_usec / interval ≥ this → cpu_throttled (default 0.02: 20 ms of every second stopped by the quota is a p99 the operator feels)
	MemUseFraction    float64 // memory.current / memory.max ≥ this → memory_pressure (default 0.90)
	MemPSISome10      float64 // memory some avg10 ≥ this % → memory_pressure (default 10)
	GCCPUFraction     float64 // gc cpu / busy cpu ≥ this → gc_pressure (default 0.25)
	GCPauseP99Ms      float64 // gc pause p99 ≥ this with ≥ GCCyclesPerS → gc_pressure (default 5)
	GCCyclesPerS      float64 // (default 2)
	SchedLatP99Ms     float64 // sched latency p99 ≥ max(this, 5 % of the request p99) → cpu_saturated (default 2 ms: a 1-vCPU box shared with anything shows ~1 ms wakeup latency that explains nothing)
	CPUPSISome10      float64 // cpu some avg10 ≥ this % corroborates (default 10)
	CPUBusyFraction   float64 // busy cpu / (interval × GOMAXPROCS) ≥ this corroborates when PSI is unavailable (default 0.85)
	PoolWaitFraction  float64 // empty_acquire_wait / interval ≥ this → pool_exhausted even without latency_high (default 0.10)
	QueryShare        float64 // query p99 / request p99 ≥ this → db_bound (default 0.5)
	MutexWaitFraction float64 // mutex wait / interval ≥ this → lock_contention (default 0.10)
}

type Check struct {
	Name     string
	URL      string
	Method   string
	Headers  map[string]string
	Expected int // expected HTTP status code; 0 = any 2xx
}

type CheckResult struct {
	Name      string    `json:"name"`
	Status    string    `json:"status"`
	LatencyMs int64     `json:"latency_ms"`
	LastCheck time.Time `json:"last_check"`
	LastError string    `json:"last_error,omitempty"`
	Uptime    float64   `json:"uptime_pct"`
	// contains filtered or unexported fields
}

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

type DBClientStats struct {
	MaxConns              int32   `json:"max_conns"`
	TotalConns            int32   `json:"total_conns"`
	AcquiredConns         int32   `json:"acquired_conns"`
	IdleConns             int32   `json:"idle_conns"`
	ConstructingConns     int32   `json:"constructing_conns"`
	AcquireCount          int64   `json:"acquire_count"`
	AcquireDurationMs     float64 `json:"acquire_duration_ms"` // cumulative, per pgxpool
	EmptyAcquireCount     int64   `json:"empty_acquire_count"`
	EmptyAcquireWaitMs    float64 `json:"empty_acquire_wait_ms"` // cumulative
	CanceledAcquireCount  int64   `json:"canceled_acquire_count"`
	NewConnsCount         int64   `json:"new_conns_count"`
	MaxLifetimeDestroy    int64   `json:"max_lifetime_destroy_count"`
	MaxIdleDestroy        int64   `json:"max_idle_destroy_count"`
	NewConnsDelta         int64   `json:"new_conns_delta"`
	AcquireDelta          int64   `json:"acquire_delta"`
	EmptyAcquireDelta     int64   `json:"empty_acquire_delta"`
	EmptyAcquireWaitDelta float64 `json:"empty_acquire_wait_delta_ms"`
	AcquireWaitDeltaMs    float64 `json:"acquire_duration_delta_ms"`
	CanceledAcquireDelta  int64   `json:"canceled_acquire_delta"`
	QueryLatencyP50Ms     float64 `json:"query_latency_p50_ms"` // client-side query stage, this tick (the "query" span)
	QueryLatencyP99Ms     float64 `json:"query_latency_p99_ms"`
	QueryCount            int64   `json:"query_count"`
	Saturated             bool    `json:"saturated"` // acquired == max && idle == 0
	// Warming is the COLD-START of the pool, not a wall: the pool has not
	// reached MaxConns yet and it opened at least one connection during this
	// tick, so the goroutines that "found no free connection" were waiting for
	// a connection to be CONSTRUCTED (TCP + TLS + auth + the session's SET),
	// which every process pays exactly once per connection. The pool_exhausted
	// rule ignores a warming tick (CAPACIDAD-USL-S1): the first second of every
	// load run used to read pool_exhausted and a false positive in the first
	// tick of every run poisons every later reading of the same series.
	Warming bool `json:"warming"`
}

type DBServerProbe func(ctx context.Context, out *DBServerStats) error

type DBServerStats struct {
	Observable    bool    `json:"observable"`
	Reason        string  `json:"reason,omitempty"` // why not observable / why skipped this tick
	ProbedAt      int64   `json:"probed_at,omitempty"`
	DBSizeBytes   int64   `json:"db_size_bytes"`
	CacheHitRatio float64 `json:"cache_hit_ratio"` // blks_hit / (blks_hit + blks_read), cumulative
	BlksHit       int64   `json:"blks_hit"`
	BlksRead      int64   `json:"blks_read"`
	XactCommit    int64   `json:"xact_commit"`
	XactRollback  int64   `json:"xact_rollback"`
	Deadlocks     int64   `json:"deadlocks"`
	TempBytes     int64   `json:"temp_bytes"`
	ActiveConns   int64   `json:"active_conns"`
	IdleInTx      int64   `json:"idle_in_transaction"`
	Waiting       int64   `json:"waiting"` // active backends with a wait_event
	TotalBackends int64   `json:"total_backends"`
	StatementsExt bool    `json:"pg_stat_statements"` // extension present
}

type DynamicCheck struct {
	Name    string
	Resolve func(ctx context.Context) (*Check, string)
}

type ErrGroup struct {
	Count     atomic.Int64
	FirstSeen int64
	LastSeen  atomic.Int64
	Message   string
	Stack     []Frame // symbolized only on first occurrence
	// contains filtered or unexported fields
}

type ErrorCapture struct {
	TraceID  string  `json:"trace_id"`
	TenantID string  `json:"tenant_id"`
	Route    string  `json:"route"`
	Method   string  `json:"method"`
	ErrMsg   string  `json:"error_msg"`
	Stack    []Frame `json:"stack"`
	// SQL is the exact statement the driver rejected, when the error came
	// from the database (the QueryTracer noted it on the request's tracker).
	SQL       string `json:"sql,omitempty"`
	UserID    string `json:"user_id"`
	Role      string `json:"role"`
	Timestamp int64  `json:"ts"`
}

type ErrorGroup struct {
	Fingerprint   uint64   `json:"fingerprint"`
	Route         string   `json:"route"`
	Status        int      `json:"status"`
	Message       string   `json:"message"`
	TopFrame      string   `json:"top_frame,omitempty"`
	FirstSeen     int64    `json:"first_seen"` // unix µs
	LastSeen      int64    `json:"last_seen"`
	Count         int64    `json:"count"`
	Users         []string `json:"users"`
	SampleTraceID string   `json:"sample_trace_id"`
}

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

type Frame struct {
	Function string `json:"function"`
	File     string `json:"file"`
	Line     int    `json:"line"`
}

type FullSnapshot struct {
	Cached   *PercentileSnapshot `json:"cached,omitempty"`
	Uncached *PercentileSnapshot `json:"uncached,omitempty"`
}

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

type HistoryPoint struct {
	TS         int64   `json:"ts"`
	P50US      int64   `json:"p50_us"`
	P95US      int64   `json:"p95_us"`
	BurnRate   float64 `json:"burn_rate"`
	ErrorRatio float64 `json:"error_ratio"`
	SLOStatus  string  `json:"slo_status"`
}

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

type MinuteBucket struct {
	Count  uint32
	Errors uint32
	SumUS  uint32
}

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

type NoopAlerter struct{}

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

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

type PSILine struct {
	SomeAvg10  float64 `json:"some_avg10"`
	SomeAvg60  float64 `json:"some_avg60"`
	SomeAvg300 float64 `json:"some_avg300"`
	SomeTotal  int64   `json:"some_total_usec"`
	FullAvg10  float64 `json:"full_avg10"`
	FullAvg60  float64 `json:"full_avg60"`
	FullAvg300 float64 `json:"full_avg300"`
	FullTotal  int64   `json:"full_total_usec"`
}

type PercentileSnapshot struct {
	P50Us  float64 `json:"p50_us"`
	P95Us  float64 `json:"p95_us"`
	P99Us  float64 `json:"p99_us"`
	P999Us float64 `json:"p999_us"`
	Count  int64   `json:"count"`
	Mean   float64 `json:"mean_us"`
}

type PoolStat struct {
	MaxConns                int32
	TotalConns              int32
	AcquiredConns           int32
	IdleConns               int32
	ConstructingConns       int32
	AcquireCount            int64
	AcquireDuration         time.Duration
	EmptyAcquireCount       int64
	EmptyAcquireWaitTime    time.Duration
	CanceledAcquireCount    int64
	NewConnsCount           int64
	MaxLifetimeDestroyCount int64
	MaxIdleDestroyCount     int64
}

type PressureStats struct {
	Source string  `json:"source"` // "cgroup" | "host" | "unavailable"
	CPU    PSILine `json:"cpu"`
	Memory PSILine `json:"memory"`
	IO     PSILine `json:"io"`
	// The spec's §7 shorthand, duplicated for the correlation chart.
	CPUSomeAvg10 float64 `json:"cpu_some_avg10"`
	MemSomeAvg10 float64 `json:"mem_some_avg10"`
	IOSomeAvg10  float64 `json:"io_some_avg10"`
}

type ProcessStats struct {
	Source            string `json:"source"`      // "cgroup" | "proc" | "unavailable"
	CgroupPath        string `json:"cgroup_path"` // relative to /sys/fs/cgroup
	MemCurrentBytes   int64  `json:"mem_current_bytes"`
	MemMaxBytes       int64  `json:"mem_max_bytes"`  // -1 = "max" (unlimited)
	MemPeakBytes      int64  `json:"mem_peak_bytes"` // -1 = unavailable (memory.peak is Linux 5.19+); /proc fallback uses VmHWM
	MemSwapBytes      int64  `json:"mem_swap_bytes"`
	CPUUsageUsec      int64  `json:"cpu_usage_usec"`
	CPUUserUsec       int64  `json:"cpu_user_usec"`
	CPUSystemUsec     int64  `json:"cpu_system_usec"`
	CPUNrPeriods      int64  `json:"cpu_nr_periods"`
	CPUNrThrottled    int64  `json:"cpu_nr_throttled"`
	CPUThrottledUsec  int64  `json:"cpu_throttled_usec"`
	CPUUsageDeltaUsec int64  `json:"cpu_usage_delta_usec"`
	CPUThrottledDelta int64  `json:"cpu_throttled_delta_usec"`
	CPUNrThrottledDlt int64  `json:"cpu_nr_throttled_delta"`
	CPUQuotaUsec      int64  `json:"cpu_quota_usec"`  // cpu.max quota; -1 = "max" (no quota)
	CPUPeriodUsec     int64  `json:"cpu_period_usec"` // cpu.max period
	PidsCurrent       int64  `json:"pids_current"`
	PidsMax           int64  `json:"pids_max"`  // -1 = max
	Threads           int64  `json:"threads"`   // /proc/self/status Threads (runtime/metrics has no thread count)
	RSSBytes          int64  `json:"rss_bytes"` // /proc/self/status VmRSS — always read (cheap), the classic number
	// CgroupShared says the cgroup holds MORE than this process (pids.current
	// > this process's thread count): a login session scope, a container
	// running a supervisor + the app. Then memory.current and cpu.stat are the
	// cgroup's, not the process's — the cards say so and lean on RSS. A
	// systemd service unit (the production layout) is never shared.
	CgroupShared bool `json:"cgroup_shared"`
}

type QueryTracer struct{}

type RecentRequest struct {
	StartUS int64  `json:"start_us"`
	DurUS   int32  `json:"dur_us"`
	QueryUS int32  `json:"query_us"`
	Route   string `json:"route"`
	Status  uint16 `json:"status"`
}

type RequestStats struct {
	Count        int64   `json:"count"`
	RPS          float64 `json:"rps"`
	LatencyP50Ms float64 `json:"latency_p50_ms"`
	LatencyP95Ms float64 `json:"latency_p95_ms"`
	LatencyP99Ms float64 `json:"latency_p99_ms"`
	LatencyMaxMs float64 `json:"latency_max_ms"`
	Errors5xx    int64   `json:"errors_5xx"`
	Status429    int64   `json:"status_429"` // shed by the tenant limiter — load the box refused, on purpose
	Status503    int64   `json:"status_503"` // shed by the breaker / memory guard
}

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

type ResourceConfig struct {
	BackgroundInterval time.Duration
	LiveInterval       time.Duration
	LiveWindow         time.Duration
	// DBServerLocal declares that Postgres runs on THIS host (loopback / unix
	// socket DSN): only then does the collector read pg_stat_* — a remote
	// database's internals are "not observable from the app", by design.
	DBServerLocal bool
	// DBServerEvery bounds the server-side probe cadence (default 10 s): it
	// borrows ONE pool connection with a 250 ms acquire timeout and gives up
	// (reported as skipped) rather than compete with requests for the pool.
	DBServerEvery time.Duration
	// Thresholds for the attribution rules; zero values take the documented
	// defaults (see attribution.go).
	Thresholds AttributionThresholds
}

type ResourceSnapshot struct {
	TS         int64         `json:"ts"` // unix milliseconds
	IntervalMs int64         `json:"interval_ms"`
	Mode       string        `json:"mode"` // "live" | "background"
	Runtime    RuntimeStats  `json:"runtime"`
	Process    ProcessStats  `json:"process_cgroup"`
	Pressure   PressureStats `json:"pressure"`
	DBClient   DBClientStats `json:"db_client"`
	DBServer   DBServerStats `json:"db_server_local_only"`
	Request    RequestStats  `json:"request"`
	// Attribution is the verdict of the §4 table for THIS tick; Verdict
	// carries its reason and the signals that fired.
	Attribution Attribution `json:"attribution"`
	Verdict     Verdict     `json:"verdict"`
}

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

type RuntimeStats struct {
	SchedLatencyP99S float64 `json:"sched_latency_p99_s"`  // /sched/latencies:seconds, p99 of the tick's delta — the CPU-saturation signal
	GCPauseTotalP99S float64 `json:"gc_pause_total_p99_s"` // /sched/pauses/total/gc:seconds, p99 of the tick's delta
	Goroutines       uint64  `json:"goroutines"`           // /sched/goroutines:goroutines
	GOMAXPROCS       uint64  `json:"gomaxprocs"`           // /sched/gomaxprocs:threads
	MutexWaitTotalS  float64 `json:"mutex_wait_total_s"`   // /sync/mutex/wait/total:seconds (cumulative)
	MutexWaitDeltaS  float64 `json:"mutex_wait_delta_s"`   // this tick
	HeapObjectsBytes uint64  `json:"heap_objects_bytes"`   // /memory/classes/heap/objects:bytes (live heap)
	MemoryTotalBytes uint64  `json:"memory_total_bytes"`   // /memory/classes/total:bytes (everything the runtime mapped)
	HeapGoalBytes    uint64  `json:"heap_goal_bytes"`      // /gc/heap/goal:bytes
	GOGCPercent      uint64  `json:"gogc_percent"`         // /gc/gogc:percent
	GOMEMLIMITBytes  uint64  `json:"gomemlimit_bytes"`     // /gc/gomemlimit:bytes (math.MaxInt64 = unset)
	GCCyclesTotal    uint64  `json:"gc_cycles_total"`      // /gc/cycles/total:gc-cycles (cumulative)
	GCCyclesDelta    uint64  `json:"gc_cycles_delta"`      // this tick
	CPUUserS         float64 `json:"cpu_user_s"`           // /cpu/classes/user:cpu-seconds (cumulative)
	CPUGCS           float64 `json:"cpu_gc_s"`             // /cpu/classes/gc/total:cpu-seconds (cumulative)
	CPUTotalS        float64 `json:"cpu_total_s"`          // /cpu/classes/total:cpu-seconds (cumulative)
	CPUIdleS         float64 `json:"cpu_idle_s"`           // /cpu/classes/idle:cpu-seconds (cumulative)
	CPUScavengeS     float64 `json:"cpu_scavenge_s"`       // /cpu/classes/scavenge/total:cpu-seconds (cumulative)
	CPUTotalDeltaS   float64 `json:"cpu_total_delta_s"`    // this tick
	CPUGCDeltaS      float64 `json:"cpu_gc_delta_s"`       // this tick
	GCCPUFraction    float64 `json:"gc_cpu_fraction"`      // cpu_gc_delta / (cpu_total_delta − cpu_idle_delta), this tick
	CPUBusyFraction  float64 `json:"cpu_busy_fraction"`    // (cpu_total_delta − cpu_idle_delta) / (interval × GOMAXPROCS)
	SchedLatencyP50S float64 `json:"sched_latency_p50_s"`  // for the chart
	GCPauseTotalMaxS float64 `json:"gc_pause_total_max_s"` // the tick's longest STW
	SchedOtherPauseS float64 `json:"sched_pause_other_p99_s"`
}

type SLOConfig struct {
	TargetUptime  float64       // e.g. 0.999 (99.9%)
	LatencySLOms  float64       // e.g. 100.0 ms — requests slower than this count as errors
	AlertCooldown time.Duration // e.g. 15min between repeat alerts of the same level
}

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

type SLOSnapshot struct {
	ErrorRatio5m float64 `json:"error_ratio_5m"`
	BurnRate5m   float64 `json:"burn_rate_5m"`
	ErrorRatio1h float64 `json:"error_ratio_1h"`
	BurnRate1h   float64 `json:"burn_rate_1h"`
	Status       string  `json:"status"`
}

type Sample struct {
	Start   int64
	DurUS   int32
	QueryUS int32
	Route   uint16
	Status  uint16
	TraceID [8]byte
	Spans   [maxSpans]Span
	NSpans  uint8
	// ErrMsg is the error message for an errored request ("" otherwise).
	// ErrorCapture carries the symbolized stack for a 500 (nil otherwise) — a
	// pointer, so non-error samples cost only 8 bytes and Record stays alloc-free.
	ErrMsg       string
	ErrorCapture *ErrorCapture
	// Client context (raw): browser/OS are parsed and country geo-resolved lazily
	// in the projection, so the hot path only stores two strings.
	IP        string
	UserAgent string
}

type Signal struct {
	Name      string  `json:"name"`
	Value     float64 `json:"value"`
	Threshold float64 `json:"threshold"`
	Unit      string  `json:"unit"`
	Fired     bool    `json:"fired"`
}

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

type Snapshot struct {
	TenantID   string  `json:"tenant_id"`
	TS         int64   `json:"ts"` // unix seconds
	P50US      int64   `json:"p50_us"`
	P95US      int64   `json:"p95_us"`
	ErrorRatio float64 `json:"error_ratio"`
	BurnRate   float64 `json:"burn_rate"`
	SLOStatus  string  `json:"slo_status"`
}

type Span struct {
	Name  string `json:"name"`
	DurUS int32  `json:"dur_us"`
	// Err marks the stage during which the request's error was recorded — the
	// bar in the waterfall where the failure happened (OBSERVABILIDAD-ERRORES-S1).
	// omitempty keeps the JSON of a healthy span byte-identical to before.
	Err bool `json:"err,omitempty"`
}

type SpanTracker struct {

	// HasError/ErrMsg are set on ANY error response (4xx/5xx) via RecordError.
	// Capture is set only for 500s (carries the symbolized stack) via SetCapture.
	HasError bool
	ErrMsg   string
	Capture  *ErrorCapture

	// UserID/Role are set by the JWT middleware once the token is validated,
	// so the request line and the trace can say WHO even though the claims
	// live in a derived context the logger never sees.
	UserID, Role string
	// LastSQL/LastSQLErr are the most recent FAILED statement seen by the
	// database tracer (QueryTracer) on this request — the exact query the
	// driver rejected, kept as data (never logged here) for the 5xx capture.
	// A handled failure (a 404 after a miss, a 409 after a unique violation)
	// leaves them set but harmless: only the 5xx writers read them.
	LastSQL    string
	LastSQLErr string
	// contains filtered or unexported fields
}

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

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

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

type TraceView struct {
	TraceID string  `json:"trace_id"`
	TS      int64   `json:"ts"` // request start, unix microseconds
	Route   string  `json:"route"`
	TotalUS int32   `json:"total_us"`
	Status  uint16  `json:"status"`
	Spans   []Span  `json:"spans"`
	ErrMsg  string  `json:"error_msg,omitempty"` // set for error responses
	Stack   []Frame `json:"stack,omitempty"`     // set only for 500s
	// Request context for the error panel — populated for recent_traces from the
	// in-memory ErrorCapture (slow_traces persists only error_msg + stack).
	Method string `json:"method,omitempty"`
	UserID string `json:"user_id,omitempty"`
	Role   string `json:"role,omitempty"`
	// Client context — IP, parsed browser/OS, and geo country.
	IP        string `json:"ip,omitempty"`
	UserAgent string `json:"user_agent,omitempty"`
	Browser   string `json:"browser,omitempty"`
	OS        string `json:"os,omitempty"`
	Country   string `json:"country,omitempty"`
	// Reproducible-request context (persisted traces only): filtered headers +
	// full URL. Method (above) completes the curl reconstruction.
	Headers map[string]string `json:"headers,omitempty"`
	FullURL string            `json:"full_url,omitempty"`
	// OBSERVABILIDAD-ERRORES-S1: the statement the driver rejected (5xx from
	// the database), the redacted request body (opt-in, APPXIMO_TRACE_BODY),
	// and the error group this trace belongs to.
	SQL         string `json:"sql,omitempty"`
	Body        string `json:"body,omitempty"`
	Fingerprint uint64 `json:"fingerprint,omitempty"`
}

type Verdict struct {
	Attribution Attribution `json:"attribution"`
	// Owner says whose problem it is: "appximo" (code / memory), "host"
	// (the plan's quota, the box's RAM), "database" (pool config / the DB /
	// the network to it), "none".
	Owner string `json:"owner"`
	// Reason is one sentence an operator can act on.
	Reason string `json:"reason"`
	// Signals are every rule input that was evaluated (fired or not), so the
	// operator sees the numbers behind the sentence.
	Signals []Signal `json:"signals"`
	// Also lists lower-priority attributions whose rule ALSO fired this tick.
	Also []Attribution `json:"also,omitempty"`
	// LatencyHigh is the gate most code-side rules share: p99 over the
	// absolute floor, or a multiple of the healthy baseline.
	LatencyHigh bool    `json:"latency_high"`
	BaselineP99 float64 `json:"baseline_p99_ms"`
}

type WindowSummary struct {
	From         int64               `json:"from"`
	To           int64               `json:"to"`
	Ticks        int                 `json:"ticks"`
	TrafficTicks int                 `json:"traffic_ticks"`
	Dominant     Attribution         `json:"dominant"`
	Owner        string              `json:"owner"`
	Reason       string              `json:"reason"`
	Distribution map[Attribution]int `json:"distribution"`
	PeakRPS      float64             `json:"peak_rps"`
	PeakP99Ms    float64             `json:"peak_p99_ms"`
	PeakTick     *ResourceSnapshot   `json:"peak_tick,omitempty"`
	Requests     int64               `json:"requests"`
	Shed         int64               `json:"shed_429_503"`
	Errors5xx    int64               `json:"errors_5xx"`
}