refactor: added new datasources config

Author: henrywhitaker3

README.md

@@ -11,8 +11,15 @@ A stateless status page using data from prometheus. [Demo page](https://status.h
 The status page is configured using a yaml config file:
 
 ```yaml
-# The url of the prometheus instance you want to query
-prometheus: http://prometheus:9090
+datasources:
+  - name: prometheus
+    url: http://prometheus:9000
+    type: prometheus
+  - name: datadog
+    url: https://api.datadoghq.eu
+    token: XXXXXXXX
+    type: datadog
+
 services:
   - name: Postgres
     # Optional. Group services together
@@ -30,6 +37,8 @@ services:
       bool: false
       # Optional. The units to display on any graphs (default: null)
       units: ""
+      # Optional. The datasource to use for the query (default: prometheus)
+      datasource: prometheus
 # Settings to configure the UI
 ui:
   # Optional. The title of the page (default: Status Page)

internal/app/app.go

@@ -9,17 +9,17 @@ import (
 type App struct {
 	Version   string
 	Config    *config.Config
-	Querier   *querier.Querier
+	Queriers  map[string]querier.Querier
 	Collector *collector.Collector
 }
 
-func NewApp(conf *config.Config, q *querier.Querier) *App {
+func NewApp(conf *config.Config, q map[string]querier.Querier) *App {
 	app := &App{
-		Config:  conf,
-		Querier: q,
+		Config:   conf,
+		Queriers: q,
 	}
 
-	app.Collector = collector.NewCollector(app.Querier, conf.Services)
+	app.Collector = collector.NewCollector(conf.Services, q)
 
 	return app
 }

internal/collector/collector.go

@@ -36,14 +36,14 @@ type Result struct {
 }
 
 type Collector struct {
-	q    *querier.Querier
-	svcs []config.Service
+	queriers map[string]querier.Querier
+	svcs     []config.Service
 }
 
-func NewCollector(q *querier.Querier, svcs []config.Service) *Collector {
+func NewCollector(svcs []config.Service, qs map[string]querier.Querier) *Collector {
 	return &Collector{
-		q:    q,
-		svcs: svcs,
+		queriers: qs,
+		svcs:     svcs,
 	}
 }
 
@@ -87,19 +87,19 @@ func (c *Collector) collectService(ctx context.Context, svc config.Service, ch c
 	}
 	log.Printf("collecting metrics for %s\n", svc.Name)
 
-	status, err := c.q.Status(ctx, svc.Query)
+	status, err := c.queriers[svc.Query.Datasource].Status(ctx, svc.Query)
 	if err != nil {
 		log.Printf("ERROR - Failed to scrape status metric for %s query %s: %s", svc.Name, svc.Query.Name, err)
 		res.Success = false
 	}
-	uptime, series, err := c.q.Uptime(ctx, svc.Query)
+	uptime, series, err := c.queriers[svc.Query.Datasource].Uptime(ctx, svc.Query)
 	if err != nil {
 		log.Printf("ERROR - Failed to scrape uptime metric for %s query %s: %s", svc.Name, svc.Query.Name, err)
 		res.Success = false
 	}
 
 	for _, extra := range svc.Extras {
-		_, series, err := c.q.Uptime(ctx, extra)
+		_, series, err := c.queriers[extra.Datasource].Uptime(ctx, extra)
 		if err != nil {
 			log.Printf("ERROR - Failed to scrape uptime metric for %s query %s: %s", svc.Name, extra.Name, err)
 		}

internal/config/config.go

@@ -3,12 +3,18 @@ package config
 import (
 	"errors"
 	"fmt"
+	"log"
 	"os"
+	"slices"
 	"time"
 
 	"gopkg.in/yaml.v3"
 )
 
+var (
+	ErrUnknownDatasource = errors.New("unknown datasource for query")
+)
+
 type Query struct {
 	Name       string        `yaml:"name"`
 	Query      string        `yaml:"query"`
@@ -17,6 +23,7 @@ type Query struct {
 	Step       time.Duration `yaml:"step"`
 	BoolValue  bool          `yaml:"bool"`
 	Units      string        `yaml:"units"`
+	Datasource string        `yaml:"datasource"`
 }
 
 type Service struct {
@@ -41,12 +48,23 @@ type Graphs struct {
 	Points int `yaml:"points"`
 }
 
+type Datasource struct {
+	Name  string `yaml:"name"`
+	Type  string `yaml:"type"`
+	Url   string `yaml:"url"`
+	Token string `yaml:"token,omitempty"`
+}
+
 type Config struct {
-	Port       int           `yaml:"port"`
-	Metrics    Metrics       `yaml:"metrics"`
-	Services   []Service     `yaml:"services"`
-	Prometheus string        `yaml:"prometheus"`
-	Refresh    time.Duration `yaml:"refresh"`
+	Port     int       `yaml:"port"`
+	Metrics  Metrics   `yaml:"metrics"`
+	Services []Service `yaml:"services"`
+
+	Datasources []Datasource `yaml:"datasources"`
+
+	Prometheus string `yaml:"prometheus"`
+
+	Refresh time.Duration `yaml:"refresh"`
 
 	UI UI `yaml:"ui"`
 }
@@ -83,6 +101,14 @@ func setDefaults(conf *Config) {
 		conf.Metrics.Port = 9743
 	}
 
+	if conf.Prometheus != "" {
+		conf.Datasources = append(conf.Datasources, Datasource{
+			Name: "prometheus",
+			Type: "prometheus",
+			Url:  conf.Prometheus,
+		})
+	}
+
 	for i, svc := range conf.Services {
 		svc.Query.Name = "main"
 		if svc.Group == "" {
@@ -122,20 +148,54 @@ func setDefaultQueryValues(q *Query) {
 	if q.Step == 0 {
 		q.Step = time.Minute * 5
 	}
+	if q.Datasource == "" {
+		q.Datasource = "prometheus"
+	}
 }
 
 func (c *Config) Validate() error {
-	if c.Prometheus == "" {
-		return errors.New("prometheus cannot be empty")
+	if c.Prometheus == "" && len(c.Datasources) == 0 {
+		return errors.New("you must configure a datasource")
+	}
+
+	if c.Prometheus != "" {
+		log.Println("DEPRECATED - the prometheus config option is deprecated, replace with an entry in datasources with name prometheus")
+	}
+
+	for _, ds := range c.Datasources {
+		if ds.Name == "" {
+			return errors.New("all datasources must have a name")
+		}
+		if !slices.Contains([]string{"prometheus", "datadog"}, ds.Type) {
+			return errors.New("datasources must be one of: prometheus, datadog")
+		}
+		if ds.Url == "" {
+			return errors.New("datasources must have a url configured")
+		}
 	}
 
 	for _, svc := range c.Services {
+		if !c.containsDatasource(svc.Query.Datasource) {
+			return ErrUnknownDatasource
+		}
 		for _, extra := range svc.Extras {
 			if extra.Name == "" {
 				return errors.New("extra query name cannot be empty")
 			}
+			if !c.containsDatasource(extra.Datasource) {
+				return ErrUnknownDatasource
+			}
 		}
 	}
 
 	return nil
 }
+
+func (c *Config) containsDatasource(name string) bool {
+	for _, ds := range c.Datasources {
+		if name == ds.Name {
+			return true
+		}
+	}
+	return false
+}

internal/querier/prometheus.go

@@ -0,0 +1,136 @@
+package querier
+
+import (
+	"context"
+	"errors"
+	"fmt"
+	"net/http"
+	"strconv"
+	"time"
+
+	"github.com/expr-lang/expr"
+	"github.com/henrywhitaker3/prompage/internal/config"
+	prometheus "github.com/prometheus/client_golang/api"
+	v1 "github.com/prometheus/client_golang/api/prometheus/v1"
+	"github.com/prometheus/common/model"
+)
+
+var (
+	ErrTypeNotImplemented = errors.New("query result type not implemented yet")
+)
+
+type Prometheus struct {
+	client v1.API
+}
+
+func NewPrometheus(conf config.Datasource) (*Prometheus, error) {
+	client, err := prometheus.NewClient(prometheus.Config{
+		Address: conf.Url,
+		Client:  http.DefaultClient,
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	api := v1.NewAPI(client)
+
+	return &Prometheus{
+		client: api,
+	}, nil
+}
+
+func (q *Prometheus) Uptime(ctx context.Context, query config.Query) (float32, []Item, error) {
+	val, _, err := q.client.QueryRange(ctx, query.Query, v1.Range{
+		Start: time.Now().Add(-query.Range),
+		End:   time.Now(),
+		Step:  query.Step,
+	})
+	if err != nil {
+		return 0, nil, err
+	}
+
+	switch r := val.(type) {
+	case model.Matrix:
+		if r.Len() < 1 {
+			return 0, nil, errors.New("no results for query")
+		}
+
+		passing := 0
+		total := 0
+		series := []Item{}
+		for _, val := range r[0].Values {
+			value := float64(0)
+			if query.BoolValue {
+				res, err := q.vector(val.Value, query)
+				if err != nil {
+					return 0, nil, err
+				}
+				if res {
+					passing++
+					value = 1
+				}
+			} else {
+				f, err := q.asFloat(val.Value)
+				if err != nil {
+					return 0, nil, err
+				}
+				value = f
+			}
+			total++
+
+			series = append(series, Item{Time: val.Timestamp.Time(), Value: value})
+		}
+
+		return (float32(passing) / float32(total)) * 100, series, nil
+	}
+
+	return 100, nil, ErrTypeNotImplemented
+}
+
+func (q *Prometheus) Status(ctx context.Context, query config.Query) (bool, error) {
+	val, _, err := q.client.Query(ctx, query.Query, time.Now())
+	if err != nil {
+		return false, err
+	}
+
+	switch r := val.(type) {
+	case model.Vector:
+		if r.Len() < 1 {
+			return false, errors.New("no results for query")
+		}
+		return q.vector(r[0].Value, query)
+	}
+
+	return false, ErrTypeNotImplemented
+}
+
+func (q *Prometheus) vector(v model.SampleValue, query config.Query) (bool, error) {
+	env := map[string]any{
+		"result": 0,
+	}
+
+	exp, err := expr.Compile(query.Expression, expr.Env(env), expr.AsBool())
+	if err != nil {
+		return false, fmt.Errorf("failed to compile expr: %v", err)
+	}
+	val, err := q.asFloat(v)
+	if err != nil {
+		return false, err
+	}
+
+	env["result"] = val
+	out, err := expr.Run(exp, env)
+	if err != nil {
+		return false, err
+	}
+
+	return out.(bool), nil
+}
+
+func (q *Prometheus) asFloat(v model.SampleValue) (float64, error) {
+	val, err := strconv.ParseFloat(v.String(), 64)
+	if err != nil {
+		return 0, fmt.Errorf("failed to parse float: %v", err)
+	}
+	return val, nil
+}