Remove loki support (#7)

Remove loki rule support

Author: friedrichg

CHANGELOG.md

@@ -6,6 +6,7 @@ Order should be `CHANGE`, `FEATURE`, `ENHANCEMENT`, and `BUGFIX`
 
 * [CHANGE] Rename to cortexproject/cortex-tools #2
 * [CHANGE] Update go image to v1.16.15. #4
+* [CHANGE] Remove loki support #7
 * [FEATURE] Support Arm64 on Darwin for all binaries (benchtool etc). #215
 * [BUGFIX] Fix `cortextool rules` legends displaying wrong symbols for updates and deletions. #226
 

cmd/logtool/main.go

@@ -64,8 +64,7 @@ func main() {
 				}
 			case "msg":
 				msg := strings.ReplaceAll(d[2], "\"", "")
-				if !(strings.HasPrefix(msg, "GET /loki/api/") ||
-					strings.HasPrefix(msg, "GET /api/prom")) {
+				if !strings.HasPrefix(msg, "GET /api/prom") {
 					continue
 				}
 

go.mod

@@ -10,7 +10,7 @@ require (
 	github.com/alecthomas/units v0.0.0-20210912230133-d1bdfacee922
 	github.com/cortexproject/cortex v1.10.1-0.20211104100946-3f329a21cad4
 	github.com/dlclark/regexp2 v1.2.0 // indirect
-	github.com/go-kit/kit v0.12.0
+	github.com/go-kit/log v0.2.0
 	github.com/gocql/gocql v0.0.0-20200526081602-cd04bd7f22a7
 	github.com/gogo/protobuf v1.3.2
 	github.com/golang/snappy v0.0.4
@@ -25,7 +25,6 @@ require (
 	github.com/gorilla/mux v1.8.0
 	github.com/grafana-tools/sdk v0.0.0-20220203092117-edae16afa87b
 	github.com/grafana/dskit v0.0.0-20211103155626-4e784973d341
-	github.com/grafana/loki v1.6.2-0.20211108134117-5b9f5b9efaa5
 	github.com/mitchellh/colorstring v0.0.0-20190213212951-d06e56a500db
 	github.com/oklog/ulid v1.3.1
 	github.com/opentracing-contrib/go-stdlib v1.0.0

go.sum

@@ -18,7 +18,7 @@ func (cmd *RuleFileAnalyseCommand) run(k *kingpin.ParseContext) error {
 	output := &analyse.MetricsInRuler{}
 	output.OverallMetrics = make(map[string]struct{})
 
-	nss, err := rules.ParseFiles("cortex", cmd.RuleFilesList)
+	nss, err := rules.ParseFiles(cmd.RuleFilesList)
 	if err != nil {
 		return errors.Wrap(err, "analyse operation unsuccessful, unable to parse rules files")
 	}

pkg/commands/analyse_rulefiles.go

@@ -47,7 +47,7 @@ func TestParseMetricsInRuleFile(t *testing.T) {
 	output := &analyse.MetricsInRuler{}
 	output.OverallMetrics = make(map[string]struct{})
 
-	nss, err := rules.ParseFiles("cortex", []string{"testdata/prometheus_rules.yaml"})
+	nss, err := rules.ParseFiles([]string{"testdata/prometheus_rules.yaml"})
 	require.NoError(t, err)
 
 	for _, ns := range nss {

pkg/commands/analyse_rules_test.go

@@ -38,8 +38,7 @@ var (
 		Help:      "The timestamp of the last successful rule load.",
 	})
 
-	backends = []string{rules.CortexBackend, rules.LokiBackend} // list of supported backend types
-	formats  = []string{"json", "yaml", "table"}                // list of supported formats for the list command
+	formats = []string{"json", "yaml", "table"} // list of supported formats for the list command
 )
 
 // RuleCommand configures and executes rule related cortex operations
@@ -48,9 +47,6 @@ type RuleCommand struct {
 
 	cli *client.CortexClient
 
-	// Backend type (cortex | loki)
-	Backend string
-
 	// Get Rule Groups Configs
 	Namespace string
 	RuleGroup string
@@ -93,7 +89,6 @@ func (r *RuleCommand) Register(app *kingpin.Application) {
 	rulesCmd.Flag("authToken", "Authentication token for bearer token or JWT auth, alternatively set CORTEX_AUTH_TOKEN.").Default("").Envar("CORTEX_AUTH_TOKEN").StringVar(&r.ClientConfig.AuthToken)
 	rulesCmd.Flag("user", "API user to use when contacting cortex, alternatively set CORTEX_API_USER. If empty, CORTEX_TENANT_ID will be used instead.").Default("").Envar("CORTEX_API_USER").StringVar(&r.ClientConfig.User)
 	rulesCmd.Flag("key", "API key to use when contacting cortex, alternatively set CORTEX_API_KEY.").Default("").Envar("CORTEX_API_KEY").StringVar(&r.ClientConfig.Key)
-	rulesCmd.Flag("backend", "Backend type to interact with: <cortex|loki>").Default("cortex").EnumVar(&r.Backend, backends...)
 
 	// Register rule commands
 	listCmd := rulesCmd.
@@ -241,11 +236,6 @@ func (r *RuleCommand) setup(k *kingpin.ParseContext) error {
 		ruleLoadSuccessTimestamp,
 	)
 
-	// Loki's non-legacy route does not match Cortex, but the legacy one does.
-	if r.Backend == rules.LokiBackend {
-		r.ClientConfig.UseLegacyRoutes = true
-	}
-
 	cli, err := client.New(r.ClientConfig)
 	if err != nil {
 		return err
@@ -378,7 +368,7 @@ func (r *RuleCommand) deleteRuleGroup(k *kingpin.ParseContext) error {
 }
 
 func (r *RuleCommand) loadRules(k *kingpin.ParseContext) error {
-	nss, err := rules.ParseFiles(r.Backend, r.RuleFilesList)
+	nss, err := rules.ParseFiles(r.RuleFilesList)
 	if err != nil {
 		return errors.Wrap(err, "load operation unsuccessful, unable to parse rules files")
 	}
@@ -440,7 +430,7 @@ func (r *RuleCommand) diffRules(k *kingpin.ParseContext) error {
 		return errors.Wrap(err, "diff operation unsuccessful, unable to load rules files")
 	}
 
-	nss, err := rules.ParseFiles(r.Backend, r.RuleFilesList)
+	nss, err := rules.ParseFiles(r.RuleFilesList)
 	if err != nil {
 		return errors.Wrap(err, "diff operation unsuccessful, unable to parse rules files")
 	}
@@ -503,7 +493,7 @@ func (r *RuleCommand) syncRules(k *kingpin.ParseContext) error {
 		return errors.Wrap(err, "sync operation unsuccessful, unable to load rules files")
 	}
 
-	nss, err := rules.ParseFiles(r.Backend, r.RuleFilesList)
+	nss, err := rules.ParseFiles(r.RuleFilesList)
 	if err != nil {
 		return errors.Wrap(err, "sync operation unsuccessful, unable to parse rules files")
 	}
@@ -625,7 +615,7 @@ func (r *RuleCommand) prepare(k *kingpin.ParseContext) error {
 		return errors.Wrap(err, "prepare operation unsuccessful, unable to load rules files")
 	}
 
-	namespaces, err := rules.ParseFiles(r.Backend, r.RuleFilesList)
+	namespaces, err := rules.ParseFiles(r.RuleFilesList)
 	if err != nil {
 		return errors.Wrap(err, "prepare operation unsuccessful, unable to parse rules files")
 	}
@@ -663,14 +653,14 @@ func (r *RuleCommand) lint(k *kingpin.ParseContext) error {
 		return errors.Wrap(err, "prepare operation unsuccessful, unable to load rules files")
 	}
 
-	namespaces, err := rules.ParseFiles(r.Backend, r.RuleFilesList)
+	namespaces, err := rules.ParseFiles(r.RuleFilesList)
 	if err != nil {
 		return errors.Wrap(err, "prepare operation unsuccessful, unable to parse rules files")
 	}
 
 	var count, mod int
 	for _, ruleNamespace := range namespaces {
-		c, m, err := ruleNamespace.LintExpressions(r.Backend)
+		c, m, err := ruleNamespace.LintExpressions()
 		if err != nil {
 			return err
 		}
@@ -697,7 +687,7 @@ func (r *RuleCommand) checkRecordingRuleNames(k *kingpin.ParseContext) error {
 		return errors.Wrap(err, "check operation unsuccessful, unable to load rules files")
 	}
 
-	namespaces, err := rules.ParseFiles(r.Backend, r.RuleFilesList)
+	namespaces, err := rules.ParseFiles(r.RuleFilesList)
 	if err != nil {
 		return errors.Wrap(err, "check operation unsuccessful, unable to parse rules files")
 	}

pkg/commands/rules.go

@@ -8,37 +8,20 @@ import (
 	"path/filepath"
 	"strings"
 
-	"github.com/grafana/loki/pkg/ruler"
-	"github.com/prometheus/prometheus/pkg/rulefmt"
 	log "github.com/sirupsen/logrus"
 	yaml "gopkg.in/yaml.v3"
 )
 
-const (
-	CortexBackend = "cortex"
-	LokiBackend   = "loki"
-)
-
 var (
-	errFileReadError  = errors.New("file read error")
-	errInvalidBackend = errors.New("invalid backend type")
+	errFileReadError = errors.New("file read error")
 )
 
 // ParseFiles returns a formatted set of prometheus rule groups
-func ParseFiles(backend string, files []string) (map[string]RuleNamespace, error) {
+func ParseFiles(files []string) (map[string]RuleNamespace, error) {
 	ruleSet := map[string]RuleNamespace{}
-	var parseFn func(f string) ([]RuleNamespace, []error)
-	switch backend {
-	case CortexBackend:
-		parseFn = Parse
-	case LokiBackend:
-		parseFn = ParseLoki
-	default:
-		return nil, errInvalidBackend
-	}
 
 	for _, f := range files {
-		nss, errs := parseFn(f)
+		nss, errs := Parse(f)
 		for _, err := range errs {
 			log.WithError(err).WithField("file", f).Errorln("unable parse rules file")
 			return nil, errFileReadError
@@ -104,44 +87,6 @@ func ParseBytes(content []byte) ([]RuleNamespace, []error) {
 	return nss, nil
 }
 
-func ParseLoki(f string) ([]RuleNamespace, []error) {
-	content, err := loadFile(f)
-	if err != nil {
-		log.WithError(err).WithField("file", f).Errorln("unable load rules file")
-		return nil, []error{errFileReadError}
-	}
-
-	decoder := yaml.NewDecoder(bytes.NewReader(content))
-	decoder.KnownFields(true)
-
-	var nss []RuleNamespace
-	for {
-		var ns RuleNamespace
-		err := decoder.Decode(&ns)
-		if err == io.EOF {
-			break
-		}
-		if err != nil {
-			return nil, []error{err}
-		}
-
-		// the upstream loki validator only validates the rulefmt rule groups,
-		// not the remote write configs this type attaches.
-		var grps []rulefmt.RuleGroup
-		for _, g := range ns.Groups {
-			grps = append(grps, g.RuleGroup)
-		}
-
-		if errs := ruler.ValidateGroups(grps...); len(errs) > 0 {
-			return nil, errs
-		}
-
-		nss = append(nss, ns)
-
-	}
-	return nss, nil
-}
-
 func loadFile(filename string) ([]byte, error) {
 	file, err := os.Open(filename)
 	if err != nil {

pkg/rules/parser.go

@@ -12,14 +12,12 @@ import (
 func TestParseFiles(t *testing.T) {
 	tests := []struct {
 		name    string
-		backend string
 		files   []string
 		want    map[string]RuleNamespace
 		wantErr bool
 	}{
 		{
-			name:    "basic_file",
-			backend: CortexBackend,
+			name: "basic_file",
 			files: []string{
 				"testdata/basic_namespace.yaml",
 			},
@@ -42,17 +40,15 @@ func TestParseFiles(t *testing.T) {
 			},
 		},
 		{
-			name:    "file_namespace_overlap",
-			backend: CortexBackend,
+			name: "file_namespace_overlap",
 			files: []string{
 				"testdata/basic_namespace.yaml",
 				"testdata/basic_namespace_repeated.yaml",
 			},
 			wantErr: true,
 		},
 		{
-			name:    "multiple_namespace_file",
-			backend: CortexBackend,
+			name: "multiple_namespace_file",
 			files: []string{
 				"testdata/multiple_namespace.yaml",
 			},
@@ -89,106 +85,11 @@ func TestParseFiles(t *testing.T) {
 				},
 			},
 		},
-		{
-			name:    "basic_loki_file",
-			backend: LokiBackend,
-			files: []string{
-				"testdata/loki_basic.yaml",
-			},
-			want: map[string]RuleNamespace{
-				"loki_basic": {
-					Namespace: "loki_basic",
-					Groups: []rwrulefmt.RuleGroup{
-						{
-							RuleGroup: rulefmt.RuleGroup{
-								Name: "testgrp2",
-								Rules: []rulefmt.RuleNode{
-									{
-										// currently the tests only check length
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		{
-			name:    "basic_loki_namespace",
-			backend: LokiBackend,
-			files: []string{
-				"testdata/loki_basic_namespace.yaml",
-			},
-			want: map[string]RuleNamespace{
-				"foo": {
-					Namespace: "foo",
-					Groups: []rwrulefmt.RuleGroup{
-						{
-							RuleGroup: rulefmt.RuleGroup{
-								Name: "testgrp2",
-								Rules: []rulefmt.RuleNode{
-									{
-										// currently the tests only check length
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
-		{
-			name:    "basic_loki_failure",
-			backend: LokiBackend,
-			files: []string{
-				"testdata/loki_basic_failure.yaml",
-			},
-			wantErr: true,
-		},
-		{
-			name:    "multiple_loki_namespace",
-			backend: LokiBackend,
-			files: []string{
-				"testdata/loki_multiple_namespace.yaml",
-			},
-			want: map[string]RuleNamespace{
-				"foo": {
-					Namespace: "foo",
-					Groups: []rwrulefmt.RuleGroup{
-						{
-							RuleGroup: rulefmt.RuleGroup{
-								Name: "testgrp2",
-								Rules: []rulefmt.RuleNode{
-									{
-										// currently the tests only check length
-									},
-								},
-							},
-						},
-					},
-				},
-				"other_foo": {
-					Namespace: "other_foo",
-					Groups: []rwrulefmt.RuleGroup{
-						{
-							RuleGroup: rulefmt.RuleGroup{
-								Name: "other_testgrp2",
-								Rules: []rulefmt.RuleNode{
-									{
-										// currently the tests only check length
-									},
-								},
-							},
-						},
-					},
-				},
-			},
-		},
 	}
 
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, err := ParseFiles(tt.backend, tt.files)
+			got, err := ParseFiles(tt.files)
 			if (err != nil) != tt.wantErr {
 				t.Errorf("ParseFiles() error = %v, wantErr %v", err, tt.wantErr)
 				return