Add matcher support to Query Rules endpoint

CHANGELOG.md

@@ -24,6 +24,7 @@ We use *breaking :warning:* to mark changes that are not backward compatible (re
 - [#4974](https://github.com/thanos-io/thanos/pull/4974) Store: Support tls_config configuration for connecting with Azure storage.
 - [#4999](https://github.com/thanos-io/thanos/pull/4999) COS: Support `endpoint` configuration for vpc internal endpoint.
 - [#5059](https://github.com/thanos-io/thanos/pull/5059) Compactor: Adding minimum retention flag validation for downsampling retention.
+- [#5111](https://github.com/thanos-io/thanos/pull/5111) Add matcher support to Query Rules endpoint
 
 ### Fixed
 

pkg/api/query/v1.go

@@ -787,10 +787,15 @@ func NewRulesHandler(client rules.UnaryClient, enablePartialResponse bool) func(
 			typ = int32(rulespb.RulesRequest_ALL)
 		}
 
+		if err := r.ParseForm(); err != nil {
+			return nil, nil, &api.ApiError{Typ: api.ErrorInternal, Err: errors.Errorf("error parsing request form='%v'", typeParam)}
+		}
+
 		// TODO(bwplotka): Allow exactly the same functionality as query API: passing replica, dedup and partial response as HTTP params as well.
 		req := &rulespb.RulesRequest{
 			Type:                    rulespb.RulesRequest_Type(typ),
 			PartialResponseStrategy: ps,
+			MatcherString:           r.Form[MatcherParam],
 		}
 		tracing.DoInSpan(ctx, "retrieve_rules", func(ctx context.Context) {
 			groups, warnings, err = client.Rules(ctx, req)

pkg/rules/rules.go

@@ -7,9 +7,12 @@ import (
 	"context"
 	"sort"
 	"sync"
+	"text/template"
+	"text/template/parse"
 
 	"github.com/pkg/errors"
 	"github.com/prometheus/prometheus/model/labels"
+	"github.com/prometheus/prometheus/promql/parser"
 	"github.com/prometheus/prometheus/storage"
 
 	"github.com/thanos-io/thanos/pkg/rules/rulespb"
@@ -58,6 +61,16 @@ func (rr *GRPCClient) Rules(ctx context.Context, req *rulespb.RulesRequest) (*ru
 		return nil, nil, errors.Wrap(err, "proxy Rules")
 	}
 
+	var matcherSets [][]*labels.Matcher
+	for _, s := range req.MatcherString {
+		matchers, err := parser.ParseMetricSelector(s)
+		if err != nil {
+			return nil, nil, errors.Wrap(err, "proxy Rules")
+		}
+		matcherSets = append(matcherSets, matchers)
+	}
+
+	resp.groups = filterRules(resp.groups, matcherSets)
 	// TODO(bwplotka): Move to SortInterface with equal method and heap.
 	resp.groups = dedupGroups(resp.groups)
 	for _, g := range resp.groups {
@@ -67,6 +80,52 @@ func (rr *GRPCClient) Rules(ctx context.Context, req *rulespb.RulesRequest) (*ru
 	return &rulespb.RuleGroups{Groups: resp.groups}, resp.warnings, nil
 }
 
+// filterRules filters rules in a group according to given matcherSets.
+func filterRules(ruleGroups []*rulespb.RuleGroup, matcherSets [][]*labels.Matcher) []*rulespb.RuleGroup {
+	if len(matcherSets) == 0 || len(ruleGroups) == 0 {
+		return ruleGroups
+	}
+
+	for _, g := range ruleGroups {
+		filteredRules := []*rulespb.Rule{}
+		for _, r := range g.Rules {
+			rl := r.GetLabels()
+			if matches(matcherSets, rl) {
+				filteredRules = append(filteredRules, r)
+			}
+		}
+		g.Rules = filteredRules
+	}
+
+	return ruleGroups
+}
+
+// matches returns whether the non-templated labels satisfy all the matchers in matcherSets.
+func matches(matcherSets [][]*labels.Matcher, l labels.Labels) bool {
+	if len(matcherSets) == 0 {
+		return true
+	}
+
+	var nonTemplatedLabels labels.Labels
+	labelTemplate := template.New("label")
+	for _, label := range l {
+		t, err := labelTemplate.Parse(label.Value)
+		// Label value is non-templated if it is one node of type NodeText.
+		if err == nil && len(t.Root.Nodes) == 1 && t.Root.Nodes[0].Type() == parse.NodeText {
+			nonTemplatedLabels = append(nonTemplatedLabels, label)
+		}
+	}
+
+	for _, matchers := range matcherSets {
+		for _, m := range matchers {
+			if v := nonTemplatedLabels.Get(m.Name); !m.Matches(v) {
+				return false
+			}
+		}
+	}
+	return true
+}
+
 // dedupRules re-sorts the set so that the same series with different replica
 // labels are coming right after each other.
 func dedupRules(rules []*rulespb.Rule, replicaLabels map[string]struct{}) []*rulespb.Rule {

pkg/rules/rulespb/rpc.proto

@@ -40,6 +40,7 @@ message RulesRequest {
     }
     Type type = 1;
     PartialResponseStrategy partial_response_strategy = 2;
+    repeated string MatcherString = 3;
 }
 
 message RulesResponse {