Adding support to filter rules

Signed-off-by: Anand Rajagopal <[email protected]>

Author: rajagopalanand

CHANGELOG.md

@@ -30,7 +30,7 @@
 * [ENHANCEMENT] Store Gateway: Add new metrics `cortex_bucket_store_sent_chunk_size_bytes`, `cortex_bucket_store_postings_size_bytes` and `cortex_bucket_store_empty_postings_total`. #5397
 * [ENHANCEMENT] Add jitter to lifecycler heartbeat. #5404
 * [ENHANCEMENT] Store Gateway: Add config `estimated_max_series_size_bytes` and `estimated_max_chunk_size_bytes` to address data overfetch. #5401
-* [ENHANCEMENT] Ruler: Support for filtering rules. #5417
+* [ENHANCEMENT] Ruler: Support for filtering rules in the API. #5417
 * [BUGFIX] Ruler: Validate if rule group can be safely converted back to rule group yaml from protobuf message #5265
 * [BUGFIX] Querier: Convert gRPC `ResourceExhausted` status code from store gateway to 422 limit error. #5286
 * [BUGFIX] Alertmanager: Route web-ui requests to the alertmanager distributor when sharding is enabled. #5293

pkg/ruler/api.go

@@ -100,11 +100,6 @@ type recordingRule struct {
 	EvaluationTime float64       `json:"evaluationTime"`
 }
 
