modulepackage
0.0.0-20150217100310-5cdb2b7e0a19
Repository: https://github.com/geertjohan/go-metrics.git
Documentation: pkg.go.dev
# README
go-metrics
Go port of Coda Hale's Metrics library: https://github.com/codahale/metrics.
Documentation: http://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)
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)
Periodically log every metric in human-readable form to standard error:
go metrics.Log(metrics.DefaultRegistry, 60e9, 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:
addr, _ := net.ResolveTCPAddr("tcp", "127.0.0.1:2003")
go metrics.Graphite(metrics.DefaultRegistry, 10e9, "metrics", addr)
Periodically emit every metric into InfluxDB:
import "github.com/rcrowley/go-metrics/influxdb"
go influxdb.Influxdb(metrics.DefaultRegistry, 10e9, &influxdb.Config{
Host: "127.0.0.1:8086",
Database: "metrics",
Username: "test",
Password: "test",
})
Periodically upload every metric to Librato:
import "github.com/rcrowley/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}, // precentiles 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]")
Installation
go get github.com/rcrowley/go-metrics
StatHat support additionally requires their Go client:
go get github.com/stathat/go
# Functions
Capture new values for the Go garbage collector statistics exported in debug.GCStats.
Capture new values for the Go garbage collector statistics exported in debug.GCStats.
Capture new values for the Go runtime statistics exported in runtime.MemStats.
Capture new values for the Go runtime statistics exported in runtime.MemStats.
Call the given function for each registered metric.
Get the metric by the given name or nil if none is registered.
Gets an existing metric or creates and registers a new one.
GetOrRegisterCounter returns an existing Counter or constructs and registers a new StandardCounter.
GetOrRegisterGauge returns an existing Gauge or constructs and registers a new StandardGauge.
GetOrRegisterGaugeFloat64 returns an existing GaugeFloat64 or constructs and registers a new StandardGaugeFloat64.
GetOrRegisterHistogram returns an existing Histogram or constructs and registers a new StandardHistogram.
GetOrRegisterMeter returns an existing Meter or constructs and registers a new StandardMeter.
GetOrRegisterTimer returns an existing Timer or constructs and registers a new StandardTimer.
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.
GraphiteOnce performs a single submission to Graphite, returning a non-nil error on failed connections.
GraphiteWithConfig is a blocking exporter function just like Graphite, but it takes a GraphiteConfig instead.
Output each metric in the given registry periodically using the given logger.
NewCounter constructs a new StandardCounter.
NewCustomTimer constructs a new StandardTimer from a Histogram and a Meter.
NewEWMA constructs a new EWMA with the given alpha.
NewEWMA1 constructs a new EWMA for a one-minute moving average.
NewEWMA15 constructs a new EWMA for a fifteen-minute moving average.
NewEWMA5 constructs a new EWMA for a five-minute moving average.
NewExpDecaySample constructs a new exponentially-decaying sample with the given reservoir size and alpha.
NewGauge constructs a new StandardGauge.
NewGaugeFloat64 constructs a new StandardGaugeFloat64.
NewHealthcheck constructs a new Healthcheck which will use the given function to update its status.
NewHistogram constructs a new StandardHistogram from a Sample.
NewMeter constructs a new StandardMeter and launches a goroutine.
NewRegisteredCounter constructs and registers a new StandardCounter.
NewRegisteredGauge constructs and registers a new StandardGauge.
NewRegisteredGaugeFloat64 constructs and registers a new StandardGaugeFloat64.
NewRegisteredHistogram constructs and registers a new StandardHistogram from a Sample.
NewMeter constructs and registers a new StandardMeter and launches a goroutine.
NewRegisteredTimer constructs and registers a new StandardTimer.
Create a new registry.
NewTimer constructs a new StandardTimer using an exponentially-decaying sample with the same reservoir size and alpha as UNIX load averages.
NewUniformSample constructs a new uniform sample with the given reservoir size.
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.
OpenTSDBWithConfig is a blocking exporter function just like OpenTSDB, but it takes a OpenTSDBConfig instead.
Register the given metric under the given name.
Register metrics for the Go garbage collector statistics exported in debug.GCStats.
Register runtimeMetrics for the Go runtime statistics exported in runtime and specifically runtime.MemStats.
Run all registered healthchecks.
SampleMax returns the maximum value of the slice of int64.
SampleMean returns the mean value of the slice of int64.
SampleMin returns the minimum value of the slice of int64.
SamplePercentiles returns an arbitrary percentile of the slice of int64.
SamplePercentiles returns a slice of arbitrary percentiles of the slice of int64.
SampleStdDev returns the standard deviation of the slice of int64.
SampleSum returns the sum of the slice of int64.
SampleVariance returns the variance of the slice of int64.
Output each metric in the given registry to syslog periodically using the given syslogger.
Unregister the metric with the given name.
Write sorts writes each metric in the given registry periodically to the given io.Writer.
WriteJSON writes metrics from the given registry periodically to the specified io.Writer as JSON.
WriteJSONOnce writes metrics from the given registry to the specified io.Writer as JSON.
WriteOnce sorts and writes metrics in the given registry to the given io.Writer.
# Variables
No description provided by the author
UseNilMetrics is checked by the constructor functions for all of the standard metrics.
# Structs
ExpDecaySample is an exponentially-decaying sample using a forward-decaying priority reservoir.
GraphiteConfig provides a container with configuration parameters for the Graphite exporter.
HistogramSnapshot is a read-only copy of another Histogram.
MeterSnapshot is a read-only copy of another Meter.
NilCounter is a no-op Counter.
NilEWMA is a no-op EWMA.
NilGauge is a no-op Gauge.
NilGauge is a no-op Gauge.
NilHealthcheck is a no-op.
NilHistogram is a no-op Histogram.
NilMeter is a no-op Meter.
NilSample is a no-op Sample.
NilTimer is a no-op Timer.
OpenTSDBConfig provides a container with configuration parameters for the OpenTSDB exporter.
SampleSnapshot is a read-only copy of another Sample.
StandardCounter is the standard implementation of a Counter and uses the sync/atomic package to manage a single int64 value.
StandardEWMA is the standard implementation of an EWMA and tracks the number of uncounted events and processes them on each tick.
StandardGauge is the standard implementation of a Gauge and uses the sync/atomic package to manage a single int64 value.
StandardGaugeFloat64 is the standard implementation of a GaugeFloat64 and uses sync.Mutex to manage a single float64 value.
StandardHealthcheck is the standard implementation of a Healthcheck and stores the status and a function to call to update the status.
StandardHistogram is the standard implementation of a Histogram and uses a Sample to bound its memory use.
StandardMeter is the standard implementation of a Meter.
The standard implementation of a Registry is a mutex-protected map of names to metrics.
StandardTimer is the standard implementation of a Timer and uses a Histogram and Meter.
TimerSnapshot is a read-only copy of another Timer.
A uniform sample using Vitter's Algorithm R.
# Interfaces
Counters hold an int64 value that can be incremented and decremented.
EWMAs continuously calculate an exponentially-weighted moving average based on an outside source of clock ticks.
Gauges hold an int64 value that can be set arbitrarily.
GaugeFloat64s hold a float64 value that can be set arbitrarily.
Healthchecks hold an error value describing an arbitrary up/down status.
Histograms calculate distribution statistics from a series of int64 values.
Meters count events to produce exponentially-weighted moving average rates at one-, five-, and fifteen-minutes and a mean rate.
A Registry holds references to a set of metrics by name and can iterate over them, calling callback functions provided by the user.
Samples maintain a statistically-significant selection of values from a stream.
Timers capture the duration and rate of events.
# Type aliases
CounterSnapshot is a read-only copy of another Counter.
DuplicateMetric is the error returned by Registry.Register when a metric already exists.
EWMASnapshot is a read-only copy of another EWMA.
GaugeFloat64Snapshot is a read-only copy of another GaugeFloat64.
GaugeSnapshot is a read-only copy of another Gauge.