Vendor main dependencies.

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

@@ -0,0 +1,60 @@
+// Package metrics provides a framework for application instrumentation. All
+// metrics are safe for concurrent use. Considerable design influence has been
+// taken from https://github.com/codahale/metrics and https://prometheus.io.
+//
+// This package contains the common interfaces. Your code should take these
+// interfaces as parameters. Implementations are provided for different
+// instrumentation systems in the various subdirectories.
+//
+// Usage
+//
+// Metrics are dependencies and should be passed to the components that need
+// them in the same way you'd construct and pass a database handle, or reference
+// to another component. So, create metrics in your func main, using whichever
+// concrete implementation is appropriate for your organization.
+//
+//    latency := prometheus.NewSummaryFrom(stdprometheus.SummaryOpts{
+//        Namespace: "myteam",
+//        Subsystem: "foosvc",
+//        Name:      "request_latency_seconds",
+//        Help:      "Incoming request latency in seconds."
+//    }, []string{"method", "status_code"})
+//
+// Write your components to take the metrics they will use as parameters to
+// their constructors. Use the interface types, not the concrete types. That is,
+//
+//    // NewAPI takes metrics.Histogram, not *prometheus.Summary
+//    func NewAPI(s Store, logger log.Logger, latency metrics.Histogram) *API {
+//        // ...
+//    }
+//
+//    func (a *API) ServeFoo(w http.ResponseWriter, r *http.Request) {
+//        begin := time.Now()
+//        // ...
+//        a.latency.Observe(time.Since(begin).Seconds())
+//    }
+//
+// Finally, pass the metrics as dependencies when building your object graph.
+// This should happen in func main, not in the global scope.
+//
+//    api := NewAPI(store, logger, latency)
+//    http.ListenAndServe("/", api)
+//
+// Implementation details
+//
+// Each telemetry system has different semantics for label values, push vs.
+// pull, support for histograms, etc. These properties influence the design of
+// their respective packages. This table attempts to summarize the key points of
+// distinction.
+//
+//    SYSTEM      DIM  COUNTERS               GAUGES                 HISTOGRAMS
+//    dogstatsd   n    batch, push-aggregate  batch, push-aggregate  native, batch, push-each
+//    statsd      1    batch, push-aggregate  batch, push-aggregate  native, batch, push-each
+//    graphite    1    batch, push-aggregate  batch, push-aggregate  synthetic, batch, push-aggregate
+//    expvar      1    atomic                 atomic                 synthetic, batch, in-place expose
+//    influx      n    custom                 custom                 custom
+//    prometheus  n    native                 native                 native
+//    circonus    1    native                 native                 native
+//    pcp         1    native                 native                 native
+//
+package metrics

vendor/github.com/go-kit/kit/metrics/internal/lv/labelvalues.go

@@ -0,0 +1,14 @@
+package lv
+
+// LabelValues is a type alias that provides validation on its With method.
+// Metrics may include it as a member to help them satisfy With semantics and
+// save some code duplication.
+type LabelValues []string
+
+// With validates the input, and returns a new aggregate labelValues.
+func (lvs LabelValues) With(labelValues ...string) LabelValues {
+	if len(labelValues)%2 != 0 {
+		labelValues = append(labelValues, "unknown")
+	}
+	return append(lvs, labelValues...)
+}

vendor/github.com/go-kit/kit/metrics/internal/lv/space.go

