metrics

package
v0.0.0-...-06fc4d1 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 29, 2020 License: GPL-3.0, BSD-2-Clause-Views Imports: 23 Imported by: 0

README ¶

go-metrics

travis build status

Go port of Coda Hale's Metrics library: https://github.com/dropwizard/metrics.

Documentation: https://godoc.org/github.com/rcrowley/go-metrics.

Usage

Create and update metrics:

c := metrics.NewCounter()
metrics.Register("foo", c)
c.Inc(47)

g := metrics.NewGauge()
metrics.Register("bar", g)
g.Update(47)

r := NewRegistry()
g := metrics.NewRegisteredFunctionalGauge("cache-evictions", r, func() int64 { return cache.getEvictionsCount() })

s := metrics.NewExpDecaySample(1028, 0.015) // or metrics.NewUniformSample(1028)
h := metrics.NewHistogram(s)
metrics.Register("baz", h)
h.Update(47)

m := metrics.NewMeter()
metrics.Register("quux", m)
m.Mark(47)

t := metrics.NewTimer()
metrics.Register("bang", t)
t.Time(func() {})
t.Update(47)

Register() is not threadsafe. For threadsafe metric registration use GetOrRegister:

t := metrics.GetOrRegisterTimer("account.create.latency", nil)
t.Time(func() {})
t.Update(47)

NOTE: Be sure to unregister short-lived meters and timers otherwise they will leak memory:

// Will call Stop() on the Meter to allow for garbage collection
metrics.Unregister("quux")
// Or similarly for a Timer that embeds a Meter
metrics.Unregister("bang")

Periodically log every metric in human-readable form to standard error:

go metrics.Log(metrics.DefaultRegistry, 5 * time.Second, log.New(os.Stderr, "metrics: ", log.Lmicroseconds))

Periodically log every metric in slightly-more-parseable form to syslog:

w, _ := syslog.Dial("unixgram", "/dev/log", syslog.LOG_INFO, "metrics")
go metrics.Syslog(metrics.DefaultRegistry, 60e9, w)

Periodically emit every metric to Graphite using the Graphite client:


import "github.com/cyberdelia/go-metrics-graphite"

addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:2003")
go graphite.Graphite(metrics.DefaultRegistry, 10e9, "metrics", addr)

Periodically emit every metric into InfluxDB:

NOTE: this has been pulled out of the library due to constant fluctuations in the InfluxDB API. In fact, all client libraries are on their way out. see issues #121 and #124 for progress and details.

import "github.com/vrischmann/go-metrics-influxdb"

go influxdb.InfluxDB(metrics.DefaultRegistry,
  10e9, 
  "127.0.0.1:8086", 
  "database-name", 
  "username", 
  "password"
)

Periodically upload every metric to Librato using the Librato client:

Note: the client included with this repository under the librato package has been deprecated and moved to the repository linked above.

import "github.com/mihasya/go-metrics-librato"

go librato.Librato(metrics.DefaultRegistry,
    10e9,                  // interval
    "[email protected]", // account owner email address
    "token",               // Librato API token
    "hostname",            // source
    []float64{0.95},       // percentiles to send
    time.Millisecond,      // time unit
)

Periodically emit every metric to StatHat:

import "github.com/rcrowley/go-metrics/stathat"

go stathat.Stathat(metrics.DefaultRegistry, 10e9, "[email protected]")

Maintain all metrics along with expvars at /debug/metrics:

This uses the same mechanism as the official expvar but exposed under /debug/metrics, which shows a json representation of all your usual expvars as well as all your go-metrics.

import "github.com/rcrowley/go-metrics/exp"

exp.Exp(metrics.DefaultRegistry)

Installation

go get github.com/rcrowley/go-metrics

StatHat support additionally requires their Go client:

go get github.com/stathat/go

Publishing Metrics

Clients are available for the following destinations:

Documentation ¶

Overview ¶

Go port of Coda Hale's Metrics library

<https://github.com/rcrowley/go-metrics>

Coda Hale's original work: <https://github.com/codahale/metrics>

Example ¶ 
c := NewCounter()
Register("money", c)
c.Inc(17)

// Threadsafe registration
t := GetOrRegisterTimer("db.get.latency", nil)
t.Time(func() { time.Sleep(10 * time.Millisecond) })
t.Update(1)

fmt.Println(c.Count())
fmt.Println(t.Min())

Output:

17
1

Index ¶

Examples ¶

Constants ¶

View Source 
const InitialResettingTimerSliceCap = 10

Initial slice capacity for the values stored in a ResettingTimer

Variables ¶

View Source 
var (
	DefaultRegistry    = NewRegistry()
	EphemeralRegistry  = NewRegistry()
	AccountingRegistry = NewRegistry() // registry used in swarm
)
View Source 
var Enabled = false

Enabled is checked by the constructor functions for all of the standard metrics. If it is true, the metric returned is a stub.

This global kill-switch helps quantify the observer effect and makes for less cluttered pprof profiles.

View Source 
var EnabledExpensive = false

EnabledExpensive is a soft-flag meant for external packages to check if costly metrics gathering is allowed or not. The goal is to separate standard metrics for health monitoring and debug metrics that might impact runtime performance.

Functions ¶

func CaptureDebugGCStats ¶ 

func CaptureDebugGCStats(r Registry, d time.Duration)

Capture new values for the Go garbage collector statistics exported in debug.GCStats. This is designed to be called as a goroutine.

func CaptureDebugGCStatsOnce ¶ 

func CaptureDebugGCStatsOnce(r Registry)

Capture new values for the Go garbage collector statistics exported in debug.GCStats. This is designed to be called in a background goroutine. Giving a registry which has not been given to RegisterDebugGCStats will panic.

Be careful (but much less so) with this because debug.ReadGCStats calls the C function runtime·lock(runtime·mheap) which, while not a stop-the-world operation, isn't something you want to be doing all the time.

func CaptureRuntimeMemStats ¶ 

func CaptureRuntimeMemStats(r Registry, d time.Duration)

Capture new values for the Go runtime statistics exported in runtime.MemStats. This is designed to be called as a goroutine.

func CaptureRuntimeMemStatsOnce ¶ 

func CaptureRuntimeMemStatsOnce(r Registry)

Capture new values for the Go runtime statistics exported in runtime.MemStats. This is designed to be called in a background goroutine. Giving a registry which has not been given to RegisterRuntimeMemStats will panic.

Be very careful with this because runtime.ReadMemStats calls the C functions runtime·semacquire(&runtime·worldsema) and runtime·stoptheworld() and that last one does what it says on the tin.

func CollectProcessMetrics ¶ 

func CollectProcessMetrics(refresh time.Duration)

CollectProcessMetrics periodically collects various metrics about the running process.

func Each ¶ 

func Each(f func(string, interface{}))

Call the given function for each registered metric.

func Get ¶ 

func Get(name string) interface{}

Get the metric by the given name or nil if none is registered.

func GetOrRegister ¶ 

func GetOrRegister(name string, i interface{}) interface{}

Gets an existing metric or creates and registers a new one. Threadsafe alternative to calling Get and Register on failure.

func Graphite ¶ 

func Graphite(r Registry, d time.Duration, prefix string, addr *net.TCPAddr)

Graphite is a blocking exporter function which reports metrics in r to a graphite server located at addr, flushing them every d duration and prepending metric names with prefix.

Example ¶ 
addr, _ := net.ResolveTCPAddr("net", ":2003")
go Graphite(DefaultRegistry, 1*time.Second, "some.prefix", addr)

Output:

func GraphiteOnce ¶ 

func GraphiteOnce(c GraphiteConfig) error

GraphiteOnce performs a single submission to Graphite, returning a non-nil error on failed connections. This can be used in a loop similar to GraphiteWithConfig for custom error handling.

func GraphiteWithConfig ¶ 

func GraphiteWithConfig(c GraphiteConfig)

GraphiteWithConfig is a blocking exporter function just like Graphite, but it takes a GraphiteConfig instead.

Example ¶ 
addr, _ := net.ResolveTCPAddr("net", ":2003")
go GraphiteWithConfig(GraphiteConfig{
	Addr:          addr,
	Registry:      DefaultRegistry,
	FlushInterval: 1 * time.Second,
	DurationUnit:  time.Millisecond,
	Percentiles:   []float64{0.5, 0.75, 0.99, 0.999},
})

Output:

func Log ¶ 

func Log(r Registry, freq time.Duration, l Logger)

func LogScaled ¶ 

func LogScaled(r Registry, freq time.Duration, scale time.Duration, l Logger)

Output each metric in the given registry periodically using the given logger. Print timings in `scale` units (eg time.Millisecond) rather than nanos.

func MustRegister ¶ 

func MustRegister(name string, i interface{})

Register the given metric under the given name. Panics if a metric by the given name is already registered.

func OpenTSDB ¶ 

func OpenTSDB(r Registry, d time.Duration, prefix string, addr *net.TCPAddr)

OpenTSDB is a blocking exporter function which reports metrics in r to a TSDB server located at addr, flushing them every d duration and prepending metric names with prefix.