-const (
-	AlertingRuleFilter  string = "alert"
-	RecordingRuleFilter string = "record"
-)
-
 func respondError(logger log.Logger, w http.ResponseWriter, msg string) {
 	b, err := json.Marshal(&response{
 		Status:    "error",
@@ -125,10 +120,10 @@ func respondError(logger log.Logger, w http.ResponseWriter, msg string) {
 	}
 }
 
-func respondClientError(logger log.Logger, w http.ResponseWriter, msg string) {
+func respondBadRequest(logger log.Logger, w http.ResponseWriter, msg string) {
 	b, err := json.Marshal(&response{
 		Status:    "error",
-		ErrorType: v1.ErrServer,
+		ErrorType: v1.ErrBadData,
 		Error:     msg,
 		Data:      nil,
 	})
@@ -173,13 +168,13 @@ func (a *API) PrometheusRules(w http.ResponseWriter, req *http.Request) {
 
 	if err := req.ParseForm(); err != nil {
 		level.Error(logger).Log("msg", "error parsing form/query params", "err", err)
-		respondClientError(logger, w, err.Error())
+		respondBadRequest(logger, w, "error parsing form/query params")
 		return
 	}
 
 	typ := strings.ToLower(req.URL.Query().Get("type"))
 	if typ != "" && typ != AlertingRuleFilter && typ != RecordingRuleFilter {
-		respondClientError(logger, w, fmt.Sprintf("not supported value %q", typ))
+		respondBadRequest(logger, w, fmt.Sprintf("unsupported rule type %q", typ))
 		return
 	}
 

pkg/ruler/ruler.go

@@ -66,6 +66,9 @@ const (
 
 	// errors
 	errListAllUser = "unable to list the ruler users"
+
+	AlertingRuleFilter  string = "alert"
+	RecordingRuleFilter string = "record"
 )
 
 // Config is the configuration for the recording rules server.
@@ -677,12 +680,17 @@ func (r *Ruler) getLocalRules(userID string, rulesRequest RulesRequest) ([]*Grou
 	fileSet := sliceToSet(rulesRequest.Files)
 	ruleType := rulesRequest.Type
 
-	returnAlerts := ruleType == "" || ruleType == "alert"
-	returnRecording := ruleType == "" || ruleType == "record"
+	returnAlerts := ruleType == "" || ruleType == AlertingRuleFilter
+	returnRecording := ruleType == "" || ruleType == RecordingRuleFilter
 
 	for _, group := range groups {
+		// The mapped filename is url path escaped encoded to make handling `/` characters easier
+		decodedNamespace, err := url.PathUnescape(strings.TrimPrefix(group.File(), prefix))
+		if err != nil {
+			return nil, errors.Wrap(err, "unable to decode rule filename")
+		}
 		if len(fileSet) > 0 {
-			if _, OK := fileSet[group.File()]; !OK {
+			if _, OK := fileSet[decodedNamespace]; !OK {
 				continue
 			}
 		}
@@ -694,12 +702,6 @@ func (r *Ruler) getLocalRules(userID string, rulesRequest RulesRequest) ([]*Grou
 		}
 		interval := group.Interval()
 
-		// The mapped filename is url path escaped encoded to make handling `/` characters easier
-		decodedNamespace, err := url.PathUnescape(strings.TrimPrefix(group.File(), prefix))
-		if err != nil {
-			return nil, errors.Wrap(err, "unable to decode rule filename")
-		}
-
 		groupDesc := &GroupStateDesc{
 			Group: &rulespb.RuleGroupDesc{
 				Name:      group.Name(),

pkg/ruler/ruler_test.go

@@ -380,11 +380,17 @@ func TestGetRules(t *testing.T) {
 		},
 		"ruler2-user2-rule-group2": []*rulespb.RuleDesc{
 			{
-				Record: "rtest_user1_1",
+				Record: "rtest_user2_1",
 				Expr:   "sum(rate(node_cpu_seconds_total[3h:10m]))",
 			},
 			{
-				Alert: "atest_user1_1",
+				Alert: "atest_user2_1",
+				Expr:  "sum(rate(node_cpu_seconds_total[3h:10m]))",
+			},
+		},
+		"ruler2-user3-rule-group1": []*rulespb.RuleDesc{
+			{
+				Alert: "atest_user3_1",
 				Expr:  "sum(rate(node_cpu_seconds_total[3h:10m]))",
 			},
 		},
@@ -438,6 +444,9 @@ func TestGetRules(t *testing.T) {
 				&rulespb.RuleGroupDesc{User: "user2", Namespace: "namespace", Name: "first", Interval: 10 * time.Second, Rules: ruleMap["ruler2-user2-rule-group1"]},
 				&rulespb.RuleGroupDesc{User: "user2", Namespace: "namespace", Name: "second", Interval: 10 * time.Second, Rules: ruleMap["ruler2-user2-rule-group2"]},
 			},
+			"user3": {
+				&rulespb.RuleGroupDesc{User: "user3", Namespace: "latency-test", Name: "first", Interval: 10 * time.Second, Rules: ruleMap["ruler2-user3-rule-group1"]},
+			},
 		},
 		"ruler3": map[string]rulespb.RuleGroupList{
 			"user3": {
@@ -451,28 +460,28 @@ func TestGetRules(t *testing.T) {
 	}
 
 	testCases := map[string]testCase{
-		"No Sharding": {
+		"No Sharding with Rule Type Filter": {
 			sharding: false,
 			rulesRequest: RulesRequest{
 				Type: AlertingRuleFilter,
 			},
 			expectedCount: map[string]int{
 				"user1": 2,
 				"user2": 4,
-				"user3": 1,
+				"user3": 2,
 			},
 		},
-		"Default Sharding": {
+		"Default Sharding with No Filter": {
 			sharding:         true,
 			shardingStrategy: util.ShardingStrategyDefault,
-			rulesRequest:     RulesRequest{},
+			//rulesRequest:     RulesRequest{},
 			expectedCount: map[string]int{
 				"user1": 5,
 				"user2": 9,
-				"user3": 2,
+				"user3": 3,
 			},
 		},
-		"Shuffle Sharding and ShardSize = 2": {
+		"Shuffle Sharding and ShardSize = 2 with Rule Type Filter": {
 			sharding:         true,
 			shuffleShardSize: 2,
 			shardingStrategy: util.ShardingStrategyShuffle,
@@ -512,6 +521,20 @@ func TestGetRules(t *testing.T) {
 				"user3": 1,
 			},
 		},
+		"Shuffle Sharding and ShardSize = 2 with Rule Type and Namespace Filters": {
+			sharding:         true,
+			shuffleShardSize: 2,
+			shardingStrategy: util.ShardingStrategyShuffle,
+			rulesRequest: RulesRequest{
+				Type:  AlertingRuleFilter,
+				Files: []string{"latency-test"},
+			},
+			expectedCount: map[string]int{
+				"user1": 0,
+				"user2": 0,
+				"user3": 1,
+			},
+		},
 	}
 
 	for name, tc := range testCases {