Extensibility model for requests/response metrics.

This allows applications to add labels to the metrics reported by middlewares.
this is done in a few steps.
1. Create an application class that inherits from the Metric class and overrides the register_metric mehtod to register metrics with the application sepcific labels.
2. Create an application class that inherits from the middleware class and overrides the label_metric method and attach the application specific labels to the relevant metrics.

Author: asherf

django_prometheus/middleware.py

@@ -216,15 +216,22 @@ def _method(self, request):
             return "<invalid method>"
         return m
 
+    def label_metric(self, metric, request, response=None, **labels):
+        return metric.labels(**labels) if labels else metric
+
     def process_request(self, request):
         transport = self._transport(request)
         method = self._method(request)
-        self.metrics.requests_by_method.labels(method=method).inc()
-        self.metrics.requests_by_transport.labels(transport=transport).inc()
+        self.label_metric(self.metrics.requests_by_method, request, method=method).inc()
+        self.label_metric(
+            self.metrics.requests_by_transport, request, transport=transport
+        ).inc()
         if request.is_ajax():
-            self.metrics.requests_ajax.inc()
+            self.label_metric(self.metrics.requests_ajax, request).inc()
         content_length = int(request.META.get("CONTENT_LENGTH") or 0)
-        self.metrics.requests_body_bytes.observe(content_length)
+        self.label_metric(self.metrics.requests_body_bytes, request).observe(
+            content_length
+        )
         request.prometheus_after_middleware_event = Time()
 
     def _get_view_name(self, request):
@@ -240,49 +247,79 @@ def process_view(self, request, view_func, *view_args, **view_kwargs):
         method = self._method(request)
         if hasattr(request, "resolver_match"):
             name = request.resolver_match.view_name or "<unnamed view>"
