Adds support for /api/v1/rules API

Signed-off-by: Harkishen-Singh <[email protected]>

This commit implements the `/api/v1/rules` API.

This implementation is done using the rule-manager in rules package
along with reusing the structs that Prometheus uses in its API package.
This ensures that our API response similar to that of Prometheus.

Author: Harkishen-Singh

CHANGELOG.md

@@ -22,6 +22,7 @@ We use the following categories for changes:
 - Query Jaeger traces directly through Promscale [#1224]
 - Additional dataset configuration options via `-startup.dataset.config` flag. Read more [here](docs/dataset.md) [#1276, #1310]
 - Adds support for alerting and recording rules in Promscale [#1286, #1315]
+- Adds support for `/api/v1/rules` API [#1320]
 
 ### Changed
 - Enable tracing by default [#1213], [#1290]

go.sum

@@ -1286,6 +1286,7 @@ github.com/jstemmer/go-junit-report v0.9.1/go.mod h1:Brl9GWCQeLvo8nXZwPNNblvFj/X
 github.com/jsternberg/zap-logfmt v1.2.0/go.mod h1:kz+1CUmCutPWABnNkOu9hOHKdT2q3TDYCcsFy9hpqb0=
 github.com/jtolds/gls v4.20.0+incompatible/go.mod h1:QJZ7F/aHp+rZTRtaJ1ow/lLfFfVYBRgL+9YlvaHOwJU=
 github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/julienschmidt/httprouter v1.3.0 h1:U0609e9tgbseu3rBINet9P48AI/D3oJs4dN7jwJOQ1U=
 github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM=
 github.com/jung-kurt/gofpdf v1.0.3-0.20190309125859-24315acbbda5/go.mod h1:7Id9E/uU8ce6rXgefFLlgrJj/GYY22cpxn+r32jIOes=
 github.com/jwilder/encoding v0.0.0-20170811194829-b4e1701a28ef/go.mod h1:Ct9fl0F6iIOGgxJ5npU/IUOhOhqlVrGjyIZc8/MagT0=

pkg/api/common.go

@@ -191,8 +191,14 @@ func respond(w http.ResponseWriter, status int, message interface{}) {
 	w.Header().Set("Content-Type", "application/json")
 	w.Header().Set("Cache-Control", "no-store")
 	w.WriteHeader(status)
+
+	statusText := "success"
+	if status != 200 {
+		statusText = http.StatusText(status)
+	}
+
 	_ = json.NewEncoder(w).Encode(&response{
-		Status: http.StatusText(status),
+		Status: statusText,
 		Data:   message,
 	})
 }

pkg/api/provider.go

@@ -0,0 +1,39 @@
+// This file and its contents are licensed under the Apache License 2.0.
+// Please see the included NOTICE for copyright information and
+// LICENSE for a copy of the license.
+
+package api
+
+import (
+	"sync"
+
+	"github.com/timescale/promscale/pkg/pgclient"
+	"github.com/timescale/promscale/pkg/rules"
+)
+
+// Provider provides the API, access to the application level implementations.
+// It must be created with its constructor so that none of its fields are nil.
+type provider struct {
+	client   *pgclient.Client
+	rulesMux sync.RWMutex
+	rules    rules.Manager
+}
+
+func NewProviderWith(client *pgclient.Client, manager rules.Manager) *provider {
+	return &provider{
+		client: client,
+		rules:  manager,
+	}
+}
+
+func (p *provider) UpdateRulesManager(m rules.Manager) {
+	p.rulesMux.Lock()
+	defer p.rulesMux.Unlock()
+	p.rules = m
+}
+
+func (p *provider) RulesManager() rules.Manager {
+	p.rulesMux.RLock()
+	defer p.rulesMux.RUnlock()
+	return p.rules
+}

pkg/api/router.go

@@ -22,24 +22,15 @@ import (
 	haClient "github.com/timescale/promscale/pkg/ha/client"
 	"github.com/timescale/promscale/pkg/jaeger"
 	"github.com/timescale/promscale/pkg/log"
-	"github.com/timescale/promscale/pkg/pgclient"
 	pgMetrics "github.com/timescale/promscale/pkg/pgmodel/metrics"
 	"github.com/timescale/promscale/pkg/query"
-	"github.com/timescale/promscale/pkg/rules"
 	"github.com/timescale/promscale/pkg/telemetry"
 )
 
-// Provider provides the API, an access to the application level implementations.
-// None of its fields should be nil.
-type Provider struct {
-	Client *pgclient.Client
-	Rules  rules.Manager
-}
-
-func GenerateRouter(apiConf *Config, promqlConf *query.Config, provider Provider) (*mux.Router, error) {
+func GenerateRouter(apiConf *Config, promqlConf *query.Config, provider *provider) (*mux.Router, error) {
 	var (
 		writePreprocessors []parser.Preprocessor
-		client             = provider.Client
+		client             = provider.client
 	)
 	if apiConf.HighAvailability {
 		service := ha.NewService(haClient.NewLeaseClient(client.Connection))
@@ -98,6 +89,9 @@ func GenerateRouter(apiConf *Config, promqlConf *query.Config, provider Provider
 	metadataHandler := timeHandler(metrics.HTTPRequestDuration, "metadata", MetricMetadata(apiConf, client))
 	apiV1.Path("/metadata").Methods(http.MethodGet, http.MethodPost).HandlerFunc(metadataHandler)
 
+	rulesHandler := timeHandler(metrics.HTTPRequestDuration, "rules", Rules(apiConf, provider, updateQueryMetrics))
+	apiV1.Path("/rules").Methods(http.MethodGet).HandlerFunc(rulesHandler)
+
 	labelValuesHandler := timeHandler(metrics.HTTPRequestDuration, "label/:name/values", LabelValues(apiConf, queryable))
 	apiV1.Path("/label/{name}/values").Methods(http.MethodGet).HandlerFunc(labelValuesHandler)
 

pkg/api/rules.go

@@ -0,0 +1,200 @@
+// This file and its contents are licensed under the Apache License 2.0.
+// Please see the included NOTICE for copyright information and
+// LICENSE for a copy of the license.
+
+package api
+
+import (
+	"fmt"
+	"net/http"
+	"strconv"
+	"strings"
+	"time"
+
+	"github.com/NYTimes/gziphandler"
+
+	"github.com/prometheus/prometheus/model/labels"
+	prom_rules "github.com/prometheus/prometheus/rules"
+
+	"github.com/timescale/promscale/pkg/log"
+)
+
+func Rules(conf *Config, p *provider, updateMetrics func(handler, code string, duration float64)) http.Handler {
+	hf := corsWrapper(conf, rulesHandler(p, updateMetrics))
+	return gziphandler.GzipHandler(hf)
+}
+
+// Below types and code is copied from prometheus/web/api.v1
+// https://github.com/prometheus/prometheus/blob/854d671b6bc5d3ae7960936103ff23863c8a3f91/web/api/v1/api.go#L1168
+//
+// Note: We cannot directly import prometheus/web/api/v1 package and use these exported structs from there.
+// This is because then we get duplicate enum registration in prompb, which is likely due to
+// some dependency in api/v1 package. Thus, copying them here avoids the enum issue.
+
+// RuleDiscovery has info for all rules
+type RuleDiscovery struct {
+	RuleGroups []*RuleGroup `json:"groups"`
+}
+
+// RuleGroup has info for rules which are part of a group
+type RuleGroup struct {
+	Name string `json:"name"`
+	File string `json:"file"`
+	// In order to preserve rule ordering, while exposing type (alerting or recording)
+	// specific properties, both alerting and recording rules are exposed in the
+	// same array.
+	Rules          []Rule    `json:"rules"`
+	Interval       float64   `json:"interval"`
+	Limit          int       `json:"limit"`
+	EvaluationTime float64   `json:"evaluationTime"`
+	LastEvaluation time.Time `json:"lastEvaluation"`
+}
+
+type Rule interface{}
+
+type AlertingRule struct {
+	// State can be "pending", "firing", "inactive".
+	State          string                `json:"state"`
+	Name           string                `json:"name"`
+	Query          string                `json:"query"`
+	Duration       float64               `json:"duration"`
+	Labels         labels.Labels         `json:"labels"`
+	Annotations    labels.Labels         `json:"annotations"`
+	Alerts         []*Alert              `json:"alerts"`
+	Health         prom_rules.RuleHealth `json:"health"`
+	LastError      string                `json:"lastError,omitempty"`
+	EvaluationTime float64               `json:"evaluationTime"`
+	LastEvaluation time.Time             `json:"lastEvaluation"`
+	// Type of an alertingRule is always "alerting".
+	Type string `json:"type"`
+}
+
+type RecordingRule struct {
+	Name           string                `json:"name"`
+	Query          string                `json:"query"`
+	Labels         labels.Labels         `json:"labels,omitempty"`
+	Health         prom_rules.RuleHealth `json:"health"`
+	LastError      string                `json:"lastError,omitempty"`
+	EvaluationTime float64               `json:"evaluationTime"`
+	LastEvaluation time.Time             `json:"lastEvaluation"`
+	// Type of a recordingRule is always "recording".
+	Type string `json:"type"`
+}
+
+// AlertDiscovery has info for all active alerts.
+type AlertDiscovery struct {
+	Alerts []*Alert `json:"alerts"`
+}
+
+// Alert has info for an alert.
+type Alert struct {
+	Labels      labels.Labels `json:"labels"`
+	Annotations labels.Labels `json:"annotations"`
+	State       string        `json:"state"`
+	ActiveAt    *time.Time    `json:"activeAt,omitempty"`
+	Value       string        `json:"value"`
+}
+
+func rulesHandler(p *provider, updateMetrics func(handler, code string, duration float64)) http.HandlerFunc {
+	return func(w http.ResponseWriter, r *http.Request) {
+		statusCode := "400"
+		begin := time.Now()
+		defer func() {
+			updateMetrics("/api/v1/rules", statusCode, time.Since(begin).Seconds())
+		}()
+
+		typ := strings.ToLower(r.URL.Query().Get("type"))
+		if typ != "" && typ != "alert" && typ != "record" {
+			log.Error("msg", "unsupported type", "type", typ)
+			respondError(w, http.StatusBadRequest, fmt.Errorf("unsupported type: type %s", typ), "bad_data")
+			return
+		}
+
+		returnAlerts := typ == "" || typ == "alert"
+		returnRecording := typ == "" || typ == "record"
+
+		ruleGroups := p.RulesManager().RuleGroups()
+		res := &RuleDiscovery{RuleGroups: make([]*RuleGroup, len(ruleGroups))}
+
+		for i, grp := range ruleGroups {
+			apiRuleGroup := &RuleGroup{
+				Name:           grp.Name(),
+				File:           grp.File(),
+				Interval:       grp.Interval().Seconds(),
+				Limit:          grp.Limit(),
+				Rules:          []Rule{},
+				EvaluationTime: grp.GetEvaluationTime().Seconds(),
+				LastEvaluation: grp.GetLastEvaluation(),
+			}
+			for _, r := range grp.Rules() {
+				var enrichedRule Rule
+
+				lastError := ""
+				if r.LastError() != nil {
+					lastError = r.LastError().Error()
+				}
+				switch rule := r.(type) {
+				case *prom_rules.AlertingRule:
+					if !returnAlerts {
+						break
+					}
+					enrichedRule = AlertingRule{
+						State:          rule.State().String(),
+						Name:           rule.Name(),
+						Query:          rule.Query().String(),
+						Duration:       rule.HoldDuration().Seconds(),
+						Labels:         rule.Labels(),
+						Annotations:    rule.Annotations(),
+						Alerts:         rulesAlertsToAPIAlerts(rule.ActiveAlerts()),
+						Health:         rule.Health(),
+						LastError:      lastError,
+						EvaluationTime: rule.GetEvaluationDuration().Seconds(),
+						LastEvaluation: rule.GetEvaluationTimestamp(),
+						Type:           "alerting",
+					}
+				case *prom_rules.RecordingRule:
+					if !returnRecording {
+						break
+					}
+					enrichedRule = RecordingRule{
+						Name:           rule.Name(),
+						Query:          rule.Query().String(),
+						Labels:         rule.Labels(),
+						Health:         rule.Health(),
+						LastError:      lastError,
+						EvaluationTime: rule.GetEvaluationDuration().Seconds(),
+						LastEvaluation: rule.GetEvaluationTimestamp(),
+						Type:           "recording",
+					}
+				default:
+					statusCode = "500"
+					err := fmt.Errorf("failed to assert type of rule '%v'", rule.Name())
+					log.Error("msg", err.Error())
+					respondError(w, http.StatusInternalServerError, err, "type_conversion")
+					return
+				}
+				if enrichedRule != nil {
+					apiRuleGroup.Rules = append(apiRuleGroup.Rules, enrichedRule)
+				}
+			}
+			res.RuleGroups[i] = apiRuleGroup
+		}
+		statusCode = "200"
+		respond(w, 200, res)
+	}
+}
+
+func rulesAlertsToAPIAlerts(rulesAlerts []*prom_rules.Alert) []*Alert {
+	apiAlerts := make([]*Alert, len(rulesAlerts))
+	for i, ruleAlert := range rulesAlerts {
+		apiAlerts[i] = &Alert{
+			Labels:      ruleAlert.Labels,
+			Annotations: ruleAlert.Annotations,
+			State:       ruleAlert.State.String(),
+			ActiveAt:    &ruleAlert.ActiveAt,
+			Value:       strconv.FormatFloat(ruleAlert.Value, 'e', -1, 64),
+		}
+	}
+
+	return apiAlerts
+}

pkg/rules/rules.go

@@ -146,8 +146,8 @@ func (m *impleManager) Stop() {
 
 type noopImple struct{}
 
-func NewNoopManager() noopImple {
-	return noopImple{}
+func NewNoopManager() *noopImple {
+	return &noopImple{}
 }
 
 func (noopImple) ApplyConfig(*prometheus_config.Config) error                         { return nil }

pkg/runner/runner.go

@@ -137,10 +137,7 @@ func Run(cfg *Config) error {
 		}
 	}
 
-	provider := api.Provider{
-		Client: client,
-		Rules:  rules.NewNoopManager(),
-	}
+	provider := api.NewProviderWith(client, rules.NewNoopManager())
 	router, err := api.GenerateRouter(&cfg.APICfg, &cfg.PromQLCfg, provider)
 	if err != nil {
 		log.Error("msg", "aborting startup due to error", "err", fmt.Sprintf("generate router: %s", err.Error()))
@@ -227,13 +224,13 @@ func Run(cfg *Config) error {
 	if cfg.RulesCfg.ContainsRules() {
 		rulesCtx, stopRuler := context.WithCancel(context.Background())
 		defer stopRuler()
+
 		manager, err := rules.NewManager(rulesCtx, prometheus.DefaultRegisterer, client, &cfg.RulesCfg)
 		if err != nil {
 			return fmt.Errorf("error creating rules manager: %w", err)
 		}
-		// This will not cause a race since its in the same routine as the api's Router,
-		// plus Promscale hasn't started yet.
-		provider.Rules = manager
+		provider.UpdateRulesManager(manager)
+
 		group.Add(
 			func() error {
 				promCfg := cfg.RulesCfg.PrometheusConfig
@@ -248,10 +245,10 @@ func Run(cfg *Config) error {
 				); err != nil {
 					return fmt.Errorf("error updating rules manager: %w", err)
 				}
-				log.Info("msg", "Starting rule-manager ...")
+				log.Info("msg", "Started Rule-Manager")
 				return manager.Run()
 			}, func(err error) {
-				log.Info("msg", "Stopping rule-manager")
+				log.Info("msg", "Stopping Rule-Manager")
 				stopRuler()    // Stops the discovery manager.
 				manager.Stop() // Stops the internal group of rule-manager.
 			},

pkg/tests/end_to_end_tests/promql_endpoint_integration_test.go

@@ -322,10 +322,8 @@ func buildRouterWithAPIConfig(pool *pgxpool.Pool, cfg *api.Config) (*mux.Router,
 		return nil, nil, fmt.Errorf("init promql engine: %w", err)
 	}
 
-	router, err := api.GenerateRouter(cfg, qryCfg, api.Provider{
-		Client: pgClient,
-		Rules:  rules.NewNoopManager(),
-	})
+	provider := api.NewProviderWith(pgClient, rules.NewNoopManager())
+	router, err := api.GenerateRouter(cfg, qryCfg, provider)
 	if err != nil {
 		return nil, nil, fmt.Errorf("generate router: %w", err)
 	}