Merge #37248

37248: util/metric: make Rate into a real metric r=ajwerner a=ajwerner

The metric package had a Rate type to track an exponential weighted moving
average for a Rate but it was unclear how a caller would use it as a metric
in a metric struct. This PR makes that Rate type into a real metric in
anticipation of using it to track throughputs.

Release note: None

Co-authored-by: Andrew Werner <[email protected]>

Author: craig[bot]

pkg/server/status/recorder.go

@@ -541,6 +541,8 @@ func extractValue(mtr interface{}) (float64, error) {
 		return float64(mtr.Count()), nil
 	case *metric.Gauge:
 		return float64(mtr.Value()), nil
+	case *metric.Rate:
+		return mtr.Value(), nil
 	case *metric.GaugeFloat64:
 		return mtr.Value(), nil
 	default:

pkg/util/metric/metric.go

@@ -27,7 +27,7 @@ import (
 	"github.com/codahale/hdrhistogram"
 	"github.com/gogo/protobuf/proto"
 	prometheusgo "github.com/prometheus/client_model/go"
-	"github.com/rcrowley/go-metrics"
+	metrics "github.com/rcrowley/go-metrics"
 )
 
 const (
@@ -125,16 +125,19 @@ var _ Iterable = &Gauge{}
 var _ Iterable = &GaugeFloat64{}
 var _ Iterable = &Counter{}
 var _ Iterable = &Histogram{}
+var _ Iterable = &Rate{}
 
 var _ json.Marshaler = &Gauge{}
 var _ json.Marshaler = &GaugeFloat64{}
 var _ json.Marshaler = &Counter{}
 var _ json.Marshaler = &Registry{}
+var _ json.Marshaler = &Rate{}
 
 var _ PrometheusExportable = &Gauge{}
 var _ PrometheusExportable = &GaugeFloat64{}
 var _ PrometheusExportable = &Counter{}
 var _ PrometheusExportable = &Histogram{}
+var _ PrometheusExportable = &Rate{}
 
 type periodic interface {
 	nextTick() time.Time
@@ -453,7 +456,7 @@ func (g *GaugeFloat64) GetType() *prometheusgo.MetricType {
 	return prometheusgo.MetricType_GAUGE.Enum()
 }
 
-// Inspect calls the given closure with the empty string and itself.
+// Inspect calls the given closure with itself.
 func (g *GaugeFloat64) Inspect(f func(interface{})) { f(g) }
 
 // MarshalJSON marshals to JSON.
@@ -478,6 +481,7 @@ func (g *GaugeFloat64) GetMetadata() Metadata {
 
 // A Rate is a exponential weighted moving average.
 type Rate struct {
+	Metadata
 	mu       syncutil.Mutex // protects fields below
 	curSum   float64
 	wrapped  ewma.MovingAverage
@@ -487,20 +491,48 @@ type Rate struct {
 
 // NewRate creates an EWMA rate on the given timescale. Timescales at
 // or below 2s are illegal and will cause a panic.
-func NewRate(timescale time.Duration) *Rate {
+func NewRate(metadata Metadata, timescale time.Duration) *Rate {
 	const tickInterval = time.Second
 	if timescale <= 2*time.Second {
 		panic(fmt.Sprintf("EWMA with per-second ticks makes no sense on timescale %s", timescale))
 	}
 	avgAge := float64(timescale) / float64(2*tickInterval)
-
 	return &Rate{
+		Metadata: metadata,
 		interval: tickInterval,
 		nextT:    now(),
 		wrapped:  ewma.NewMovingAverage(avgAge),
 	}
 }
 
+// GetType returns the prometheus type enum for this metric.
+func (e *Rate) GetType() *prometheusgo.MetricType {
+	return prometheusgo.MetricType_GAUGE.Enum()
+}
+
+// Inspect calls the given closure with itself.
+func (e *Rate) Inspect(f func(interface{})) { f(e) }
+
+// MarshalJSON marshals to JSON.
+func (e *Rate) MarshalJSON() ([]byte, error) {
+	return json.Marshal(e.Value())
+}
+
+// ToPrometheusMetric returns a filled-in prometheus metric of the right type.
+func (e *Rate) ToPrometheusMetric() *prometheusgo.Metric {
+	return &prometheusgo.Metric{
+		Gauge: &prometheusgo.Gauge{Value: proto.Float64(e.Value())},
+	}
+}
+
+// GetMetadata returns the metric's metadata including the Prometheus
+// MetricType.
+func (e *Rate) GetMetadata() Metadata {
+	baseMetadata := e.Metadata
+	baseMetadata.MetricType = prometheusgo.MetricType_GAUGE
+	return baseMetadata
+}
+
 // Value returns the current value of the Rate.
 func (e *Rate) Value() float64 {
 	e.mu.Lock()

pkg/util/metric/metric_test.go

@@ -75,6 +75,15 @@ func TestGaugeFloat64(t *testing.T) {
 	testMarshal(t, g, "10.4")
 }
 
+func TestRate(t *testing.T) {
+	r := NewRate(emptyMetadata, time.Minute)
+	r.Add(0)
+	if v := r.Value(); v != 0 {
+		t.Fatalf("unexpected value: %f", v)
+	}
+	testMarshal(t, r, "0")
+}
+
 func TestCounter(t *testing.T) {
 	c := NewCounter(emptyMetadata)
 	c.Inc(90)
@@ -164,7 +173,7 @@ func TestRateRotate(t *testing.T) {
 	defer TestingSetNow(nil)()
 	setNow(0)
 	const interval = 10 * time.Second
-	r := NewRate(interval)
+	r := NewRate(emptyMetadata, interval)
 
 	// Skip the warmup phase of the wrapped EWMA for this test.
 	for i := 0; i < 100; i++ {