Merge pull request #848 from sapcc/designate_liquid_prometheus_query

switch liquid designate to use prometheus queries for usage

Author: majewsky

docs/liquids/designate.md

@@ -13,7 +13,11 @@ This liquid provides support for the DNS service Designate.
 
 ## Service-specific configuration
 
-None.
+| Field | Type | Description |
+| ----- | ---- | ----------- |
+| `prometheus_config.api` | [`promquery.Config`](https://pkg.go.dev/github.com/sapcc/go-bits/promquery#Config) | Configuration for the Prometheus connection from which usage data is queried by the liquid. |
+| `prometheus_config.queries.zones` | [`text/template`](https://pkg.go.dev/text/template) compatible string | Prometheus query for scraping the number of zones per project. The template should contain a filter string `{{.ProjectUUID}}` to be filled with the UUID of the project to be queried for usages. |
+| `prometheus_config.queries.recordsets_per_zone` | [`text/template`](https://pkg.go.dev/text/template) compatible string | Prometheus query for scraping the maximum number of recordsets across all zones of this project. The template should contain a filter string `{{.ProjectUUID}}` to be filled with the UUID of the project to be queried for usages. |
 
 ## Resources
 
@@ -25,3 +29,9 @@ None.
 When the `recordsets_per_zone` quota is set, the backend quota for records per zone is set to 20 times that value, to
 fit into the `records_per_recordset` quota (which is set to 20 by default in Designate). The quota for records per zone
 cannot be managed explicitly in this liquid.
+
+### Considerations for cloud operators
+
+Because querying usage for the zones and especially recordsets resources is very inefficient using the Designate API, this liquid will instead collect usage data from Prometheus metrics.
+Your Designate operator will have to provide suitable metrics that report the count of all zones per project, as well as the number of recordsets in those zones.
+Be aware that when exporting these figures from the designate database, you have to take into account that deleted zones are soft deleted at first and have to be filtered from the result (`status != "DELETED"`).

internal/liquids/designate/client.go

@@ -8,8 +8,6 @@ import (
 
 	"github.com/gophercloud/gophercloud/v2"
 	"github.com/gophercloud/gophercloud/v2/openstack"
-	"github.com/gophercloud/gophercloud/v2/openstack/dns/v2/zones"
-	"github.com/gophercloud/gophercloud/v2/pagination"
 )
 
 // Client is a gophercloud.ServiceClient for the Designate API.
@@ -49,46 +47,3 @@ func (c *Client) setQuota(ctx context.Context, projectUUID string, qs quotaSet)
 	_, _, err := gophercloud.ParseResponse(c.Patch(ctx, url, qs, nil, &opts)) //nolint:bodyclose
 	return err
 }
-
-func (c *Client) listZoneIDs(ctx context.Context, projectUUID string) ([]string, error) {
-	pager := zones.List(c.ServiceClient, zones.ListOpts{})
-	pager.Headers = map[string]string{
-		"X-Auth-All-Projects":    "false",
-		"X-Auth-Sudo-Project-Id": projectUUID,
-	}
-
-	var ids []string
-	err := pager.EachPage(ctx, func(ctx context.Context, page pagination.Page) (bool, error) {
-		zones, err := zones.ExtractZones(page)
-		if err != nil {
-			return false, err
-		}
-		for _, zone := range zones {
-			ids = append(ids, zone.ID)
-		}
-		return true, nil
-	})
-	return ids, err
-}
-
-func (c *Client) countZoneRecordsets(ctx context.Context, projectUUID, zoneID string) (uint64, error) {
-	url := c.ServiceURL("zones", zoneID, "recordsets")
-	url += "?limit=1" // do not need all data about all recordsets, just the total count
-	opts := gophercloud.RequestOpts{
-		MoreHeaders: map[string]string{
-			"X-Auth-All-Projects":    "false",
-			"X-Auth-Sudo-Project-Id": projectUUID,
-		},
-	}
-
-	var r gophercloud.Result
-	_, r.Header, r.Err = gophercloud.ParseResponse(c.Get(ctx, url, &r.Body, &opts)) //nolint:bodyclose
-
-	var data struct {
-		Metadata struct {
-			Count uint64 `json:"total_count"`
-		} `json:"metadata"`
-	}
-	err := r.ExtractInto(&data)
-	return data.Metadata.Count, err
-}

internal/liquids/designate/liquid.go

@@ -4,28 +4,67 @@
 package designate
 
 import (
+	"bytes"
 	"context"
 	"errors"
+	"fmt"
+	"math"
 	"net/http"
+	"text/template"
 
 	"github.com/gophercloud/gophercloud/v2"
 	. "github.com/majewsky/gg/option"
 	"github.com/sapcc/go-api-declarations/liquid"
+	"github.com/sapcc/go-bits/promquery"
 	"github.com/sapcc/go-bits/respondwith"
 )
 
 // Logic implements the liquidapi.Logic interface for Designate.
 type Logic struct {
+	// configuration
+	PrometheusConfig struct {
+		APIConfig promquery.Config `json:"api"`
+		Queries   struct {
+			Zones             string `json:"zones"`
+			RecordsetsPerZone string `json:"recordsets_per_zone"`
+		} `json:"queries"`
+	} `json:"prometheus_config"`
 	// connections
 	DesignateV2 *Client `json:"-"`
+	Templates   struct {
+		Zones             *template.Template `json:"-"`
+		RecordsetsPerZone *template.Template `json:"-"`
+	}
 }
 
 // Init implements the liquidapi.Logic interface.
 func (l *Logic) Init(ctx context.Context, provider *gophercloud.ProviderClient, eo gophercloud.EndpointOpts) (err error) {
 	l.DesignateV2, err = newClient(provider, eo)
+	if err != nil {
+		return fmt.Errorf("init designate v2 client: %w", err)
+	}
+	l.Templates.Zones, err = parseQuery(l.PrometheusConfig.Queries.Zones)
+	if err != nil {
+		return fmt.Errorf("parse zones query: %w", err)
+	}
+	l.Templates.RecordsetsPerZone, err = parseQuery(l.PrometheusConfig.Queries.RecordsetsPerZone)
+	if err != nil {
+		return fmt.Errorf("parse recordsets per zone query: %w", err)
+	}
 	return err
 }
 
+func parseQuery(query string) (tmpl *template.Template, err error) {
+	if query == "" {
+		return tmpl, errors.New("query is empty")
+	}
+	tmpl, err = template.New("query").Parse(query)
+	if err != nil {
+		return tmpl, fmt.Errorf("error while parsing the template: %w", err)
+	}
+	return tmpl, nil
+}
+
 // BuildServiceInfo implements the liquidapi.Logic interface.
 func (l *Logic) BuildServiceInfo(ctx context.Context) (liquid.ServiceInfo, error) {
 	return liquid.ServiceInfo{
@@ -62,24 +101,38 @@ func (l *Logic) ScanUsage(ctx context.Context, projectUUID string, req liquid.Se
 		return liquid.ServiceUsageReport{}, err
 	}
 
-	// to query usage, start by listing all zones
-	zoneIDs, err := l.DesignateV2.listZoneIDs(ctx, projectUUID)
+	// note: The following data is available via designate API, but we transitioned to use
+	// Prometheus queries because of the faster response times for more frequent scraping.
+	client, err := l.PrometheusConfig.APIConfig.Connect()
 	if err != nil {
-		return liquid.ServiceUsageReport{}, err
+		return liquid.ServiceUsageReport{}, fmt.Errorf("while getting prometheus client: %w", err)
 	}
-
-	// query "recordsets per zone" usage by counting recordsets in each zone
-	// individually (we could count all recordsets over the all project at once,
-	// but that won't help since the quota applies per individual zone)
-	maxRecordsetsPerZone := uint64(0)
-	for _, zoneID := range zoneIDs {
-		count, err := l.DesignateV2.countZoneRecordsets(ctx, projectUUID, zoneID)
+	scrapeUsageMetric := func(template *template.Template) (uint64, error) {
+		data := map[string]any{
+			"ProjectUUID": projectUUID,
+		}
+		var templated bytes.Buffer
+		err = template.Execute(&templated, data)
+		if err != nil {
+			return 0, fmt.Errorf("error while filling the template: %w", err)
+		}
+		value, err := client.GetSingleValue(ctx, templated.String(), new(0.0))
 		if err != nil {
-			return liquid.ServiceUsageReport{}, err
+			return 0, fmt.Errorf("error while retrieving prometheus value: %w", err)
 		}
-		if maxRecordsetsPerZone < count {
-			maxRecordsetsPerZone = count
+		if value < 0 || math.IsNaN(value) || math.IsInf(value, 0) {
+			return 0, fmt.Errorf("unexpected value: %f", value)
 		}
+		return uint64(math.Round(value)), nil
+	}
+
+	zones, err := scrapeUsageMetric(l.Templates.Zones)
+	if err != nil {
+		return liquid.ServiceUsageReport{}, fmt.Errorf("while scraping zones usage: %w", err)
+	}
+	maxRecordsetsPerZone, err := scrapeUsageMetric(l.Templates.RecordsetsPerZone)
+	if err != nil {
+		return liquid.ServiceUsageReport{}, fmt.Errorf("while scraping recordsets per zone usage: %w", err)
 	}
 
 	return liquid.ServiceUsageReport{
@@ -88,7 +141,7 @@ func (l *Logic) ScanUsage(ctx context.Context, projectUUID string, req liquid.Se
 			"zones": {
 				Quota: Some(quotas.Zones),
 				PerAZ: liquid.InAnyAZ(liquid.AZResourceUsageReport{
-					Usage: uint64(len(zoneIDs)),
+					Usage: zones,
 				}),
 			},
 			"recordsets_per_zone": {

main.go

@@ -88,6 +88,7 @@ func main() {
 			opts.ServiceInfoRefreshInterval = 0
 			must.Succeed(liquidapi.Run(ctx, &cronus.Logic{}, opts))
 		case "designate":
+			opts.TakesConfiguration = true
 			opts.ServiceInfoRefreshInterval = 0
 			must.Succeed(liquidapi.Run(ctx, &designate.Logic{}, opts))
 		case "ironic":