Method getLocalRules

pkg/ruler/ruler.go:1130–1320

(userID string, rulesRequest RulesRequest, includeBackups bool)

}

func (r *Ruler) getLocalRules(userID string, rulesRequest RulesRequest, includeBackups bool) (RulesResponse, 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
	alertState := rulesRequest.State
	health := rulesRequest.Health
	matcherSets, err := parseMatchersParam(rulesRequest.Matchers)
	if err != nil {
		return RulesResponse{}, errors.Wrap(err, "error parsing matcher values")
	}

	returnAlerts := ruleType == "" || ruleType == alertingRuleFilter
	returnRecording := (ruleType == "" || ruleType == recordingRuleFilter) && alertState == ""

	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 RulesResponse{}, errors.Wrap(err, "unable to decode rule filename")
		}
		if len(fileSet) > 0 {
			if _, OK := fileSet[decodedNamespace]; !OK {
				continue
			}
		}

		if len(ruleGroupNameSet) > 0 {
			if _, OK := ruleGroupNameSet[group.Name()]; !OK {
				continue
			}
		}
		interval := group.Interval()

		queryOffset := group.QueryOffset()
		groupDesc := &GroupStateDesc{
			Group: &rulespb.RuleGroupDesc{
				Name:        group.Name(),
				Namespace:   string(decodedNamespace),
				Interval:    interval,
				User:        userID,
				Limit:       int64(group.Limit()),
				QueryOffset: &queryOffset,
			},