Added options support to SendSumOfCountersPerUser() (#1794)

* Added options support to SendSumOfCountersPerUser()

Signed-off-by: Marco Pracucci <[email protected]>

* Renamed SkipZeroValueMetrics() to WithSkipZeroValueMetrics()

Signed-off-by: Marco Pracucci <[email protected]>

Author: pracucci

pkg/alertmanager/alertmanager_metrics.go

@@ -296,10 +296,10 @@ func (m *alertmanagerMetrics) Collect(out chan<- prometheus.Metric) {
 	data.SendSumOfCountersPerUser(out, m.alertsReceived, "alertmanager_alerts_received_total")
 	data.SendSumOfCountersPerUser(out, m.alertsInvalid, "alertmanager_alerts_invalid_total")
 
-	data.SendSumOfCountersPerUserWithLabelsAndOptions(out, m.numNotifications, "alertmanager_notifications_total", []string{"integration"}, util.SkipZeroValueMetrics)
-	data.SendSumOfCountersPerUserWithLabelsAndOptions(out, m.numFailedNotifications, "alertmanager_notifications_failed_total", []string{"integration"}, util.SkipZeroValueMetrics)
-	data.SendSumOfCountersPerUserWithLabelsAndOptions(out, m.numNotificationRequestsTotal, "alertmanager_notification_requests_total", []string{"integration"}, util.SkipZeroValueMetrics)
-	data.SendSumOfCountersPerUserWithLabelsAndOptions(out, m.numNotificationRequestsFailedTotal, "alertmanager_notification_requests_failed_total", []string{"integration"}, util.SkipZeroValueMetrics)
+	data.SendSumOfCountersPerUser(out, m.numNotifications, "alertmanager_notifications_total", util.WithLabels("integration"), util.WithSkipZeroValueMetrics)
+	data.SendSumOfCountersPerUser(out, m.numFailedNotifications, "alertmanager_notifications_failed_total", util.WithLabels("integration"), util.WithSkipZeroValueMetrics)
+	data.SendSumOfCountersPerUser(out, m.numNotificationRequestsTotal, "alertmanager_notification_requests_total", util.WithLabels("integration"), util.WithSkipZeroValueMetrics)
+	data.SendSumOfCountersPerUser(out, m.numNotificationRequestsFailedTotal, "alertmanager_notification_requests_failed_total", util.WithLabels("integration"), util.WithSkipZeroValueMetrics)
 	data.SendSumOfHistograms(out, m.notificationLatencySeconds, "alertmanager_notification_latency_seconds")
 	data.SendSumOfGaugesPerUserWithLabels(out, m.markerAlerts, "alertmanager_alerts", "state")
 
@@ -334,7 +334,7 @@ func (m *alertmanagerMetrics) Collect(out chan<- prometheus.Metric) {
 	data.SendSumOfCounters(out, m.persistTotal, "alertmanager_state_persist_total")
 	data.SendSumOfCounters(out, m.persistFailed, "alertmanager_state_persist_failed_total")
 
-	data.SendSumOfCountersPerUserWithLabelsAndOptions(out, m.notificationRateLimited, "alertmanager_notification_rate_limited_total", []string{"integration"}, util.SkipZeroValueMetrics)
+	data.SendSumOfCountersPerUser(out, m.notificationRateLimited, "alertmanager_notification_rate_limited_total", util.WithLabels("integration"), util.WithSkipZeroValueMetrics)
 	data.SendSumOfCountersPerUser(out, m.dispatcherAggregationGroupsLimitReached, "alertmanager_dispatcher_aggregation_group_limit_reached_total")
 	data.SendSumOfCountersPerUser(out, m.insertAlertFailures, "alertmanager_alerts_insert_limited_total")
 	data.SendSumOfGaugesPerUser(out, m.alertsLimiterAlertsCount, "alertmanager_alerts_limiter_current_alerts")

pkg/ruler/manager_metrics.go

@@ -139,10 +139,10 @@ func (m *ManagerMetrics) Collect(out chan<- prometheus.Metric) {
 	data.SendSumOfSummariesPerUser(out, m.EvalDuration, "prometheus_rule_evaluation_duration_seconds")
 	data.SendSumOfSummariesPerUser(out, m.IterationDuration, "prometheus_rule_group_duration_seconds")
 
-	data.SendSumOfCountersPerUserWithLabels(out, m.IterationsMissed, "prometheus_rule_group_iterations_missed_total", "rule_group")
-	data.SendSumOfCountersPerUserWithLabels(out, m.IterationsScheduled, "prometheus_rule_group_iterations_total", "rule_group")
-	data.SendSumOfCountersPerUserWithLabels(out, m.EvalTotal, "prometheus_rule_evaluations_total", "rule_group")
-	data.SendSumOfCountersPerUserWithLabels(out, m.EvalFailures, "prometheus_rule_evaluation_failures_total", "rule_group")
+	data.SendSumOfCountersPerUser(out, m.IterationsMissed, "prometheus_rule_group_iterations_missed_total", util.WithLabels("rule_group"))
+	data.SendSumOfCountersPerUser(out, m.IterationsScheduled, "prometheus_rule_group_iterations_total", util.WithLabels("rule_group"))
+	data.SendSumOfCountersPerUser(out, m.EvalTotal, "prometheus_rule_evaluations_total", util.WithLabels("rule_group"))
+	data.SendSumOfCountersPerUser(out, m.EvalFailures, "prometheus_rule_evaluation_failures_total", util.WithLabels("rule_group"))
 	data.SendSumOfGaugesPerUserWithLabels(out, m.GroupInterval, "prometheus_rule_group_interval_seconds", "rule_group")
 	data.SendSumOfGaugesPerUserWithLabels(out, m.GroupLastEvalTime, "prometheus_rule_group_last_evaluation_timestamp_seconds", "rule_group")
 	data.SendSumOfGaugesPerUserWithLabels(out, m.GroupLastDuration, "prometheus_rule_group_last_duration_seconds", "rule_group")

pkg/util/metrics_helper.go

@@ -162,27 +162,18 @@ func (d MetricFamiliesPerUser) SendSumOfCountersWithLabels(out chan<- prometheus
 	d.sumOfSingleValuesWithLabels(counter, counterValue, labelNames, false).WriteToMetricChannel(out, desc, prometheus.CounterValue)
 }
 
-func (d MetricFamiliesPerUser) SendSumOfCountersPerUser(out chan<- prometheus.Metric, desc *prometheus.Desc, counter string) {
-	d.SendSumOfCountersPerUserWithLabels(out, desc, counter)
-}
-
-// SendSumOfCountersPerUserWithLabels provides metrics with the provided label names on a per-user basis. This function assumes that `user` is the
-// first label on the provided metric Desc
-func (d MetricFamiliesPerUser) SendSumOfCountersPerUserWithLabels(out chan<- prometheus.Metric, desc *prometheus.Desc, metric string, labelNames ...string) {
-	d.SendSumOfCountersPerUserWithLabelsAndOptions(out, desc, metric, labelNames)
-}
+// SendSumOfCountersPerUser provides metrics on a per-user basis, with additional and optional label names.
+// This function assumes that `user` is the first label on the provided metric Desc.
+func (d MetricFamiliesPerUser) SendSumOfCountersPerUser(out chan<- prometheus.Metric, desc *prometheus.Desc, metric string, options ...MetricOption) {
+	opts := applyMetricOptions(options...)
 
-// SendSumOfCountersPerUserWithLabelsAndOptions provides metrics with the provided label names on a per-user basis. This function assumes that `user` is the
-// first label on the provided metric Desc
-func (d MetricFamiliesPerUser) SendSumOfCountersPerUserWithLabelsAndOptions(out chan<- prometheus.Metric, desc *prometheus.Desc, metric string, labelNames []string, options ...MetricOption) {
 	for _, userEntry := range d {
 		if userEntry.user == "" {
 			continue
 		}
 
 		result := singleValueWithLabelsMap{}
-		opts := applyMetricOptions(options...)
-		userEntry.metrics.sumOfSingleValuesWithLabels(metric, labelNames, counterValue, result.aggregateFn, opts.skipZeroValueMetrics)
+		userEntry.metrics.sumOfSingleValuesWithLabels(metric, opts.labelNames, counterValue, result.aggregateFn, opts.skipZeroValueMetrics)
 		result.prependUserLabelValue(userEntry.user)
 		result.WriteToMetricChannel(out, desc, prometheus.CounterValue)
 	}
@@ -825,11 +816,18 @@ type CollectorVec interface {
 // MetricOption defines a functional-style option for metrics aggregation.
 type MetricOption func(options *metricOptions)
 
-// SkipZeroValueMetrics controls whether metrics aggregation should skip zero value metrics.
-func SkipZeroValueMetrics(options *metricOptions) {
+// WithSkipZeroValueMetrics controls whether metrics aggregation should skip zero value metrics.
+func WithSkipZeroValueMetrics(options *metricOptions) {
 	options.skipZeroValueMetrics = true
 }
 
+// WithLabels set labels to use for aggregations.
+func WithLabels(labelNames ...string) MetricOption {
+	return func(options *metricOptions) {
+		options.labelNames = labelNames
+	}
+}
+
 // applyMetricOptions returns a metricOptions with all the input options applied.
 func applyMetricOptions(options ...MetricOption) *metricOptions {
 	actual := &metricOptions{}
@@ -842,4 +840,5 @@ func applyMetricOptions(options ...MetricOption) *metricOptions {
 
 type metricOptions struct {
 	skipZeroValueMetrics bool
+	labelNames           []string
 }

pkg/util/metrics_helper_test.go

@@ -322,9 +322,9 @@ func TestSendSumOfHistogramsWithLabels(t *testing.T) {
 	}
 }
 
-// TestSendSumOfCountersPerUserWithLabels tests to ensure multiple metrics for the same user with a matching label are
+// TestSendSumOfCountersPerUser_WithLabels tests to ensure multiple metrics for the same user with a matching label are
 // summed correctly
-func TestSendSumOfCountersPerUserWithLabels(t *testing.T) {
+func TestSendSumOfCountersPerUser_WithLabels(t *testing.T) {
 	user1Metric := prometheus.NewCounterVec(prometheus.CounterOpts{Name: "test_metric"}, []string{"label_one", "label_two"})
 	user2Metric := prometheus.NewCounterVec(prometheus.CounterOpts{Name: "test_metric"}, []string{"label_one", "label_two"})
 	user3Metric := prometheus.NewCounterVec(prometheus.CounterOpts{Name: "test_metric"}, []string{"label_one", "label_two"})
@@ -351,7 +351,7 @@ func TestSendSumOfCountersPerUserWithLabels(t *testing.T) {
 	t.Run("group metrics by user and label_one", func(t *testing.T) {
 		desc := prometheus.NewDesc("test_metric", "", []string{"user", "label_one"}, nil)
 		actual := collectMetrics(t, func(out chan prometheus.Metric) {
-			mf.SendSumOfCountersPerUserWithLabels(out, desc, "test_metric", "label_one")
+			mf.SendSumOfCountersPerUser(out, desc, "test_metric", WithLabels("label_one"))
 		})
 		expected := []*dto.Metric{
 			{Label: makeLabels("label_one", "a", "user", "user-1"), Counter: &dto.Counter{Value: proto.Float64(180)}},
@@ -364,7 +364,7 @@ func TestSendSumOfCountersPerUserWithLabels(t *testing.T) {
 	t.Run("group metrics by user and label_one, and skip zero value metrics", func(t *testing.T) {
 		desc := prometheus.NewDesc("test_metric", "", []string{"user", "label_one"}, nil)
 		actual := collectMetrics(t, func(out chan prometheus.Metric) {
-			mf.SendSumOfCountersPerUserWithLabelsAndOptions(out, desc, "test_metric", []string{"label_one"}, SkipZeroValueMetrics)
+			mf.SendSumOfCountersPerUser(out, desc, "test_metric", WithLabels("label_one"), WithSkipZeroValueMetrics)
 		})
 		expected := []*dto.Metric{
 			{Label: makeLabels("label_one", "a", "user", "user-1"), Counter: &dto.Counter{Value: proto.Float64(180)}},
@@ -376,7 +376,7 @@ func TestSendSumOfCountersPerUserWithLabels(t *testing.T) {
 	t.Run("group metrics by user and label_two", func(t *testing.T) {
 		desc := prometheus.NewDesc("test_metric", "", []string{"user", "label_two"}, nil)
 		actual := collectMetrics(t, func(out chan prometheus.Metric) {
-			mf.SendSumOfCountersPerUserWithLabels(out, desc, "test_metric", "label_two")
+			mf.SendSumOfCountersPerUser(out, desc, "test_metric", WithLabels("label_two"))
 		})
 		expected := []*dto.Metric{
 			{Label: makeLabels("label_two", "b", "user", "user-1"), Counter: &dto.Counter{Value: proto.Float64(100)}},
@@ -392,7 +392,7 @@ func TestSendSumOfCountersPerUserWithLabels(t *testing.T) {
 	t.Run("group metrics by user and label_two, and skip zero value metrics", func(t *testing.T) {
 		desc := prometheus.NewDesc("test_metric", "", []string{"user", "label_two"}, nil)
 		actual := collectMetrics(t, func(out chan prometheus.Metric) {
-			mf.SendSumOfCountersPerUserWithLabelsAndOptions(out, desc, "test_metric", []string{"label_two"}, SkipZeroValueMetrics)
+			mf.SendSumOfCountersPerUser(out, desc, "test_metric", WithLabels("label_two"), WithSkipZeroValueMetrics)
 		})
 		expected := []*dto.Metric{
 			{Label: makeLabels("label_two", "b", "user", "user-1"), Counter: &dto.Counter{Value: proto.Float64(100)}},
@@ -405,7 +405,7 @@ func TestSendSumOfCountersPerUserWithLabels(t *testing.T) {
 	t.Run("group metrics by user, label_one and label_two", func(t *testing.T) {
 		desc := prometheus.NewDesc("test_metric", "", []string{"user", "label_one", "label_two"}, nil)
 		actual := collectMetrics(t, func(out chan prometheus.Metric) {
-			mf.SendSumOfCountersPerUserWithLabels(out, desc, "test_metric", "label_one", "label_two")
+			mf.SendSumOfCountersPerUser(out, desc, "test_metric", WithLabels("label_one", "label_two"))
 		})
 		expected := []*dto.Metric{
 			{Label: makeLabels("label_one", "a", "label_two", "b", "user", "user-1"), Counter: &dto.Counter{Value: proto.Float64(100)}},
@@ -421,7 +421,7 @@ func TestSendSumOfCountersPerUserWithLabels(t *testing.T) {
 	t.Run("group metrics by user, label_one and label_two, and skip zero value metrics", func(t *testing.T) {
 		desc := prometheus.NewDesc("test_metric", "", []string{"user", "label_one", "label_two"}, nil)
 		actual := collectMetrics(t, func(out chan prometheus.Metric) {
-			mf.SendSumOfCountersPerUserWithLabelsAndOptions(out, desc, "test_metric", []string{"label_one", "label_two"}, SkipZeroValueMetrics)
+			mf.SendSumOfCountersPerUser(out, desc, "test_metric", WithLabels("label_one", "label_two"), WithSkipZeroValueMetrics)
 		})
 		expected := []*dto.Metric{
 			{Label: makeLabels("label_one", "a", "label_two", "b", "user", "user-1"), Counter: &dto.Counter{Value: proto.Float64(100)}},