Example ¶ 
addr, _ := net.ResolveTCPAddr("net", ":2003")
go OpenTSDB(DefaultRegistry, 1*time.Second, "some.prefix", addr)

Output:

func OpenTSDBWithConfig ¶ 

func OpenTSDBWithConfig(c OpenTSDBConfig)

OpenTSDBWithConfig is a blocking exporter function just like OpenTSDB, but it takes a OpenTSDBConfig instead.

Example ¶ 
addr, _ := net.ResolveTCPAddr("net", ":2003")
go OpenTSDBWithConfig(OpenTSDBConfig{
	Addr:          addr,
	Registry:      DefaultRegistry,
	FlushInterval: 1 * time.Second,
	DurationUnit:  time.Millisecond,
})

Output:

func ReadCPUStats ¶ 

func ReadCPUStats(stats *CPUStats)

ReadCPUStats retrieves the current CPU stats.

func ReadDiskStats ¶ 

func ReadDiskStats(stats *DiskStats) error

ReadDiskStats retrieves the disk IO stats belonging to the current process.

func Register ¶ 

func Register(name string, i interface{}) error

Register the given metric under the given name. Returns a DuplicateMetric if a metric by the given name is already registered.

func RegisterDebugGCStats ¶ 

func RegisterDebugGCStats(r Registry)

Register metrics for the Go garbage collector statistics exported in debug.GCStats. The metrics are named by their fully-qualified Go symbols, i.e. debug.GCStats.PauseTotal.

func RegisterRuntimeMemStats ¶ 

func RegisterRuntimeMemStats(r Registry)

Register runtimeMetrics for the Go runtime statistics exported in runtime and specifically runtime.MemStats. The runtimeMetrics are named by their fully-qualified Go symbols, i.e. runtime.MemStats.Alloc.

func RunHealthchecks ¶ 

func RunHealthchecks()

Run all registered healthchecks.

func SampleMax ¶ 

func SampleMax(values []int64) int64

SampleMax returns the maximum value of the slice of int64.

func SampleMean ¶ 

func SampleMean(values []int64) float64

SampleMean returns the mean value of the slice of int64.

func SampleMin ¶ 

func SampleMin(values []int64) int64

SampleMin returns the minimum value of the slice of int64.

func SamplePercentile ¶ 

func SamplePercentile(values int64Slice, p float64) float64

SamplePercentiles returns an arbitrary percentile of the slice of int64.

func SamplePercentiles ¶ 

func SamplePercentiles(values int64Slice, ps []float64) []float64

SamplePercentiles returns a slice of arbitrary percentiles of the slice of int64.

func SampleStdDev ¶ 

func SampleStdDev(values []int64) float64

SampleStdDev returns the standard deviation of the slice of int64.

func SampleSum ¶ 

func SampleSum(values []int64) int64

SampleSum returns the sum of the slice of int64.

func SampleVariance ¶ 

func SampleVariance(values []int64) float64

SampleVariance returns the variance of the slice of int64.

func Syslog ¶ 

func Syslog(r Registry, d time.Duration, w *syslog.Writer)

Output each metric in the given registry to syslog periodically using the given syslogger.

func Unregister ¶ 

func Unregister(name string)

Unregister the metric with the given name.

func Write ¶ 

func Write(r Registry, d time.Duration, w io.Writer)

Write sorts writes each metric in the given registry periodically to the given io.Writer.

func WriteJSON ¶ 

func WriteJSON(r Registry, d time.Duration, w io.Writer)

WriteJSON writes metrics from the given registry periodically to the specified io.Writer as JSON.

func WriteJSONOnce ¶ 

func WriteJSONOnce(r Registry, w io.Writer)

WriteJSONOnce writes metrics from the given registry to the specified io.Writer as JSON.

func WriteOnce ¶ 

func WriteOnce(r Registry, w io.Writer)

WriteOnce sorts and writes metrics in the given registry to the given io.Writer.

Types ¶

type CPUStats ¶ 

type CPUStats struct {
	GlobalTime int64 // Time spent by the CPU working on all processes
	GlobalWait int64 // Time spent by waiting on disk for all processes
	LocalTime  int64 // Time spent by the CPU working on this process
}

CPUStats is the system and process CPU stats.

type Counter ¶ 

type Counter interface {
	Clear()
	Count() int64
	Dec(int64)
	Inc(int64)
	Snapshot() Counter
}

Counters hold an int64 value that can be incremented and decremented.

func GetOrRegisterCounter ¶ 

func GetOrRegisterCounter(name string, r Registry) Counter

GetOrRegisterCounter returns an existing Counter or constructs and registers a new StandardCounter.

func GetOrRegisterCounterForced ¶ 

func GetOrRegisterCounterForced(name string, r Registry) Counter

GetOrRegisterCounterForced returns an existing Counter or constructs and registers a new Counter no matter the global switch is enabled or not. Be sure to unregister the counter from the registry once it is of no use to allow for garbage collection.

func NewCounter ¶ 

func NewCounter() Counter

NewCounter constructs a new StandardCounter.

func NewCounterForced ¶ 

func NewCounterForced() Counter

NewCounterForced constructs a new StandardCounter and returns it no matter if the global switch is enabled or not.

func NewRegisteredCounter ¶ 

func NewRegisteredCounter(name string, r Registry) Counter

NewRegisteredCounter constructs and registers a new StandardCounter.

func NewRegisteredCounterForced ¶ 

func NewRegisteredCounterForced(name string, r Registry) Counter

NewRegisteredCounterForced constructs and registers a new StandardCounter and launches a goroutine no matter the global switch is enabled or not. Be sure to unregister the counter from the registry once it is of no use to allow for garbage collection.

type CounterSnapshot ¶ 

type CounterSnapshot int64

CounterSnapshot is a read-only copy of another Counter.

func (CounterSnapshot) Clear ¶ 

func (CounterSnapshot) Clear()

Clear panics.

func (CounterSnapshot) Count ¶ 

func (c CounterSnapshot) Count() int64

Count returns the count at the time the snapshot was taken.

func (CounterSnapshot) Dec ¶ 

func (CounterSnapshot) Dec(int64)

Dec panics.

func (CounterSnapshot) Inc ¶ 

func (CounterSnapshot) Inc(int64)

Inc panics.

func (CounterSnapshot) Snapshot ¶ 

func (c CounterSnapshot) Snapshot() Counter

Snapshot returns the snapshot.

type DiskStats ¶ 

type DiskStats struct {
	ReadCount  int64 // Number of read operations executed
	ReadBytes  int64 // Total number of bytes read
	WriteCount int64 // Number of write operations executed
	WriteBytes int64 // Total number of byte written
}

DiskStats is the per process disk io stats.

type DuplicateMetric ¶ 

type DuplicateMetric string

DuplicateMetric is the error returned by Registry.Register when a metric already exists. If you mean to Register that metric you must first Unregister the existing metric.

func (DuplicateMetric) Error ¶ 

func (err DuplicateMetric) Error() string

type EWMA ¶ 

type EWMA interface {
	Rate() float64
	Snapshot() EWMA
	Tick()
	Update(int64)
}

EWMAs continuously calculate an exponentially-weighted moving average based on an outside source of clock ticks.

func NewEWMA ¶ 

func NewEWMA(alpha float64) EWMA

NewEWMA constructs a new EWMA with the given alpha.

func NewEWMA1 ¶ 

func NewEWMA1() EWMA

NewEWMA1 constructs a new EWMA for a one-minute moving average.

func NewEWMA15 ¶ 

func NewEWMA15() EWMA

NewEWMA15 constructs a new EWMA for a fifteen-minute moving average.

func NewEWMA5 ¶ 

func NewEWMA5() EWMA

NewEWMA5 constructs a new EWMA for a five-minute moving average.

type EWMASnapshot ¶ 

type EWMASnapshot float64

EWMASnapshot is a read-only copy of another EWMA.

func (EWMASnapshot) Rate ¶ 

func (a EWMASnapshot) Rate() float64

Rate returns the rate of events per second at the time the snapshot was taken.

func (EWMASnapshot) Snapshot ¶ 

func (a EWMASnapshot) Snapshot() EWMA

Snapshot returns the snapshot.

func (EWMASnapshot) Tick ¶ 

func (EWMASnapshot) Tick()

Tick panics.

func (EWMASnapshot) Update ¶ 

func (EWMASnapshot) Update(int64)

Update panics.

type ExpDecaySample ¶ 

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

ExpDecaySample is an exponentially-decaying sample using a forward-decaying priority reservoir. See Cormode et al's "Forward Decay: A Practical Time Decay Model for Streaming Systems".

<http://dimacs.rutgers.edu/~graham/pubs/papers/fwddecay.pdf>

func (*ExpDecaySample) Clear ¶ 

func (s *ExpDecaySample) Clear()

Clear clears all samples.

func (*ExpDecaySample) Count ¶ 

func (s *ExpDecaySample) Count() int64

Count returns the number of samples recorded, which may exceed the reservoir size.

