metrics

type Bucket struct {
	Lo, Hi uint64 // inclusive value range in µs
	Count  uint64
}

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

type ErrorExample struct {
	At      time.Time `json:"at"`
	TraceID string    `json:"traceId,omitempty"`
	// Request is "METHOD URL"; RequestBody its first MaxExampleBody bytes.
	Request         string            `json:"request"`
	RequestHeaders  map[string]string `json:"requestHeaders,omitempty"`
	RequestBody     string            `json:"requestBody,omitempty"`
	Status          int               `json:"status,omitempty"`
	ResponseHeaders map[string]string `json:"responseHeaders,omitempty"`
	ResponseBody    string            `json:"responseBody,omitempty"`
	// Detail is the error message, such as a check's mismatch or a
	// connection error.
	Detail string `json:"detail,omitempty"`
	// Browser steps: a JPEG screenshot of the page when it failed, its
	// console errors and warnings, and a HAR of its requests (no bodies).
	Screenshot []byte   `json:"screenshot,omitempty"`
	Console    []string `json:"console,omitempty"`
	HAR        string   `json:"har,omitempty"`
}

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

type JourneyStats struct {
	Started   uint64     `json:"started"`
	Completed uint64     `json:"completed"`
	Failed    uint64     `json:"failed"`
	Duration  *Histogram `json:"duration"`
}

type Percentiles struct {
	Count uint64  `json:"count"`
	Min   float64 `json:"min"`
	Mean  float64 `json:"mean"`
	P50   float64 `json:"p50"`
	P90   float64 `json:"p90"`
	P95   float64 `json:"p95"`
	P99   float64 `json:"p99"`
	P999  float64 `json:"p999"`
	Max   float64 `json:"max"`
}

type Phase int

type Sample struct {
	Step int
	// Intended is when the request should have been sent. In open-model
	// runs a late dispatch makes it earlier than Start; latency is
	// measured from here to avoid coordinated omission.
	Intended time.Time
	Start    time.Time
	End      time.Time
	Phases   [NumPhases]time.Duration
	Status   int
	// Err is an error class ("" for success at the transport level).
	Err          string
	Failed       bool
	ChecksPassed int
	ChecksFailed int
	BytesIn      int64
	BytesOut     int64
	// Proto is the negotiated protocol, such as "HTTP/1.1" or "HTTP/2.0".
	Proto string
	// Events counts the events or messages a streaming step received;
	// StreamTime is the time from the first of them to the end of the step.
	Events     int
	StreamTime time.Duration
	// TraceID is the W3C trace ID sent with the request (all zero when
	// none was sent).
	TraceID [16]byte
	// Exchange, set on some failed samples, is an example of the failure
	// for the report (see MaxErrorExamples).
	Exchange *ErrorExample
}

type SlowRequest struct {
	// Latency is measured from the intended send time, like StepStats.Latency.
	Latency time.Duration `json:"latency"`
	// Start is when the request was sent.
	Start time.Time `json:"start"`
	// TraceID is the 32-hex-digit W3C trace ID, empty when none was sent.
	TraceID string `json:"traceId,omitempty"`
	Status  int    `json:"status,omitempty"`
	Err     string `json:"error,omitempty"`
}

type Snapshot struct {
	// Interval is the number of whole intervals since the run's T0.
	Interval int64 `json:"interval"`
	// Seq increases by one per snapshot from a worker so resends are
	// detected and never counted twice.
	Seq      uint64                `json:"seq,omitempty"`
	Worker   string                `json:"worker,omitempty"`
	Steps    map[int]*StepStats    `json:"steps,omitempty"`
	Journeys map[int]*JourneyStats `json:"journeys,omitempty"`
	// Dropped counts open-model iterations that could not start because
	// no virtual user was free.
	Dropped uint64 `json:"dropped,omitempty"`
	// SchedLag is how late iterations were dispatched versus schedule.
	SchedLag *Histogram `json:"schedLag,omitempty"`
	// VUs is the number of active virtual users at the end of the interval.
	VUs int `json:"vus"`
	// Planned is the planned load (users or rate) at the interval.
	Planned float64 `json:"planned,omitempty"`
}

type StepStats struct {
	Requests     uint64            `json:"requests"`
	Failed       uint64            `json:"failed"`
	Errors       map[string]uint64 `json:"errors,omitempty"`
	Status       map[int]uint64    `json:"status,omitempty"`
	ChecksPassed uint64            `json:"checksPassed,omitempty"`
	ChecksFailed uint64            `json:"checksFailed,omitempty"`
	BytesIn      uint64            `json:"bytesIn"`
	BytesOut     uint64            `json:"bytesOut"`
	// Latency is measured from the intended send time.
	Latency *Histogram `json:"latency"`
	// Service is measured from the actual send time.
	Service *Histogram `json:"service"`
	// PhaseSum holds per-phase totals in µs for computing means.
	PhaseSum [NumPhases]uint64 `json:"phaseSum"`
	// Streams counts samples that received at least one stream event,
	// Events the events they received and StreamUs the µs from each
	// stream's first event to its end. Events per second after the first
	// event is (Events - Streams) / StreamUs.
	Streams  uint64 `json:"streams,omitempty"`
	Events   uint64 `json:"events,omitempty"`
	StreamUs uint64 `json:"streamUs,omitempty"`
	// Protocols counts requests by negotiated protocol (HTTP/1.1, HTTP/2.0).
	Protocols map[string]uint64 `json:"protocols,omitempty"`
	// Slowest holds up to MaxSlowest of the slowest requests, slowest
	// first, with their trace IDs.
	Slowest []SlowRequest `json:"slowest,omitempty"`
	// Examples holds up to MaxErrorExamples failed requests per error.
	Examples map[string][]ErrorExample `json:"examples,omitempty"`
}