harness

type Baseline struct {
	Name       string `json:"name"`
	RecordedAt string `json:"recorded_at"`
	// Hardware is the machine the figures were measured on, and it is load-bearing: comparing a
	// run against figures from different iron measures the iron. A run on hardware this does not
	// name records its measurement and compares nothing (observability-reliability.md §13.2).
	Hardware string `json:"hardware"`
	Dataset  struct {
		Tenants int `json:"tenants"`
		Items   int `json:"items"`
	} `json:"dataset"`
	Figures map[string]Figure `json:"figures"`
}

type Bucket struct {
	SecondsIn       int `json:"seconds_in"`
	OfferedRate     int `json:"offered_rate"`
	Requests        int `json:"requests"`
	NonSuccess      int `json:"non_success"`
	ServerErrors    int `json:"server_errors"`
	Shed            int `json:"shed"`
	TransportErrors int `json:"transport_errors"`
	// InteractiveP95 is the number RT-6 is about, per interval rather than over the run: an
	// average that holds while the middle three minutes were terrible is not evidence.
	InteractiveP95 int64 `json:"interactive_p95_ms"`
	// contains filtered or unexported fields
}

type Class string

type Direction string

type Figure struct {
	Value     float64   `json:"value"`
	Direction Direction `json:"direction"`
	// BandPercent is how far the figure may move in the worse direction before it is a
	// regression. It is per figure because the figures are not equally noisy: a P95 on a shared
	// runner moves far more than a count of refusals does.
	BandPercent float64 `json:"band_percent"`
	// MinimumDelta is the smallest absolute movement worth calling a regression, and it exists
	// because a percentage band is the wrong shape for a small number. A P95 of six milliseconds
	// with a 60 % band is red at ten, and ten is what one garbage collection during the run looks
	// like - the guard would report the machine and be turned off within a week. Both conditions
	// have to hold: past the band *and* moved by at least this much.
	MinimumDelta float64 `json:"minimum_delta,omitempty"`
	// Note says what the figure is, in words, so that a red build is readable without this file
	// beside the test that produced it.
	Note string `json:"note,omitempty"`
}

type Latency struct {
	Count int   `json:"count"`
	P50   int64 `json:"p50"`
	P95   int64 `json:"p95"`
	P99   int64 `json:"p99"`
	Max   int64 `json:"max"`
}

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

type Plan []Stage

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

type Regression struct {
	Figure   string  `json:"figure"`
	Baseline float64 `json:"baseline"`
	Measured float64 `json:"measured"`
	// Allowed is the worst value that would still have passed - the edge of the band, so that a
	// red build says how far past it the run landed rather than only that it was past.
	Allowed float64 `json:"allowed"`
	Note    string  `json:"note,omitempty"`
}

type Stage struct {
	// PerSecond is the offered rate over the whole generator, not per worker.
	PerSecond int
	// For is how long this step is held.
	For time.Duration
}

type Summary struct {
	StartedAt time.Time `json:"started_at"`
	EndedAt   time.Time `json:"ended_at"`
	// OfferedPeak is the plan's ceiling. Recorded beside the achieved rate, because a run that
	// offered 400 a second and achieved 120 is a capacity finding rather than a failed run.
	OfferedPeak     int                `json:"offered_peak_per_second"`
	Requests        int                `json:"requests"`
	ByStatus        map[string]int     `json:"by_status"`
	Shed            map[string]int     `json:"shed_by_class"`
	TransportErrors int                `json:"transport_errors"`
	ErrorExamples   []string           `json:"transport_error_examples,omitempty"`
	Latency         map[string]Latency `json:"latency_ms_by_class"`
	Timeline        []Bucket           `json:"timeline"`
}

type Window struct {
	From time.Duration
	To   time.Duration
}