func (*ExpDecaySample) Max ¶ 

func (s *ExpDecaySample) Max() int64

Max returns the maximum value in the sample, which may not be the maximum value ever to be part of the sample.

func (*ExpDecaySample) Mean ¶ 

func (s *ExpDecaySample) Mean() float64

Mean returns the mean of the values in the sample.

func (*ExpDecaySample) Min ¶ 

func (s *ExpDecaySample) Min() int64

Min returns the minimum value in the sample, which may not be the minimum value ever to be part of the sample.

func (*ExpDecaySample) Percentile ¶ 

func (s *ExpDecaySample) Percentile(p float64) float64

Percentile returns an arbitrary percentile of values in the sample.

func (*ExpDecaySample) Percentiles ¶ 

func (s *ExpDecaySample) Percentiles(ps []float64) []float64

Percentiles returns a slice of arbitrary percentiles of values in the sample.

func (*ExpDecaySample) Size ¶ 

func (s *ExpDecaySample) Size() int

Size returns the size of the sample, which is at most the reservoir size.

func (*ExpDecaySample) Snapshot ¶ 

func (s *ExpDecaySample) Snapshot() Sample

Snapshot returns a read-only copy of the sample.

func (*ExpDecaySample) StdDev ¶ 

func (s *ExpDecaySample) StdDev() float64

StdDev returns the standard deviation of the values in the sample.

func (*ExpDecaySample) Sum ¶ 

func (s *ExpDecaySample) Sum() int64

Sum returns the sum of the values in the sample.

func (*ExpDecaySample) Update ¶ 

func (s *ExpDecaySample) Update(v int64)

Update samples a new value.

func (*ExpDecaySample) Values ¶ 

func (s *ExpDecaySample) Values() []int64

Values returns a copy of the values in the sample.

func (*ExpDecaySample) Variance ¶ 

func (s *ExpDecaySample) Variance() float64

Variance returns the variance of the values in the sample.

type FunctionalGauge ¶ 

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

FunctionalGauge returns value from given function

func (FunctionalGauge) Dec ¶ 

func (FunctionalGauge) Dec(int64)

Dec panics.

func (FunctionalGauge) Inc ¶ 

func (FunctionalGauge) Inc(int64)

Inc panics.

func (FunctionalGauge) Snapshot ¶ 

func (g FunctionalGauge) Snapshot() Gauge

Snapshot returns the snapshot.

func (FunctionalGauge) Update ¶ 

func (FunctionalGauge) Update(int64)

Update panics.

func (FunctionalGauge) Value ¶ 

func (g FunctionalGauge) Value() int64

Value returns the gauge's current value.

type FunctionalGaugeFloat64 ¶ 

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

FunctionalGaugeFloat64 returns value from given function

func (FunctionalGaugeFloat64) Snapshot ¶ 

func (g FunctionalGaugeFloat64) Snapshot() GaugeFloat64

Snapshot returns the snapshot.

func (FunctionalGaugeFloat64) Update ¶ 

func (FunctionalGaugeFloat64) Update(float64)

Update panics.

func (FunctionalGaugeFloat64) Value ¶ 

func (g FunctionalGaugeFloat64) Value() float64

Value returns the gauge's current value.

type Gauge ¶ 

type Gauge interface {
	Snapshot() Gauge
	Update(int64)
	Dec(int64)
	Inc(int64)
	Value() int64
}

Gauges hold an int64 value that can be set arbitrarily.

func GetOrRegisterGauge ¶ 

func GetOrRegisterGauge(name string, r Registry) Gauge

GetOrRegisterGauge returns an existing Gauge or constructs and registers a new StandardGauge.

Example ¶ 
m := "server.bytes_sent"
g := GetOrRegisterGauge(m, nil)
g.Update(47)
fmt.Println(g.Value()) 

Output:

47

func NewFunctionalGauge ¶ 

func NewFunctionalGauge(f func() int64) Gauge

NewFunctionalGauge constructs a new FunctionalGauge.

func NewGauge ¶ 

func NewGauge() Gauge

NewGauge constructs a new StandardGauge.

func NewRegisteredFunctionalGauge ¶ 

func NewRegisteredFunctionalGauge(name string, r Registry, f func() int64) Gauge

NewRegisteredFunctionalGauge constructs and registers a new StandardGauge.

func NewRegisteredGauge ¶ 

func NewRegisteredGauge(name string, r Registry) Gauge

NewRegisteredGauge constructs and registers a new StandardGauge.

type GaugeFloat64 ¶ 

type GaugeFloat64 interface {
	Snapshot() GaugeFloat64
	Update(float64)
	Value() float64
}

GaugeFloat64s hold a float64 value that can be set arbitrarily.

func GetOrRegisterGaugeFloat64 ¶ 

func GetOrRegisterGaugeFloat64(name string, r Registry) GaugeFloat64

GetOrRegisterGaugeFloat64 returns an existing GaugeFloat64 or constructs and registers a new StandardGaugeFloat64.

func NewFunctionalGaugeFloat64 ¶ 

func NewFunctionalGaugeFloat64(f func() float64) GaugeFloat64

NewFunctionalGauge constructs a new FunctionalGauge.

func NewGaugeFloat64 ¶ 

func NewGaugeFloat64() GaugeFloat64

NewGaugeFloat64 constructs a new StandardGaugeFloat64.

func NewRegisteredFunctionalGaugeFloat64 ¶ 

func NewRegisteredFunctionalGaugeFloat64(name string, r Registry, f func() float64) GaugeFloat64

NewRegisteredFunctionalGauge constructs and registers a new StandardGauge.

func NewRegisteredGaugeFloat64 ¶ 

func NewRegisteredGaugeFloat64(name string, r Registry) GaugeFloat64

NewRegisteredGaugeFloat64 constructs and registers a new StandardGaugeFloat64.

type GaugeFloat64Snapshot ¶ 

type GaugeFloat64Snapshot float64

GaugeFloat64Snapshot is a read-only copy of another GaugeFloat64.

func (GaugeFloat64Snapshot) Snapshot ¶ 

func (g GaugeFloat64Snapshot) Snapshot() GaugeFloat64

Snapshot returns the snapshot.

func (GaugeFloat64Snapshot) Update ¶ 

func (GaugeFloat64Snapshot) Update(float64)

Update panics.

func (GaugeFloat64Snapshot) Value ¶ 

func (g GaugeFloat64Snapshot) Value() float64

Value returns the value at the time the snapshot was taken.

type GaugeSnapshot ¶ 

type GaugeSnapshot int64

GaugeSnapshot is a read-only copy of another Gauge.

func (GaugeSnapshot) Dec ¶ 

func (GaugeSnapshot) Dec(int64)

Dec panics.

func (GaugeSnapshot) Inc ¶ 

func (GaugeSnapshot) Inc(int64)

Inc panics.

func (GaugeSnapshot) Snapshot ¶ 

func (g GaugeSnapshot) Snapshot() Gauge

Snapshot returns the snapshot.

func (GaugeSnapshot) Update ¶ 

func (GaugeSnapshot) Update(int64)

Update panics.

func (GaugeSnapshot) Value ¶ 

func (g GaugeSnapshot) Value() int64

Value returns the value at the time the snapshot was taken.

type GraphiteConfig ¶ 

type GraphiteConfig struct {
	Addr          *net.TCPAddr  // Network address to connect to
	Registry      Registry      // Registry to be exported
	FlushInterval time.Duration // Flush interval
	DurationUnit  time.Duration // Time conversion unit for durations
	Prefix        string        // Prefix to be prepended to metric names
	Percentiles   []float64     // Percentiles to export from timers and histograms
}

GraphiteConfig provides a container with configuration parameters for the Graphite exporter

type Healthcheck ¶ 

type Healthcheck interface {
	Check()
	Error() error
	Healthy()
	Unhealthy(error)
}

Healthchecks hold an error value describing an arbitrary up/down status.

func NewHealthcheck ¶ 

func NewHealthcheck(f func(Healthcheck)) Healthcheck

NewHealthcheck constructs a new Healthcheck which will use the given function to update its status.

type Histogram ¶ 

type Histogram interface {
	Clear()
	Count() int64
	Max() int64
	Mean() float64
	Min() int64
	Percentile(float64) float64
	Percentiles([]float64) []float64
	Sample() Sample
	Snapshot() Histogram
	StdDev() float64
	Sum() int64
	Update(int64)
	Variance() float64
}

Histograms calculate distribution statistics from a series of int64 values.

func GetOrRegisterHistogram ¶ 

func GetOrRegisterHistogram(name string, r Registry, s Sample) Histogram

GetOrRegisterHistogram returns an existing Histogram or constructs and registers a new StandardHistogram.

func NewHistogram ¶ 

func NewHistogram(s Sample) Histogram

NewHistogram constructs a new StandardHistogram from a Sample.

func NewRegisteredHistogram ¶ 

func NewRegisteredHistogram(name string, r Registry, s Sample) Histogram

NewRegisteredHistogram constructs and registers a new StandardHistogram from a Sample.

