feat: record request metrics

Author: ALikesToCode

routes/core.py

@@ -461,6 +461,20 @@ def openrouter_dashboard():
                 return jsonify({"status": "error", "message": str(error)}), 500
             return render_template("500.html", error=str(error)), 500
 
+    @app.route("/admin/metrics/requests")
+    @login_required
+    def admin_request_metrics():
+        require_admin_dashboard_user()
+        try:
+            limit = max(1, min(int(request.args.get("limit", 100)), 500))
+        except ValueError:
+            limit = 100
+        return jsonify(
+            {
+                "requests": MetricsService.get_instance().get_request_records(limit=limit),
+            }
+        )
+
     @app.route("/dashboard/openrouter/chat-completions", methods=["POST"])
     @login_required
     def dashboard_openrouter_chat_completions():

services/metrics_service.py

@@ -2,6 +2,9 @@
 from collections import deque
 from threading import Lock
 from datetime import datetime, timedelta
+from typing import Optional
+
+from flask import g, has_request_context, request
 
 class MetricsService:
     _instance = None
@@ -79,14 +82,62 @@ def _build_traffic_series(self, recent_requests, hours=24, now=None):
 
         return buckets
 
-    def track_request(self, provider, status_code, response_time, timestamp=None):
+    def _request_context_metadata(self, provider):
+        if not has_request_context():
+            return {}
+
+        user = getattr(g, "authenticated_user", None) or {}
+        rate_limit = getattr(g, "rate_limit", None) or {}
+        payload = request.get_json(silent=True) if request.is_json else None
+        model = payload.get("model") if isinstance(payload, dict) else None
+        if model and ":" not in str(model) and provider:
+            model = f"{provider}:{model}"
+
+        return {
+            "request_id": getattr(g, "request_id", None),
+            "user_id": user.get("username") or user.get("id"),
+            "api_key_prefix": user.get("api_key_prefix"),
+            "model": model,
+            "input_tokens": rate_limit.get("input_tokens"),
+            "output_tokens": rate_limit.get("output_tokens"),
+            "estimated_tokens": rate_limit.get("estimated_tokens"),
+        }
+
+    def track_request(
+        self,
+        provider,
+        status_code,
+        response_time,
+        timestamp=None,
+        request_id: Optional[str] = None,
+        user_id: Optional[str] = None,
+        api_key_prefix: Optional[str] = None,
+        model: Optional[str] = None,
+        input_tokens: Optional[int] = None,
+        output_tokens: Optional[int] = None,
+        estimated_tokens: Optional[int] = None,
+        estimated_cost: Optional[float] = None,
+        actual_cost: Optional[float] = None,
+        ttft_ms: Optional[float] = None,
+    ):
         """Track a new request"""
         now = timestamp if timestamp is not None else time.time()
+        context_metadata = self._request_context_metadata(provider)
         self.requests.append({
             'timestamp': now,
             'provider': provider,
             'status_code': status_code,
-            'response_time': response_time
+            'response_time': response_time,
+            'request_id': request_id or context_metadata.get("request_id"),
+            'user_id': user_id or context_metadata.get("user_id"),
+            'api_key_prefix': api_key_prefix or context_metadata.get("api_key_prefix"),
+            'model': model or context_metadata.get("model"),
+            'input_tokens': input_tokens if input_tokens is not None else context_metadata.get("input_tokens"),
+            'output_tokens': output_tokens if output_tokens is not None else context_metadata.get("output_tokens"),
+            'estimated_tokens': estimated_tokens if estimated_tokens is not None else context_metadata.get("estimated_tokens"),
+            'estimated_cost': estimated_cost,
+            'actual_cost': actual_cost,
+            'ttft_ms': ttft_ms,
         })
 
     def get_stats(self, hours=24, now=None):
@@ -248,13 +299,44 @@ def get_recent_failures(self, limit=5, now=None, hours=24):
         return [
             {
                 "time": datetime.fromtimestamp(request["timestamp"]).strftime('%Y-%m-%d %H:%M:%S'),
+                "request_id": request.get("request_id"),
                 "provider": request["provider"],
+                "model": request.get("model"),
                 "status_code": request["status_code"],
                 "response_time": round(request["response_time"], 2),
                 "status_bucket": self._status_code_bucket(request["status_code"]),
             }
             for request in failures
         ]
