feat(resolver): add blocky_client_response_total metric (#2222)

Author: jvandenbroek

docs/prometheus_grafana.md

@@ -17,6 +17,7 @@ Following metrics will be exported:
 | blocky_query_total                               | Counter of total queries, partitioned by client and DNS request type (A, AAAA, PTR, etc) |
 | blocky_request_duration_seconds                  | Histogram of request duration, partitioned by response type (Blocked, cached, etc)  |
 | blocky_response_total                            | Counter of responses, partitioned by response type (Blocked, cached, etc), DNS response code, and reason |
+| blocky_client_response_total                     | Counter of responses, partitioned by client and response type (Blocked, cached, etc) |
 | blocky_blocking_enabled                          | Boolean 1 if blocking is enabled, 0 otherwise |
 | blocky_cache_entries                             | Gauge of entries in cache |
 | blocky_cache_hits_total                          | Counter of the number of cache hits |
@@ -42,6 +43,15 @@ Following metrics will be exported:
     matched rule (e.g. `BLOCKED (ads: *.docler.com)`) is still available in the [query log](configuration.md#query-log).
     This avoids unbounded metric cardinality when large deny lists are used.
 
+!!! note "`client` label cardinality"
+
+    The `client` label (used by `blocky_query_total` and `blocky_client_response_total`) is derived
+    from a reverse DNS lookup and is **not** bounded by configuration — it grows with the number of
+    distinct devices Blocky has seen. On networks with a stable, limited set of devices (a typical
+    home LAN) this stays small, but on networks with high device turnover (e.g. public or guest Wi-Fi)
+    the set of `client` label values can grow effectively unbounded over time. Consider this before
+    scraping/retaining these metrics on such networks.
+
 ### Grafana dashboard
 
 Example [Grafana](https://grafana.com/) dashboard

metrics/metrics_test.go

@@ -57,6 +57,7 @@ func AssertRegistryComplete(t *testing.T, reg *prometheus.Registry) {
 		"blocky_query_total",
 		"blocky_request_duration_seconds",
 		"blocky_response_total",
+		"blocky_client_response_total",
 		// these should be default
 		"blocky_error_total",
 		"blocky_blocking_enabled",

resolver/metrics_resolver.go

@@ -31,10 +31,11 @@ type MetricsResolver struct {
 	NextResolver
 	typed
 
-	totalQueries      *prometheus.CounterVec
-	totalResponse     *prometheus.CounterVec
-	totalErrors       prometheus.Counter
-	durationHistogram *prometheus.HistogramVec
+	totalQueries        *prometheus.CounterVec
+	totalResponse       *prometheus.CounterVec
+	totalClientResponse *prometheus.CounterVec
+	totalErrors         prometheus.Counter
+	durationHistogram   *prometheus.HistogramVec
 }
 
 // Resolve resolves the passed request
@@ -45,8 +46,10 @@ func (r *MetricsResolver) Resolve(ctx context.Context, request *model.Request) (
 		return response, err
 	}
 
+	clientLabel := strings.Join(request.ClientNames, ",")
+
 	r.totalQueries.With(prometheus.Labels{
-		labelClient: strings.Join(request.ClientNames, ","),
+		labelClient: clientLabel,
 		labelType:   dns.TypeToString[request.Req.Question[0].Qtype],
 	}).Inc()
 
@@ -59,6 +62,11 @@ func (r *MetricsResolver) Resolve(ctx context.Context, request *model.Request) (
 
 	r.durationHistogram.WithLabelValues(responseType).Observe(reqDuration.Seconds())
 
+	r.totalClientResponse.With(prometheus.Labels{
+		labelClient:       clientLabel,
+		labelResponseType: responseType,
+	}).Inc()
+
 	if err != nil {
 		r.totalErrors.Inc()
 	} else {
@@ -87,10 +95,11 @@ func NewMetricsResolver(cfg config.Metrics) *MetricsResolver {
 		configurable: withConfig(&cfg),
 		typed:        withType("metrics"),
 
-		durationHistogram: durationHistogram(),
-		totalQueries:      totalQueriesMetric(),
-		totalResponse:     totalResponseMetric(),
-		totalErrors:       totalErrorMetric(),
+		durationHistogram:   durationHistogram(),
+		totalQueries:        totalQueriesMetric(),
+		totalResponse:       totalResponseMetric(),
+		totalClientResponse: totalClientResponseMetric(),
+		totalErrors:         totalErrorMetric(),
 	}
 
 	m.registerMetrics()
@@ -102,6 +111,7 @@ func (r *MetricsResolver) registerMetrics() {
 	metrics.RegisterMetric(r.durationHistogram)
 	metrics.RegisterMetric(r.totalQueries)
 	metrics.RegisterMetric(r.totalResponse)
+	metrics.RegisterMetric(r.totalClientResponse)
 	metrics.RegisterMetric(r.totalErrors)
 }
 
@@ -143,3 +153,12 @@ func totalResponseMetric() *prometheus.CounterVec {
 		}, []string{labelReason, labelResponseCode, labelResponseType},
 	)
 }
+
+func totalClientResponseMetric() *prometheus.CounterVec {
+	return prometheus.NewCounterVec(
+		prometheus.CounterOpts{
+			Name: "blocky_client_response_total",
+			Help: "Number of total responses per client and response type",
+		}, []string{labelClient, labelResponseType},
+	)
+}

resolver/metrics_resolver_test.go

@@ -74,6 +74,14 @@ var _ = Describe("MetricResolver", func() {
 					Expect(err).Should(Succeed())
 
 					Expect(testutil.ToFloat64(cnt)).Should(BeNumerically("==", 1))
+
+					clientCnt, err := sut.totalClientResponse.GetMetricWith(prometheus.Labels{
+						"client":        "client",
+						"response_type": "RESOLVED",
+					})
+					Expect(err).Should(Succeed())
+					Expect(testutil.ToFloat64(clientCnt)).Should(BeNumerically("==", 1))
+
 					m.AssertExpectations(GinkgoT())
 				})
 			})
@@ -136,6 +144,13 @@ var _ = Describe("MetricResolver", func() {
 					Expect(err).Should(HaveOccurred())
 
 					Expect(testutil.ToFloat64(sut.totalErrors)).Should(BeNumerically("==", 1))
+
+					clientCnt, err := sut.totalClientResponse.GetMetricWith(prometheus.Labels{
+						"client":        "client",
+						"response_type": "err",
+					})
+					Expect(err).Should(Succeed())
+					Expect(testutil.ToFloat64(clientCnt)).Should(BeNumerically("==", 1))
 				})
 			})
 		})