loadrun

type Config struct {
	// ScenarioName is the `load:` block entry this profile came from, or ""
	// when the profile was assembled from --vus/--duration/--iterations.
	ScenarioName string
	// Flow is the already-imported flow to drive.
	Flow *mflow.Flow
	// Executor is the scheduling strategy. "" means constant-vus.
	Executor mload.Executor
	// VUs is the number of concurrent virtual users (constant-vus).
	VUs int
	// Duration bounds the window during which new iterations start
	// (constant-vus and constant-arrival-rate).
	Duration time.Duration
	// MaxIterations bounds the total iterations issued (constant-vus).
	MaxIterations int64

	// StartVUs, Stages and GracefulRampDown drive ramping-vus; Stages also
	// drives ramping-arrival-rate.
	StartVUs         int
	Stages           []mload.Stage
	GracefulRampDown time.Duration
	// Rate, StartRate, TimeUnit, PreAllocatedVUs and MaxVUs drive the
	// arrival-rate executors.
	Rate            float64
	StartRate       float64
	TimeUnit        time.Duration
	PreAllocatedVUs int
	MaxVUs          int
	// GracefulStop bounds in-flight iterations once a ramping or
	// arrival-rate schedule ends.
	GracefulStop time.Duration
	// ThinkTime is the pause each VU takes after an iteration.
	ThinkTime mload.ThinkTime

	// Thresholds are evaluated once, against the final report.
	Thresholds []mload.Condition
	// Abort rules are evaluated every FrameInterval.
	Abort []mload.AbortRule

	// FrameInterval is how often metrics are flushed into an interval
	// frame. Zero means DefaultFrameInterval.
	FrameInterval time.Duration
	// OnFrame, when set, receives every interval frame, including the final
	// partial one. It is called from the run's metrics goroutine and must
	// not block.
	OnFrame func(IntervalFrame)
	// Stopper, when set, lets a caller end the run early; Run creates its
	// own otherwise. Either way abort rules stop the run through it.
	Stopper *Stopper
}

type IntervalFrame struct {
	// Seq numbers frames from zero, contiguously.
	Seq   int64
	Frame loadmetrics.Frame
	// ActiveVUs is the number of VUs mid-iteration when the frame was cut.
	ActiveVUs int64
	// Dropped is the cumulative count of dropped arrival-rate iterations.
	Dropped int64
	// Final marks the last frame of the run.
	Final bool
}

type Options struct {
	// Requested is set by the command layer when the user passed any load
	// flag at all - including one whose value happens to be a zero, like
	// `--vus 0` or `--duration 30s` with no --vus. Those are load runs the
	// user got wrong, and they deserve a load-mode error rather than a
	// silent fall-through to a functional run.
	Requested bool
	// Scenario names an entry of the file's `load:` block.
	Scenario string
	// VUs, Duration and Iterations describe a profile inline, for runs that
	// do not want a scenario in the file.
	VUs        int
	Duration   time.Duration
	Iterations int64
	// VUsScale and RateScale size the profile for one machine of a run
	// split across several: VU counts are multiplied by VUsScale and
	// arrival rates by RateScale (see mload.Scenario.Scaled). Zero means 1.
	VUsScale  float64
	RateScale float64
}

type Result struct {
	// Config is the profile that was executed.
	Config Config
	// Summary is the scheduler's view: iterations completed, iterations that
	// returned an error, interrupted and dropped iterations, wall time.
	Summary scenariorunner.Summary
	// Report is the merged metrics report keyed by (step, status class).
	Report loadmetrics.Report
	// ByStep is the same data folded across status classes, so each step has
	// exactly one row. This is what the console table renders.
	ByStep loadmetrics.Report
	// Thresholds holds one verdict per configured threshold, in order.
	Thresholds []ThresholdResult
	// AbortReason says why the run stopped early, or is "" when it ran its
	// course.
	AbortReason string
	// Frames is how many interval frames the run produced.
	Frames int64
}

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

type ThresholdResult struct {
	Condition mload.Condition
	// Observed is the measured value, in the condition's Limit units. It is
	// meaningless when HasData is false.
	Observed float64
	// HasData is false when the run recorded no request the threshold could
	// be measured on, e.g. a step that never ran. Such a threshold fails:
	// a gate that cannot be checked must not pass silently.
	HasData bool
	Passed  bool
}