Improved metrics handling - remove timestamps

app.py

@@ -1,71 +1,82 @@
 import contextlib
 import os
-from datetime import datetime
+from collections.abc import Awaitable, Callable
+from typing import Any
 
 import aiofiles
 import orjson
 from environs import Env
 
-env = Env()
+env: Env = Env()
 env.read_env()
 
 unit_log_file: str = env.str("UNIT_LOG_FILE")
 
 
-def escape_label_value(value):
+def escape_label_value(value: str) -> str:
     return value.replace("\\", "\\\\").replace('"', '\\"').replace("\n", "\\n")
 
 
-async def read_and_process_logs():
-    metric_lines = []
+async def read_and_process_logs() -> dict[tuple[str, str], dict[str, float]]:
+    metrics_data: dict[tuple[str, str], dict[str, float]] = {}
 
     if os.path.exists(unit_log_file):
         async with aiofiles.open(unit_log_file, mode="r+") as f:
-            lines = await f.readlines()
+            lines: list[str] = await f.readlines()
             await f.truncate(0)
 
         for line in lines:
             with contextlib.suppress(Exception):
-                log_data = orjson.loads(line)
-                request_time = float(log_data["request_time"])
-                url = log_data["url"]
-                http_method = log_data["http_method"]
-                datetime_str = log_data["datetime"]
+                log_data: dict[str, str] = orjson.loads(line)
+                request_time: float = float(log_data["request_time"])
+                url: str = log_data["url"]
+                http_method: str = log_data["http_method"]
+                key: tuple[str, str] = (url, http_method)
 
-                # Parse datetime_str to Unix timestamp in milliseconds
-                dt = datetime.strptime(datetime_str, "%d/%b/%Y:%H:%M:%S %z")
-                timestamp_ms = int(dt.timestamp() * 1000)
+                if key in metrics_data:
+                    metrics_data[key]["count"] += 1
+                    metrics_data[key]["sum"] += request_time
+                else:
+                    metrics_data[key] = {"count": 1, "sum": request_time}
 
-                labels = (
-                    f'url="{escape_label_value(url)}",'
-                    f'http_method="{escape_label_value(http_method)}"'
-                )
-
-                # Generate the metric line
-                metric_line = f"request_duration_seconds{{{labels}}} {request_time} {timestamp_ms}"
-                metric_lines.append(metric_line)
-    return metric_lines
+    return metrics_data
 
 
-async def generate_metrics_text():
-    lines = [
-        "# HELP request_duration_seconds Request duration in seconds",
-        "# TYPE request_duration_seconds gauge",
+async def generate_metrics_text() -> str:
+    lines: list[str] = [
+        "# HELP request_duration_seconds_total Total request duration in seconds",
+        "# TYPE request_duration_seconds_total counter",
+        "# HELP request_duration_seconds_count Total number of requests",
+        "# TYPE request_duration_seconds_count counter",
     ]
 
-    metric_lines = await read_and_process_logs()
+    metrics_data: dict[tuple[str, str], dict[str, float]] = await read_and_process_logs()
 
-    lines.extend(metric_lines)
+    for key, data in metrics_data.items():
+        url, http_method = key
+        count: int = int(data["count"])
+        sum_values: float = data["sum"]
+
+        labels: str = (
+            f'url="{escape_label_value(url)}",' f'http_method="{escape_label_value(http_method)}"'
+        )
+
+        lines.append(f"request_duration_seconds_count{{{labels}}} {count}")
+        lines.append(f"request_duration_seconds_total{{{labels}}} {sum_values}")
 
     return "\n".join(lines) + "\n"
 
 
-async def app(scope, receive, send):
+async def app(
+    scope: dict[str, Any],
+    _: Callable[[], Awaitable[dict[str, Any]]],
+    send: Callable[[dict[str, Any]], Awaitable[None]],
+) -> None:
     if scope["type"] == "http":
         if scope["path"] == "/metrics":
-            headers = [(b"content-type", b"text/plain; charset=utf-8")]
-            metrics_text = await generate_metrics_text()
-            body = metrics_text.encode("utf-8")
+            headers: list[tuple[bytes, bytes]] = [(b"content-type", b"text/plain; charset=utf-8")]
+            metrics_text: str = await generate_metrics_text()
+            body: bytes = metrics_text.encode("utf-8")
 
             await send({"type": "http.response.start", "status": 200, "headers": headers})
             await send({"type": "http.response.body", "body": body})