type HistogramSnapshot ¶ 

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

HistogramSnapshot is a read-only copy of another Histogram.

func (*HistogramSnapshot) Clear ¶ 

func (*HistogramSnapshot) Clear()

Clear panics.

func (*HistogramSnapshot) Count ¶ 

func (h *HistogramSnapshot) Count() int64

Count returns the number of samples recorded at the time the snapshot was taken.

func (*HistogramSnapshot) Max ¶ 

func (h *HistogramSnapshot) Max() int64

Max returns the maximum value in the sample at the time the snapshot was taken.

func (*HistogramSnapshot) Mean ¶ 

func (h *HistogramSnapshot) Mean() float64

Mean returns the mean of the values in the sample at the time the snapshot was taken.

func (*HistogramSnapshot) Min ¶ 

func (h *HistogramSnapshot) Min() int64

Min returns the minimum value in the sample at the time the snapshot was taken.

func (*HistogramSnapshot) Percentile ¶ 

func (h *HistogramSnapshot) Percentile(p float64) float64

Percentile returns an arbitrary percentile of values in the sample at the time the snapshot was taken.

func (*HistogramSnapshot) Percentiles ¶ 

func (h *HistogramSnapshot) Percentiles(ps []float64) []float64

Percentiles returns a slice of arbitrary percentiles of values in the sample at the time the snapshot was taken.

func (*HistogramSnapshot) Sample ¶ 

func (h *HistogramSnapshot) Sample() Sample

Sample returns the Sample underlying the histogram.

func (*HistogramSnapshot) Snapshot ¶ 

func (h *HistogramSnapshot) Snapshot() Histogram

Snapshot returns the snapshot.

func (*HistogramSnapshot) StdDev ¶ 

func (h *HistogramSnapshot) StdDev() float64

StdDev returns the standard deviation of the values in the sample at the time the snapshot was taken.

func (*HistogramSnapshot) Sum ¶ 

func (h *HistogramSnapshot) Sum() int64

Sum returns the sum in the sample at the time the snapshot was taken.

func (*HistogramSnapshot) Update ¶ 

func (*HistogramSnapshot) Update(int64)

Update panics.

func (*HistogramSnapshot) Variance ¶ 

func (h *HistogramSnapshot) Variance() float64

Variance returns the variance of inputs at the time the snapshot was taken.

type Int64Slice ¶ 

type Int64Slice []int64

Int64Slice attaches the methods of sort.Interface to []int64, sorting in increasing order.

func (Int64Slice) Len ¶ 

func (s Int64Slice) Len() int

func (Int64Slice) Less ¶ 

func (s Int64Slice) Less(i, j int) bool

func (Int64Slice) Swap ¶ 

func (s Int64Slice) Swap(i, j int)

type Logger ¶ 

type Logger interface {
	Printf(format string, v ...interface{})
}

type Meter ¶ 

type Meter interface {
	Count() int64
	Mark(int64)
	Rate1() float64
	Rate5() float64
	Rate15() float64
	RateMean() float64
	Snapshot() Meter
	Stop()
}

Meters count events to produce exponentially-weighted moving average rates at one-, five-, and fifteen-minutes and a mean rate.

func GetOrRegisterMeter ¶ 

func GetOrRegisterMeter(name string, r Registry) Meter

GetOrRegisterMeter returns an existing Meter or constructs and registers a new StandardMeter. Be sure to unregister the meter from the registry once it is of no use to allow for garbage collection.

func GetOrRegisterMeterForced ¶ 

func GetOrRegisterMeterForced(name string, r Registry) Meter

GetOrRegisterMeterForced returns an existing Meter or constructs and registers a new StandardMeter no matter the global switch is enabled or not. Be sure to unregister the meter from the registry once it is of no use to allow for garbage collection.

func NewMeter ¶ 

func NewMeter() Meter

NewMeter constructs a new StandardMeter and launches a goroutine. Be sure to call Stop() once the meter is of no use to allow for garbage collection.

func NewMeterForced ¶ 

func NewMeterForced() Meter

NewMeterForced constructs a new StandardMeter and launches a goroutine no matter the global switch is enabled or not. Be sure to call Stop() once the meter is of no use to allow for garbage collection.

func NewRegisteredMeter ¶ 

func NewRegisteredMeter(name string, r Registry) Meter

NewRegisteredMeter constructs and registers a new StandardMeter and launches a goroutine. Be sure to unregister the meter from the registry once it is of no use to allow for garbage collection.

func NewRegisteredMeterForced ¶ 

func NewRegisteredMeterForced(name string, r Registry) Meter

NewRegisteredMeterForced constructs and registers a new StandardMeter and launches a goroutine no matter the global switch is enabled or not. Be sure to unregister the meter from the registry once it is of no use to allow for garbage collection.

type MeterSnapshot ¶ 

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

MeterSnapshot is a read-only copy of another Meter.

func (*MeterSnapshot) Count ¶ 

func (m *MeterSnapshot) Count() int64

Count returns the count of events at the time the snapshot was taken.

func (*MeterSnapshot) Mark ¶ 

func (*MeterSnapshot) Mark(n int64)

Mark panics.

func (*MeterSnapshot) Rate1 ¶ 

func (m *MeterSnapshot) Rate1() float64

Rate1 returns the one-minute moving average rate of events per second at the time the snapshot was taken.

func (*MeterSnapshot) Rate15 ¶ 

func (m *MeterSnapshot) Rate15() float64

Rate15 returns the fifteen-minute moving average rate of events per second at the time the snapshot was taken.

func (*MeterSnapshot) Rate5 ¶ 

func (m *MeterSnapshot) Rate5() float64

Rate5 returns the five-minute moving average rate of events per second at the time the snapshot was taken.

func (*MeterSnapshot) RateMean ¶ 

func (m *MeterSnapshot) RateMean() float64

RateMean returns the meter's mean rate of events per second at the time the snapshot was taken.

func (*MeterSnapshot) Snapshot ¶ 

func (m *MeterSnapshot) Snapshot() Meter

Snapshot returns the snapshot.

func (*MeterSnapshot) Stop ¶ 

func (m *MeterSnapshot) Stop()

Stop is a no-op.

type NilCounter ¶ 

type NilCounter struct{}

NilCounter is a no-op Counter.

func (NilCounter) Clear ¶ 

func (NilCounter) Clear()

Clear is a no-op.

func (NilCounter) Count ¶ 

func (NilCounter) Count() int64

Count is a no-op.

func (NilCounter) Dec ¶ 

func (NilCounter) Dec(i int64)

Dec is a no-op.

func (NilCounter) Inc ¶ 

func (NilCounter) Inc(i int64)

Inc is a no-op.

func (NilCounter) Snapshot ¶ 

func (NilCounter) Snapshot() Counter

Snapshot is a no-op.

type NilEWMA ¶ 

type NilEWMA struct{}

NilEWMA is a no-op EWMA.

func (NilEWMA) Rate ¶ 

func (NilEWMA) Rate() float64

Rate is a no-op.

func (NilEWMA) Snapshot ¶ 

func (NilEWMA) Snapshot() EWMA

Snapshot is a no-op.

func (NilEWMA) Tick ¶ 

func (NilEWMA) Tick()

Tick is a no-op.

func (NilEWMA) Update ¶ 

func (NilEWMA) Update(n int64)

Update is a no-op.

type NilGauge ¶ 

type NilGauge struct{}

NilGauge is a no-op Gauge.

func (NilGauge) Dec ¶ 

func (NilGauge) Dec(i int64)

Dec is a no-op.

func (NilGauge) Inc ¶ 

func (NilGauge) Inc(i int64)

Inc is a no-op.

func (NilGauge) Snapshot ¶ 

func (NilGauge) Snapshot() Gauge

Snapshot is a no-op.

func (NilGauge) Update ¶ 

func (NilGauge) Update(v int64)

Update is a no-op.

func (NilGauge) Value ¶ 

func (NilGauge) Value() int64

Value is a no-op.

type NilGaugeFloat64 ¶ 

type NilGaugeFloat64 struct{}

NilGauge is a no-op Gauge.

func (NilGaugeFloat64) Snapshot ¶ 

func (NilGaugeFloat64) Snapshot() GaugeFloat64

Snapshot is a no-op.

func (NilGaugeFloat64) Update ¶ 

func (NilGaugeFloat64) Update(v float64)

Update is a no-op.

func (NilGaugeFloat64) Value ¶ 

func (NilGaugeFloat64) Value() float64

Value is a no-op.

type NilHealthcheck ¶ 

type NilHealthcheck struct{}

NilHealthcheck is a no-op.

func (NilHealthcheck) Check ¶ 

func (NilHealthcheck) Check()

Check is a no-op.

func (NilHealthcheck) Error ¶ 

func (NilHealthcheck) Error() error

Error is a no-op.

func (NilHealthcheck) Healthy ¶ 

func (NilHealthcheck) Healthy()

Healthy is a no-op.

func (NilHealthcheck) Unhealthy ¶ 

func (NilHealthcheck) Unhealthy(error)

