Prefix all Prometheus metrics with drf_api_logger_ to avoid collisions

Renamed all metric names from drf_api_* to drf_api_logger_* to match
the package name and prevent conflicts with custom application metrics.

https://claude.ai/code/session_01Xm34otsnCyKstNXxvzgABT

Author: claude

README.md

@@ -403,31 +403,31 @@ urlpatterns = [
 
 ```
 # Total request and error counts
-drf_api_requests_total 15234
-drf_api_errors_total 342
-drf_api_error_rate_pct 2.24
+drf_api_logger_requests_total 15234
+drf_api_logger_errors_total 342
+drf_api_logger_error_rate_pct 2.24
 
 # Status code distribution
-drf_api_responses_total{range="2xx"} 14892
-drf_api_responses_total{range="4xx"} 298
-drf_api_responses_total{range="5xx"} 44
+drf_api_logger_responses_total{range="2xx"} 14892
+drf_api_logger_responses_total{range="4xx"} 298
+drf_api_logger_responses_total{range="5xx"} 44
 
 # Latency
-drf_api_latency_avg_ms 45.2
-drf_api_latency_max_ms 3200.5
+drf_api_logger_latency_avg_ms 45.2
+drf_api_logger_latency_max_ms 3200.5
 
 # Per-method breakdown
-drf_api_requests_by_method{method="GET"} 10234
-drf_api_requests_by_method{method="POST"} 4100
+drf_api_logger_requests_by_method{method="GET"} 10234
+drf_api_logger_requests_by_method{method="POST"} 4100
 
 # Per-endpoint stats
-drf_api_endpoint_requests{endpoint="/api/users/"} 5200
-drf_api_endpoint_errors{endpoint="/api/users/"} 12
-drf_api_endpoint_latency_avg_ms{endpoint="/api/users/"} 32.1
+drf_api_logger_endpoint_requests{endpoint="/api/users/"} 5200
+drf_api_logger_endpoint_errors{endpoint="/api/users/"} 12
+drf_api_logger_endpoint_latency_avg_ms{endpoint="/api/users/"} 32.1
 
 # Error types
-drf_api_errors_by_type{type="NotFound"} 200
-drf_api_errors_by_type{type="Unauthorized"} 98
+drf_api_logger_errors_by_type{type="NotFound"} 200
+drf_api_logger_errors_by_type{type="Unauthorized"} 98
 ```
 
 **Prometheus scrape config:**

drf_api_logger/metrics.py

@@ -90,45 +90,45 @@ def get_metrics():
 def format_prometheus():
     m = get_metrics()
     lines = []
-    lines.append('# HELP drf_api_requests_total Total API requests')
-    lines.append('# TYPE drf_api_requests_total counter')
-    lines.append('drf_api_requests_total {}'.format(m['counters']['request_total']))
+    lines.append('# HELP drf_api_logger_requests_total Total API requests')
+    lines.append('# TYPE drf_api_logger_requests_total counter')
+    lines.append('drf_api_logger_requests_total {}'.format(m['counters']['request_total']))
 
-    lines.append('# HELP drf_api_errors_total Total API errors (4xx + 5xx)')
-    lines.append('# TYPE drf_api_errors_total counter')
-    lines.append('drf_api_errors_total {}'.format(m['counters']['error_total']))
+    lines.append('# HELP drf_api_logger_errors_total Total API errors (4xx + 5xx)')
+    lines.append('# TYPE drf_api_logger_errors_total counter')
+    lines.append('drf_api_logger_errors_total {}'.format(m['counters']['error_total']))
 
-    lines.append('# HELP drf_api_error_rate_pct Error rate percentage')
-    lines.append('# TYPE drf_api_error_rate_pct gauge')
-    lines.append('drf_api_error_rate_pct {}'.format(m['error_rate_pct']))
+    lines.append('# HELP drf_api_logger_error_rate_pct Error rate percentage')
+    lines.append('# TYPE drf_api_logger_error_rate_pct gauge')
+    lines.append('drf_api_logger_error_rate_pct {}'.format(m['error_rate_pct']))
 
     for status_key in ['status_2xx', 'status_3xx', 'status_4xx', 'status_5xx']:
         code_range = status_key.replace('status_', '')
-        lines.append('drf_api_responses_total{{range="{}"}} {}'.format(
+        lines.append('drf_api_logger_responses_total{{range="{}"}} {}'.format(
             code_range, m['counters'][status_key]
         ))
 
-    lines.append('# HELP drf_api_latency_avg_ms Average request latency in milliseconds')
-    lines.append('# TYPE drf_api_latency_avg_ms gauge')
-    lines.append('drf_api_latency_avg_ms {}'.format(m['latency']['avg_ms']))
+    lines.append('# HELP drf_api_logger_latency_avg_ms Average request latency in milliseconds')
+    lines.append('# TYPE drf_api_logger_latency_avg_ms gauge')
+    lines.append('drf_api_logger_latency_avg_ms {}'.format(m['latency']['avg_ms']))
 
-    lines.append('# HELP drf_api_latency_max_ms Maximum request latency in milliseconds')
-    lines.append('# TYPE drf_api_latency_max_ms gauge')
-    lines.append('drf_api_latency_max_ms {}'.format(m['latency']['max_ms']))
+    lines.append('# HELP drf_api_logger_latency_max_ms Maximum request latency in milliseconds')
+    lines.append('# TYPE drf_api_logger_latency_max_ms gauge')
+    lines.append('drf_api_logger_latency_max_ms {}'.format(m['latency']['max_ms']))
 
     for method, count in m['per_method'].items():
-        lines.append('drf_api_requests_by_method{{method="{}"}} {}'.format(method, count))
+        lines.append('drf_api_logger_requests_by_method{{method="{}"}} {}'.format(method, count))
 
     for error_type, count in m['per_error_type'].items():
         safe_type = error_type.replace('"', '\\"')
-        lines.append('drf_api_errors_by_type{{type="{}"}} {}'.format(safe_type, count))
+        lines.append('drf_api_logger_errors_by_type{{type="{}"}} {}'.format(safe_type, count))
 
     for endpoint, stats in sorted(m['per_endpoint'].items(), key=lambda x: -x[1]['count'])[:50]:
         safe_ep = endpoint.replace('"', '\\"')
         avg_ms = round((stats['latency_sum'] / stats['count']) * 1000, 3) if stats['count'] > 0 else 0
-        lines.append('drf_api_endpoint_requests{{endpoint="{}"}} {}'.format(safe_ep, stats['count']))
-        lines.append('drf_api_endpoint_errors{{endpoint="{}"}} {}'.format(safe_ep, stats['errors']))
-        lines.append('drf_api_endpoint_latency_avg_ms{{endpoint="{}"}} {}'.format(safe_ep, avg_ms))
+        lines.append('drf_api_logger_endpoint_requests{{endpoint="{}"}} {}'.format(safe_ep, stats['count']))
+        lines.append('drf_api_logger_endpoint_errors{{endpoint="{}"}} {}'.format(safe_ep, stats['errors']))
+        lines.append('drf_api_logger_endpoint_latency_avg_ms{{endpoint="{}"}} {}'.format(safe_ep, avg_ms))
 
     return '\n'.join(lines) + '\n'
 

tests/test_metrics.py

@@ -122,8 +122,8 @@ def tearDown(self):
 
     def test_format_empty(self):
         output = format_prometheus()
-        self.assertIn('drf_api_requests_total 0', output)
-        self.assertIn('drf_api_errors_total 0', output)
+        self.assertIn('drf_api_logger_requests_total 0', output)
+        self.assertIn('drf_api_logger_errors_total 0', output)
 
     def test_format_with_data(self):
         record_request({
@@ -135,10 +135,10 @@ def test_format_with_data(self):
             'execution_time': 0.02, 'error_type': 'BadRequest',
         })
         output = format_prometheus()
-        self.assertIn('drf_api_requests_total 2', output)
-        self.assertIn('drf_api_errors_total 1', output)
-        self.assertIn('drf_api_latency_avg_ms', output)
-        self.assertIn('drf_api_latency_max_ms', output)
+        self.assertIn('drf_api_logger_requests_total 2', output)
+        self.assertIn('drf_api_logger_errors_total 1', output)
+        self.assertIn('drf_api_logger_latency_avg_ms', output)
+        self.assertIn('drf_api_logger_latency_max_ms', output)
         self.assertIn('method="GET"', output)
         self.assertIn('method="POST"', output)
         self.assertIn('type="BadRequest"', output)
@@ -175,7 +175,7 @@ def test_prometheus_view(self):
         response = metrics_prometheus(request)
         self.assertEqual(response.status_code, 200)
         self.assertIn('text/plain', response['Content-Type'])
-        self.assertIn('drf_api_requests_total 1', response.content.decode())
+        self.assertIn('drf_api_logger_requests_total 1', response.content.decode())
 
 
 class TestMiddlewareMetricsIntegration(TestCase):