stackrox · parametalol · Jun 10, 2025 · Jun 10, 2025 · Jun 10, 2025 · Jun 10, 2025
diff --git a/central/metrics/aggregator/common/common.go b/central/metrics/aggregator/common/common.go
@@ -3,6 +3,7 @@ package common
 import (
 	"context"
 	"iter"
+	"maps"
 	"regexp"
 	"slices"
 
@@ -41,6 +42,26 @@ func (mcfg MetricsConfiguration) HasAnyLabelOf(labels []Label) bool {
 	return false
 }
 
+func (mcfg MetricsConfiguration) DiffLabels(another MetricsConfiguration) ([]MetricName, []MetricName, []MetricName) {
+	if mcfg == nil && another == nil {
+		return nil, nil, nil
+	}
+	var toAdd, toDelete, changed []MetricName
+	for metric, labels := range mcfg {
+		if anotherLabels, ok := another[metric]; !ok {
+			toDelete = append(toDelete, metric)
+		} else if !maps.EqualFunc(labels, anotherLabels, Expression.Equals) {
+			changed = append(changed, metric)
+		}
+	}
+	for metric := range another {
+		if _, ok := mcfg[metric]; !ok {
+			toAdd = append(toAdd, metric)
+		}
+	}
+	return toAdd, toDelete, changed
+}
+
 type OneOrMore int
 
 func (o OneOrMore) Count() int {

diff --git a/central/metrics/aggregator/common/common_test.go b/central/metrics/aggregator/common/common_test.go
@@ -55,6 +55,8 @@ func makeTestMetricLabels(t *testing.T) map[string]*storage.PrometheusMetricsCon
 				},
 				"Cluster": nil,
 			},