Unhealthy is a no-op.

type NilHistogram ¶ 

type NilHistogram struct{}

NilHistogram is a no-op Histogram.

func (NilHistogram) Clear ¶ 

func (NilHistogram) Clear()

Clear is a no-op.

func (NilHistogram) Count ¶ 

func (NilHistogram) Count() int64

Count is a no-op.

func (NilHistogram) Max ¶ 

func (NilHistogram) Max() int64

Max is a no-op.

func (NilHistogram) Mean ¶ 

func (NilHistogram) Mean() float64

Mean is a no-op.

func (NilHistogram) Min ¶ 

func (NilHistogram) Min() int64

Min is a no-op.

func (NilHistogram) Percentile ¶ 

func (NilHistogram) Percentile(p float64) float64

Percentile is a no-op.

func (NilHistogram) Percentiles ¶ 

func (NilHistogram) Percentiles(ps []float64) []float64

Percentiles is a no-op.

func (NilHistogram) Sample ¶ 

func (NilHistogram) Sample() Sample

Sample is a no-op.

func (NilHistogram) Snapshot ¶ 

func (NilHistogram) Snapshot() Histogram

Snapshot is a no-op.

func (NilHistogram) StdDev ¶ 

func (NilHistogram) StdDev() float64

StdDev is a no-op.

func (NilHistogram) Sum ¶ 

func (NilHistogram) Sum() int64

Sum is a no-op.

func (NilHistogram) Update ¶ 

func (NilHistogram) Update(v int64)

Update is a no-op.

func (NilHistogram) Variance ¶ 

func (NilHistogram) Variance() float64

Variance is a no-op.

type NilMeter ¶ 

type NilMeter struct{}

NilMeter is a no-op Meter.

func (NilMeter) Count ¶ 

func (NilMeter) Count() int64

Count is a no-op.

func (NilMeter) Mark ¶ 

func (NilMeter) Mark(n int64)

Mark is a no-op.

func (NilMeter) Rate1 ¶ 

func (NilMeter) Rate1() float64

Rate1 is a no-op.

func (NilMeter) Rate15 ¶ 

func (NilMeter) Rate15() float64

Rate15 is a no-op.

func (NilMeter) Rate5 ¶ 

func (NilMeter) Rate5() float64

Rate5 is a no-op.

func (NilMeter) RateMean ¶ 

func (NilMeter) RateMean() float64

RateMean is a no-op.

func (NilMeter) Snapshot ¶ 

func (NilMeter) Snapshot() Meter

Snapshot is a no-op.

func (NilMeter) Stop ¶ 

func (NilMeter) Stop()

Stop is a no-op.

type NilResettingTimer ¶ 

type NilResettingTimer struct {
}

NilResettingTimer is a no-op ResettingTimer.

func (NilResettingTimer) Mean ¶ 

func (NilResettingTimer) Mean() float64

Mean panics.

func (NilResettingTimer) Percentiles ¶ 

func (NilResettingTimer) Percentiles([]float64) []int64

Percentiles panics.

func (NilResettingTimer) Snapshot ¶ 

func (NilResettingTimer) Snapshot() ResettingTimer

Snapshot is a no-op.

func (NilResettingTimer) Time ¶ 

func (NilResettingTimer) Time(func())

Time is a no-op.

func (NilResettingTimer) Update ¶ 

func (NilResettingTimer) Update(time.Duration)

Update is a no-op.

func (NilResettingTimer) UpdateSince ¶ 

func (NilResettingTimer) UpdateSince(time.Time)

UpdateSince is a no-op.

func (NilResettingTimer) Values ¶ 

func (NilResettingTimer) Values() []int64

Values is a no-op.

type NilSample ¶ 

type NilSample struct{}

NilSample is a no-op Sample.

func (NilSample) Clear ¶ 

func (NilSample) Clear()

Clear is a no-op.

func (NilSample) Count ¶ 

func (NilSample) Count() int64

Count is a no-op.

func (NilSample) Max ¶ 

func (NilSample) Max() int64

Max is a no-op.

func (NilSample) Mean ¶ 

func (NilSample) Mean() float64

Mean is a no-op.

func (NilSample) Min ¶ 

func (NilSample) Min() int64

Min is a no-op.

func (NilSample) Percentile ¶ 

func (NilSample) Percentile(p float64) float64

Percentile is a no-op.

func (NilSample) Percentiles ¶ 

func (NilSample) Percentiles(ps []float64) []float64

Percentiles is a no-op.

func (NilSample) Size ¶ 

func (NilSample) Size() int

Size is a no-op.

func (NilSample) Snapshot ¶ 

func (NilSample) Snapshot() Sample

Sample is a no-op.

func (NilSample) StdDev ¶ 

func (NilSample) StdDev() float64

StdDev is a no-op.

func (NilSample) Sum ¶ 

func (NilSample) Sum() int64

Sum is a no-op.

func (NilSample) Update ¶ 

func (NilSample) Update(v int64)

Update is a no-op.

func (NilSample) Values ¶ 

func (NilSample) Values() []int64

Values is a no-op.

func (NilSample) Variance ¶ 

func (NilSample) Variance() float64

Variance is a no-op.

type NilTimer ¶ 

type NilTimer struct{}

NilTimer is a no-op Timer.

func (NilTimer) Count ¶ 

func (NilTimer) Count() int64

Count is a no-op.

func (NilTimer) Max ¶ 

func (NilTimer) Max() int64

Max is a no-op.

func (NilTimer) Mean ¶ 

func (NilTimer) Mean() float64

Mean is a no-op.

func (NilTimer) Min ¶ 

func (NilTimer) Min() int64

Min is a no-op.

func (NilTimer) Percentile ¶ 

func (NilTimer) Percentile(p float64) float64

Percentile is a no-op.

func (NilTimer) Percentiles ¶ 

func (NilTimer) Percentiles(ps []float64) []float64

Percentiles is a no-op.

func (NilTimer) Rate1 ¶ 

func (NilTimer) Rate1() float64

Rate1 is a no-op.

func (NilTimer) Rate15 ¶ 

func (NilTimer) Rate15() float64

Rate15 is a no-op.

func (NilTimer) Rate5 ¶ 

func (NilTimer) Rate5() float64

Rate5 is a no-op.

func (NilTimer) RateMean ¶ 

func (NilTimer) RateMean() float64

RateMean is a no-op.

func (NilTimer) Snapshot ¶ 

func (NilTimer) Snapshot() Timer

Snapshot is a no-op.

func (NilTimer) StdDev ¶ 

func (NilTimer) StdDev() float64

StdDev is a no-op.

func (NilTimer) Stop ¶ 

func (NilTimer) Stop()

Stop is a no-op.

func (NilTimer) Sum ¶ 

func (NilTimer) Sum() int64

Sum is a no-op.

func (NilTimer) Time ¶ 

func (NilTimer) Time(func())

Time is a no-op.

func (NilTimer) Update ¶ 

func (NilTimer) Update(time.Duration)

Update is a no-op.

func (NilTimer) UpdateSince ¶ 

func (NilTimer) UpdateSince(time.Time)

UpdateSince is a no-op.

func (NilTimer) Variance ¶ 

func (NilTimer) Variance() float64

Variance is a no-op.

type OpenTSDBConfig ¶ 

type OpenTSDBConfig struct {
	Addr          *net.TCPAddr  // Network address to connect to
	Registry      Registry      // Registry to be exported
	FlushInterval time.Duration // Flush interval
	DurationUnit  time.Duration // Time conversion unit for durations
	Prefix        string        // Prefix to be prepended to metric names
}

OpenTSDBConfig provides a container with configuration parameters for the OpenTSDB exporter

type PrefixedRegistry ¶ 

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

func (*PrefixedRegistry) Each ¶ 

func (r *PrefixedRegistry) Each(fn func(string, interface{}))

Call the given function for each registered metric.

func (*PrefixedRegistry) Get ¶ 

func (r *PrefixedRegistry) Get(name string) interface{}

Get the metric by the given name or nil if none is registered.

func (*PrefixedRegistry) GetAll ¶ 

func (r *PrefixedRegistry) GetAll() map[string]map[string]interface{}

GetAll metrics in the Registry

func (*PrefixedRegistry) GetOrRegister ¶ 

func (r *PrefixedRegistry) GetOrRegister(name string, metric interface{}) interface{}

Gets an existing metric or registers the given one. The interface can be the metric to register if not found in registry, or a function returning the metric for lazy instantiation.

func (*PrefixedRegistry) MarshalJSON ¶ 

func (p *PrefixedRegistry) MarshalJSON() ([]byte, error)

func (*PrefixedRegistry) Register ¶ 

func (r *PrefixedRegistry) Register(name string, metric interface{}) error

Register the given metric under the given name. The name will be prefixed.

func (*PrefixedRegistry) RunHealthchecks ¶ 

func (r *PrefixedRegistry) RunHealthchecks()

Run all registered healthchecks.

func (*PrefixedRegistry) Unregister ¶ 

func (r *PrefixedRegistry) Unregister(name string)

