Cache Azure blob cost query on scrape interval

Author: suntala

docs/metrics/azure/blob.md

@@ -2,7 +2,7 @@
 
 ## Status
 
-The `BLOB` service is registered when you pass `BLOB` in `--azure.services`. `Collect` calls **`StorageCostQuerier.QueryBlobStorage`** (see `pkg/azure/blob/cost_query.go`) and **`Set`s** the storage gauge per row. The default querier is a **no-op** (returns no rows), and **`azure.go` does not inject a real implementation yet**, so production scrapes still show **no samples** until Cost Management is wired to `Config.CostQuerier`. Lookback for the query is **30 days** (`defaultQueryLookback`), similar in spirit to the S3 billing window.
+The `BLOB` service is registered when you pass `BLOB` in `--azure.services`. `Collect` applies the **last successful** cost rows to the storage gauge. It calls **`StorageCostQuerier.QueryBlobStorage`** (see `pkg/azure/blob/cost_query.go`) only when **`ScrapeInterval`** has elapsed since the last successful query—same pattern as S3 billing refresh (`pkg/aws/s3/s3.go`). The default querier is a **no-op** (returns no rows), and **`azure.go` does not inject a real implementation yet**, so production scrapes still show **no samples** until Cost Management is wired to `Config.CostQuerier`. Lookback for each query is **30 days** (`defaultQueryLookback`), similar in spirit to the S3 billing window; **interval** controls refetch frequency only.
 
 ## Planned behavior (see issue #54):
 

pkg/azure/blob/blob.go

@@ -3,6 +3,7 @@ package blob
 import (
 	"context"
 	"log/slog"
+	"sync"
 	"time"
 
 	"github.com/grafana/cloudcost-exporter/pkg/provider"
@@ -48,6 +49,10 @@ type Collector struct {
 	querier        StorageCostQuerier
 	subscriptionID string
 	scrapeInterval time.Duration
+
+	mu          sync.Mutex
+	cachedRows  []StorageCostRow
+	nextRefresh time.Time // QueryBlobStorage when time.Now is on or after this (S3 billing refresh pattern).
 }
 
 // Config holds settings for the blob collector.
@@ -75,20 +80,33 @@ func New(cfg *Config) (*Collector, error) {
 		querier:        q,
 		subscriptionID: cfg.SubscriptionId,
 		scrapeInterval: interval,
+		// First Collect runs a query immediately (same idea as pkg/aws/s3 nextScrape).
+		nextRefresh: time.Now().Add(-interval),
 	}, nil
 }
 
 // Collect satisfies provider.Collector.
 func (c *Collector) Collect(ctx context.Context, _ chan<- prometheus.Metric) error {
 	c.logger.LogAttrs(ctx, slog.LevelInfo, "collecting metrics")
-	rows, err := c.querier.QueryBlobStorage(ctx, c.subscriptionID, defaultQueryLookback)
-	if err != nil {
-		return err
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	now := time.Now()
+	if !now.Before(c.nextRefresh) {
+		rows, err := c.querier.QueryBlobStorage(ctx, c.subscriptionID, defaultQueryLookback)
+		if err != nil {
+			return err
+		}
+		c.cachedRows = rows
+		c.nextRefresh = now.Add(c.scrapeInterval)
 	}
+	c.applyRowsToGauge(c.cachedRows)
+	return nil
+}
+
+func (c *Collector) applyRowsToGauge(rows []StorageCostRow) {
 	for _, row := range rows {
 		c.metrics.StorageGauge.WithLabelValues(row.Region, row.Class).Set(row.Rate)
 	}
-	return nil
 }
 
 // Describe satisfies provider.Collector.

pkg/azure/blob/blob_test.go

@@ -6,6 +6,7 @@ import (
 	"log/slog"
 	"os"
 	"strings"
+	"sync"
 	"testing"
 	"time"
 
@@ -30,14 +31,63 @@ func (s stubCostQuerier) QueryBlobStorage(context.Context, string, time.Duration
 	return s.rows, s.err
 }
 
-func TestCollector_Collect_queryError(t *testing.T) {
+type countingCostQuerier struct {
+	mu   sync.Mutex
+	n    int
+	rows []StorageCostRow
+	err  error
+}
+
+func (c *countingCostQuerier) QueryBlobStorage(context.Context, string, time.Duration) ([]StorageCostRow, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	c.n++
+	return c.rows, c.err
+}
+
+func (c *countingCostQuerier) calls() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.n
+}
+
+func newCollectorWithCountingQuerier(t *testing.T, rows []StorageCostRow, querierErr error) (*Collector, *countingCostQuerier) {
+	t.Helper()
+	q := &countingCostQuerier{rows: rows, err: querierErr}
 	c, err := New(&Config{
 		Logger:         testLogger,
 		SubscriptionId: "sub",
-		CostQuerier:    stubCostQuerier{err: errors.New("query failed")},
+		ScrapeInterval: time.Hour,
+		CostQuerier:    q,
 	})
 	require.NoError(t, err)
-	assert.Error(t, c.Collect(t.Context(), nil))
+	return c, q
+}
+
+func TestCollector_Collect_costQueryRefresh(t *testing.T) {
+	sampleRows := []StorageCostRow{{Region: "eastus", Class: "Hot", Rate: 0.001}}
+
+	t.Run("skips_until_interval", func(t *testing.T) {
+		c, q := newCollectorWithCountingQuerier(t, sampleRows, nil)
+		require.NoError(t, c.Collect(t.Context(), nil))
+		require.NoError(t, c.Collect(t.Context(), nil))
+		assert.Equal(t, 1, q.calls(), "second scrape within interval should not call querier")
+	})
+
+	t.Run("refetches_when_next_refresh_elapsed", func(t *testing.T) {
+		c, q := newCollectorWithCountingQuerier(t, sampleRows, nil)
+		require.NoError(t, c.Collect(t.Context(), nil))
+		c.nextRefresh = time.Now().Add(-time.Second)
+		require.NoError(t, c.Collect(t.Context(), nil))
+		assert.Equal(t, 2, q.calls())
+	})
+
+	t.Run("retries_after_error", func(t *testing.T) {
+		c, q := newCollectorWithCountingQuerier(t, nil, errors.New("query failed"))
+		assert.Error(t, c.Collect(t.Context(), nil))
+		assert.Error(t, c.Collect(t.Context(), nil))
+		assert.Equal(t, 2, q.calls(), "errors do not advance nextRefresh; querier should run again")
+	})
 }
 
 func TestCollector_Collect_setsGaugeFromQuerier(t *testing.T) {