+
+    def get_request_records(self, limit=100, now=None, hours=24):
+        """Return recent request-level records without prompt or response bodies."""
+        current_time = now if now is not None else time.time()
+        records = sorted(
+            self._get_recent_requests(hours=hours, now=current_time),
+            key=lambda item: item["timestamp"],
+            reverse=True,
+        )[:limit]
+
+        return [
+            {
+                "time": datetime.fromtimestamp(record["timestamp"]).strftime('%Y-%m-%d %H:%M:%S'),
+                "request_id": record.get("request_id"),
+                "user_id": record.get("user_id"),
+                "api_key_prefix": record.get("api_key_prefix"),
+                "provider": record["provider"],
+                "model": record.get("model"),
+                "status_code": record["status_code"],
+                "input_tokens": record.get("input_tokens"),
+                "output_tokens": record.get("output_tokens"),
+                "estimated_tokens": record.get("estimated_tokens"),
+                "estimated_cost": record.get("estimated_cost"),
+                "actual_cost": record.get("actual_cost"),
+                "response_time": round(record["response_time"], 2),
+                "ttft_ms": record.get("ttft_ms"),
+            }
+            for record in records
+        ]
 
     def get_recent_activity(self, limit=10):
         """Get recent activity for the status page"""

test_metrics_service.py

@@ -1,5 +1,7 @@
 import unittest
 
+from flask import Flask, g
+
 from services.metrics_service import MetricsService
 
 
@@ -49,6 +51,39 @@ def test_get_recent_failures_returns_newest_errors_first(self):
         self.assertEqual(failures[1]["provider"], "openrouter")
         self.assertEqual(failures[1]["status_code"], 429)
 
+    def test_track_request_records_request_metadata_without_prompt_text(self):
+        app = Flask(__name__)
+        metrics = MetricsService()
+
+        with app.test_request_context(
+            "/v1/chat/completions",
+            method="POST",
+            json={
+                "model": "opencode:kimi-k2.5",
+                "messages": [{"role": "user", "content": "secret prompt"}],
+            },
+        ):
+            g.request_id = "req_test"
+            g.authenticated_user = {
+                "username": "alice",
+                "api_key_prefix": "mllm_live_alice",
+            }
+            g.rate_limit = {
+                "input_tokens": 12,
+                "output_tokens": 6,
+                "estimated_tokens": 18,
+            }
+            metrics.track_request("opencode", 200, 42)
+
+        record = metrics.get_request_records(limit=1)[0]
+        self.assertEqual(record["request_id"], "req_test")
+        self.assertEqual(record["user_id"], "alice")
+        self.assertEqual(record["api_key_prefix"], "mllm_live_alice")
+        self.assertEqual(record["model"], "opencode:kimi-k2.5")
+        self.assertEqual(record["input_tokens"], 12)
+        self.assertNotIn("prompt", record)
+        self.assertNotIn("secret prompt", str(record))
+
 
 if __name__ == "__main__":
     unittest.main()

test_opencode_provider.py

@@ -164,6 +164,39 @@ def test_status_json_includes_dashboard_analytics(self):
         self.assertIn("traffic_series", payload["stats"])
         self.assertEqual(payload["stats"]["failed_requests"], 1)
 
+    def test_admin_request_metrics_returns_request_records(self):
+        metrics_service = self.app_module.MetricsService.get_instance()
+        metrics_service.requests.clear()
+        metrics_service.track_request(
+            "opencode",
+            200,
+            45,
+            request_id="req-admin-test",
+            user_id="admin",
+            api_key_prefix="mllm_live_admin",
+            model="opencode:kimi-k2.5",
+            input_tokens=4,
+            output_tokens=8,
+        )
+
+        with self.client.session_transaction() as session:
+            session["authenticated"] = True
+            session["user"] = {
+                "username": "admin",
+                "is_admin": True,
+                "api_key_prefix": "mllm_live_admin",
+                "scopes": ["admin"],
+            }
+
+        response = self.client.get("/admin/metrics/requests?limit=1")
+
+        self.assertEqual(response.status_code, 200)
+        record = response.get_json()["requests"][0]
+        self.assertEqual(record["request_id"], "req-admin-test")
+        self.assertEqual(record["model"], "opencode:kimi-k2.5")
+        self.assertEqual(record["input_tokens"], 4)
+        self.assertNotIn("prompt", record)
+
     def test_streaming_proxy_response_is_returned_without_rewrapping(self):
         upstream_stream = Response(
             'data: {"choices":[{"delta":{"content":"Hello"}}]}\n\ndata: [DONE]\n\n',