periodic

Documentation

Overview

Package periodic for fortio (from greek for load) is a set of utilities to run a given task at a target rate (qps) and gather statistics - for instance http requests.

The main executable using the library is fortio but there is also ../histogram to use the stats from the command line and ../echosrv as a very light http server that can be used to test proxies etc like the Istio components.

Index

• Constants
• Variables
• type HasRunnerResult
• type PeriodicRunner
  • func NewPeriodicRunner(params *RunnerOptions) PeriodicRunner
• type Runnable
• type RunnerOptions
  • func (ro *RunnerOptions) MakeRunners(r Runnable)
• type RunnerResults
  • func (r *RunnerResults) ID() string
  • func (r *RunnerResults) Result() *RunnerResults

Constants

const (
	// Version is the overall package version (used to version json output too).
	Version = "0.4.2"
)

Variables

var DefaultRunnerOptions = RunnerOptions{
	QPS:         8,
	Duration:    5 * time.Second,
	NumThreads:  4,
	Percentiles: []float64{90.0},
	Resolution:  0.001,
}

DefaultRunnerOptions are the default values for options (do not mutate!). This is only useful for initializing flag default values. You do not need to use this directly, you can pass a newly created RunnerOptions and 0 valued fields will be reset to these defaults.

Types

type HasRunnerResult

type HasRunnerResult interface {
	Result() *RunnerResults
}

HasRunnerResult is the interface implictly implemented by HTTPRunnerResults and GrpcRunnerResults so the common results can ge extracted irrespective of the type.

type PeriodicRunner

type PeriodicRunner interface {
	// Starts the run. Returns actual QPS and Histogram of function durations.
	Run() RunnerResults
	// Returns the options normalized by constructor - do not mutate
	// (where is const when you need it...)
	Options() *RunnerOptions
}

PeriodicRunner let's you exercise the Function at the given QPS and collect statistics and histogram about the run.

func NewPeriodicRunner

func NewPeriodicRunner(params *RunnerOptions) PeriodicRunner

NewPeriodicRunner constructs a runner from input parameters/options.

type Runnable

type Runnable interface {
	Run(tid int)
}

Runnable are the function to run periodically.

type RunnerOptions

type RunnerOptions struct {
	// Array of objects to run in each thread (use MakeRunners() to clone the same one)
	Runners  []Runnable
	QPS      float64
	Duration time.Duration
	// Note that this actually maps to gorountines and not actual threads
	// but threads seems like a more familiar name to use for non go users
	// and in a benchmarking context
	NumThreads  int
	Percentiles []float64
	Resolution  float64
	// Where to write the textual version of the results, defaults to stdout
	Out io.Writer
	// Extra data to be copied back to the results (to be saved/JSON serialized)
	Labels string
}

RunnerOptions are the parameters to the PeriodicRunner.

func (*RunnerOptions) MakeRunners

func (ro *RunnerOptions) MakeRunners(r Runnable)

MakeRunners creates an array of NumThreads identical Runnable instances. (for the (rare/test) cases where there is no unique state needed)

type RunnerResults

type RunnerResults struct {
	Labels            string
	StartTime         time.Time
	RequestedQPS      string
	RequestedDuration string
	ActualQPS         float64
	ActualDuration    time.Duration
	NumThreads        int
	Version           string
	DurationHistogram *stats.HistogramData
}

RunnerResults encapsulates the actual QPS observed and duration histogram.

func (*RunnerResults) ID

func (r *RunnerResults) ID() string

ID Returns an id for the result: 64 bytes YYYY-MM-DD-HHmmSS_{alpha_labels} where alpha_labels is the filtered labels with only alphanumeric characters and all non alpha num replaced by _; truncated to 64 bytes.

func (*RunnerResults) Result

func (r *RunnerResults) Result() *RunnerResults

Result returns the common RunnerResults.