filter rules

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

Author: rajagopalanand

pkg/ruler/api.go

@@ -2,6 +2,7 @@ package ruler
 
 import (
 	"encoding/json"
+	"fmt"
 	io "io"
 	"net/http"
 	"net/url"
@@ -99,6 +100,11 @@ 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",
@@ -119,6 +125,26 @@ func respondError(logger log.Logger, w http.ResponseWriter, msg string) {
 	}
 }
 
+func respondClientError(logger log.Logger, w http.ResponseWriter, msg string) {
+	b, err := json.Marshal(&response{
+		Status:    "error",
+		ErrorType: v1.ErrServer,
+		Error:     msg,
+		Data:      nil,
+	})
+
+	if err != nil {
+		level.Error(logger).Log("msg", "error marshaling json response", "err", err)
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusBadRequest)
+	if n, err := w.Write(b); err != nil {
+		level.Error(logger).Log("msg", "error writing response", "bytesWritten", n, "err", err)
+	}
+}
+
 // API is used to handle HTTP requests for the ruler service
 type API struct {
 	ruler *Ruler
@@ -145,8 +171,27 @@ func (a *API) PrometheusRules(w http.ResponseWriter, req *http.Request) {
 		return
 	}
 
+	if err := req.ParseForm(); err != nil {
+		level.Error(logger).Log("msg", "error parsing form/query params", "err", err)
+		respondClientError(logger, w, err.Error())
+		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))
+		return
+	}
+
+	rulesRequest := RulesRequest{
+		RuleNames:      req.Form["rule_name[]"],
+		RuleGroupNames: req.Form["rule_group[]"],
+		Files:          req.Form["files[]"],
+		Type:           typ,
+	}
+
 	w.Header().Set("Content-Type", "application/json")
