events

type Custom []CustomPoint

type CustomPoint struct {
	Name  string
	Value interface{}
}

type Performance struct {
	Timestamp time.Time           `bson:"ts" json:"ts" yaml:"ts"`
	ID        int64               `bson:"id" json:"id" yaml:"id"`
	Counters  PerformanceCounters `bson:"counters" json:"counters" yaml:"counters"`
	Timers    PerformanceTimers   `bson:"timers" json:"timers" yaml:"timers"`
	Gauges    PerformanceGauges   `bson:"gauges" json:"gauges" yaml:"gauges"`
}

type PerformanceCounters struct {
	Number     int64 `bson:"n" json:"n" yaml:"n"`
	Operations int64 `bson:"ops" json:"ops" yaml:"ops"`
	Size       int64 `bson:"size" json:"size" yaml:"size"`
	Errors     int64 `bson:"errors" json:"errors" yaml:"errors"`
}

type PerformanceCountersHDR struct {
	Number     *hdrhist.Histogram
	Operations *hdrhist.Histogram
	Size       *hdrhist.Histogram
	Errors     *hdrhist.Histogram
}

type PerformanceGauges struct {
	State   int64 `bson:"state" json:"state" yaml:"state"`
	Workers int64 `bson:"workers" json:"workers" yaml:"workers"`
	Failed  bool  `bson:"failed" json:"failed" yaml:"failed"`
}

type PerformanceHDR struct {
	Timestamp time.Time              `bson:"ts" json:"ts" yaml:"ts"`
	ID        int64                  `bson:"id" json:"id" yaml:"id"`
	Counters  PerformanceCountersHDR `bson:"counters" json:"counters" yaml:"counters"`
	Timers    PerformanceTimersHDR   `bson:"timers" json:"timers" yaml:"timers"`
	Gauges    PerformanceGauges      `bson:"guages" json:"guages" yaml:"guages"`
}

type PerformanceTimers struct {
	Duration time.Duration `bson:"dur" json:"dur" yaml:"dur"`
	Total    time.Duration `bson:"total" json:"total" yaml:"total"`
}

type PerformanceTimersHDR struct {
	Duration *hdrhist.Histogram
	Total    *hdrhist.Histogram
}

type Recorder interface {
	// The Inc<> operations add values to the specified counters
	// tracked by the collector. There is an additional
	// "iteration" counter that the recorder tracks based on the
	// number of times that Begin/End are called, but is also
	// accessible via the IncIter counter.
	//
	// In general, ops should refer to the number of logical
	// operations collected. This differs from the iteration
	// count, in the case of workloads that comprise of multiple
	// logical operations.
	//
	// Use size to record, typically, the number of bytes
	// processed or generated by the operation. Use this in
	// combination with logical operations to be able to explore
	// the impact of data size on overall performance. Finally use
	// Error count to tract the number of errors encountered
	// during the event.
	IncOps(int64)
	IncSize(int64)
	IncError(int64)
	IncIterations(int64)

	// The Set<> operations replace existing values for the state,
	// workers, and failed gauges. Workers should typically report
	// the number of active threads. The meaning of state depends
	// on the test requirements but can describe phases of an
	// experiment or operation. Use SetFailed to flag a test as
	// failed during the operation.
	SetState(int64)
	SetWorkers(int64)
	SetFailed(bool)

	// The Begin and End methods mark the beginning and end of
	// a tests's iteration. Typically calling record records the
	// duration specified as its argument and increments the
	// counter for number of iterations. Additionally there is a
	// "total duration" value captured which represents the total
	// time taken in the iteration in addition to the operation
	// latency.
	//
	// The Flush method writes any unflushed material if the
	// collector's Record method does not. In all cases Flush
	// reports all errors since the last flush call, and resets
	// the internal error tracking and unsets the tracked starting
	// time. Generally you should call Flush once at the end of
	// every test run, and fail if there are errors reported.
	//
	// The Reset method set's the tracked starting time, like
	// Begin, but does not record any other values, as some
	// recorders use begin to persist the previous iteration.
	Begin()
	Reset()
	End(time.Duration)
	Flush() error

	// SetID sets the unique id for the event, to allow users to
	// identify events per thread.
	SetID(int64)

	// SetTime defines the timestamp of the current point. SetTime
	// is ususally not needed: Begin will set the time to the
	// current time; however, if you're using a recorder as part
	// of post-processing, you will want to use SetTime directly.
	SetTime(time.Time)

	// SetTotalDuration allows you to set the total time covered by
	// the event in question. The total time is usually derived by
	// the difference between the time set in Begin (or reset) and the time
	// when record is called. Typically the duration passed to
	// End() refers to a subset of this time (i.e. the amount
	// of time that the operations in question took,) and the
	// total time, includes some period of overhead.
	//
	// In simplest terms, this should typically be the time since
	// the last event was recorded.
	SetTotalDuration(time.Duration)

	// SetDuration allows you to define the duration of a the
	// operation, this is likely a subset of the total duration,
	// with the difference between the duration and the total
	// duration, representing some kind of operational overhead.
	SetDuration(time.Duration)
}

type TimerManager interface {
	ResetTimer()
	StartTimer()
	StopTimer()
}