Create mimir client

docs/content/configuration.md

@@ -32,30 +32,31 @@ establish authentication credentials.
 
 ```sh
 grr config set grafana.url http://localhost:3000 # URL for the root of your Grafana instance
-grr config set grafana.user admin # Optional: Username if using basic auth
+grr config set grafana.user admin # (Optional) Username if using basic auth
 grr config set grafana.token abcd12345 # Service account token (or basic auth password)
 ```
 
 ## Grafana Cloud Prometheus
 To interact with Grafana Cloud Prometheus (aka Mimir), use these settings:
 
 ```sh
-grr config set mimir.address https://mimir.example.com # URL for Grafana Cloud Prometheus instance
-grr config set mimir.tenant-id 1234567 # Tenant ID for your Grafana Cloud Prometheus account
-grr config set mimir.api-key abcdef12345 # Authentication token
+grr config set mimir.address https://mimir.example.com # URL for Mimir instance or Grafana Cloud Prometheus instance
+grr config set mimir.tenant-id myTenant # Tenant ID for your Grafana Cloud Prometheus account
+grr config set mimir.api-key abcdef12345 # Authentication token (if you are using Grafana Cloud)
 ```
 
-Note, this will also work with other Cortex installations, alongside Grafana Cloud Prometheus/Mimir.
+**Notes** 
+* Be sure to set `api-key` when you need to interact with Grafana Cloud.
 
 ## Grafana Synthetic Monitoring
 To interact with Grafana Synthetic Monitoring, you must configure the below settings:
 
 ```sh
 grr config set synthetic-monitoring.token abcdef123456 # API key (must have MetricsPublisher permissions)
-grr config set synthetic-monitoring.stack-id # Grafana stack ID
-grr config set synthetic-monitoring.metrics-id # Metrics instance ID
-grr config set synthetic-monitoring.logs-id # Logs instance ID
-grr config set synthetic-monitoring.url # Synthetic Monitoring instance URL
+grr config set synthetic-monitoring.stack-id 123 # Grafana stack ID
+grr config set synthetic-monitoring.metrics-id 123 # Metrics instance ID
+grr config set synthetic-monitoring.logs-id 123 # Logs instance ID
+grr config set synthetic-monitoring.url https://synthetic-monitoring-api.grafana.net # Synthetic Monitoring instance URL
 ```
 Your stack ID is the number at the end of the url when you view your Grafana instance details, ie. `grafana.com/orgs/myorg/stacks/123456` would be `123456`. Your metrics and logs ID's are the `User` when you view your Prometheus or Loki instance details in Grafana Cloud.
 You can find your instance URL under your Synthetic Monitoring configuration.