Unregister the metric with the given name. The name will be prefixed.

func (*PrefixedRegistry) UnregisterAll ¶ 

func (r *PrefixedRegistry) UnregisterAll()

Unregister all metrics. (Mostly for testing.)

type Registry ¶ 

type Registry interface {

	// Call the given function for each registered metric.
	Each(func(string, interface{}))

	// Get the metric by the given name or nil if none is registered.
	Get(string) interface{}

	// GetAll metrics in the Registry.
	GetAll() map[string]map[string]interface{}

	// Gets an existing metric or registers the given one.
	// The interface can be the metric to register if not found in registry,
	// or a function returning the metric for lazy instantiation.
	GetOrRegister(string, interface{}) interface{}

	// Register the given metric under the given name.
	Register(string, interface{}) error

	// Run all registered healthchecks.
	RunHealthchecks()

	// Unregister the metric with the given name.
	Unregister(string)

	// Unregister all metrics.  (Mostly for testing.)
	UnregisterAll()
}

A Registry holds references to a set of metrics by name and can iterate over them, calling callback functions provided by the user.

This is an interface so as to encourage other structs to implement the Registry API as appropriate.

func NewPrefixedChildRegistry ¶ 

func NewPrefixedChildRegistry(parent Registry, prefix string) Registry

func NewPrefixedRegistry ¶ 

func NewPrefixedRegistry(prefix string) Registry

func NewRegistry ¶ 

func NewRegistry() Registry

Create a new registry.

type ResettingTimer ¶ 

type ResettingTimer interface {
	Values() []int64
	Snapshot() ResettingTimer
	Percentiles([]float64) []int64
	Mean() float64
	Time(func())
	Update(time.Duration)
	UpdateSince(time.Time)
}

ResettingTimer is used for storing aggregated values for timers, which are reset on every flush interval.

func GetOrRegisterResettingTimer ¶ 

func GetOrRegisterResettingTimer(name string, r Registry) ResettingTimer

GetOrRegisterResettingTimer returns an existing ResettingTimer or constructs and registers a new StandardResettingTimer.

func NewRegisteredResettingTimer ¶ 

func NewRegisteredResettingTimer(name string, r Registry) ResettingTimer

NewRegisteredResettingTimer constructs and registers a new StandardResettingTimer.

func NewResettingTimer ¶ 

func NewResettingTimer() ResettingTimer

NewResettingTimer constructs a new StandardResettingTimer

type ResettingTimerSnapshot ¶ 

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

ResettingTimerSnapshot is a point-in-time copy of another ResettingTimer.

func (*ResettingTimerSnapshot) Mean ¶ 

func (t *ResettingTimerSnapshot) Mean() float64

Mean returns the mean of the snapshotted values

func (*ResettingTimerSnapshot) Percentiles ¶ 

func (t *ResettingTimerSnapshot) Percentiles(percentiles []float64) []int64

Percentiles returns the boundaries for the input percentiles.

func (*ResettingTimerSnapshot) Snapshot ¶ 

func (t *ResettingTimerSnapshot) Snapshot() ResettingTimer

Snapshot returns the snapshot.

func (*ResettingTimerSnapshot) Time ¶ 

func (*ResettingTimerSnapshot) Time(func())

Time panics.

func (*ResettingTimerSnapshot) Update ¶ 

func (*ResettingTimerSnapshot) Update(time.Duration)

Update panics.

func (*ResettingTimerSnapshot) UpdateSince ¶ 

func (*ResettingTimerSnapshot) UpdateSince(time.Time)

UpdateSince panics.

func (*ResettingTimerSnapshot) Values ¶ 

func (t *ResettingTimerSnapshot) Values() []int64

Values returns all values from snapshot.

type Sample ¶ 

type Sample interface {
	Clear()
	Count() int64
	Max() int64
	Mean() float64
	Min() int64
	Percentile(float64) float64
	Percentiles([]float64) []float64
	Size() int
	Snapshot() Sample
	StdDev() float64
	Sum() int64
	Update(int64)
	Values() []int64
	Variance() float64
}

Samples maintain a statistically-significant selection of values from a stream.

func NewExpDecaySample ¶ 

func NewExpDecaySample(reservoirSize int, alpha float64) Sample

NewExpDecaySample constructs a new exponentially-decaying sample with the given reservoir size and alpha.

func NewUniformSample ¶ 

func NewUniformSample(reservoirSize int) Sample

NewUniformSample constructs a new uniform sample with the given reservoir size.

type SampleSnapshot ¶ 

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

SampleSnapshot is a read-only copy of another Sample.

func NewSampleSnapshot ¶ 

func NewSampleSnapshot(count int64, values []int64) *SampleSnapshot

func (*SampleSnapshot) Clear ¶ 

func (*SampleSnapshot) Clear()

Clear panics.

func (*SampleSnapshot) Count ¶ 

func (s *SampleSnapshot) Count() int64

Count returns the count of inputs at the time the snapshot was taken.

func (*SampleSnapshot) Max ¶ 

func (s *SampleSnapshot) Max() int64

Max returns the maximal value at the time the snapshot was taken.

func (*SampleSnapshot) Mean ¶ 

func (s *SampleSnapshot) Mean() float64

Mean returns the mean value at the time the snapshot was taken.

func (*SampleSnapshot) Min ¶ 

func (s *SampleSnapshot) Min() int64

Min returns the minimal value at the time the snapshot was taken.

func (*SampleSnapshot) Percentile ¶ 

func (s *SampleSnapshot) Percentile(p float64) float64

Percentile returns an arbitrary percentile of values at the time the snapshot was taken.

func (*SampleSnapshot) Percentiles ¶ 

func (s *SampleSnapshot) Percentiles(ps []float64) []float64

Percentiles returns a slice of arbitrary percentiles of values at the time the snapshot was taken.

func (*SampleSnapshot) Size ¶ 

func (s *SampleSnapshot) Size() int

Size returns the size of the sample at the time the snapshot was taken.

func (*SampleSnapshot) Snapshot ¶ 

func (s *SampleSnapshot) Snapshot() Sample

Snapshot returns the snapshot.

func (*SampleSnapshot) StdDev ¶ 

func (s *SampleSnapshot) StdDev() float64

StdDev returns the standard deviation of values at the time the snapshot was taken.

func (*SampleSnapshot) Sum ¶ 

func (s *SampleSnapshot) Sum() int64

Sum returns the sum of values at the time the snapshot was taken.

func (*SampleSnapshot) Update ¶ 

func (*SampleSnapshot) Update(int64)

Update panics.

func (*SampleSnapshot) Values ¶ 

func (s *SampleSnapshot) Values() []int64

Values returns a copy of the values in the sample.

func (*SampleSnapshot) Variance ¶ 

func (s *SampleSnapshot) Variance() float64

Variance returns the variance of values at the time the snapshot was taken.

type StandardCounter ¶ 

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

StandardCounter is the standard implementation of a Counter and uses the sync/atomic package to manage a single int64 value.

func (*StandardCounter) Clear ¶ 

func (c *StandardCounter) Clear()

Clear sets the counter to zero.

func (*StandardCounter) Count ¶ 

func (c *StandardCounter) Count() int64

Count returns the current count.

func (*StandardCounter) Dec ¶ 

func (c *StandardCounter) Dec(i int64)

Dec decrements the counter by the given amount.

func (*StandardCounter) Inc ¶ 

func (c *StandardCounter) Inc(i int64)

Inc increments the counter by the given amount.

func (*StandardCounter) Snapshot ¶ 

func (c *StandardCounter) Snapshot() Counter

Snapshot returns a read-only copy of the counter.

type StandardEWMA ¶ 

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

StandardEWMA is the standard implementation of an EWMA and tracks the number of uncounted events and processes them on each tick. It uses the sync/atomic package to manage uncounted events.

func (*StandardEWMA) Rate ¶ 

func (a *StandardEWMA) Rate() float64

Rate returns the moving average rate of events per second.

func (*StandardEWMA) Snapshot ¶ 

func (a *StandardEWMA) Snapshot() EWMA

Snapshot returns a read-only copy of the EWMA.

func (*StandardEWMA) Tick ¶ 

func (a *StandardEWMA) Tick()

Tick ticks the clock to update the moving average. It assumes it is called every five seconds.

func (*StandardEWMA) Update ¶ 

func (a *StandardEWMA) Update(n int64)

Update adds n uncounted events.

type StandardGauge ¶ 

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

StandardGauge is the standard implementation of a Gauge and uses the sync/atomic package to manage a single int64 value.

func (*StandardGauge) Dec ¶ 

func (g *StandardGauge) Dec(i int64)

Dec decrements the gauge's current value by the given amount.

func (*StandardGauge) Inc ¶ 

func (g *StandardGauge) Inc(i int64)

Inc increments the gauge's current value by the given amount.

func (*StandardGauge) Snapshot ¶ 

func (g *StandardGauge) Snapshot() Gauge

Snapshot returns a read-only copy of the gauge.

func (*StandardGauge) Update ¶ 