@@ -0,0 +1,106 @@
+package lv
+
+import "sync"
+
+// NewSpace returns an N-dimensional vector space.
+func NewSpace() *Space {
+	return &Space{}
+}
+
+// Space represents an N-dimensional vector space. Each name and unique label
+// value pair establishes a new dimension and point within that dimension. Order
+// matters, i.e. [a=1 b=2] identifies a different timeseries than [b=2 a=1].
+type Space struct {
+	mtx   sync.RWMutex
+	nodes map[string]*node
+}
+
+// Observe locates the time series identified by the name and label values in
+// the vector space, and appends the value to the list of observations.
+func (s *Space) Observe(name string, lvs LabelValues, value float64) {
+	s.nodeFor(name).observe(lvs, value)
+}
+
+// Walk traverses the vector space and invokes fn for each non-empty time series
+// which is encountered. Return false to abort the traversal.
+func (s *Space) Walk(fn func(name string, lvs LabelValues, observations []float64) bool) {
+	s.mtx.RLock()
+	defer s.mtx.RUnlock()
+	for name, node := range s.nodes {
+		f := func(lvs LabelValues, observations []float64) bool { return fn(name, lvs, observations) }
+		if !node.walk(LabelValues{}, f) {
+			return
+		}
+	}
+}
+
+// Reset empties the current space and returns a new Space with the old
+// contents. Reset a Space to get an immutable copy suitable for walking.
+func (s *Space) Reset() *Space {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	n := NewSpace()
+	n.nodes, s.nodes = s.nodes, n.nodes
+	return n
+}
+
+func (s *Space) nodeFor(name string) *node {
+	s.mtx.Lock()
+	defer s.mtx.Unlock()
+	if s.nodes == nil {
+		s.nodes = map[string]*node{}
+	}
+	n, ok := s.nodes[name]
+	if !ok {
+		n = &node{}
+		s.nodes[name] = n
+	}
+	return n
+}
+
+// node exists at a specific point in the N-dimensional vector space of all
+// possible label values. The node collects observations and has child nodes
+// with greater specificity.
+type node struct {
+	mtx          sync.RWMutex
+	observations []float64
+	children     map[pair]*node
+}
+
+type pair struct{ label, value string }
+
+func (n *node) observe(lvs LabelValues, value float64) {
+	n.mtx.Lock()
+	defer n.mtx.Unlock()
+	if len(lvs) == 0 {
+		n.observations = append(n.observations, value)
+		return
+	}
+	if len(lvs) < 2 {
+		panic("too few LabelValues; programmer error!")
+	}
+	head, tail := pair{lvs[0], lvs[1]}, lvs[2:]
+	if n.children == nil {
+		n.children = map[pair]*node{}
+	}
+	child, ok := n.children[head]
+	if !ok {
+		child = &node{}
+		n.children[head] = child
+	}
+	child.observe(tail, value)
+}
+
+func (n *node) walk(lvs LabelValues, fn func(LabelValues, []float64) bool) bool {
+	n.mtx.RLock()
+	defer n.mtx.RUnlock()
+	if len(n.observations) > 0 && !fn(lvs, n.observations) {
+		return false
+	}
+	for p, child := range n.children {
+		if !child.walk(append(lvs, p.label, p.value), fn) {
+			return false
+		}
+	}
+	return true
+}

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

@@ -0,0 +1,24 @@
+package metrics
+
+// Counter describes a metric that accumulates values monotonically.
+// An example of a counter is the number of received HTTP requests.
+type Counter interface {
+	With(labelValues ...string) Counter
+	Add(delta float64)
+}
+
+// Gauge describes a metric that takes specific values over time.
+// An example of a gauge is the current depth of a job queue.
+type Gauge interface {
+	With(labelValues ...string) Gauge
+	Set(value float64)
+}
+
+// Histogram describes a metric that takes repeated observations of the same
+// kind of thing, and produces a statistical summary of those observations,
+// typically expressed as quantiles or buckets. An example of a histogram is
+// HTTP request latencies.
+type Histogram interface {
+	With(labelValues ...string) Histogram
+	Observe(value float64)
+}

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

