support v1 rules, update changelog, address review comments

Signed-off-by: Jacob Lisi <jacob.t.lisi@gmail.com>

Author: jtlisi

go.mod

@@ -41,7 +41,6 @@ require (
 	github.com/hashicorp/go-cleanhttp v0.5.1
 	github.com/hashicorp/go-sockaddr v1.0.2
 	github.com/hashicorp/memberlist v0.1.4
-	github.com/jonboulle/clockwork v0.1.0
 	github.com/json-iterator/go v1.1.7
 	github.com/konsorten/go-windows-terminal-sequences v1.0.2 // indirect
 	github.com/kylelemons/godebug v0.0.0-20170820004349-d65d576e9348 // indirect

pkg/configs/client/client.go

@@ -14,7 +14,7 @@ import (
 	"github.com/cortexproject/cortex/pkg/util/flagext"
 	"github.com/go-kit/kit/log/level"
 	"github.com/prometheus/client_golang/prometheus"
-	"github.com/prometheus/client_golang/prometheus/promauto"
+	"github.com/weaveworks/common/instrument"
 )
 
 // Config says where we can find the ruler configs.
@@ -29,12 +29,12 @@ func (cfg *Config) RegisterFlagsWithPrefix(prefix string, f *flag.FlagSet) {
 	f.DurationVar(&cfg.ClientTimeout, prefix+"configs.client-timeout", 5*time.Second, "Timeout for requests to Weave Cloud configs service.")
 }
 
-var configsRequestDuration = promauto.NewHistogramVec(prometheus.HistogramOpts{
+var configsRequestDuration = instrument.NewHistogramCollector(prometheus.NewHistogramVec(prometheus.HistogramOpts{
 	Namespace: "cortex",
 	Name:      "configs_request_duration_seconds",
 	Help:      "Time spent requesting configs.",
 	Buckets:   prometheus.DefBuckets,
-}, []string{"operation", "status_code"})
+}, []string{"operation", "status_code"}))
 
 // Client is what the ruler and altermanger needs from a config store to process rules.
 type Client interface {
@@ -67,7 +67,12 @@ func (c ConfigDBClient) GetRules(ctx context.Context, since configs.ID) (map[str
 		suffix = fmt.Sprintf("?since=%d", since)
 	}
 	endpoint := fmt.Sprintf("%s/private/api/prom/configs/rules%s", c.URL.String(), suffix)
-	response, err := doRequest(endpoint, c.Timeout, since, "GetRules")
+	var response *ConfigsResponse
+	err := instrument.CollectedRequest(ctx, "GetRules", configsRequestDuration, instrument.ErrorCode, func(ctx context.Context) error {
+		var err error
+		response, err = doRequest(endpoint, c.Timeout, since)
+		return err
+	})
 	if err != nil {
 		return nil, err
 	}
@@ -88,23 +93,27 @@ func (c ConfigDBClient) GetAlerts(ctx context.Context, since configs.ID) (*Confi
 		suffix = fmt.Sprintf("?since=%d", since)
 	}
 	endpoint := fmt.Sprintf("%s/private/api/prom/configs/alertmanager%s", c.URL.String(), suffix)
-	return doRequest(endpoint, c.Timeout, since, "GetAlerts")
+	var response *ConfigsResponse
+	err := instrument.CollectedRequest(ctx, "GetAlerts", configsRequestDuration, instrument.ErrorCode, func(ctx context.Context) error {
+		var err error
+		response, err = doRequest(endpoint, c.Timeout, since)
+		return err
+	})
+	return response, err
 }
 
-func doRequest(endpoint string, timeout time.Duration, since configs.ID, operation string) (*ConfigsResponse, error) {
+func doRequest(endpoint string, timeout time.Duration, since configs.ID) (*ConfigsResponse, error) {
 	req, err := http.NewRequest("GET", endpoint, nil)
 	if err != nil {
 		return nil, err
 	}
 
 	client := &http.Client{Timeout: timeout}
 
-	start := time.Now()
 	resp, err := client.Do(req)
 	if err != nil {
 		return nil, err
 	}
-	configsRequestDuration.WithLabelValues(operation, resp.Status).Observe(time.Since(start).Seconds())
 	defer resp.Body.Close()
 
 	if resp.StatusCode != http.StatusOK {

pkg/configs/client/config.go

@@ -34,7 +34,7 @@ func TestDoRequest(t *testing.T) {
 	}))
 	defer server.Close()
 
-	resp, err := doRequest(server.URL, 1*time.Second, 0, "TestDoRequest")
+	resp, err := doRequest(server.URL, 1*time.Second, 0)
 	assert.Nil(t, err)
 
 	expected := ConfigsResponse{Configs: map[string]configs.View{

pkg/configs/client/configs_test.go

@@ -6,6 +6,7 @@ import (
 	"time"
 
 	"github.com/go-kit/kit/log"
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/pkg/labels"
 	"github.com/prometheus/prometheus/pkg/rulefmt"
 	"github.com/prometheus/prometheus/promql"
@@ -185,7 +186,21 @@ func (c RulesConfig) Parse() (map[string][]rules.Rule, error) {
 // ParseFormatted returns the rulefmt map of a users rules configs. It allows
 // for rules to be mapped to disk and read by the prometheus rules manager.
 func (c RulesConfig) ParseFormatted() (map[string]rulefmt.RuleGroups, error) {
+	switch c.FormatVersion {
+	case RuleFormatV1:
+		return c.parseV1Formatted()
+	case RuleFormatV2:
+		return c.parseV2Formatted()
+	default:
+		return nil, fmt.Errorf("unknown rule format version %v", c.FormatVersion)
+	}
+}
+
+// parseV2 parses and validates the content of the rule files in a RulesConfig
+// according to the Prometheus 2.x rule format.
+func (c RulesConfig) parseV2Formatted() (map[string]rulefmt.RuleGroups, error) {
 	ruleMap := map[string]rulefmt.RuleGroups{}
+
 	for fn, content := range c.Files {
 		rgs, errs := rulefmt.Parse([]byte(content))
 		if errs != nil {
@@ -199,6 +214,63 @@ func (c RulesConfig) ParseFormatted() (map[string]rulefmt.RuleGroups, error) {
 	return ruleMap, nil
 }
 
+// parseV1 parses and validates the content of the rule files in a RulesConfig
+// according to the Prometheus 1.x rule format.
+func (c RulesConfig) parseV1Formatted() (map[string]rulefmt.RuleGroups, error) {
+	result := map[string]rulefmt.RuleGroups{}
+	for fn, content := range c.Files {
+		stmts, err := legacy_promql.ParseStmts(content)
+		if err != nil {
+			return nil, fmt.Errorf("error parsing %s: %s", fn, err)
+		}
+
+		ra := []rulefmt.Rule{}
+		for _, stmt := range stmts {
+			var rule rulefmt.Rule
+			switch r := stmt.(type) {
+			case *legacy_promql.AlertStmt:
+				_, err := promql.ParseExpr(r.Expr.String())
+				if err != nil {
+					return nil, err
+				}
+
+				rule = rulefmt.Rule{
+					Alert:       r.Name,
+					Expr:        r.Expr.String(),
+					For:         model.Duration(r.Duration),
+					Labels:      r.Labels.Map(),
+					Annotations: r.Annotations.Map(),
+				}
+
+			case *legacy_promql.RecordStmt:
+				_, err := promql.ParseExpr(r.Expr.String())
+				if err != nil {
+					return nil, err
+				}
+
+				rule = rulefmt.Rule{
+					Record: r.Name,
+					Expr:   r.Expr.String(),
+					Labels: r.Labels.Map(),
+				}
+
+			default:
+				return nil, fmt.Errorf("ruler.GetRules: unknown statement type")
+			}
+			ra = append(ra, rule)
+		}
+		result[fn] = rulefmt.RuleGroups{
+			Groups: []rulefmt.RuleGroup{
+				{
+					Name:  "rg:" + fn,
+					Rules: ra,
+				},
+			},
+		}
+	}
+	return result, nil
+}
+
 // parseV2 parses and validates the content of the rule files in a RulesConfig
 // according to the Prometheus 2.x rule format.
 //

pkg/configs/configs.go

@@ -6,16 +6,36 @@ import (
 	"testing"
 	"time"
 
+	"github.com/cortexproject/cortex/pkg/util"
 	"github.com/go-kit/kit/log"
+	"github.com/prometheus/common/model"
 	"github.com/prometheus/prometheus/pkg/labels"
+	"github.com/prometheus/prometheus/pkg/rulefmt"
 	"github.com/prometheus/prometheus/promql"
 	"github.com/prometheus/prometheus/rules"
 	"github.com/stretchr/testify/assert"
 	"github.com/stretchr/testify/require"
-
-	"github.com/cortexproject/cortex/pkg/util"
 )
 
+var legacyRulesFile = `ALERT TestAlert
+IF up == 0
+FOR 5m
+LABELS { severity = "critical" }
+ANNOTATIONS {
+	message = "I am a message"
+}`
+
+var ruleFile = `groups:
+- name: example
+  rules:
+  - alert: TestAlert
+    expr: up == 0
+    for: 5m
+    labels:
+      severity: critical
+    annotations:
+      message: I am a message`
+
 func TestUnmarshalLegacyConfigWithMissingRuleFormatVersionSucceeds(t *testing.T) {
 	actual := Config{}
 	buf := []byte(`{"rules_files": {"a": "b"}}`)
@@ -104,3 +124,70 @@ groups:
 		})
 	}
 }
+
+func TestParseFormatted(t *testing.T) {
+	dur, err := model.ParseDuration("5m")
+	require.NoError(t, err)
+
+	rules := []rulefmt.Rule{
+		{
+			Alert: "TestAlert",
+			Expr:  "up == 0",
+			For:   dur,
+			Labels: map[string]string{
+				"severity": "critical",
+			},
+			Annotations: map[string]string{
+				"message": "I am a message",
+			},
+		},
+	}
+
+	for i, tc := range []struct {
+		cfg      RulesConfig
+		expected map[string]rulefmt.RuleGroups
+	}{
+		{
+			cfg: RulesConfig{
+				FormatVersion: RuleFormatV1,
+				Files: map[string]string{
+					"legacy.rules": legacyRulesFile,
+				},
+			},
+			expected: map[string]rulefmt.RuleGroups{
+				"legacy.rules": {
+					Groups: []rulefmt.RuleGroup{
+						{
+							Name:  "rg:legacy.rules",
+							Rules: rules,
+						},
+					},
+				},
+			},
+		},
+		{
+			cfg: RulesConfig{
+				FormatVersion: RuleFormatV2,
+				Files: map[string]string{
+					"alerts.yaml": ruleFile,
+				},
+			},
+			expected: map[string]rulefmt.RuleGroups{
+				"alerts.yaml": {
+					Groups: []rulefmt.RuleGroup{
+						{
+							Name:  "example",
+							Rules: rules,
+						},
+					},
+				},
+			},
+		},
+	} {
+		t.Run(strconv.Itoa(i), func(t *testing.T) {
+			rules, err := tc.cfg.ParseFormatted()
+			require.NoError(t, err)
+			require.Equal(t, tc.expected, rules)
+		})
+	}
+}

pkg/configs/configs_test.go

@@ -74,7 +74,6 @@ type Config struct {
 	Encoding       encoding.Config          `yaml:"-"` // No yaml for this, it only works with flags.
 	TSDB           tsdb.Config              `yaml:"tsdb"`
 
-	ConfigDB     db.Config                                  `yaml:"configdb,omitempty"`
 	Ruler        ruler.Config                               `yaml:"ruler,omitempty"`
 	ConfigDB     db.Config                                  `yaml:"configdb,omitempty"`
 	ConfigStore  config_client.Config                       `yaml:"config_store,omitempty"`