Merge metric controller and holder (#925)

* merge metric controller and holder

* decrease SecondsBucketsDetailedNano buckets count

Author: timggggggg

fd/file.d.go

@@ -36,7 +36,7 @@ type FileD struct {
 
 	// file_d metrics
 
-	versionMetric *prometheus.GaugeVec
+	versionMetric *metric.GaugeVec
 }
 
 func New(config *cfg.Config, httpAddr string) *FileD {
@@ -63,7 +63,7 @@ func (f *FileD) Start() {
 }
 
 func (f *FileD) initMetrics() {
-	f.metricCtl = metric.NewCtl("file_d", f.registry)
+	f.metricCtl = metric.NewCtl("file_d", f.registry, 0)
 	f.versionMetric = f.metricCtl.RegisterGaugeVec("version", "", "version")
 	f.versionMetric.WithLabelValues(buildinfo.Version).Inc()
 }

metric/controller.go

@@ -2,6 +2,7 @@ package metric
 
 import (
 	"sync"
+	"time"
 
 	"github.com/prometheus/client_golang/prometheus"
 )
@@ -11,73 +12,95 @@ const (
 )
 
 var (
-	SecondsBucketsDetailedNano = prometheus.ExponentialBuckets(0.000005, 2, 19) // covers range from 5ns to 1.3ms
-	SecondsBucketsDetailed     = prometheus.ExponentialBuckets(0.0005, 2, 16)   // covers range from 500us to 16.384s
-	SecondsBucketsLong         = prometheus.ExponentialBuckets(0.005, 2, 16)    // covers range from 5ms to 163.84s
+	SecondsBucketsDetailedNano = prometheus.ExponentialBuckets(0.000005, 2.18, 17) // covers range from 5µs to 1.3s
+	SecondsBucketsDetailed     = prometheus.ExponentialBuckets(0.0005, 2, 16)      // covers range from 500µs to 16.384s
+	SecondsBucketsLong         = prometheus.ExponentialBuckets(0.005, 2, 16)       // covers range from 5000µs to 163.84s
 )
 
 type Ctl struct {
 	subsystem string
 	register  *prometheus.Registry
 
+	holder  *Holder
 	metrics map[string]prometheus.Collector
 	mu      sync.RWMutex
 }
 
-func NewCtl(subsystem string, registry *prometheus.Registry) *Ctl {
+func NewCtl(subsystem string, registry *prometheus.Registry, metricHoldDuration time.Duration) *Ctl {
 	ctl := &Ctl{
 		subsystem: subsystem,
 		register:  registry,
 		metrics:   make(map[string]prometheus.Collector),
 	}
+
+	if metricHoldDuration != 0 {
+		ctl.holder = NewHolder(metricHoldDuration)
+	}
+
 	return ctl
 }
 
-func (mc *Ctl) RegisterCounter(name, help string) prometheus.Counter {
+func (mc *Ctl) Maintenance() {
+	if mc.holder == nil {
+		return
+	}
+
+	mc.holder.maintenance()
+}
+
+func (mc *Ctl) AddToHolder(mv heldMetricVec) {
+	if mc.holder == nil {
+		return
+	}
+
+	mc.holder.addMetricVec(mv)
+}
+
+func (mc *Ctl) RegisterCounter(name, help string) *Counter {
 	counter := prometheus.NewCounter(prometheus.CounterOpts{
 		Namespace: PromNamespace,
 		Subsystem: mc.subsystem,
 		Name:      name,
 		Help:      help,
 	})
 
-	return mc.registerMetric(name, counter).(prometheus.Counter)
+	return newCounter(mc.registerMetric(name, counter).(prometheus.Counter))
 }
 
-func (mc *Ctl) RegisterCounterVec(name, help string, labels ...string) *prometheus.CounterVec {
+func (mc *Ctl) RegisterCounterVec(name, help string, labels ...string) *CounterVec {
 	counterVec := prometheus.NewCounterVec(prometheus.CounterOpts{
 		Namespace: PromNamespace,
 		Subsystem: mc.subsystem,
 		Name:      name,
 		Help:      help,
 	}, labels)
 
-	return mc.registerMetric(name, counterVec).(*prometheus.CounterVec)
+	return newCounterVec(mc.registerMetric(name, counterVec).(*prometheus.CounterVec))
 }
 
-func (mc *Ctl) RegisterGauge(name, help string) prometheus.Gauge {
+func (mc *Ctl) RegisterGauge(name, help string) *Gauge {
 	gauge := prometheus.NewGauge(prometheus.GaugeOpts{
 		Namespace: PromNamespace,
 		Subsystem: mc.subsystem,
 		Name:      name,
 		Help:      help,
 	})
 
-	return mc.registerMetric(name, gauge).(prometheus.Gauge)
+	return newGauge(mc.registerMetric(name, gauge).(prometheus.Gauge))
 }
 
-func (mc *Ctl) RegisterGaugeVec(name, help string, labels ...string) *prometheus.GaugeVec {
+func (mc *Ctl) RegisterGaugeVec(name, help string, labels ...string) *GaugeVec {
 	gaugeVec := prometheus.NewGaugeVec(prometheus.GaugeOpts{
 		Namespace: PromNamespace,
 		Subsystem: mc.subsystem,
 		Name:      name,
 		Help:      help,
 	}, labels)
 
-	return mc.registerMetric(name, gaugeVec).(*prometheus.GaugeVec)
+	return newGaugeVec(mc.registerMetric(name, gaugeVec).(*prometheus.GaugeVec))
 }
 
-func (mc *Ctl) RegisterHistogram(name, help string, buckets []float64) prometheus.Histogram {
+func (mc *Ctl) RegisterHistogram(name, help string, buckets []float64) *Histogram {
 	histogram := prometheus.NewHistogram(prometheus.HistogramOpts{
 		Namespace: PromNamespace,
 		Subsystem: mc.subsystem,
@@ -86,10 +109,10 @@ func (mc *Ctl) RegisterHistogram(name, help string, buckets []float64) prometheu
 		Buckets:   buckets,
 	})
 
-	return mc.registerMetric(name, histogram).(prometheus.Histogram)
+	return newHistogram(mc.registerMetric(name, histogram).(prometheus.Histogram))
 }
 
-func (mc *Ctl) RegisterHistogramVec(name, help string, buckets []float64, labels ...string) *prometheus.HistogramVec {
+func (mc *Ctl) RegisterHistogramVec(name, help string, buckets []float64, labels ...string) *HistogramVec {
 	histogramVec := prometheus.NewHistogramVec(prometheus.HistogramOpts{
 		Namespace: PromNamespace,
 		Subsystem: mc.subsystem,
@@ -98,7 +121,7 @@ func (mc *Ctl) RegisterHistogramVec(name, help string, buckets []float64, labels
 		Buckets:   buckets,
 	}, labels)
 
-	return mc.registerMetric(name, histogramVec).(*prometheus.HistogramVec)
+	return newHistogramVec(mc.registerMetric(name, histogramVec).(*prometheus.HistogramVec))
 }
 
 func (mc *Ctl) registerMetric(name string, newMetric prometheus.Collector) prometheus.Collector {

metric/counter.go

@@ -0,0 +1,59 @@
+package metric
+
+import (
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/testutil"
+)
+
+type Counter struct {
+	*heldMetric[prometheus.Counter]
+}
+
+func newCounter(c prometheus.Counter) *Counter {
+	return &Counter{
+		heldMetric: newHeldMetric(nil, c),
+	}
+}
+
+func (c *Counter) Inc() {
+	c.metric.Inc()
+	c.updateUsage()
+}
+
+func (c *Counter) Add(v float64) {
+	c.metric.Add(v)
+	c.updateUsage()
+}
+
+// should only be used in tests
+func (c *Counter) ToFloat64() float64 {
+	return testutil.ToFloat64(c.metric)
+}
+
+type CounterVec struct {
+	store *heldMetricsStore[prometheus.Counter]
+	vec   *prometheus.CounterVec
+}
+
+func newCounterVec(cv *prometheus.CounterVec) *CounterVec {
+	return &CounterVec{
+		vec:   cv,
+		store: newHeldMetricsStore[prometheus.Counter](),
+	}
+}
+
+func (cv *CounterVec) WithLabelValues(lvs ...string) *Counter {
+	return &Counter{
+		heldMetric: cv.store.GetOrCreate(lvs, cv.vec.WithLabelValues),
+	}
+}
+
+func (cv *CounterVec) DeleteLabelValues(lvs ...string) bool {
+	return cv.store.Delete(lvs, cv.vec)
+}
+
+func (cv *CounterVec) DeleteOldMetrics(holdDuration time.Duration) {
+	cv.store.DeleteOldMetrics(holdDuration, cv.vec)
+}

metric/gauge.go

@@ -0,0 +1,74 @@
+package metric
+
+import (
+	"time"
+
+	"github.com/prometheus/client_golang/prometheus"
+	"github.com/prometheus/client_golang/prometheus/testutil"
+)
+
+type Gauge struct {
+	*heldMetric[prometheus.Gauge]
+}
+
+func newGauge(c prometheus.Gauge) *Gauge {
+	return &Gauge{
+		heldMetric: newHeldMetric(nil, c),
+	}
+}
+
+func (g *Gauge) Set(v float64) {
+	g.metric.Set(v)
+	g.updateUsage()
+}
+
+func (g *Gauge) Inc() {
+	g.metric.Inc()
+	g.updateUsage()
+}
+
+func (g *Gauge) Dec() {
+	g.metric.Dec()
+	g.updateUsage()
+}
+
+func (g *Gauge) Add(v float64) {
+	g.metric.Add(v)
+	g.updateUsage()
+}
+
+func (g *Gauge) Sub(v float64) {
+	g.metric.Sub(v)
+	g.updateUsage()
+}
+
+// should only be used in tests
+func (c *Gauge) ToFloat64() float64 {
+	return testutil.ToFloat64(c.metric)
+}
+
+type GaugeVec struct {
+	store *heldMetricsStore[prometheus.Gauge]
+	vec   *prometheus.GaugeVec
+}
+
+func newGaugeVec(gv *prometheus.GaugeVec) *GaugeVec {
+	return &GaugeVec{
+		vec:   gv,
+		store: newHeldMetricsStore[prometheus.Gauge](),
+	}
+}
+
+func (gv *GaugeVec) WithLabelValues(lvs ...string) *Gauge {
+	return &Gauge{
+		heldMetric: gv.store.GetOrCreate(lvs, gv.vec.WithLabelValues),
+	}
+}
+
+func (cv *GaugeVec) DeleteLabelValues(lvs ...string) bool {
+	return cv.store.Delete(lvs, cv.vec)
+}
+
+func (gv *GaugeVec) DeleteOldMetrics(holdDuration time.Duration) {
+	gv.store.DeleteOldMetrics(holdDuration, gv.vec)
+}