Adding support to filter rules

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

Author: rajagopalanand

CHANGELOG.md

@@ -17,6 +17,7 @@
 * [FEATURE] Querier: Log query stats when querying store gateway. #5376
 * [FEATURE] Querier/StoreGateway: Allow the tenant shard sizes to be a percent of total instances. #5393
 * [FEATURE] Added the flag `-alertmanager.api-concurrency` to configure alert manager api concurrency limit. #5412
+* [FEATURE] Ruler: Support for filtering rules in the API. #5417
 * [ENHANCEMENT] Distributor/Ingester: Add span on push path #5319
 * [ENHANCEMENT] Support object storage backends for runtime configuration file. #5292
 * [ENHANCEMENT] Query Frontend: Reject subquery with too small step size. #5323
@@ -31,7 +32,6 @@
 * [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
 * [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

docs/contributing/how-integration-tests-work.md

@@ -20,13 +20,13 @@ This will locally build the `quay.io/cortexproject/cortex:latest` image used by
 Once the Docker image is built, you can run integration tests:
 
 ```
-go test -v -tags=integration,requires_docker,integration_alertmanager,integration_memberlist,integration_querier,integration_ruler,integration_query_fuzz ./integration/...
+go test -v -tags=requires_docker ./integration/...
 ```
 
-If you want to run a single test you can use a filter. For example, to only run `TestRulerMetricsWhenIngesterFails`:
+If you want to run a single test you can use a filter. For example, to only run `TestChunksStorageAllIndexBackends`:
 
 ```
-go test -v -tags=integration,requires_docker,integration_ruler ./integration/ -run "^TestRulerMetricsWhenIngesterFails$" -count=1
+go test -v -tags=requires_docker ./integration -run "^TestChunksStorageAllIndexBackends$"
 ```
 
 ### Supported environment variables
@@ -46,4 +46,4 @@ Integration tests have `requires_docker` tag (`// +build requires_docker` line f
 
 ## Isolation
 
-Each integration test runs in isolation. For each integration test, we do create a Docker network, start Cortex and its dependencies containers, push/query series to/from Cortex and run assertions on it. Once the test has done, both the Docker network and containers are terminated and deleted.
+Each integration test runs in isolation. For each integration test, we do create a Docker network, start Cortex and its dependencies containers, push/query series to/from Cortex and run assertions on it. Once the test has done, both the Docker network and containers are terminated and deleted.

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))
+	if typ != "" && typ != alertingRuleFilter && typ != recordingRuleFilter {
+		respondBadRequest(logger, w, fmt.Sprintf("unsupported rule type %q", typ))
 		return
 	}
 
@@ -284,7 +279,7 @@ func (a *API) PrometheusAlerts(w http.ResponseWriter, req *http.Request) {
 
 	w.Header().Set("Content-Type", "application/json")
 	rulesRequest := RulesRequest{
-		Type: AlertingRuleFilter,
+		Type: alertingRuleFilter,
 	}
 	rgs, err := a.ruler.GetRules(req.Context(), rulesRequest)
 

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,33 +460,33 @@ func TestGetRules(t *testing.T) {
 	}
 
 	testCases := map[string]testCase{
-		"No Sharding": {
+		"No Sharding with Rule Type Filter": {
 			sharding: false,
 			rulesRequest: RulesRequest{
-				Type: AlertingRuleFilter,
+				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,
 			rulesRequest: RulesRequest{
-				Type: RecordingRuleFilter,
+				Type: recordingRuleFilter,
 			},
 			expectedCount: map[string]int{
 				"user1": 3,
@@ -504,14 +513,28 @@ func TestGetRules(t *testing.T) {
 			shardingStrategy: util.ShardingStrategyShuffle,
 			rulesRequest: RulesRequest{
 				RuleGroupNames: []string{"second", "third"},
-				Type:           RecordingRuleFilter,
+				Type:           recordingRuleFilter,
 			},
 			expectedCount: map[string]int{
 				"user1": 2,
 				"user2": 2,
 				"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 {