feat(ruler): add select merger — parse rules and compute merge plan

Author: alanprot

pkg/ruler/select_merger.go

@@ -0,0 +1,119 @@
+package ruler
+
+import (
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql/parser"
+	"github.com/prometheus/prometheus/rules"
+)
+
+type mergedSelect struct {
+	metricName      string
+	mergedMatchers  []*labels.Matcher
+	originalEntries [][]*labels.Matcher // per-rule matchers
+}
+
+func planMergedSelects(rls []rules.Rule, minRules int) []mergedSelect {
+	// Group selectors by metric name.
+	type entry struct {
+		matchers []*labels.Matcher
+	}
+	groups := map[string][]entry{}
+
+	for _, r := range rls {
+		extractSelectors(r.Query(), func(vs *parser.VectorSelector) {
+			name := metricNameFromMatchers(vs.LabelMatchers)
+			if name == "" {
+				return
+			}
+			groups[name] = append(groups[name], entry{matchers: vs.LabelMatchers})
+		})
+	}
+
+	var result []mergedSelect
+	for name, entries := range groups {
+		if len(entries) < minRules {
+			continue
+		}
+		originals := make([][]*labels.Matcher, len(entries))
+		for i, e := range entries {
+			originals[i] = e.matchers
+		}
+		result = append(result, mergedSelect{
+			metricName:      name,
+			mergedMatchers:  computeMergedMatchers(originals),
+			originalEntries: originals,
+		})
+	}
+	return result
+}
+
+func extractSelectors(expr parser.Expr, fn func(*parser.VectorSelector)) {
+	parser.Inspect(expr, func(node parser.Node, _ []parser.Node) error {
+		if vs, ok := node.(*parser.VectorSelector); ok {
+			fn(vs)
+		}
+		return nil
+	})
+}
+
+func metricNameFromMatchers(ms []*labels.Matcher) string {
+	for _, m := range ms {
+		if m.Name == labels.MetricName && m.Type == labels.MatchEqual {
+			return m.Value
+		}
+	}
+	return ""
+}
+
+func computeMergedMatchers(entries [][]*labels.Matcher) []*labels.Matcher {
+	// Collect all label names across entries.
+	labelMatchers := map[string][]*labels.Matcher{}
+	for _, ms := range entries {
+		for _, m := range ms {
+			labelMatchers[m.Name] = append(labelMatchers[m.Name], m)
+		}
+	}
+
+	var result []*labels.Matcher
+	for _, ms := range labelMatchers {
+		if sup := findSuperset(ms); sup != nil {
+			result = append(result, sup)
+		}
+	}
+	return result
+}
+
+func findSuperset(ms []*labels.Matcher) *labels.Matcher {
+	for _, candidate := range ms {
+		coversAll := true
+		for _, other := range ms {
+			if !isMatcherSuperset(candidate, other) {
+				coversAll = false
+				break
+			}
+		}
+		if coversAll {
+			return candidate
+		}
+	}
+	return nil
+}
+
+func isMatcherSuperset(a, b *labels.Matcher) bool {
+	if a.Name != b.Name {
+		return false
+	}
+	// =~".*" covers everything.
+	if a.Type == labels.MatchRegexp && a.Value == ".*" {
+		return true
+	}
+	// =~".+" covers any non-empty value.
+	if a.Type == labels.MatchRegexp && a.Value == ".+" {
+		if b.Type == labels.MatchEqual && b.Value == "" {
+			return false
+		}
+		return true
+	}
+	// Same type and value covers itself.
+	return a.Type == b.Type && a.Value == b.Value
+}

pkg/ruler/select_merger_test.go

@@ -0,0 +1,108 @@
+package ruler
+
+import (
+	"testing"
+
+	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql/parser"
+	"github.com/prometheus/prometheus/rules"
+	"github.com/stretchr/testify/assert"
+	"github.com/stretchr/testify/require"
+)
+
+type fakeRule struct {
+	rules.Rule
+	expr parser.Expr
+}
+
+func (f *fakeRule) Query() parser.Expr { return f.expr }
+
+func mustParseRule(t *testing.T, expr string) rules.Rule {
+	t.Helper()
+	e, err := parser.ParseExpr(expr)
+	require.NoError(t, err)
+	return &fakeRule{expr: e}
+}
+
+func TestSelectMerger_Plan_GroupsByMetric(t *testing.T) {
+	rls := []rules.Rule{
+		mustParseRule(t, `sum(http_requests_total{job="api"})`),
+		mustParseRule(t, `sum(http_requests_total{job="web"})`),
+		mustParseRule(t, `avg(cpu_usage{host="a"})`),
+		mustParseRule(t, `avg(cpu_usage{host="b"})`),
+	}
+
+	result := planMergedSelects(rls, 2)
+
+	// Should produce 2 merged selects: one for http_requests_total, one for cpu_usage
+	assert.Len(t, result, 2)
+
+	metricNames := map[string]bool{}
+	for _, ms := range result {
+		metricNames[ms.metricName] = true
+	}
+	assert.True(t, metricNames["http_requests_total"])
+	assert.True(t, metricNames["cpu_usage"])
+}
+
+func TestSelectMerger_SupersetDetection(t *testing.T) {
+	tests := []struct {
+		name     string
+		a, b     *labels.Matcher
+		aCoversB bool
+	}{
+		{
+			name:     "regex .* covers equality",
+			a:        labels.MustNewMatcher(labels.MatchRegexp, "job", ".*"),
+			b:        labels.MustNewMatcher(labels.MatchEqual, "job", "blue"),
+			aCoversB: true,
+		},
+		{
+			name:     "regex .+ covers non-empty equality",
+			a:        labels.MustNewMatcher(labels.MatchRegexp, "job", ".+"),
+			b:        labels.MustNewMatcher(labels.MatchEqual, "job", "blue"),
+			aCoversB: true,
+		},
+		{
+			name:     "regex .+ does not cover empty",
+			a:        labels.MustNewMatcher(labels.MatchRegexp, "job", ".+"),
+			b:        labels.MustNewMatcher(labels.MatchEqual, "job", ""),
+			aCoversB: false,
+		},
+		{
+			name:     "same equality covers itself",
+			a:        labels.MustNewMatcher(labels.MatchEqual, "job", "api"),
+			b:        labels.MustNewMatcher(labels.MatchEqual, "job", "api"),
+			aCoversB: true,
+		},
+		{
+			name:     "different equality does not cover",
+			a:        labels.MustNewMatcher(labels.MatchEqual, "job", "api"),
+			b:        labels.MustNewMatcher(labels.MatchEqual, "job", "web"),
+			aCoversB: false,
+		},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			assert.Equal(t, tc.aCoversB, isMatcherSuperset(tc.a, tc.b))
+		})
+	}
+}
+
+func TestSelectMerger_MinRulesThreshold(t *testing.T) {
+	rls := []rules.Rule{
+		mustParseRule(t, `sum(http_requests_total{job="api"})`),
+		mustParseRule(t, `sum(http_requests_total{job="web"})`),
+		mustParseRule(t, `avg(cpu_usage{host="a"})`),
+	}
+
+	// minRules=2: http_requests_total has 2 rules, cpu_usage has 1
+	result := planMergedSelects(rls, 2)
+	assert.Len(t, result, 1)
+	assert.Equal(t, "http_requests_total", result[0].metricName)
+
+	// minRules=3: nothing qualifies
+	result = planMergedSelects(rls, 3)
+	assert.Len(t, result, 0)
+}