metrics

type AccumulatingBucket ¶

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

func (b *AccumulatingBucket) Add(value float64)

func (b *AccumulatingBucket) Humanize() string

func (b *AccumulatingBucket) Observations() int

func (b *AccumulatingBucket) ValueForIndex(index int) float64

type Bucket ¶

type Bucket interface {
	/*
		Add a value to the bucket.
	*/
	Add(value float64)
	/*
	  Provide a humanized representation hereof.
	*/
	Humanize() string
	/*
		Provide a count of observations throughout the bucket's lifetime.
	*/
	Observations() int
	/*
		Provide the value from the given in-memory value cache or an estimate
		thereof for the given index.  The consumer of the bucket's data makes
		no assumptions about the underlying storage mechanisms that the bucket
		employs.
	*/
	ValueForIndex(index int) float64
}

This defines the base Bucket type. The exact behaviors of the bucket are at the whim of the implementor.

A Bucket is used as a container by Histogram as a collection for its accumulated samples.

func TallyingBucketBuilder() Bucket

type BucketBuilder ¶

type BucketBuilder func() Bucket

The Histogram class and associated types build buckets on their own.

func AccumulatingBucketBuilder(evictionPolicy EvictionPolicy, maximumSize int) BucketBuilder

type CompletionCallback ¶

type CompletionCallback func(duration time.Duration)

This callback is called upon the completion of the timer—i.e., when it stops.

type EvictionPolicy ¶

type EvictionPolicy func(h heap.Interface)

EvictionPolicy implements some sort of garbage collection methodology for an underlying heap.Interface. This is presently only used for AccumulatingBucket.

func EvictAndReplaceWith(count int, reducer maths.ReductionMethod) EvictionPolicy

func EvictOldest(count int) EvictionPolicy

type GaugeMetric ¶

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

A gauge metric merely provides an instantaneous representation of a scalar value or an accumulation. For instance, if one wants to expose the current temperature or the hitherto bandwidth used, this would be the metric for such circumstances.

func (metric *GaugeMetric) Decrement() float64

func (metric *GaugeMetric) DecrementBy(value float64) float64

func (metric *GaugeMetric) Get() float64

func (metric *GaugeMetric) Humanize() string

func (metric *GaugeMetric) Increment() float64

func (metric *GaugeMetric) IncrementBy(value float64) float64

func (metric *GaugeMetric) Marshallable() map[string]interface{}

func (metric *GaugeMetric) Set(value float64) float64

type Histogram ¶

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

The histogram is an accumulator for samples. It merely routes into which to bucket to capture an event and provides a percentile calculation mechanism.

Histogram makes do without locking by employing the law of large numbers to presume a convergence toward a given bucket distribution. Locking may be implemented in the buckets themselves, though.

func CreateHistogram(specification *HistogramSpecification) *Histogram

func (h *Histogram) Add(value float64)

func (h *Histogram) Humanize() string

func (h *Histogram) Marshallable() map[string]interface{}

func (h *Histogram) Percentile(percentile float64) float64

type HistogramSpecification ¶

type HistogramSpecification struct {
	Starts                []float64
	BucketMaker           BucketBuilder
	ReportablePercentiles []float64
}

A HistogramSpecification defines how a Histogram is to be built.

type InstrumentableCall ¶

type InstrumentableCall func()

This is meant to capture a function that a StopWatch can call for purposes of instrumentation.

type Metric ¶

type Metric interface {
	/*
	  Produce a human-consumable representation of the metric.
	*/
	Humanize() string
	/*
		Produce a JSON-consumable representation of the metric.
	*/
	Marshallable() map[string]interface{}
}

A Metric is something that can be exposed via the registry framework.

type StopWatch ¶

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

StopWatch is the structure that captures instrumentation for durations.

N.B.(mtp): A major limitation hereof is that the StopWatch protocol cannot retain instrumentation if a panic percolates within the context that is being measured.

func Start(onCompletion CompletionCallback) *StopWatch

func (s *StopWatch) Stop() time.Duration

type TallyingBucket ¶

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

A TallyingBucket is a Bucket that tallies when an object is added to it. Upon insertion, an object is compared against collected extrema and noted as a new minimum or maximum if appropriate.

func CustomTallyingBucket(estimator TallyingIndexEstimator) TallyingBucket

func DefaultTallyingBucket() TallyingBucket

func (b *TallyingBucket) Add(value float64)

func (b *TallyingBucket) Humanize() string

func (b *TallyingBucket) Observations() int

func (b *TallyingBucket) ValueForIndex(index int) float64

type TallyingIndexEstimator ¶

type TallyingIndexEstimator func(minimum, maximum float64, index, observations int) float64

A TallyingIndexEstimator is responsible for estimating the value of index for a given TallyingBucket, even though a TallyingBucket does not possess a collection of samples. There are a few strategies listed below for how this value should be approximated.

var Average TallyingIndexEstimator = emptyFilter(func(minimum, maximum float64, _, observations int) float64 {
	return maths.Average([]float64{minimum, maximum})
})

var Maximum TallyingIndexEstimator = emptyFilter(func(minimum, maximum float64, _, observations int) float64 {
	return maximum
})

var Minimum TallyingIndexEstimator = emptyFilter(func(minimum, maximum float64, _, observations int) float64 {
	return minimum
})

var Uniform TallyingIndexEstimator = emptyFilter(func(minimum, maximum float64, index, observations int) float64 {
	if observations == 1 {
		return minimum
	}

	location := float64(index) / float64(observations)

	if location > upperThird {
		return maximum
	} else if location < lowerThird {
		return minimum
	}

	return maths.Average([]float64{minimum, maximum})
})