func (g *StandardGauge) Update(v int64)

Update updates the gauge's value.

func (*StandardGauge) Value ¶ 

func (g *StandardGauge) Value() int64

Value returns the gauge's current value.

type StandardGaugeFloat64 ¶ 

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

StandardGaugeFloat64 is the standard implementation of a GaugeFloat64 and uses sync.Mutex to manage a single float64 value.

func (*StandardGaugeFloat64) Snapshot ¶ 

func (g *StandardGaugeFloat64) Snapshot() GaugeFloat64

Snapshot returns a read-only copy of the gauge.

func (*StandardGaugeFloat64) Update ¶ 

func (g *StandardGaugeFloat64) Update(v float64)

Update updates the gauge's value.

func (*StandardGaugeFloat64) Value ¶ 

func (g *StandardGaugeFloat64) Value() float64

Value returns the gauge's current value.

type StandardHealthcheck ¶ 

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

StandardHealthcheck is the standard implementation of a Healthcheck and stores the status and a function to call to update the status.

func (*StandardHealthcheck) Check ¶ 

func (h *StandardHealthcheck) Check()

Check runs the healthcheck function to update the healthcheck's status.

func (*StandardHealthcheck) Error ¶ 

func (h *StandardHealthcheck) Error() error

Error returns the healthcheck's status, which will be nil if it is healthy.

func (*StandardHealthcheck) Healthy ¶ 

func (h *StandardHealthcheck) Healthy()

Healthy marks the healthcheck as healthy.

func (*StandardHealthcheck) Unhealthy ¶ 

func (h *StandardHealthcheck) Unhealthy(err error)

Unhealthy marks the healthcheck as unhealthy. The error is stored and may be retrieved by the Error method.

type StandardHistogram ¶ 

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

StandardHistogram is the standard implementation of a Histogram and uses a Sample to bound its memory use.

func (*StandardHistogram) Clear ¶ 

func (h *StandardHistogram) Clear()

Clear clears the histogram and its sample.

func (*StandardHistogram) Count ¶ 

func (h *StandardHistogram) Count() int64

Count returns the number of samples recorded since the histogram was last cleared.

func (*StandardHistogram) Max ¶ 

func (h *StandardHistogram) Max() int64

Max returns the maximum value in the sample.

func (*StandardHistogram) Mean ¶ 

func (h *StandardHistogram) Mean() float64

Mean returns the mean of the values in the sample.

func (*StandardHistogram) Min ¶ 

func (h *StandardHistogram) Min() int64

Min returns the minimum value in the sample.

func (*StandardHistogram) Percentile ¶ 

func (h *StandardHistogram) Percentile(p float64) float64

Percentile returns an arbitrary percentile of the values in the sample.

func (*StandardHistogram) Percentiles ¶ 

func (h *StandardHistogram) Percentiles(ps []float64) []float64

Percentiles returns a slice of arbitrary percentiles of the values in the sample.

func (*StandardHistogram) Sample ¶ 

func (h *StandardHistogram) Sample() Sample

Sample returns the Sample underlying the histogram.

func (*StandardHistogram) Snapshot ¶ 

func (h *StandardHistogram) Snapshot() Histogram

Snapshot returns a read-only copy of the histogram.

func (*StandardHistogram) StdDev ¶ 

func (h *StandardHistogram) StdDev() float64

StdDev returns the standard deviation of the values in the sample.

func (*StandardHistogram) Sum ¶ 

func (h *StandardHistogram) Sum() int64

Sum returns the sum in the sample.

func (*StandardHistogram) Update ¶ 

func (h *StandardHistogram) Update(v int64)

Update samples a new value.

func (*StandardHistogram) Variance ¶ 

func (h *StandardHistogram) Variance() float64

Variance returns the variance of the values in the sample.

type StandardMeter ¶ 

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

StandardMeter is the standard implementation of a Meter.

func (*StandardMeter) Count ¶ 

func (m *StandardMeter) Count() int64

Count returns the number of events recorded. It updates the meter to be as accurate as possible

func (*StandardMeter) Mark ¶ 

func (m *StandardMeter) Mark(n int64)

Mark records the occurrence of n events.

func (*StandardMeter) Rate1 ¶ 

func (m *StandardMeter) Rate1() float64

Rate1 returns the one-minute moving average rate of events per second.

func (*StandardMeter) Rate15 ¶ 

func (m *StandardMeter) Rate15() float64

Rate15 returns the fifteen-minute moving average rate of events per second.

func (*StandardMeter) Rate5 ¶ 

func (m *StandardMeter) Rate5() float64

Rate5 returns the five-minute moving average rate of events per second.

func (*StandardMeter) RateMean ¶ 

func (m *StandardMeter) RateMean() float64

RateMean returns the meter's mean rate of events per second.

func (*StandardMeter) Snapshot ¶ 

func (m *StandardMeter) Snapshot() Meter

Snapshot returns a read-only copy of the meter.

func (*StandardMeter) Stop ¶ 

func (m *StandardMeter) Stop()

Stop stops the meter, Mark() will be a no-op if you use it after being stopped.

type StandardRegistry ¶ 

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

The standard implementation of a Registry is a mutex-protected map of names to metrics.

func (*StandardRegistry) Each ¶ 

func (r *StandardRegistry) Each(f func(string, interface{}))

Call the given function for each registered metric.

func (*StandardRegistry) Get ¶ 

func (r *StandardRegistry) Get(name string) interface{}

Get the metric by the given name or nil if none is registered.

func (*StandardRegistry) GetAll ¶ 

func (r *StandardRegistry) GetAll() map[string]map[string]interface{}

GetAll metrics in the Registry

func (*StandardRegistry) GetOrRegister ¶ 

func (r *StandardRegistry) GetOrRegister(name string, i interface{}) interface{}

Gets an existing metric or creates and registers a new one. Threadsafe alternative to calling Get and Register on failure. The interface can be the metric to register if not found in registry, or a function returning the metric for lazy instantiation.

func (*StandardRegistry) MarshalJSON ¶ 

func (r *StandardRegistry) MarshalJSON() ([]byte, error)

MarshalJSON returns a byte slice containing a JSON representation of all the metrics in the Registry.

func (*StandardRegistry) Register ¶ 

func (r *StandardRegistry) Register(name string, i interface{}) error

Register the given metric under the given name. Returns a DuplicateMetric if a metric by the given name is already registered.

func (*StandardRegistry) RunHealthchecks ¶ 

func (r *StandardRegistry) RunHealthchecks()

Run all registered healthchecks.

func (*StandardRegistry) Unregister ¶ 

func (r *StandardRegistry) Unregister(name string)

Unregister the metric with the given name.

func (*StandardRegistry) UnregisterAll ¶ 

func (r *StandardRegistry) UnregisterAll()

Unregister all metrics. (Mostly for testing.)

type StandardResettingTimer ¶ 

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

StandardResettingTimer is the standard implementation of a ResettingTimer. and Meter.

func (*StandardResettingTimer) Mean ¶ 

func (t *StandardResettingTimer) Mean() float64

Mean panics.

func (*StandardResettingTimer) Percentiles ¶ 

func (t *StandardResettingTimer) Percentiles([]float64) []int64

Percentiles panics.

func (*StandardResettingTimer) Snapshot ¶ 

func (t *StandardResettingTimer) Snapshot() ResettingTimer

Snapshot resets the timer and returns a read-only copy of its contents.

func (*StandardResettingTimer) Time ¶ 

func (t *StandardResettingTimer) Time(f func())

Record the duration of the execution of the given function.

func (*StandardResettingTimer) Update ¶ 

func (t *StandardResettingTimer) Update(d time.Duration)

Record the duration of an event.

func (*StandardResettingTimer) UpdateSince ¶ 

func (t *StandardResettingTimer) UpdateSince(ts time.Time)

Record the duration of an event that started at a time and ends now.

func (*StandardResettingTimer) Values ¶ 

func (t *StandardResettingTimer) Values() []int64

Values returns a slice with all measurements.

type StandardTimer ¶ 

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

StandardTimer is the standard implementation of a Timer and uses a Histogram and Meter.

func (*StandardTimer) Count ¶ 

func (t *StandardTimer) Count() int64

Count returns the number of events recorded.

func (*StandardTimer) Max ¶ 

func (t *StandardTimer) Max() int64

Max returns the maximum value in the sample.

func (*StandardTimer) Mean ¶ 

func (t *StandardTimer) Mean() float64

Mean returns the mean of the values in the sample.

func (*StandardTimer) Min ¶ 

func (t *StandardTimer) Min() int64

Min returns the minimum value in the sample.

func (*StandardTimer) Percentile ¶ 

func (t *StandardTimer) Percentile(p float64) float64

Percentile returns an arbitrary percentile of the values in the sample.

func (*StandardTimer) Percentiles ¶ 

func (t *StandardTimer) Percentiles(ps []float64) []float64

Percentiles returns a slice of arbitrary percentiles of the values in the sample.

func (*StandardTimer) Rate1 ¶ 

func (t *StandardTimer) Rate1() float64

