Moved to google.golang.org/genproto/googleapis/api/annotations
Fixes #52
This commit is contained in:
Valerio Gheri
108
vendor/github.com/go-kit/kit/metrics/influx/example_test.go
generated
vendored
Normal file
108
vendor/github.com/go-kit/kit/metrics/influx/example_test.go
generated
vendored
Normal file
@@ -0,0 +1,108 @@
|
||||
package influx
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"regexp"
|
||||
|
||||
influxdb "github.com/influxdata/influxdb/client/v2"
|
||||
|
||||
"github.com/go-kit/kit/log"
|
||||
)
|
||||
|
||||
func ExampleCounter() {
|
||||
in := New(map[string]string{"a": "b"}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
counter := in.NewCounter("influx_counter")
|
||||
counter.Add(10)
|
||||
counter.With("error", "true").Add(1)
|
||||
counter.With("error", "false").Add(2)
|
||||
counter.Add(50)
|
||||
|
||||
client := &bufWriter{}
|
||||
in.WriteTo(client)
|
||||
|
||||
expectedLines := []string{
|
||||
`(influx_counter,a=b count=60) [0-9]{19}`,
|
||||
`(influx_counter,a=b,error=true count=1) [0-9]{19}`,
|
||||
`(influx_counter,a=b,error=false count=2) [0-9]{19}`,
|
||||
}
|
||||
|
||||
if err := extractAndPrintMessage(expectedLines, client.buf.String()); err != nil {
|
||||
fmt.Println(err.Error())
|
||||
}
|
||||
|
||||
// Output:
|
||||
// influx_counter,a=b count=60
|
||||
// influx_counter,a=b,error=true count=1
|
||||
// influx_counter,a=b,error=false count=2
|
||||
}
|
||||
|
||||
func ExampleGauge() {
|
||||
in := New(map[string]string{"a": "b"}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
gauge := in.NewGauge("influx_gauge")
|
||||
gauge.Set(10)
|
||||
gauge.With("error", "true").Set(2)
|
||||
gauge.With("error", "true").Set(1)
|
||||
gauge.With("error", "false").Set(2)
|
||||
gauge.Set(50)
|
||||
gauge.With("test", "true").Set(1)
|
||||
gauge.With("test", "true").Add(1)
|
||||
|
||||
client := &bufWriter{}
|
||||
in.WriteTo(client)
|
||||
|
||||
expectedLines := []string{
|
||||
`(influx_gauge,a=b,test=true value=2) [0-9]{19}`,
|
||||
`(influx_gauge,a=b value=50) [0-9]{19}`,
|
||||
`(influx_gauge,a=b,error=true value=1) [0-9]{19}`,
|
||||
`(influx_gauge,a=b,error=false value=2) [0-9]{19}`,
|
||||
}
|
||||
|
||||
if err := extractAndPrintMessage(expectedLines, client.buf.String()); err != nil {
|
||||
fmt.Println(err.Error())
|
||||
}
|
||||
|
||||
// Output:
|
||||
// influx_gauge,a=b,test=true value=2
|
||||
// influx_gauge,a=b value=50
|
||||
// influx_gauge,a=b,error=true value=1
|
||||
// influx_gauge,a=b,error=false value=2
|
||||
}
|
||||
|
||||
func ExampleHistogram() {
|
||||
in := New(map[string]string{"foo": "alpha"}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
histogram := in.NewHistogram("influx_histogram")
|
||||
histogram.Observe(float64(10))
|
||||
histogram.With("error", "true").Observe(float64(1))
|
||||
histogram.With("error", "false").Observe(float64(2))
|
||||
histogram.Observe(float64(50))
|
||||
|
||||
client := &bufWriter{}
|
||||
in.WriteTo(client)
|
||||
|
||||
expectedLines := []string{
|
||||
`(influx_histogram,foo=alpha p50=10,p90=50,p95=50,p99=50) [0-9]{19}`,
|
||||
`(influx_histogram,error=true,foo=alpha p50=1,p90=1,p95=1,p99=1) [0-9]{19}`,
|
||||
`(influx_histogram,error=false,foo=alpha p50=2,p90=2,p95=2,p99=2) [0-9]{19}`,
|
||||
}
|
||||
|
||||
if err := extractAndPrintMessage(expectedLines, client.buf.String()); err != nil {
|
||||
fmt.Println(err.Error())
|
||||
}
|
||||
|
||||
// Output:
|
||||
// influx_histogram,foo=alpha p50=10,p90=50,p95=50,p99=50
|
||||
// influx_histogram,error=true,foo=alpha p50=1,p90=1,p95=1,p99=1
|
||||
// influx_histogram,error=false,foo=alpha p50=2,p90=2,p95=2,p99=2
|
||||
}
|
||||
|
||||
func extractAndPrintMessage(expected []string, msg string) error {
|
||||
for _, pattern := range expected {
|
||||
re := regexp.MustCompile(pattern)
|
||||
match := re.FindStringSubmatch(msg)
|
||||
if len(match) != 2 {
|
||||
return fmt.Errorf("Pattern not found! {%s} [%s]: %v\n", pattern, msg, match)
|
||||
}
|
||||
fmt.Println(match[1])
|
||||
}
|
||||
return nil
|
||||
}
|
||||
267
vendor/github.com/go-kit/kit/metrics/influx/influx.go
generated
vendored
Normal file
267
vendor/github.com/go-kit/kit/metrics/influx/influx.go
generated
vendored
Normal file
@@ -0,0 +1,267 @@
|
||||
// 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,
|
||||
add: in.gauges.Add,
|
||||
}
|
||||
}
|
||||
|
||||
// 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")
|
||||
}
|
||||
ret := make(map[string]string, len(tags)+len(labelValues)/2)
|
||||
for k, v := range tags {
|
||||
ret[k] = v
|
||||
}
|
||||
for i := 0; i < len(labelValues); i += 2 {
|
||||
ret[labelValues[i]] = labelValues[i+1]
|
||||
}
|
||||
return ret
|
||||
}
|
||||
|
||||
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
|
||||
add 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,
|
||||
add: g.add,
|
||||
}
|
||||
}
|
||||
|
||||
// Set implements metrics.Gauge.
|
||||
func (g *Gauge) Set(value float64) {
|
||||
g.obs(g.name, g.lvs, value)
|
||||
}
|
||||
|
||||
// Add implements metrics.Gauge.
|
||||
func (g *Gauge) Add(delta float64) {
|
||||
g.add(g.name, g.lvs, delta)
|
||||
}
|
||||
|
||||
// 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)
|
||||
}
|
||||
125
vendor/github.com/go-kit/kit/metrics/influx/influx_test.go
generated
vendored
Normal file
125
vendor/github.com/go-kit/kit/metrics/influx/influx_test.go
generated
vendored
Normal file
@@ -0,0 +1,125 @@
|
||||
package influx
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"testing"
|
||||
|
||||
influxdb "github.com/influxdata/influxdb/client/v2"
|
||||
|
||||
"github.com/go-kit/kit/log"
|
||||
"github.com/go-kit/kit/metrics/teststat"
|
||||
)
|
||||
|
||||
func TestCounter(t *testing.T) {
|
||||
in := New(map[string]string{"a": "b"}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
re := regexp.MustCompile(`influx_counter,a=b count=([0-9\.]+) [0-9]+`) // reverse-engineered :\
|
||||
counter := in.NewCounter("influx_counter")
|
||||
value := func() float64 {
|
||||
client := &bufWriter{}
|
||||
in.WriteTo(client)
|
||||
match := re.FindStringSubmatch(client.buf.String())
|
||||
f, _ := strconv.ParseFloat(match[1], 64)
|
||||
return f
|
||||
}
|
||||
if err := teststat.TestCounter(counter, value); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGauge(t *testing.T) {
|
||||
in := New(map[string]string{"foo": "alpha"}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
re := regexp.MustCompile(`influx_gauge,foo=alpha value=([0-9\.]+) [0-9]+`)
|
||||
gauge := in.NewGauge("influx_gauge")
|
||||
value := func() float64 {
|
||||
client := &bufWriter{}
|
||||
in.WriteTo(client)
|
||||
match := re.FindStringSubmatch(client.buf.String())
|
||||
f, _ := strconv.ParseFloat(match[1], 64)
|
||||
return f
|
||||
}
|
||||
if err := teststat.TestGauge(gauge, value); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHistogram(t *testing.T) {
|
||||
in := New(map[string]string{"foo": "alpha"}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
re := regexp.MustCompile(`influx_histogram,bar=beta,foo=alpha p50=([0-9\.]+),p90=([0-9\.]+),p95=([0-9\.]+),p99=([0-9\.]+) [0-9]+`)
|
||||
histogram := in.NewHistogram("influx_histogram").With("bar", "beta")
|
||||
quantiles := func() (float64, float64, float64, float64) {
|
||||
w := &bufWriter{}
|
||||
in.WriteTo(w)
|
||||
match := re.FindStringSubmatch(w.buf.String())
|
||||
if len(match) != 5 {
|
||||
t.Errorf("These are not the quantiles you're looking for: %v\n", match)
|
||||
}
|
||||
var result [4]float64
|
||||
for i, q := range match[1:] {
|
||||
result[i], _ = strconv.ParseFloat(q, 64)
|
||||
}
|
||||
return result[0], result[1], result[2], result[3]
|
||||
}
|
||||
if err := teststat.TestHistogram(histogram, quantiles, 0.01); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
}
|
||||
|
||||
func TestHistogramLabels(t *testing.T) {
|
||||
in := New(map[string]string{}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
h := in.NewHistogram("foo")
|
||||
h.Observe(123)
|
||||
h.With("abc", "xyz").Observe(456)
|
||||
w := &bufWriter{}
|
||||
if err := in.WriteTo(w); err != nil {
|
||||
t.Fatal(err)
|
||||
}
|
||||
if want, have := 2, len(strings.Split(strings.TrimSpace(w.buf.String()), "\n")); want != have {
|
||||
t.Errorf("want %d, have %d", want, have)
|
||||
}
|
||||
}
|
||||
|
||||
func TestIssue404(t *testing.T) {
|
||||
in := New(map[string]string{}, influxdb.BatchPointsConfig{}, log.NewNopLogger())
|
||||
|
||||
counterOne := in.NewCounter("influx_counter_one").With("a", "b")
|
||||
counterOne.Add(123)
|
||||
|
||||
counterTwo := in.NewCounter("influx_counter_two").With("c", "d")
|
||||
counterTwo.Add(456)
|
||||
|
||||
w := &bufWriter{}
|
||||
in.WriteTo(w)
|
||||
|
||||
lines := strings.Split(strings.TrimSpace(w.buf.String()), "\n")
|
||||
if want, have := 2, len(lines); want != have {
|
||||
t.Fatalf("want %d, have %d", want, have)
|
||||
}
|
||||
for _, line := range lines {
|
||||
if strings.HasPrefix(line, "influx_counter_one") {
|
||||
if !strings.HasPrefix(line, "influx_counter_one,a=b count=123 ") {
|
||||
t.Errorf("invalid influx_counter_one: %s", line)
|
||||
}
|
||||
} else if strings.HasPrefix(line, "influx_counter_two") {
|
||||
if !strings.HasPrefix(line, "influx_counter_two,c=d count=456 ") {
|
||||
t.Errorf("invalid influx_counter_two: %s", line)
|
||||
}
|
||||
} else {
|
||||
t.Errorf("unexpected line: %s", line)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
type bufWriter struct {
|
||||
buf bytes.Buffer
|
||||
}
|
||||
|
||||
func (w *bufWriter) Write(bp influxdb.BatchPoints) error {
|
||||
for _, p := range bp.Points() {
|
||||
fmt.Fprintf(&w.buf, p.String()+"\n")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
Reference in New Issue
Block a user