Add InfluxDB support for traefik metrics

vendor/github.com/go-kit/kit/metrics/generic/generic.go

@@ -0,0 +1,218 @@
+// Package generic implements generic versions of each of the metric types. They
+// can be embedded by other implementations, and converted to specific formats
+// as necessary.
+package generic
+
+import (
+	"fmt"
+	"io"
+	"math"
+	"sync"
+	"sync/atomic"
+
+	"github.com/VividCortex/gohistogram"
+
+	"github.com/go-kit/kit/metrics"
+	"github.com/go-kit/kit/metrics/internal/lv"
+)
+
+// Counter is an in-memory implementation of a Counter.
+type Counter struct {
+	Name string
+	lvs  lv.LabelValues
+	bits uint64
+}
+
+// NewCounter returns a new, usable Counter.
+func NewCounter(name string) *Counter {
+	return &Counter{
+		Name: name,
+	}
+}
+
+// With implements Counter.
+func (c *Counter) With(labelValues ...string) metrics.Counter {
+	return &Counter{
+		bits: atomic.LoadUint64(&c.bits),
+		lvs:  c.lvs.With(labelValues...),
+	}
+}
+
+// Add implements Counter.
+func (c *Counter) Add(delta float64) {
+	for {
+		var (
+			old  = atomic.LoadUint64(&c.bits)
+			newf = math.Float64frombits(old) + delta
+			new  = math.Float64bits(newf)
+		)
+		if atomic.CompareAndSwapUint64(&c.bits, old, new) {
+			break
+		}
+	}
+}
+
+// Value returns the current value of the counter.
+func (c *Counter) Value() float64 {
+	return math.Float64frombits(atomic.LoadUint64(&c.bits))
+}
+
+// ValueReset returns the current value of the counter, and resets it to zero.
+// This is useful for metrics backends whose counter aggregations expect deltas,
+// like Graphite.
+func (c *Counter) ValueReset() float64 {
+	for {
+		var (
+			old  = atomic.LoadUint64(&c.bits)
+			newf = 0.0
+			new  = math.Float64bits(newf)
+		)
+		if atomic.CompareAndSwapUint64(&c.bits, old, new) {
+			return math.Float64frombits(old)
+		}
+	}
+}
+
+// LabelValues returns the set of label values attached to the counter.
+func (c *Counter) LabelValues() []string {
+	return c.lvs
+}
+
+// Gauge is an in-memory implementation of a Gauge.
+type Gauge struct {
+	Name string
+	lvs  lv.LabelValues
+	bits uint64
+}
+
+// NewGauge returns a new, usable Gauge.
+func NewGauge(name string) *Gauge {
+	return &Gauge{
+		Name: name,
+	}
+}
+
+// With implements Gauge.
+func (g *Gauge) With(labelValues ...string) metrics.Gauge {
+	return &Gauge{
+		bits: atomic.LoadUint64(&g.bits),
+		lvs:  g.lvs.With(labelValues...),
+	}
+}
+
+// Set implements Gauge.
+func (g *Gauge) Set(value float64) {
+	atomic.StoreUint64(&g.bits, math.Float64bits(value))
+}
+
+// Value returns the current value of the gauge.
+func (g *Gauge) Value() float64 {
+	return math.Float64frombits(atomic.LoadUint64(&g.bits))
+}
+
+// LabelValues returns the set of label values attached to the gauge.
+func (g *Gauge) LabelValues() []string {
+	return g.lvs
+}
+
+// Histogram is an in-memory implementation of a streaming histogram, based on
+// VividCortex/gohistogram. It dynamically computes quantiles, so it's not
+// suitable for aggregation.
+type Histogram struct {
+	Name string
+	lvs  lv.LabelValues
+	h    gohistogram.Histogram
+}
+
+// NewHistogram returns a numeric histogram based on VividCortex/gohistogram. A
+// good default value for buckets is 50.
+func NewHistogram(name string, buckets int) *Histogram {
+	return &Histogram{
+		Name: name,
+		h:    gohistogram.NewHistogram(buckets),
+	}
+}
+
+// With implements Histogram.
+func (h *Histogram) With(labelValues ...string) metrics.Histogram {
+	return &Histogram{
+		lvs: h.lvs.With(labelValues...),
+		h:   h.h,
+	}
+}
+
+// Observe implements Histogram.
+func (h *Histogram) Observe(value float64) {
+	h.h.Add(value)
+}
+
+// Quantile returns the value of the quantile q, 0.0 < q < 1.0.
+func (h *Histogram) Quantile(q float64) float64 {
+	return h.h.Quantile(q)
+}
+
+// LabelValues returns the set of label values attached to the histogram.
+func (h *Histogram) LabelValues() []string {
+	return h.lvs
+}
+
+// Print writes a string representation of the histogram to the passed writer.
+// Useful for printing to a terminal.
+func (h *Histogram) Print(w io.Writer) {
+	fmt.Fprintf(w, h.h.String())
+}
+
+// Bucket is a range in a histogram which aggregates observations.
+type Bucket struct {
+	From, To, Count int64
+}
+
+// Quantile is a pair of a quantile (0..100) and its observed maximum value.
+type Quantile struct {
+	Quantile int // 0..100
+	Value    int64
+}
+
+// SimpleHistogram is an in-memory implementation of a Histogram. It only tracks
+// an approximate moving average, so is likely too naïve for many use cases.
+type SimpleHistogram struct {
+	mtx sync.RWMutex
+	lvs lv.LabelValues
+	avg float64
+	n   uint64
+}
+
+// NewSimpleHistogram returns a SimpleHistogram, ready for observations.
+func NewSimpleHistogram() *SimpleHistogram {
+	return &SimpleHistogram{}
+}
+
+// With implements Histogram.
+func (h *SimpleHistogram) With(labelValues ...string) metrics.Histogram {
+	return &SimpleHistogram{
+		lvs: h.lvs.With(labelValues...),
+		avg: h.avg,
+		n:   h.n,
+	}
+}
+
+// Observe implements Histogram.
+func (h *SimpleHistogram) Observe(value float64) {
+	h.mtx.Lock()
+	defer h.mtx.Unlock()
+	h.n++
+	h.avg -= h.avg / float64(h.n)
+	h.avg += value / float64(h.n)
+}
+
+// ApproximateMovingAverage returns the approximate moving average of observations.
+func (h *SimpleHistogram) ApproximateMovingAverage() float64 {
+	h.mtx.RLock()
+	defer h.mtx.RUnlock()
+	return h.avg
+}
+
+// LabelValues returns the set of label values attached to the histogram.
+func (h *SimpleHistogram) LabelValues() []string {
+	return h.lvs
+}