Rate1 returns the one-minute moving average rate of events per second.

func (*StandardTimer) Rate15 ¶ 

func (t *StandardTimer) Rate15() float64

Rate15 returns the fifteen-minute moving average rate of events per second.

func (*StandardTimer) Rate5 ¶ 

func (t *StandardTimer) Rate5() float64

Rate5 returns the five-minute moving average rate of events per second.

func (*StandardTimer) RateMean ¶ 

func (t *StandardTimer) RateMean() float64

RateMean returns the meter's mean rate of events per second.

func (*StandardTimer) Snapshot ¶ 

func (t *StandardTimer) Snapshot() Timer

Snapshot returns a read-only copy of the timer.

func (*StandardTimer) StdDev ¶ 

func (t *StandardTimer) StdDev() float64

StdDev returns the standard deviation of the values in the sample.

func (*StandardTimer) Stop ¶ 

func (t *StandardTimer) Stop()

Stop stops the meter.

func (*StandardTimer) Sum ¶ 

func (t *StandardTimer) Sum() int64

Sum returns the sum in the sample.

func (*StandardTimer) Time ¶ 

func (t *StandardTimer) Time(f func())

Record the duration of the execution of the given function.

func (*StandardTimer) Update ¶ 

func (t *StandardTimer) Update(d time.Duration)

Record the duration of an event.

func (*StandardTimer) UpdateSince ¶ 

func (t *StandardTimer) UpdateSince(ts time.Time)

Record the duration of an event that started at a time and ends now.

func (*StandardTimer) Variance ¶ 

func (t *StandardTimer) Variance() float64

Variance returns the variance of the values in the sample.

type Stoppable ¶ 

type Stoppable interface {
	Stop()
}

Stoppable defines the metrics which has to be stopped.

type Timer ¶ 

type Timer interface {
	Count() int64
	Max() int64
	Mean() float64
	Min() int64
	Percentile(float64) float64
	Percentiles([]float64) []float64
	Rate1() float64
	Rate5() float64
	Rate15() float64
	RateMean() float64
	Snapshot() Timer
	StdDev() float64
	Stop()
	Sum() int64
	Time(func())
	Update(time.Duration)
	UpdateSince(time.Time)
	Variance() float64
}

Timers capture the duration and rate of events.

func GetOrRegisterTimer ¶ 

func GetOrRegisterTimer(name string, r Registry) Timer

GetOrRegisterTimer returns an existing Timer or constructs and registers a new StandardTimer. Be sure to unregister the meter from the registry once it is of no use to allow for garbage collection.

Example ¶ 
m := "account.create.latency"
t := GetOrRegisterTimer(m, nil)
t.Update(47)
fmt.Println(t.Max()) 

Output:

47

func NewCustomTimer ¶ 

func NewCustomTimer(h Histogram, m Meter) Timer

NewCustomTimer constructs a new StandardTimer from a Histogram and a Meter. Be sure to call Stop() once the timer is of no use to allow for garbage collection.

func NewRegisteredTimer ¶ 

func NewRegisteredTimer(name string, r Registry) Timer

NewRegisteredTimer constructs and registers a new StandardTimer. Be sure to unregister the meter from the registry once it is of no use to allow for garbage collection.

func NewTimer ¶ 

func NewTimer() Timer

NewTimer constructs a new StandardTimer using an exponentially-decaying sample with the same reservoir size and alpha as UNIX load averages. Be sure to call Stop() once the timer is of no use to allow for garbage collection.

type TimerSnapshot ¶ 

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

TimerSnapshot is a read-only copy of another Timer.

func (*TimerSnapshot) Count ¶ 

func (t *TimerSnapshot) Count() int64

Count returns the number of events recorded at the time the snapshot was taken.

func (*TimerSnapshot) Max ¶ 

func (t *TimerSnapshot) Max() int64

Max returns the maximum value at the time the snapshot was taken.

func (*TimerSnapshot) Mean ¶ 

func (t *TimerSnapshot) Mean() float64

Mean returns the mean value at the time the snapshot was taken.

func (*TimerSnapshot) Min ¶ 

func (t *TimerSnapshot) Min() int64

Min returns the minimum value at the time the snapshot was taken.

func (*TimerSnapshot) Percentile ¶ 

func (t *TimerSnapshot) Percentile(p float64) float64

Percentile returns an arbitrary percentile of sampled values at the time the snapshot was taken.

func (*TimerSnapshot) Percentiles ¶ 

func (t *TimerSnapshot) Percentiles(ps []float64) []float64

Percentiles returns a slice of arbitrary percentiles of sampled values at the time the snapshot was taken.

func (*TimerSnapshot) Rate1 ¶ 

func (t *TimerSnapshot) Rate1() float64

Rate1 returns the one-minute moving average rate of events per second at the time the snapshot was taken.

func (*TimerSnapshot) Rate15 ¶ 

func (t *TimerSnapshot) Rate15() float64

Rate15 returns the fifteen-minute moving average rate of events per second at the time the snapshot was taken.

func (*TimerSnapshot) Rate5 ¶ 

func (t *TimerSnapshot) Rate5() float64

Rate5 returns the five-minute moving average rate of events per second at the time the snapshot was taken.

func (*TimerSnapshot) RateMean ¶ 

func (t *TimerSnapshot) RateMean() float64

RateMean returns the meter's mean rate of events per second at the time the snapshot was taken.

func (*TimerSnapshot) Snapshot ¶ 

func (t *TimerSnapshot) Snapshot() Timer

Snapshot returns the snapshot.

func (*TimerSnapshot) StdDev ¶ 

func (t *TimerSnapshot) StdDev() float64

StdDev returns the standard deviation of the values at the time the snapshot was taken.

func (*TimerSnapshot) Stop ¶ 

func (t *TimerSnapshot) Stop()

Stop is a no-op.

func (*TimerSnapshot) Sum ¶ 

func (t *TimerSnapshot) Sum() int64

Sum returns the sum at the time the snapshot was taken.

func (*TimerSnapshot) Time ¶ 

func (*TimerSnapshot) Time(func())

Time panics.

func (*TimerSnapshot) Update ¶ 

func (*TimerSnapshot) Update(time.Duration)

Update panics.

func (*TimerSnapshot) UpdateSince ¶ 

func (*TimerSnapshot) UpdateSince(time.Time)

UpdateSince panics.

func (*TimerSnapshot) Variance ¶ 

func (t *TimerSnapshot) Variance() float64

Variance returns the variance of the values at the time the snapshot was taken.

type UniformSample ¶ 

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

A uniform sample using Vitter's Algorithm R.

<http://www.cs.umd.edu/~samir/498/vitter.pdf>

func (*UniformSample) Clear ¶ 

func (s *UniformSample) Clear()

Clear clears all samples.

func (*UniformSample) Count ¶ 

func (s *UniformSample) Count() int64

Count returns the number of samples recorded, which may exceed the reservoir size.

func (*UniformSample) Max ¶ 

func (s *UniformSample) Max() int64

Max returns the maximum value in the sample, which may not be the maximum value ever to be part of the sample.

func (*UniformSample) Mean ¶ 

func (s *UniformSample) Mean() float64

Mean returns the mean of the values in the sample.

func (*UniformSample) Min ¶ 

func (s *UniformSample) Min() int64

Min returns the minimum value in the sample, which may not be the minimum value ever to be part of the sample.

func (*UniformSample) Percentile ¶ 

func (s *UniformSample) Percentile(p float64) float64

Percentile returns an arbitrary percentile of values in the sample.

func (*UniformSample) Percentiles ¶ 

func (s *UniformSample) Percentiles(ps []float64) []float64

Percentiles returns a slice of arbitrary percentiles of values in the sample.

func (*UniformSample) Size ¶ 

func (s *UniformSample) Size() int

Size returns the size of the sample, which is at most the reservoir size.

func (*UniformSample) Snapshot ¶ 

func (s *UniformSample) Snapshot() Sample

Snapshot returns a read-only copy of the sample.

func (*UniformSample) StdDev ¶ 

func (s *UniformSample) StdDev() float64

StdDev returns the standard deviation of the values in the sample.

func (*UniformSample) Sum ¶ 

func (s *UniformSample) Sum() int64

Sum returns the sum of the values in the sample.

func (*UniformSample) Update ¶ 

func (s *UniformSample) Update(v int64)

Update samples a new value.

func (*UniformSample) Values ¶ 

func (s *UniformSample) Values() []int64

Values returns a copy of the values in the sample.

func (*UniformSample) Variance ¶ 

func (s *UniformSample) Variance() float64

Variance returns the variance of the values in the sample.

Source Files ¶

View all Source files

Directories ¶

Path Synopsis
Hook go-metrics into expvar on any /debug/metrics request, load all vars from the registry into expvar, and execute regular expvar handler
 Hook go-metrics into expvar on any /debug/metrics request, load all vars from the registry into expvar, and execute regular expvar handler
Package prometheus exposes go-metrics into a Prometheus format.
 Package prometheus exposes go-metrics into a Prometheus format.

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.