-            self.metrics.requests_by_view_transport_method.labels(
-                view=name, transport=transport, method=method
+            self.label_metric(
+                self.metrics.requests_by_view_transport_method,
+                request,
+                view=name,
+                transport=transport,
+                method=method,
             ).inc()
 
     def process_template_response(self, request, response):
         if hasattr(response, "template_name"):
-            self.metrics.responses_by_templatename.labels(
-                templatename=str(response.template_name)
+            self.label_metric(
+                self.metrics.responses_by_templatename,
+                request,
+                response=response,
+                templatename=str(response.template_name),
             ).inc()
         return response
 
     def process_response(self, request, response):
         method = self._method(request)
         name = self._get_view_name(request)
         status = str(response.status_code)
-        self.metrics.responses_by_status.labels(status=status).inc()
-        self.metrics.responses_by_status_view_method.labels(
-            status=status, view=name, method=method
+        self.label_metric(
+            self.metrics.responses_by_status, request, response, status=status
+        ).inc()
+        self.label_metric(
+            self.metrics.responses_by_status_view_method,
+            request,
+            response,
+            status=status,
+            view=name,
+            method=method,
         ).inc()
         if hasattr(response, "charset"):
-            self.metrics.responses_by_charset.labels(
-                charset=str(response.charset)
+            self.label_metric(
+                self.metrics.responses_by_charset,
+                request,
+                response,
+                charset=str(response.charset),
             ).inc()
         if hasattr(response, "streaming") and response.streaming:
-            self.metrics.responses_streaming.inc()
+            self.label_metric(self.metrics.responses_streaming, request, response).inc()
         if hasattr(response, "content"):
-            self.metrics.responses_body_bytes.observe(len(response.content))
+            self.label_metric(
+                self.metrics.responses_body_bytes, request, response
+            ).observe(len(response.content))
         if hasattr(request, "prometheus_after_middleware_event"):
-            self.metrics.requests_latency_by_view_method.labels(
-                view=self._get_view_name(request), method=request.method
+            self.label_metric(
+                self.metrics.requests_latency_by_view_method,
+                request,
+                response,
+                view=self._get_view_name(request),
+                method=request.method,
             ).observe(TimeSince(request.prometheus_after_middleware_event))
         else:
-            self.metrics.requests_unknown_latency.inc()
+            self.label_metric(
+                self.metrics.requests_unknown_latency, request, response
+            ).inc()
         return response
 
     def process_exception(self, request, exception):
-        self.metrics.exceptions_by_type.labels(type=type(exception).__name__).inc()
+        self.label_metric(
+            self.metrics.exceptions_by_type, request, type=type(exception).__name__
+        ).inc()
         if hasattr(request, "resolver_match"):
             name = request.resolver_match.view_name or "<unnamed view>"
-            self.metrics.exceptions_by_view.labels(view=name).inc()
+            self.label_metric(self.metrics.exceptions_by_view, request, view=name).inc()
         if hasattr(request, "prometheus_after_middleware_event"):
-            self.metrics.requests_latency_by_view_method.labels(
-                view=self._get_view_name(request), method=request.method
+            self.label_metric(
+                self.metrics.requests_latency_by_view_method,
+                request,
+                view=self._get_view_name(request),
+                method=request.method,
             ).observe(TimeSince(request.prometheus_after_middleware_event))
         else:
-            self.metrics.requests_unknown_latency.inc()
+            self.label_metric(self.metrics.requests_unknown_latency, request).inc()

django_prometheus/tests/end2end/testapp/test_middleware_custom_labels.py

@@ -0,0 +1,110 @@
+from django.test import SimpleTestCase, override_settings
+from django_prometheus.middleware import (
+    Metrics,
+    PrometheusAfterMiddleware,
+    PrometheusBeforeMiddleware,
+)
+from django_prometheus.testutils import PrometheusTestCaseMixin
+from testapp.helpers import get_middleware
+from testapp.test_middleware import M, T
+
+EXTENDED_METRICS = [
+    "django_http_requests_latency_seconds_by_view_method",
+    "django_http_responses_total_by_status_view_method",
+]
+
+
+class CustomMetrics(Metrics):
+    def register_metric(
+        self, metric_cls, name, documentation, labelnames=tuple(), **kwargs
+    ):
+        if name in EXTENDED_METRICS:
+            labelnames = labelnames + ("view_type", "user_agent_type")
+        return super(CustomMetrics, self).register_metric(
+            metric_cls, name, documentation, labelnames=labelnames, **kwargs
+        )
+
+
+class AppMetricsBeforeMiddleware(PrometheusBeforeMiddleware):
+    metrics_cls = CustomMetrics
+
+
+class AppMetricsAfterMiddleware(PrometheusAfterMiddleware):
+    metrics_cls = CustomMetrics
+
+    def label_metric(self, metric, request, response=None, **labels):
+        if metric._name in EXTENDED_METRICS:
+            labels.update({"view_type": "foo", "user_agent_type": "browser"})
+        return super(AppMetricsAfterMiddleware, self).label_metric(
+            metric, request, response=response, **labels
+        )
+
+
+@override_settings(
+    MIDDLEWARE_X=get_middleware(
+        "testapp.test_middleware_custom_labels.AppMetricsBeforeMiddleware",
+        "testapp.test_middleware_custom_labels.AppMetricsAfterMiddleware",
+    )
+)
+class TestMiddlewareMetricsWithCustomLabels(PrometheusTestCaseMixin, SimpleTestCase):
+    """Test django_prometheus.middleware.
+
+    Note that counters related to exceptions can't be tested as
+    Django's test Client only simulates requests and the exception
+    handling flow is very different in that simulation.
+    """
+
+    def test_request_counters(self):
+        registry = self.saveRegistry()
+        self.client.get("/")
+        self.client.get("/")
+        self.client.get("/help")
+        self.client.post("/", {"test": "data"})
+
+        self.assertMetricDiff(registry, 4, M("requests_before_middlewares_total"))
+        self.assertMetricDiff(registry, 4, M("responses_before_middlewares_total"))
+        self.assertMetricDiff(registry, 3, T("requests_total_by_method"), method="GET")
+        self.assertMetricDiff(registry, 1, T("requests_total_by_method"), method="POST")
+        self.assertMetricDiff(
+            registry, 4, T("requests_total_by_transport"), transport="http"
+        )
+        self.assertMetricDiff(
+            registry,
+            2,
+            T("requests_total_by_view_transport_method"),
+            view="testapp.views.index",
+            transport="http",
+            method="GET",
+        )
+        self.assertMetricDiff(
+            registry,
+            1,
+            T("requests_total_by_view_transport_method"),
+            view="testapp.views.help",
+            transport="http",
+            method="GET",
+        )
+        self.assertMetricDiff(
+            registry,
+            1,
+            T("requests_total_by_view_transport_method"),
+            view="testapp.views.index",
+            transport="http",
+            method="POST",
+        )
+        self.assertMetricDiff(
+            registry,
+            2.0,
+            T("responses_total_by_status_view_method"),
+            status="200",
+            view="testapp.views.index",
+            method="GET",
+        )
+        self.assertMetricDiff(
+            registry,
+            1.0,
+            T("responses_total_by_status_view_method"),
+            status="200",
+            view="testapp.views.help",
+            method="GET",
+        )