vendor/github.com/go-kit/kit/metrics/influx/influx.go

@@ -0,0 +1,255 @@
+// Package influx provides an InfluxDB implementation for metrics. The model is
+// similar to other push-based instrumentation systems. Observations are
+// aggregated locally and emitted to the Influx server on regular intervals.
+package influx
+
+import (
+	"time"
+
+	influxdb "github.com/influxdata/influxdb/client/v2"
+
+	"github.com/go-kit/kit/log"
+	"github.com/go-kit/kit/metrics"
+	"github.com/go-kit/kit/metrics/generic"
+	"github.com/go-kit/kit/metrics/internal/lv"
+)
+
+// Influx is a store for metrics that will be emitted to an Influx database.
+//
+// Influx is a general purpose time-series database, and has no native concepts
+// of counters, gauges, or histograms. Counters are modeled as a timeseries with
+// one data point per flush, with a "count" field that reflects all adds since
+// the last flush. Gauges are modeled as a timeseries with one data point per
+// flush, with a "value" field that reflects the current state of the gauge.
+// Histograms are modeled as a timeseries with one data point per combination of tags,
+// with a set of quantile fields that reflects the p50, p90, p95 & p99.
+//
+// Influx tags are attached to the Influx object, can be given to each
+// metric at construction and can be updated anytime via With function. Influx fields
+// are mapped to Go kit label values directly by this collector. Actual metric
+// values are provided as fields with specific names depending on the metric.
+//
+// All observations are collected in memory locally, and flushed on demand.
+type Influx struct {
+	counters   *lv.Space
+	gauges     *lv.Space
+	histograms *lv.Space
+	tags       map[string]string
+	conf       influxdb.BatchPointsConfig
+	logger     log.Logger
+}
+
+// New returns an Influx, ready to create metrics and collect observations. Tags
+// are applied to all metrics created from this object. The BatchPointsConfig is
+// used during flushing.
+func New(tags map[string]string, conf influxdb.BatchPointsConfig, logger log.Logger) *Influx {
+	return &Influx{
+		counters:   lv.NewSpace(),
+		gauges:     lv.NewSpace(),
+		histograms: lv.NewSpace(),
+		tags:       tags,
+		conf:       conf,
+		logger:     logger,
+	}
+}
+
+// NewCounter returns an Influx counter.
+func (in *Influx) NewCounter(name string) *Counter {
+	return &Counter{
+		name: name,
+		obs:  in.counters.Observe,
+	}
+}
+
+// NewGauge returns an Influx gauge.
+func (in *Influx) NewGauge(name string) *Gauge {
+	return &Gauge{
+		name: name,
+		obs:  in.gauges.Observe,
+	}
+}
+
+// NewHistogram returns an Influx histogram.
+func (in *Influx) NewHistogram(name string) *Histogram {
+	return &Histogram{
+		name: name,
+		obs:  in.histograms.Observe,
+	}
+}
+
+// BatchPointsWriter captures a subset of the influxdb.Client methods necessary
+// for emitting metrics observations.
+type BatchPointsWriter interface {
+	Write(influxdb.BatchPoints) error
+}
+
+// WriteLoop is a helper method that invokes WriteTo to the passed writer every
+// time the passed channel fires. This method blocks until the channel is
+// closed, so clients probably want to run it in its own goroutine. For typical
+// usage, create a time.Ticker and pass its C channel to this method.
+func (in *Influx) WriteLoop(c <-chan time.Time, w BatchPointsWriter) {
+	for range c {
+		if err := in.WriteTo(w); err != nil {
+			in.logger.Log("during", "WriteTo", "err", err)
+		}
+	}
+}
+
+// WriteTo flushes the buffered content of the metrics to the writer, in an
+// Influx BatchPoints format. WriteTo abides best-effort semantics, so
+// observations are lost if there is a problem with the write. Clients should be
+// sure to call WriteTo regularly, ideally through the WriteLoop helper method.
+func (in *Influx) WriteTo(w BatchPointsWriter) (err error) {
+	bp, err := influxdb.NewBatchPoints(in.conf)
+	if err != nil {
+		return err
+	}
+
+	now := time.Now()
+
+	in.counters.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool {
+		tags := mergeTags(in.tags, lvs)
+		var p *influxdb.Point
+		fields := map[string]interface{}{"count": sum(values)}
+		p, err = influxdb.NewPoint(name, tags, fields, now)
+		if err != nil {
+			return false
+		}
+		bp.AddPoint(p)
+		return true
+	})
+	if err != nil {
+		return err
+	}
+
+	in.gauges.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool {
+		tags := mergeTags(in.tags, lvs)
+		var p *influxdb.Point
+		fields := map[string]interface{}{"value": last(values)}
+		p, err = influxdb.NewPoint(name, tags, fields, now)
+		if err != nil {
+			return false
+		}
+		bp.AddPoint(p)
+		return true
+	})
+	if err != nil {
+		return err
+	}
+
+	in.histograms.Reset().Walk(func(name string, lvs lv.LabelValues, values []float64) bool {
+		histogram := generic.NewHistogram(name, 50)
+		tags := mergeTags(in.tags, lvs)
+		var p *influxdb.Point
+		for _, v := range values {
+			histogram.Observe(v)
+		}
+		fields := map[string]interface{}{
+			"p50": histogram.Quantile(0.50),
+			"p90": histogram.Quantile(0.90),
+			"p95": histogram.Quantile(0.95),
+			"p99": histogram.Quantile(0.99),
+		}
+		p, err = influxdb.NewPoint(name, tags, fields, now)
+		if err != nil {
+			return false
+		}
+		bp.AddPoint(p)
+		return true
+	})
+	if err != nil {
+		return err
+	}
+
+	return w.Write(bp)
+}
+
+func mergeTags(tags map[string]string, labelValues []string) map[string]string {
+	if len(labelValues)%2 != 0 {
+		panic("mergeTags received a labelValues with an odd number of strings")
+	}
+	for i := 0; i < len(labelValues); i += 2 {
+		tags[labelValues[i]] = labelValues[i+1]
+	}
+	return tags
+}
+
+func sum(a []float64) float64 {
+	var v float64
+	for _, f := range a {
+		v += f
+	}
+	return v
+}
+
+func last(a []float64) float64 {
+	return a[len(a)-1]
+}
+
+type observeFunc func(name string, lvs lv.LabelValues, value float64)
+
+// Counter is an Influx counter. Observations are forwarded to an Influx
+// object, and aggregated (summed) per timeseries.
+type Counter struct {
+	name string
+	lvs  lv.LabelValues
+	obs  observeFunc
+}
+
+// With implements metrics.Counter.
+func (c *Counter) With(labelValues ...string) metrics.Counter {
+	return &Counter{
+		name: c.name,
+		lvs:  c.lvs.With(labelValues...),
+		obs:  c.obs,
+	}
+}
+
+// Add implements metrics.Counter.
+func (c *Counter) Add(delta float64) {
+	c.obs(c.name, c.lvs, delta)
+}
+
+// Gauge is an Influx gauge. Observations are forwarded to a Dogstatsd
+// object, and aggregated (the last observation selected) per timeseries.
+type Gauge struct {
+	name string
+	lvs  lv.LabelValues
+	obs  observeFunc
+}
+
+// With implements metrics.Gauge.
+func (g *Gauge) With(labelValues ...string) metrics.Gauge {
+	return &Gauge{
+		name: g.name,
+		lvs:  g.lvs.With(labelValues...),
+		obs:  g.obs,
+	}
+}
+
+// Set implements metrics.Gauge.
+func (g *Gauge) Set(value float64) {
+	g.obs(g.name, g.lvs, value)
+}
+
+// Histogram is an Influx histrogram. Observations are aggregated into a
+// generic.Histogram and emitted as per-quantile gauges to the Influx server.
+type Histogram struct {
+	name string
+	lvs  lv.LabelValues
+	obs  observeFunc
+}
+
+// With implements metrics.Histogram.
+func (h *Histogram) With(labelValues ...string) metrics.Histogram {
+	return &Histogram{
+		name: h.name,
+		lvs:  h.lvs.With(labelValues...),
+		obs:  h.obs,
+	}
+}
+
+// Observe implements metrics.Histogram.
+func (h *Histogram) Observe(value float64) {
+	h.obs(h.name, h.lvs, value)
+}