+			Exposure:     storage.PrometheusMetricsConfig_Labels_BOTH,
+			RegistryName: "registry1",
 		},
 		pfx + "_metric2": {
 			Labels: map[string]*storage.PrometheusMetricsConfig_Labels_Expression{
@@ -126,3 +128,223 @@ func TestOneOrMore(t *testing.T) {
 	assert.Equal(t, 1, OneOrMore(1).Count())
 	assert.Equal(t, 2, OneOrMore(2).Count())
 }
+
+/*
+func TestEquals(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		assert.False(t, one.Equals(MetricsConfiguration{}))
+		assert.False(t, MetricsConfiguration{}.Equals(one))
+	})
+
+	t.Run("equals", func(t *testing.T) {
+		var m MetricsConfiguration
+		assert.True(t, m.Equals(m))
+		assert.True(t, MetricsConfiguration{}.Equals(MetricsConfiguration{}))
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+		assert.True(t, one.Equals(one))
+		assert.True(t, one.Equals(another))
+		assert.True(t, another.Equals(one))
+	})
+
+	t.Run("changed condition", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+
+	loop:
+		for _, labels := range another {
+			for _, expr := range labels {
+				for _, cond := range expr {
+					cond.arg = "changed"
+					break loop
+				}
+			}
+		}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+	t.Run("extra condition", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+
+	loop:
+		for _, labels := range another {
+			for label, expr := range labels {
+				labels[label] = append(expr, &Condition{"=", "extra"})
+				break loop
+			}
+		}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+	t.Run("extra label", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+
+		for _, labels := range another {
+			labels["extra"] = Expression{}
+			break
+		}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+	t.Run("extra metric", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+		another["extra"] = map[Label]Expression{}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+}
+
+func TestEqualLabels(t *testing.T) {
+	t.Run("empty", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		assert.False(t, one.Equals(MetricsConfiguration{}))
+		assert.False(t, MetricsConfiguration{}.Equals(one))
+	})
+
+	t.Run("equals", func(t *testing.T) {
+		var m MetricsConfiguration
+		assert.True(t, m.Equals(m))
+		assert.True(t, MetricsConfiguration{}.Equals(MetricsConfiguration{}))
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+		assert.True(t, one.Equals(one))
+		assert.True(t, one.Equals(another))
+		assert.True(t, another.Equals(one))
+	})
+
+	t.Run("changed condition", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+
+	loop:
+		for _, labels := range another {
+			for _, expr := range labels {
+				for _, cond := range expr {
+					cond.arg = "changed"
+					break loop
+				}
+			}
+		}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+	t.Run("extra condition", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+
+	loop:
+		for _, labels := range another {
+			for label, expr := range labels {
+				labels[label] = append(expr, &Condition{"=", "extra"})
+				break loop
+			}
+		}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+	t.Run("extra label", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+
+		for _, labels := range another {
+			labels["extra"] = Expression{}
+			break
+		}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+	t.Run("extra metric", func(t *testing.T) {
+		one := makeTestMetricLabelExpression(t)
+		another := makeTestMetricLabelExpression(t)
+		another["extra"] = map[Label]Expression{}
+		assert.False(t, one.Equals(another))
+		assert.False(t, another.Equals(one))
+	})
+
+}
+*/
+
+func TestDiffLabels(t *testing.T) {
+	tests := []struct {
+		name         string
+		a, b         MetricsConfiguration
+		wantToAdd    []MetricName
+		wantToDelete []MetricName
+		wantChanged  []MetricName
+	}{
+		{
+			name:         "both nil",
+			a:            nil,
+			b:            nil,
+			wantToAdd:    nil,
+			wantToDelete: nil,
+		},
+		{
+			name:         "a empty, b has one",
+			a:            MetricsConfiguration{},
+			b:            MetricsConfiguration{"metric1": {"label1": nil}},
+			wantToAdd:    []MetricName{"metric1"},
+			wantToDelete: nil,
+		},
+		{
+			name:         "a has one, b empty",
+			a:            MetricsConfiguration{"metric1": {"label1": nil}},
+			b:            MetricsConfiguration{},
+			wantToAdd:    nil,
+			wantToDelete: []MetricName{"metric1"},
+		},
+		{
+			name:         "a has one, b has another",
+			a:            MetricsConfiguration{"metric1": {"label1": nil}},
+			b:            MetricsConfiguration{"metric2": {"label2": nil}},
+			wantToAdd:    []MetricName{"metric2"},
+			wantToDelete: []MetricName{"metric1"},
+		},
+		{
+			name: "a and b have overlap",
+			a: MetricsConfiguration{
+				"metric1": {"label1": nil},
+				"metric2": {"label2": nil},
+			},
+			b: MetricsConfiguration{
+				"metric2": {"label2": nil},
+				"metric3": {"label3": nil},
+			},
+			wantToAdd:    []MetricName{"metric3"},
+			wantToDelete: []MetricName{"metric1"},
+		},
+		{
+			name: "identical",
+			a: MetricsConfiguration{
+				"metric1": {"label1": nil},
+				"metric2": {"label2": nil},
+			},
+			b: MetricsConfiguration{
+				"metric1": {"label1": nil},
+				"metric2": {"label2": nil},
+			},
+			wantToAdd:    nil,
+			wantToDelete: nil,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotToAdd, gotToDelete, gotChanged := tt.a.DiffLabels(tt.b)
+			assert.ElementsMatch(t, tt.wantToAdd, gotToAdd)
+			assert.ElementsMatch(t, tt.wantToDelete, gotToDelete)
+			assert.ElementsMatch(t, tt.wantChanged, gotChanged)
+		})
+	}
+}
diff --git a/central/metrics/aggregator/common/condition.go b/central/metrics/aggregator/common/condition.go
@@ -73,6 +73,10 @@ func (c *Condition) validate() error {
 	return nil
 }
 
+func (c *Condition) Equals(b *Condition) bool {
+	return c == b || c != nil && b != nil && c.op == b.op && c.arg == b.arg
+}
+
 func (c *Condition) String() string {
 	return string(c.op) + c.arg
 }

diff --git a/central/metrics/aggregator/common/config_parser.go b/central/metrics/aggregator/common/config_parser.go
@@ -2,13 +2,18 @@ package common
 
 import (
 	"maps"
+	"regexp"
 	"slices"
 
 	"github.com/stackrox/rox/generated/storage"
 	"github.com/stackrox/rox/pkg/errox"
 )
 
-var errInvalidConfiguration = errox.InvalidArgs.New("invalid configuration")
+var (
+	errInvalidConfiguration = errox.InvalidArgs.New("invalid configuration")
+
+	registryNamePattern = regexp.MustCompile("^[a-zA-Z0-9-_]*$")
+)
 
 func isKnownLabel(label string, labelOrder map[Label]int) bool {
 	_, ok := labelOrder[Label(label)]
@@ -19,6 +24,12 @@ func isKnownLabel(label string, labelOrder map[Label]int) bool {
 func parseMetricLabels(config map[string]*storage.PrometheusMetricsConfig_Labels, labelOrder map[Label]int) (MetricsConfiguration, error) {
 	result := make(MetricsConfiguration, len(config))
 	for metric, labels := range config {
+
+		if !registryNamePattern.MatchString(labels.GetRegistryName()) {
+			return nil, errInvalidConfiguration.CausedByf(
+				`registry name for metric %s doesn't match "`+registryNamePattern.String()+`"`, metric)
+		}
+
 		if err := validateMetricName(metric); err != nil {
 			return nil, errInvalidConfiguration.CausedByf(
 				"invalid metric name %q: %v", metric, err)

diff --git a/central/metrics/aggregator/common/expression.go b/central/metrics/aggregator/common/expression.go
@@ -1,7 +1,13 @@
 package common
 
+import "slices"
+
 type Expression []*Condition
 
+func (expr Expression) Equals(another Expression) bool {
+	return slices.EqualFunc(expr, another, (*Condition).Equals)
+}
+
 func (expr Expression) match(value string) bool {
 	if len(expr) == 0 {
 		return true