Metrics package

pkg/metrics/gauge.go

@@ -0,0 +1,53 @@
+package metrics
+
+import (
+	"fmt"
+	"strings"
+	"sync"
+	"time"
+)
+
+// Gauge is a metric type that represents a single numerical value that can
+// arbitrarily go up and down.
+type Gauge struct {
+	name   string
+	labels map[string]string
+
+	value     float64
+	timestamp int64
+	mutex     sync.RWMutex
+}
+
+// Set allows setting the gauge to an arbitrary value.
+func (g *Gauge) Set(value float64) {
+	g.mutex.Lock()
+	defer g.mutex.Unlock()
+
+	g.value = value
+	g.timestamp = time.Now().UnixNano() / int64(time.Millisecond)
+}
+
+// Exposes the gauge in the text-based exposition format.
+func (g *Gauge) expose() string {
+	g.mutex.RLock()
+	defer g.mutex.RUnlock()
+
+	typeLine := fmt.Sprintf("# TYPE %v %v", g.name, "gauge")
+
+	labelsStrings := make([]string, 0)
+	for name, value := range g.labels {
+		labelsStrings = append(
+			labelsStrings,
+			fmt.Sprintf("%v=\"%v\"", name, value),
+		)
+	}
+	labels := strings.Join(labelsStrings, ",")
+
+	if len(labels) > 0 {
+		labels = "{" + labels + "}"
+	}
+
+	body := fmt.Sprintf("%v%v %v %v", g.name, labels, g.value, g.timestamp)
+
+	return fmt.Sprintf("%v\n%v", typeLine, body)
+}

pkg/metrics/gauge_test.go

@@ -0,0 +1,84 @@
+package metrics
+
+import (
+	"testing"
+)
+
+func TestGaugeSet(t *testing.T) {
+	gauge := &Gauge{
+		name:   "test_gauge",
+		labels: map[string]string{"label": "value"},
+	}
+
+	if gauge.value != 0 {
+		t.Fatal("incorrect gauge initial value")
+	}
+
+	if gauge.timestamp != 0 {
+		t.Fatal("incorrect gauge initial timestamp")
+	}
+
+	newGaugeValue := float64(500)
+
+	gauge.Set(newGaugeValue)
+
+	if gauge.value != newGaugeValue {
+		t.Fatalf(
+			"incorrect gauge value:\n"+
+				"expected: [%v]\n"+
+				"actual:   [%v]",
+			newGaugeValue,
+			gauge.value,
+		)
+	}
+
+	if gauge.timestamp == 0 {
+		t.Fatal("timestamp should be set")
+	}
+}
+
+func TestGaugeExpose(t *testing.T) {
+	gauge := &Gauge{
+		name:      "test_gauge",
+		labels:    map[string]string{"label": "value"},
+		value:     500,
+		timestamp: 1000,
+	}
+
+	actualText := gauge.expose()
+
+	expectedText := "# TYPE test_gauge gauge\ntest_gauge{label=\"value\"} 500 1000"
+
+	if actualText != expectedText {
+		t.Fatalf(
+			"incorrect gauge expose text:\n"+
+				"expected: [%v]\n"+
+				"actual:   [%v]",
+			expectedText,
+			actualText,
+		)
+	}
+}
+
+func TestGaugeWithoutLabelsExpose(t *testing.T) {
+	gauge := &Gauge{
+		name:      "test_gauge",
+		labels:    map[string]string{},
+		value:     500,
+		timestamp: 1000,
+	}
+
+	actualText := gauge.expose()
+
+	expectedText := "# TYPE test_gauge gauge\ntest_gauge 500 1000"
+
+	if actualText != expectedText {
+		t.Fatalf(
+			"incorrect gauge expose text:\n"+
+				"expected: [%v]\n"+
+				"actual:   [%v]",
+			expectedText,
+			actualText,
+		)
+	}
+}

pkg/metrics/info.go

@@ -0,0 +1,27 @@
+package metrics
+
+import (
+	"fmt"
+	"strings"
+)
+
+// Info is a metric type that represents a constant information
+// that cannot change in the time.
+type Info struct {
+	name   string
+	labels map[string]string
+}
+
+// Exposes the info in the text-based exposition format.
+func (i *Info) expose() string {
+	labelsStrings := make([]string, 0)
+	for name, value := range i.labels {
+		labelsStrings = append(
+			labelsStrings,
+			fmt.Sprintf("%v=\"%v\"", name, value),
+		)
+	}
+	labels := strings.Join(labelsStrings, ",")
+
+	return fmt.Sprintf("%v{%v} %v", i.name, labels, "1")
+}

pkg/metrics/info_test.go

@@ -0,0 +1,24 @@
+package metrics
+
+import "testing"
+
+func TestInfoExpose(t *testing.T) {
+	info := &Info{
+		name:   "test_info",
+		labels: map[string]string{"label": "value"},
+	}
+
+	actualText := info.expose()
+
+	expectedText := "test_info{label=\"value\"} 1"
+
+	if actualText != expectedText {
+		t.Fatalf(
+			"incorrect gauge expose text:\n"+
+				"expected: [%v]\n"+
+				"actual:   [%v]",
+			expectedText,
+			actualText,
+		)
+	}
+}

pkg/metrics/observer.go

@@ -0,0 +1,40 @@
+package metrics
+
+import (
+	"context"
+	"time"
+)
+
+// ObserverInput defines a source of metric data.
+type ObserverInput func() float64
+
+// ObserverOutput defines a destination of collected metric data.
+type ObserverOutput interface {
+	Set(value float64)
+}
+
+// Observer represent a definition of a cyclic metric observation process.
+type Observer struct {
+	input  ObserverInput
+	output ObserverOutput
+}
+
+// Observe triggers a cyclic metric observation process.
+func (o *Observer) Observe(
+	ctx context.Context,
+	tick time.Duration,
+) {
+	go func() {
+		ticker := time.NewTicker(tick)
+		defer ticker.Stop()
+
+		for {
+			select {
+			case <-ticker.C:
+				o.output.Set(o.input())
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
+}

pkg/metrics/observer_test.go

@@ -0,0 +1,36 @@
+package metrics
+
+import (
+	"context"
+	"testing"
+	"time"
+)
+
+func TestObserve(t *testing.T) {
+	input := func() float64 {
+		return 5000
+	}
+	gauge := &Gauge{}
+	ctx, _ := context.WithTimeout(context.Background(), 5*time.Millisecond)
+
+	observer := &Observer{input, gauge}
+
+	observer.Observe(ctx, 1*time.Millisecond)
+
+	<-ctx.Done()
+
+	expectedGaugeValue := float64(5000)
+	if gauge.value != expectedGaugeValue {
+		t.Fatalf(
+			"incorrect gauge value:\n"+
+				"expected: [%v]\n"+
+				"actual:   [%v]",
+			expectedGaugeValue,
+			gauge.value,
+		)
+	}
+
+	if gauge.timestamp == 0 {
+		t.Fatal("timestamp should be set")
+	}
+}