@@ -0,0 +1,165 @@
+// Package prometheus provides Prometheus implementations for metrics.
+// Individual metrics are mapped to their Prometheus counterparts, and
+// (depending on the constructor used) may be automatically registered in the
+// global Prometheus metrics registry.
+package prometheus
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+
+	"github.com/go-kit/kit/metrics"
+	"github.com/go-kit/kit/metrics/internal/lv"
+)
+
+// Counter implements Counter, via a Prometheus CounterVec.
+type Counter struct {
+	cv  *prometheus.CounterVec
+	lvs lv.LabelValues
+}
+
+// NewCounterFrom constructs and registers a Prometheus CounterVec,
+// and returns a usable Counter object.
+func NewCounterFrom(opts prometheus.CounterOpts, labelNames []string) *Counter {
+	cv := prometheus.NewCounterVec(opts, labelNames)
+	prometheus.MustRegister(cv)
+	return NewCounter(cv)
+}
+
+// NewCounter wraps the CounterVec and returns a usable Counter object.
+func NewCounter(cv *prometheus.CounterVec) *Counter {
+	return &Counter{
+		cv: cv,
+	}
+}
+
+// With implements Counter.
+func (c *Counter) With(labelValues ...string) metrics.Counter {
+	return &Counter{
+		cv:  c.cv,
+		lvs: c.lvs.With(labelValues...),
+	}
+}
+
+// Add implements Counter.
+func (c *Counter) Add(delta float64) {
+	c.cv.With(makeLabels(c.lvs...)).Add(delta)
+}
+
+// Gauge implements Gauge, via a Prometheus GaugeVec.
+type Gauge struct {
+	gv  *prometheus.GaugeVec
+	lvs lv.LabelValues
+}
+
+// NewGaugeFrom construts and registers a Prometheus GaugeVec,
+// and returns a usable Gauge object.
+func NewGaugeFrom(opts prometheus.GaugeOpts, labelNames []string) *Gauge {
+	gv := prometheus.NewGaugeVec(opts, labelNames)
+	prometheus.MustRegister(gv)
+	return NewGauge(gv)
+}
+
+// NewGauge wraps the GaugeVec and returns a usable Gauge object.
+func NewGauge(gv *prometheus.GaugeVec) *Gauge {
+	return &Gauge{
+		gv: gv,
+	}
+}
+
+// With implements Gauge.
+func (g *Gauge) With(labelValues ...string) metrics.Gauge {
+	return &Gauge{
+		gv:  g.gv,
+		lvs: g.lvs.With(labelValues...),
+	}
+}
+
+// Set implements Gauge.
+func (g *Gauge) Set(value float64) {
+	g.gv.With(makeLabels(g.lvs...)).Set(value)
+}
+
+// Add is supported by Prometheus GaugeVecs.
+func (g *Gauge) Add(delta float64) {
+	g.gv.With(makeLabels(g.lvs...)).Add(delta)
+}
+
+// Summary implements Histogram, via a Prometheus SummaryVec. The difference
+// between a Summary and a Histogram is that Summaries don't require predefined
+// quantile buckets, but cannot be statistically aggregated.
+type Summary struct {
+	sv  *prometheus.SummaryVec
+	lvs lv.LabelValues
+}
+
+// NewSummaryFrom constructs and registers a Prometheus SummaryVec,
+// and returns a usable Summary object.
+func NewSummaryFrom(opts prometheus.SummaryOpts, labelNames []string) *Summary {
+	sv := prometheus.NewSummaryVec(opts, labelNames)
+	prometheus.MustRegister(sv)
+	return NewSummary(sv)
+}
+
+// NewSummary wraps the SummaryVec and returns a usable Summary object.
+func NewSummary(sv *prometheus.SummaryVec) *Summary {
+	return &Summary{
+		sv: sv,
+	}
+}
+
+// With implements Histogram.
+func (s *Summary) With(labelValues ...string) metrics.Histogram {
+	return &Summary{
+		sv:  s.sv,
+		lvs: s.lvs.With(labelValues...),
+	}
+}
+
+// Observe implements Histogram.
+func (s *Summary) Observe(value float64) {
+	s.sv.With(makeLabels(s.lvs...)).Observe(value)
+}
+
+// Histogram implements Histogram via a Prometheus HistogramVec. The difference
+// between a Histogram and a Summary is that Histograms require predefined
+// quantile buckets, and can be statistically aggregated.
+type Histogram struct {
+	hv  *prometheus.HistogramVec
+	lvs lv.LabelValues
+}
+
+// NewHistogramFrom constructs and registers a Prometheus HistogramVec,
+// and returns a usable Histogram object.
+func NewHistogramFrom(opts prometheus.HistogramOpts, labelNames []string) *Histogram {
+	hv := prometheus.NewHistogramVec(opts, labelNames)
+	prometheus.MustRegister(hv)
+	return NewHistogram(hv)
+}
+
+// NewHistogram wraps the HistogramVec and returns a usable Histogram object.
+func NewHistogram(hv *prometheus.HistogramVec) *Histogram {
+	return &Histogram{
+		hv: hv,
+	}
+}
+
+// With implements Histogram.
+func (h *Histogram) With(labelValues ...string) metrics.Histogram {
+	return &Histogram{
+		hv:  h.hv,
+		lvs: h.lvs.With(labelValues...),
+	}
+}
+
+// Observe implements Histogram.
+func (h *Histogram) Observe(value float64) {
+	h.hv.With(makeLabels(h.lvs...)).Observe(value)
+}
+
+func makeLabels(labelValues ...string) prometheus.Labels {
+	labels := prometheus.Labels{}
+	for i := 0; i < len(labelValues); i += 2 {
+		labels[labelValues[i]] = labelValues[i+1]
+	}
+	return labels
+}

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

@@ -0,0 +1,28 @@
+package metrics
+
+import "time"
+
+// Timer acts as a stopwatch, sending observations to a wrapped histogram.
+// It's a bit of helpful syntax sugar for h.Observe(time.Since(x)).
+type Timer struct {
+	h Histogram
+	t time.Time
+}
+
+// NewTimer wraps the given histogram and records the current time.
+func NewTimer(h Histogram) *Timer {
+	return &Timer{
+		h: h,
+		t: time.Now(),
+	}
+}
+
+// ObserveDuration captures the number of seconds since the timer was
+// constructed, and forwards that observation to the histogram.
+func (t *Timer) ObserveDuration() {
+	d := time.Since(t.t).Seconds()
+	if d < 0 {
+		d = 0
+	}
+	t.h.Observe(d)
+}