feat: enhance logging configuration and add request logging context

backend/tests/test_common_logging_policy.py

@@ -0,0 +1,114 @@
+from __future__ import annotations
+
+import io
+import logging
+import re
+from pathlib import Path
+
+from app.core.logging import TRACE_LEVEL, AppLogger, get_logger
+
+BACKEND_ROOT = Path(__file__).resolve().parents[1]
+APP_ROOT = BACKEND_ROOT / "app"
+COMMON_LOGGER_FILE = APP_ROOT / "core" / "logging.py"
+
+
+def _iter_app_python_files() -> list[Path]:
+    files: list[Path] = []
+    for path in APP_ROOT.rglob("*.py"):
+        if "__pycache__" in path.parts:
+            continue
+        files.append(path)
+    return files
+
+
+def test_common_logger_supports_trace_to_critical_levels() -> None:
+    AppLogger.configure(force=True)
+    logger = get_logger("tests.common_logging_policy.levels")
+    logger.setLevel(TRACE_LEVEL)
+
+    stream = io.StringIO()
+    handler = logging.StreamHandler(stream)
+    handler.setLevel(TRACE_LEVEL)
+    handler.setFormatter(logging.Formatter("%(levelname)s:%(message)s"))
+    logger.addHandler(handler)
+
+    try:
+        logger.log(TRACE_LEVEL, "trace-level")
+        logger.debug("debug-level")
+        logger.info("info-level")
+        logger.warning("warning-level")
+        logger.error("error-level")
+        logger.critical("critical-level")
+    finally:
+        logger.removeHandler(handler)
+        handler.close()
+
+    lines = [line.strip() for line in stream.getvalue().splitlines() if line.strip()]
+    assert lines == [
+        "TRACE:trace-level",
+        "DEBUG:debug-level",
+        "INFO:info-level",
+        "WARNING:warning-level",
+        "ERROR:error-level",
+        "CRITICAL:critical-level",
+    ]
+
+
+def test_backend_app_uses_common_logger() -> None:
+    offenders: list[str] = []
+
+    for path in _iter_app_python_files():
+        if path == COMMON_LOGGER_FILE:
+            continue
+
+        text = path.read_text(encoding="utf-8")
+        rel = path.relative_to(BACKEND_ROOT).as_posix()
+
+        if re.search(r"^\s*import\s+logging\b", text, flags=re.MULTILINE):
+            offenders.append(f"{rel}: imports logging directly")
+        if "logging.getLogger(" in text:
+            offenders.append(f"{rel}: calls logging.getLogger directly")
+
+    assert not offenders, "\n".join(offenders)
+
+
+def test_module_level_loggers_bind_via_get_logger() -> None:
+    offenders: list[str] = []
+    assignment_pattern = re.compile(r"^\s*logger\s*=\s*(.+)$", flags=re.MULTILINE)
+
+    for path in _iter_app_python_files():
+        if path == COMMON_LOGGER_FILE:
+            continue
+        text = path.read_text(encoding="utf-8")
+        rel = path.relative_to(BACKEND_ROOT).as_posix()
+        for expression in assignment_pattern.findall(text):
+            normalized = expression.strip()
+            if normalized.startswith("get_logger("):
+                continue
+            offenders.append(f"{rel}: logger assignment `{normalized}` is not get_logger(...)")
+
+    assert not offenders, "\n".join(offenders)
+
+
+def test_backend_app_has_all_log_levels_in_use() -> None:
+    level_patterns: dict[str, re.Pattern[str]] = {
+        "trace": re.compile(
+            r"\b(?:self\.)?logger\.log\(\s*TRACE_LEVEL\b|\b(?:self\.)?logger\.trace\("
+        ),
+        "debug": re.compile(r"\b(?:self\.)?logger\.debug\("),
+        "info": re.compile(r"\b(?:self\.)?logger\.info\("),
+        "warning": re.compile(r"\b(?:self\.)?logger\.warning\("),
+        "error": re.compile(r"\b(?:self\.)?logger\.error\("),
+        "critical": re.compile(r"\b(?:self\.)?logger\.critical\("),
+    }
+
+    merged_source = "\n".join(
+        path.read_text(encoding="utf-8")
+        for path in _iter_app_python_files()
+        if path != COMMON_LOGGER_FILE
+    )
+
+    missing = [
+        name for name, pattern in level_patterns.items() if not pattern.search(merged_source)
+    ]
+    assert not missing, f"Missing log levels in backend app code: {', '.join(missing)}"