@@ -149,13 +150,13 @@ docs](https://grafana.com/docs/grafana/latest/http_api/auth/) for more info.
 ## Grafana Cloud Prometheus
 To interact with Grafana Cloud Prometheus, you must have these environment variables set:
 
-| Name               | Description                                         | Required |
-|--------------------|-----------------------------------------------------|----------|
-| `CORTEX_ADDRESS`   | URL for Grafana Cloud Prometheus instance           | true     |
-| `CORTEX_TENANT_ID` | Tenant ID for your Grafana Cloud Prometheus account | true     |
-| `CORTEX_API_KEY`   | Authentication token/api key                        | true     |
+| Name              | Description                                         | Required |
+|-------------------|-----------------------------------------------------|----------|
+| `MIMIR_ADDRESS`   | URL for Grafana Cloud Prometheus instance           | true     |
+| `MIMIR_TENANT_ID` | Tenant ID for your Grafana Cloud Prometheus account | true     |
+| `MIMIR_API_KEY`   | Authentication token/api key                        | false    |
 
-Note, this will also work with other Cortex installations, alongside Grafana Cloud Prometheus.
+Note, this will also work with other Mimir installations, alongside Grafana Cloud Prometheus.
 
 ## Grafana Synthetic Monitoring
 To interact with Grafana Synthetic Monitoring, you must have these environment variable set:

docs/content/prometheus.md

@@ -9,7 +9,7 @@ local disk. As Grizzly focuses on systems that can be managed via HTTP APIs,
 Grizzly cannot (currently) work with Prometheus itself.
 
 Various hosted Prometheus installations, such as Grafana Cloud Prometheus
-are supported, as are systems running Cortex.
+are supported, as are systems running Mimir.
 
 ## Configuring Prometheus
 Prometheus alert and recording rules are both created using the same `kind`:

pkg/config/config.go

@@ -39,18 +39,37 @@ func override(v *viper.Viper) {
 		"synthetic-monitoring.metrics-id": "GRAFANA_SM_METRICS_ID",
 		"synthetic-monitoring.url":        "GRAFANA_SM_URL",
 
-		"mimir.address":   "CORTEX_ADDRESS",
-		"mimir.tenant-id": "CORTEX_TENANT_ID",
-		"mimir.api-key":   "CORTEX_API_KEY",
+		"mimir.address":   "MIMIR_ADDRESS",
+		"mimir.tenant-id": "MIMIR_TENANT_ID",
+		"mimir.api-key":   "MIMIR_API_KEY",
 	}
+
+	// To keep retro compatibility
+	legacyBindings := map[string]string{
+		"MIMIR_ADDRESS":   "CORTEX_ADDRESS",
+		"MIMIR_TENANT_ID": "CORTEX_TENANT_ID",
+		"MIMIR_API_KEY":   "CORTEX_API_KEY",
+	}
+
 	for key, env := range bindings {
-		val := os.Getenv(env)
-		if val != "" {
+		if val := getVal(env, legacyBindings); val != "" {
 			v.Set(key, val)
 		}
 	}
 }
 
+func getVal(env string, alternativeMap map[string]string) string {
+	if val := os.Getenv(env); val != "" {
+		return val
+	}
+
+	if alternativeMap[env] != "" {
+		return getVal(alternativeMap[env], nil)
+	}
+
+	return ""
+}
+
 func Read() error {
 	err := viper.ReadInConfig()
 	if err != nil {

pkg/mimir/client/http_client.go

@@ -0,0 +1,130 @@
+package client
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"io"
+	"net/http"
+	"os"
+	"strconv"
+	"time"
+
+	"github.com/grafana/grizzly/pkg/config"
+	"github.com/grafana/grizzly/pkg/mimir/models"
+	"gopkg.in/yaml.v3"
+)
+
+var loadRulesEndpoint = "%s/prometheus/config/v1/rules/%s"
+var listRulesEndpoint = "%s/prometheus/api/v1/rules"
+
+type ListGroupResponse struct {
+	Status string `yaml:"status"`
+	Data   struct {
+		DataGroups []DataGroups `yaml:"groups"`
+	} `yaml:"data"`
+}
+
+type DataGroups struct {
+	Name  string        `yaml:"name"`
+	File  string        `yaml:"file"`
+	Rules []interface{} `yaml:"rules"`
+}
+
+type Client struct {
+	config *config.MimirConfig
+}
+
+func NewHTTPClient(config *config.MimirConfig) Mimir {
+	return &Client{config: config}
+}
+
+func (c *Client) ListRules() (map[string][]models.PrometheusRuleGroup, error) {
+	url := fmt.Sprintf(listRulesEndpoint, c.config.Address)
+	res, err := c.doRequest(http.MethodGet, url, nil)
+	if err != nil {
+		return nil, err
+	}
+
+	var response ListGroupResponse
+	if err := yaml.Unmarshal(res, &response); err != nil {
+		return nil, err
+	}
+
+	groups := make(map[string][]models.PrometheusRuleGroup)
+	for _, g := range response.Data.DataGroups {
+		groups[g.File] = append(groups[g.File], models.PrometheusRuleGroup{
+			Name:  g.Name,
+			Rules: g.Rules,
+		})
+	}
+
+	return groups, nil
+}
+
+func (c *Client) CreateRules(resource models.PrometheusRuleGrouping) error {
+	url := fmt.Sprintf(loadRulesEndpoint, c.config.Address, resource.Namespace)
+	for _, group := range resource.Groups {
+		out, err := yaml.Marshal(group)
+		if err != nil {
+			return fmt.Errorf("cannot marshall groups: %s", err)
+		}
+
+		if _, err = c.doRequest(http.MethodPost, url, out); err != nil {
+			return fmt.Errorf("error found creating rule group: %s", group.Name)
+		}
+	}
+
+	return nil
+}
+
+func (c *Client) doRequest(method string, url string, body []byte) ([]byte, error) {
+	if c.config.TenantID == "" {
+		return nil, errors.New("missing tenant-id")
+	}
+	req, err := http.NewRequest(method, url, bytes.NewReader(body))
+	if err != nil {
+		return nil, err
+	}
+
+	req.Header.Set("Content-Type", "application/yaml")
+	if c.config.APIKey != "" {
+		req.SetBasicAuth(c.config.TenantID, c.config.APIKey)
+	} else {
+		req.Header.Set("X-Scope-OrgID", c.config.TenantID)
+	}
+
+	client, err := createHTTPClient()
+	if err != nil {
+		return nil, err
+	}
+
+	res, err := client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("request to load rules failed: %s", err)
+	}
+
+	if res.StatusCode >= 300 {
+		return nil, fmt.Errorf("error loading rules: %d", res.StatusCode)
+	}
+
+	b, err := io.ReadAll(res.Body)
+	if err != nil {
+		return nil, fmt.Errorf("cannot read response body: %s", err)
+	}
+
+	return b, nil
+}
+
+func createHTTPClient() (*http.Client, error) {
+	timeout := 10 * time.Second
+	// TODO: Move this configuration to the global configuration
+	if timeoutStr := os.Getenv("GRIZZLY_HTTP_TIMEOUT"); timeoutStr != "" {
+		timeoutSeconds, err := strconv.Atoi(timeoutStr)
+		if err != nil {
+			return nil, err
+		}
+		timeout = time.Duration(timeoutSeconds) * time.Second
+	}
+	return &http.Client{Timeout: timeout}, nil
+}

pkg/mimir/client/mimir.go

@@ -0,0 +1,10 @@
+package client
+
+import (
+	"github.com/grafana/grizzly/pkg/mimir/models"
+)
+
+type Mimir interface {
+	ListRules() (map[string][]models.PrometheusRuleGroup, error)
+	CreateRules(resource models.PrometheusRuleGrouping) error
+}

pkg/mimir/models/models.go

@@ -0,0 +1,13 @@
+package models
+
+// PrometheusRuleGroup encapsulates a list of rules
+type PrometheusRuleGroup struct {
+	Name  string        `yaml:"name"`
+	Rules []interface{} `yaml:"rules"`
+}
+
+// PrometheusRuleGrouping encapsulates a set of named rule groups
+type PrometheusRuleGrouping struct {
+	Namespace string                `yaml:"namespace"`
+	Groups    []PrometheusRuleGroup `yaml:"groups"`
+}

pkg/mimir/provider.go

@@ -2,32 +2,32 @@ package mimir
 
 import (
 	"fmt"
-	"os/exec"
 	"path/filepath"
 
 	"github.com/grafana/grizzly/pkg/config"
 	"github.com/grafana/grizzly/pkg/grizzly"
+	"github.com/grafana/grizzly/pkg/mimir/client"
 )
 
 // Provider is a grizzly.Provider implementation for Grafana.
 type Provider struct {
-	config *config.MimirConfig
+	config     *config.MimirConfig
+	clientTool client.Mimir
 }
 
 // NewProvider instantiates a new Provider.
 func NewProvider(config *config.MimirConfig) (*Provider, error) {
-	if _, err := exec.LookPath("cortextool"); err != nil {
-		return nil, err
-	}
+	clientTool := client.NewHTTPClient(config)
 	if config.Address == "" {
 		return nil, fmt.Errorf("mimir address is not set")
 	}
-	if config.APIKey == "" {
-		return nil, fmt.Errorf("mimir api key is not set")
+	if config.TenantID == "" {
+		return nil, fmt.Errorf("mimir tenant id is not set")
 	}
 
 	return &Provider{
-		config: config,
+		config:     config,
+		clientTool: clientTool,
 	}, nil
 }
 
@@ -53,6 +53,6 @@ func (p *Provider) APIVersion() string {
 // GetHandlers identifies the handlers for the Grafana provider
 func (p *Provider) GetHandlers() []grizzly.Handler {
 	return []grizzly.Handler{
-		NewRuleHandler(p),
+		NewRuleHandler(p, p.clientTool),
 	}
 }