First product

app/logging_config.py

@@ -0,0 +1,183 @@
+from __future__ import annotations
+
+from datetime import datetime, timezone
+import json
+import logging
+import sys
+from typing import Any
+
+from app.logging_context import get_request_id
+
+DEFAULT_REDACT_FIELDS = {
+    "authorization",
+    "cookie",
+    "csrf_token",
+    "new_password",
+    "password",
+    "password_hash",
+    "session",
+    "session_secret_key",
+}
+
+_BASE_RECORD = logging.makeLogRecord({})
+_STANDARD_RECORD_FIELDS = set(_BASE_RECORD.__dict__.keys()) | {"message", "asctime"}
+_NOISY_RECORD_FIELDS = {"color_message"}
+
+
+def parse_redact_fields(raw: str | None) -> set[str]:
+    fields = {field.strip().lower() for field in (raw or "").split(",") if field.strip()}
+    return DEFAULT_REDACT_FIELDS | fields
+
+
+def configure_logging(
+    *,
+    level: str,
+    log_format: str,
+    redact_fields: set[str],
+    include_uvicorn_access: bool,
+) -> None:
+    normalized_level = _normalize_level(level)
+    root_logger = logging.getLogger()
+    root_logger.handlers.clear()
+    root_logger.setLevel(normalized_level)
+
+    handler = logging.StreamHandler(stream=sys.stdout)
+    handler.setLevel(normalized_level)
+    handler.addFilter(RequestContextFilter())
+
+    normalized_format = log_format.strip().lower()
+    if normalized_format == "json":
+        handler.setFormatter(JsonLogFormatter(redact_fields=redact_fields))
+    else:
+        handler.setFormatter(ConsoleLogFormatter(redact_fields=redact_fields))
+
+    root_logger.addHandler(handler)
+
+    # Route server/framework logs through our single root handler.
+    for logger_name in ("uvicorn", "uvicorn.error"):
+        framework_logger = logging.getLogger(logger_name)
+        framework_logger.handlers.clear()
+        framework_logger.propagate = True
+        framework_logger.setLevel(normalized_level)
+
+    access_logger = logging.getLogger("uvicorn.access")
+    access_logger.handlers.clear()
+    access_logger.propagate = True
+    access_logger.setLevel(normalized_level if include_uvicorn_access else logging.WARNING)
+
+
+class RequestContextFilter(logging.Filter):
+    def filter(self, record: logging.LogRecord) -> bool:
+        if not getattr(record, "request_id", None):
+            request_id = get_request_id()
+            if request_id:
+                record.request_id = request_id
+        return True
+
+
+class JsonLogFormatter(logging.Formatter):
+    def __init__(self, *, redact_fields: set[str]) -> None:
+        super().__init__()
+        self._redact_fields = {field.lower() for field in redact_fields}
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload: dict[str, Any] = {
+            "timestamp": _format_timestamp(record.created),
+            "level": record.levelname.lower(),
+            "logger": record.name,
+            "event": getattr(record, "event", record.getMessage()),
+        }
+        request_id = getattr(record, "request_id", None)
+        if request_id:
+            payload["request_id"] = request_id
+        payload.update(self._redact_mapping(_extra_fields(record)))
+        if record.exc_info:
+            payload["exception"] = self.formatException(record.exc_info)
+        return json.dumps(payload, ensure_ascii=True, default=str)
+
+    def _redact_mapping(self, value: dict[str, Any]) -> dict[str, Any]:
+        return {key: self._redact_value(key, item) for key, item in value.items()}
+
+    def _redact_value(self, key: str, value: Any) -> Any:
+        if key.lower() in self._redact_fields:
+            return "[REDACTED]"
+        if isinstance(value, dict):
+            return {nested_key: self._redact_value(nested_key, nested_value) for nested_key, nested_value in value.items()}
+        if isinstance(value, (list, tuple)):
+            return [self._redact_value(key, item) for item in value]
+        return value
+
+
+class ConsoleLogFormatter(logging.Formatter):
+    def __init__(self, *, redact_fields: set[str]) -> None:
+        super().__init__()
+        self._json_formatter = JsonLogFormatter(redact_fields=redact_fields)
+
+    def format(self, record: logging.LogRecord) -> str:
+        payload = json.loads(self._json_formatter.format(record))
+        timestamp = payload.get("timestamp", "")
+        level = _short_level(payload.get("level", "info"))
+        logger_name = str(payload.get("logger", "app"))
+        event = str(payload.get("event", ""))
+
+        parts = [timestamp, level, logger_name, event]
+
+        request_id = payload.pop("request_id", None)
+        method = payload.pop("method", None)
+        path = payload.pop("path", None)
+        status_code = payload.pop("status_code", None)
+        duration_ms = payload.pop("duration_ms", None)
+
+        if request_id:
+            parts.append(f"rid={request_id}")
+        if method and path:
+            parts.append(f"{method} {path}")
+        if status_code is not None:
+            parts.append(str(status_code))
+        if duration_ms is not None:
+            parts.append(f"{duration_ms}ms")
+
+        for key in sorted(payload.keys()):
+            if key in {"timestamp", "level", "logger", "event", "exception"}:
+                continue
+            parts.append(f"{key}={payload[key]}")
+
+        if "exception" in payload:
+            parts.append(f"exception={payload['exception']}")
+
+        return " | ".join(str(part) for part in parts if part)
+
+
+def _extra_fields(record: logging.LogRecord) -> dict[str, Any]:
+    extras: dict[str, Any] = {}
+    for key, value in record.__dict__.items():
+        if key in _STANDARD_RECORD_FIELDS or key.startswith("_"):
+            continue
+        if key in _NOISY_RECORD_FIELDS:
+            continue
+        extras[key] = value
+    return extras
+
+
+def _normalize_level(level: str) -> int:
+    normalized = level.strip().upper()
+    mapping = logging.getLevelNamesMapping()
+    if normalized not in mapping:
+        return logging.INFO
+    return mapping[normalized]
+
+
+def _format_timestamp(created_ts: float) -> str:
+    dt = datetime.fromtimestamp(created_ts, tz=timezone.utc)
+    return dt.strftime("%Y-%m-%d %H:%M:%SZ")
+
+
+def _short_level(level: str) -> str:
+    mapping = {
+        "debug": "DBG",
+        "info": "INF",
+        "warning": "WRN",
+        "error": "ERR",
+        "critical": "CRT",
+    }
+    return mapping.get(level.lower(), level[:3].upper())