Add Metrics

vendor/github.com/go-kit/kit/log/value.go

@@ -1,9 +1,10 @@
 package log
 
 import (
+	"runtime"
+	"strconv"
+	"strings"
 	"time"
-
-	"github.com/go-stack/stack"
 )
 
 // A Valuer generates a log value. When passed to With or WithPrefix in a
@@ -81,7 +82,14 @@ func (tf timeFormat) MarshalText() (text []byte, err error) {
 // Caller returns a Valuer that returns a file and line from a specified depth
 // in the callstack. Users will probably want to use DefaultCaller.
 func Caller(depth int) Valuer {
-	return func() interface{} { return stack.Caller(depth) }
+	return func() interface{} {
+		_, file, line, _ := runtime.Caller(depth)
+		idx := strings.LastIndexByte(file, '/')
+		// using idx+1 below handles both of following cases:
+		// idx == -1 because no "/" was found, or
+		// idx >= 0 and we want to start at the character after the found "/".
+		return file[idx+1:] + ":" + strconv.Itoa(line)
+	}
 }
 
 var (

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

@@ -11,8 +11,10 @@
 package dogstatsd
 
 import (
+	"context"
 	"fmt"
 	"io"
+	"math/rand"
 	"strings"
 	"sync"
 	"sync/atomic"
@@ -72,7 +74,7 @@ func (d *Dogstatsd) NewCounter(name string, sampleRate float64) *Counter {
 	d.rates.Set(name, sampleRate)
 	return &Counter{
 		name: name,
-		obs:  d.counters.Observe,
+		obs:  sampleObservations(d.counters.Observe, sampleRate),
 	}
 }
 
@@ -94,7 +96,7 @@ func (d *Dogstatsd) NewTiming(name string, sampleRate float64) *Timing {
 	d.rates.Set(name, sampleRate)
 	return &Timing{
 		name: name,
-		obs:  d.timings.Observe,
+		obs:  sampleObservations(d.timings.Observe, sampleRate),
 	}
 }
 
@@ -104,29 +106,34 @@ func (d *Dogstatsd) NewHistogram(name string, sampleRate float64) *Histogram {
 	d.rates.Set(name, sampleRate)
 	return &Histogram{
 		name: name,
-		obs:  d.histograms.Observe,
+		obs:  sampleObservations(d.histograms.Observe, sampleRate),
 	}
 }
 
 // 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
+// time the passed channel fires. This method blocks until ctx is canceled,
+// 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 (d *Dogstatsd) WriteLoop(c <-chan time.Time, w io.Writer) {
-	for range c {
-		if _, err := d.WriteTo(w); err != nil {
-			d.logger.Log("during", "WriteTo", "err", err)
+func (d *Dogstatsd) WriteLoop(ctx context.Context, c <-chan time.Time, w io.Writer) {
+	for {
+		select {
+		case <-c:
+			if _, err := d.WriteTo(w); err != nil {
+				d.logger.Log("during", "WriteTo", "err", err)
+			}
+		case <-ctx.Done():
+			return
 		}
 	}
 }
 
 // SendLoop is a helper method that wraps WriteLoop, passing a managed
 // connection to the network and address. Like WriteLoop, this method blocks
-// until the channel is closed, so clients probably want to start it in its own
+// until ctx is canceled, so clients probably want to start it in its own
 // goroutine. For typical usage, create a time.Ticker and pass its C channel to
 // this method.
-func (d *Dogstatsd) SendLoop(c <-chan time.Time, network, address string) {
-	d.WriteLoop(c, conn.NewDefaultManager(network, address, d.logger))
+func (d *Dogstatsd) SendLoop(ctx context.Context, c <-chan time.Time, network, address string) {
+	d.WriteLoop(ctx, c, conn.NewDefaultManager(network, address, d.logger))
 }
 
 // WriteTo flushes the buffered content of the metrics to the writer, in
@@ -233,6 +240,19 @@ func (d *Dogstatsd) tagValues(labelValues []string) string {
 
 type observeFunc func(name string, lvs lv.LabelValues, value float64)
 
+// sampleObservations returns a modified observeFunc that samples observations.
+func sampleObservations(obs observeFunc, sampleRate float64) observeFunc {
+	if sampleRate >= 1 {
+		return obs
+	}
+	return func(name string, lvs lv.LabelValues, value float64) {
+		if rand.Float64() > sampleRate {
+			return
+		}
+		obs(name, lvs, value)
+	}
+}
+
 // Counter is a DogStatsD counter. Observations are forwarded to a Dogstatsd
 // object, and aggregated (summed) per timeseries.
 type Counter struct {

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

@@ -4,9 +4,10 @@
 package influx
 
 import (
+	"context"
 	"time"
 
-	influxdb "github.com/influxdata/influxdb/client/v2"
+	influxdb "github.com/influxdata/influxdb1-client/v2"
 
 	"github.com/go-kit/kit/log"
 	"github.com/go-kit/kit/metrics"
@@ -88,10 +89,15 @@ type BatchPointsWriter interface {
 // 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)
+func (in *Influx) WriteLoop(ctx context.Context, c <-chan time.Time, w BatchPointsWriter) {
+	for {
+		select {
+		case <-c:
+			if err := in.WriteTo(w); err != nil {
+				in.logger.Log("during", "WriteTo", "err", err)
+			}
+		case <-ctx.Done():
+			return
 		}
 	}
 }

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

@@ -79,7 +79,7 @@ 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 {
+	if len(lvs) <= 0 {
 		n.observations = append(n.observations, value)
 		return
 	}
@@ -101,7 +101,7 @@ func (n *node) observe(lvs LabelValues, value float64) {
 func (n *node) add(lvs LabelValues, delta float64) {
 	n.mtx.Lock()
 	defer n.mtx.Unlock()
-	if len(lvs) == 0 {
+	if len(lvs) <= 0 {
 		var value float64
 		if len(n.observations) > 0 {
 			value = last(n.observations) + delta

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

@@ -9,6 +9,7 @@
 package statsd
 
 import (
+	"context"
 	"fmt"
 	"io"
 	"time"
@@ -89,24 +90,29 @@ func (s *Statsd) NewTiming(name string, sampleRate float64) *Timing {
 }
 
 // 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
+// time the passed channel fires. This method blocks until ctx is canceled,
+// 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 (s *Statsd) WriteLoop(c <-chan time.Time, w io.Writer) {
-	for range c {
-		if _, err := s.WriteTo(w); err != nil {
-			s.logger.Log("during", "WriteTo", "err", err)
+func (s *Statsd) WriteLoop(ctx context.Context, c <-chan time.Time, w io.Writer) {
+	for {
+		select {
+		case <-c:
+			if _, err := s.WriteTo(w); err != nil {
+				s.logger.Log("during", "WriteTo", "err", err)
+			}
+		case <-ctx.Done():
+			return
 		}
 	}
 }
 
 // SendLoop is a helper method that wraps WriteLoop, passing a managed
 // connection to the network and address. Like WriteLoop, this method blocks
-// until the channel is closed, so clients probably want to start it in its own
+// until ctx is canceled, so clients probably want to start it in its own
 // goroutine. For typical usage, create a time.Ticker and pass its C channel to
 // this method.
-func (s *Statsd) SendLoop(c <-chan time.Time, network, address string) {
-	s.WriteLoop(c, conn.NewDefaultManager(network, address, s.logger))
+func (s *Statsd) SendLoop(ctx context.Context, c <-chan time.Time, network, address string) {
+	s.WriteLoop(ctx, c, conn.NewDefaultManager(network, address, s.logger))
 }
 
 // WriteTo flushes the buffered content of the metrics to the writer, in

vendor/github.com/go-kit/kit/util/conn/manager.go

@@ -2,6 +2,7 @@ package conn
 
 import (
 	"errors"
+	"math/rand"
 	"net"
 	"time"
 
@@ -103,7 +104,7 @@ func (m *Manager) loop() {
 		case conn = <-connc:
 			if conn == nil {
 				// didn't work
-				backoff = exponential(backoff) // wait longer
+				backoff = Exponential(backoff) // wait longer
 				reconnectc = m.after(backoff)  // try again
 			} else {
 				// worked!
@@ -132,12 +133,18 @@ func dial(d Dialer, network, address string, logger log.Logger) net.Conn {
 	return conn
 }
 
-func exponential(d time.Duration) time.Duration {
+// Exponential takes a duration and returns another one that is twice as long, +/- 50%. It is
+// used to provide backoff for operations that may fail and should avoid thundering herds.
+// See https://aws.amazon.com/blogs/architecture/exponential-backoff-and-jitter/ for rationale
+func Exponential(d time.Duration) time.Duration {
 	d *= 2
+	jitter := rand.Float64() + 0.5
+	d = time.Duration(int64(float64(d.Nanoseconds()) * jitter))
 	if d > time.Minute {
 		d = time.Minute
 	}
 	return d
+
 }
 
 // ErrConnectionUnavailable is returned by the Manager's Write method when the