Initial commit

metrics/prometheus/prometheus.go

@@ -0,0 +1,169 @@
+package prometheus
+
+import (
+	"github.com/prometheus/client_golang/prometheus"
+	"globalfintech/golib/metrics"
+)
+
+// Counter implements Counter, via a Prometheus CounterVec.
+type Counter struct {
+	Cv  *prometheus.CounterVec
+	lvs metrics.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)
+}
+
+// Inc implement Counter.
+func (c *Counter) Inc() {
+	c.Cv.With(makeLabels(c.lvs...)).Inc()
+}
+
+// Gauge implements Gauge, via a Prometheus GaugeVec.
+type Gauge struct {
+	gv  *prometheus.GaugeVec
+	lvs metrics.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)
+}
+
+// Sub is supported by Prometheus GaugeVecs.
+func (g *Gauge) Sub(delta float64) {
+	g.gv.With(makeLabels(g.lvs...)).Sub(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 metrics.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 metrics.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
+}

metrics/prometheus/prometheus_test.go

@@ -0,0 +1,61 @@
+package prometheus
+
+import (
+	"fmt"
+	stdprometheus "github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/promhttp"
+	"globalfintech/golib/metrics"
+	"io/ioutil"
+	"math/rand"
+	"net/http"
+	"net/http/httptest"
+	"regexp"
+	"strconv"
+	"testing"
+)
+
+func TestCounter(t *testing.T) {
+	s := httptest.NewServer(promhttp.Handler())
+	defer s.Close()
+
+	scrape := func() string {
+		resp, _ := http.Get(s.URL)
+		buf, _ := ioutil.ReadAll(resp.Body)
+		return string(buf)
+	}
+
+	namespace, subsystem, name := "ns", "ss", "foo"
+	re := regexp.MustCompile(namespace + `_` + subsystem + `_` + name + `{alpha="alpha-value",beta="beta-value"} ([0-9\.]+)`)
+
+	counter := NewCounterFrom(stdprometheus.CounterOpts{
+		Namespace: namespace,
+		Subsystem: subsystem,
+		Name:      name,
+		Help:      "This is the help string.",
+	}, []string{"alpha", "beta"}).With("beta", "beta-value", "alpha", "alpha-value") // order shouldn't matter
+
+	value := func() float64 {
+		matches := re.FindStringSubmatch(scrape())
+		f, _ := strconv.ParseFloat(matches[1], 64)
+		return f
+	}
+	want := FillCounter(counter)
+	if have := value(); want != have {
+		t.Fatal(fmt.Errorf("want %f, have %f", want, have))
+	}
+
+}
+
+// FillCounter puts some deltas through the counter and returns the total value.
+func FillCounter(counter metrics.Counter) float64 {
+	a := rand.Perm(100)
+	n := rand.Intn(len(a))
+
+	var want float64
+	for i := 0; i < n; i++ {
+		f := float64(a[i])
+		counter.Add(f)
+		want += f
+	}
+	return want
+}