-	rgs, err := a.ruler.GetRules(req.Context())
+	rgs, err := a.ruler.GetRules(req.Context(), rulesRequest)
 
 	if err != nil {
 		respondError(logger, w, err.Error())
@@ -238,7 +283,10 @@ func (a *API) PrometheusAlerts(w http.ResponseWriter, req *http.Request) {
 	}
 
 	w.Header().Set("Content-Type", "application/json")
-	rgs, err := a.ruler.GetRules(req.Context())
+	rulesRequest := RulesRequest{
+		//Type: AlertingRuleFilter,
+	}
+	rgs, err := a.ruler.GetRules(req.Context(), rulesRequest)
 
 	if err != nil {
 		respondError(logger, w, err.Error())

pkg/ruler/ruler.go

@@ -645,26 +645,53 @@ func filterRuleGroups(userID string, ruleGroups []*rulespb.RuleGroupDesc, ring r
 
 // GetRules retrieves the running rules from this ruler and all running rulers in the ring if
 // sharding is enabled
-func (r *Ruler) GetRules(ctx context.Context) ([]*GroupStateDesc, error) {
+func (r *Ruler) GetRules(ctx context.Context, rulesRequest RulesRequest) ([]*GroupStateDesc, error) {
 	userID, err := tenant.TenantID(ctx)
 	if err != nil {
 		return nil, fmt.Errorf("no user id found in context")
 	}
 
 	if r.cfg.EnableSharding {
-		return r.getShardedRules(ctx, userID)
+		return r.getShardedRules(ctx, userID, rulesRequest)
 	}
 
-	return r.getLocalRules(userID)
+	return r.getLocalRules(userID, rulesRequest)
 }
 
-func (r *Ruler) getLocalRules(userID string) ([]*GroupStateDesc, error) {
+func (r *Ruler) getLocalRules(userID string, rulesRequest RulesRequest) ([]*GroupStateDesc, error) {
 	groups := r.manager.GetRules(userID)
 
 	groupDescs := make([]*GroupStateDesc, 0, len(groups))
 	prefix := filepath.Join(r.cfg.RulePath, userID) + "/"
 
+	sliceToSet := func(values []string) map[string]struct{} {
+		set := make(map[string]struct{}, len(values))
+		for _, v := range values {
+			set[v] = struct{}{}
+		}
+		return set
+	}
+
+	ruleNameSet := sliceToSet(rulesRequest.RuleNames)
+	ruleGroupNameSet := sliceToSet(rulesRequest.RuleGroupNames)
+	fileSet := sliceToSet(rulesRequest.Files)
+	ruleType := rulesRequest.Type
+
+	returnAlerts := ruleType == "" || ruleType == "alert"
+	returnRecording := ruleType == "" || ruleType == "record"
+
 	for _, group := range groups {
+		if len(fileSet) > 0 {
+			if _, OK := fileSet[group.File()]; !OK {
+				continue
+			}
+		}
+
+		if len(ruleGroupNameSet) > 0 {
+			if _, OK := ruleGroupNameSet[group.Name()]; !OK {
+				continue
+			}
+		}
 		interval := group.Interval()
 
 		// The mapped filename is url path escaped encoded to make handling `/` characters easier
@@ -685,6 +712,11 @@ func (r *Ruler) getLocalRules(userID string) ([]*GroupStateDesc, error) {
 			EvaluationDuration:  group.GetEvaluationTime(),
 		}
 		for _, r := range group.Rules() {
+			if len(ruleNameSet) > 0 {
+				if _, OK := ruleNameSet[r.Name()]; !OK {
+					continue
+				}
+			}
 			lastError := ""
 			if r.LastError() != nil {
 				lastError = r.LastError().Error()
@@ -693,7 +725,9 @@ func (r *Ruler) getLocalRules(userID string) ([]*GroupStateDesc, error) {
 			var ruleDesc *RuleStateDesc
 			switch rule := r.(type) {
 			case *promRules.AlertingRule:
-				rule.ActiveAlerts()
+				if !returnAlerts {
+					break
+				}
 				alerts := []*AlertStateDesc{}
 				for _, a := range rule.ActiveAlerts() {
 					alerts = append(alerts, &AlertStateDesc{
@@ -725,6 +759,9 @@ func (r *Ruler) getLocalRules(userID string) ([]*GroupStateDesc, error) {
 					EvaluationDuration:  rule.GetEvaluationDuration(),
 				}
 			case *promRules.RecordingRule:
+				if !returnRecording {
+					break
+				}
 				ruleDesc = &RuleStateDesc{
 					Rule: &rulespb.RuleDesc{
 						Record: rule.Name(),
@@ -741,12 +778,14 @@ func (r *Ruler) getLocalRules(userID string) ([]*GroupStateDesc, error) {
 			}
 			groupDesc.ActiveRules = append(groupDesc.ActiveRules, ruleDesc)
 		}
-		groupDescs = append(groupDescs, groupDesc)
+		if len(groupDesc.ActiveRules) > 0 {
+			groupDescs = append(groupDescs, groupDesc)
+		}
 	}
 	return groupDescs, nil
 }
 
-func (r *Ruler) getShardedRules(ctx context.Context, userID string) ([]*GroupStateDesc, error) {
+func (r *Ruler) getShardedRules(ctx context.Context, userID string, rulesRequest RulesRequest) ([]*GroupStateDesc, error) {
 	ring := ring.ReadRing(r.ring)
 
 	if shardSize := r.limits.RulerTenantShardSize(userID); shardSize > 0 && r.cfg.ShardingStrategy == util.ShardingStrategyShuffle {
@@ -779,7 +818,7 @@ func (r *Ruler) getShardedRules(ctx context.Context, userID string) ([]*GroupSta
 			return errors.Wrapf(err, "unable to get client for ruler %s", addr)
 		}
 
-		newGrps, err := rulerClient.Rules(ctx, &RulesRequest{})
+		newGrps, err := rulerClient.Rules(ctx, &rulesRequest)
 		if err != nil {
 			return errors.Wrapf(err, "unable to retrieve rules from ruler %s", addr)
 		}
@@ -801,7 +840,7 @@ func (r *Ruler) Rules(ctx context.Context, in *RulesRequest) (*RulesResponse, er
 		return nil, fmt.Errorf("no user id found in context")
 	}
 
-	groupDescs, err := r.getLocalRules(userID)
+	groupDescs, err := r.getLocalRules(userID, *in)
 	if err != nil {
 		return nil, err
 	}