refactor: migrate all remaining logging to structured_log, remove boilerplate helpers

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

app/services/domains/arxiv/client.py

@@ -5,6 +5,7 @@ import logging
 
 import httpx
 
+from app.logging_utils import structured_log
 from app.services.domains.arxiv.cache import (
     build_query_fingerprint,
     get_cached_feed,
@@ -102,17 +103,9 @@ class ArxivClient:
         if self._cache_enabled:
             cached = await get_cached_feed(query_fingerprint=query_fingerprint)
             if cached is not None:
-                _log_cache_event(
-                    event_name="arxiv.cache_hit",
-                    query_fingerprint=query_fingerprint,
-                    source_path=source_path,
-                )
+                structured_log(logger, "info", "arxiv.cache_hit", query_fingerprint=query_fingerprint, source_path=source_path)
                 return cached
-            _log_cache_event(
-                event_name="arxiv.cache_miss",
-                query_fingerprint=query_fingerprint,
-                source_path=source_path,
-            )
+            structured_log(logger, "info", "arxiv.cache_miss", query_fingerprint=query_fingerprint, source_path=source_path)
         return await run_with_inflight_dedupe(
             query_fingerprint=query_fingerprint,
             fetch_feed=lambda: self._fetch_live_feed(
@@ -222,9 +215,10 @@ async def _request_arxiv_feed(
     source_path = _source_path_from_params(params)
     cooldown_status = await get_arxiv_cooldown_status()
     if cooldown_status.is_active:
-        _log_request_skipped_for_cooldown(
+        structured_log(
+            logger, "warning", "arxiv.request_skipped_cooldown",
             source_path=source_path,
-            cooldown_remaining_seconds=cooldown_status.remaining_seconds,
+            cooldown_remaining_seconds=float(cooldown_status.remaining_seconds),
         )
         raise ArxivRateLimitError(
             f"arXiv global cooldown active ({cooldown_status.remaining_seconds:.0f}s remaining)"
@@ -280,32 +274,3 @@ def _source_path_from_params(params: dict[str, object]) -> str:
     return ARXIV_SOURCE_PATH_UNKNOWN
 
 
-def _log_cache_event(
-    *,
-    event_name: str,
-    query_fingerprint: str,
-    source_path: str,
-) -> None:
-    logger.info(
-        event_name,
-        extra={
-            "event": event_name,
-            "query_fingerprint": query_fingerprint,
-            "source_path": source_path,
-        },
-    )
-
-
-def _log_request_skipped_for_cooldown(
-    *,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.warning(
-        "arxiv.request_skipped_cooldown",
-        extra={
-            "event": "arxiv.request_skipped_cooldown",
-            "source_path": source_path,
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-        },
-    )

app/services/domains/arxiv/gateway.py

@@ -5,6 +5,7 @@ import re
 from typing import TYPE_CHECKING, Protocol
 import unicodedata
 
+from app.logging_utils import structured_log
 from app.services.domains.arxiv.client import ArxivClient
 from app.services.domains.arxiv.errors import ArxivRateLimitError
 from app.services.domains.arxiv.types import ArxivFeed
@@ -112,7 +113,7 @@ class HttpArxivGateway:
         except ArxivRateLimitError:
             raise
         except Exception as exc:
-            logger.debug("arxiv.query_failed", extra={"event": "arxiv.query_failed", "error": str(exc)})
+            structured_log(logger, "debug", "arxiv.query_failed", error=str(exc))
             return None
 
 
@@ -136,6 +137,6 @@ def _author_surname(scholar_label: str | None) -> str | None:
 def _first_discovered_id(result: ArxivFeed) -> str | None:
     for entry in result.entries:
         if entry.arxiv_id:
-            logger.debug("arxiv.id_discovered", extra={"event": "arxiv.id_discovered", "arxiv_id": entry.arxiv_id})
+            structured_log(logger, "debug", "arxiv.id_discovered", arxiv_id=entry.arxiv_id)
             return entry.arxiv_id
     return None

app/services/domains/arxiv/rate_limit.py

@@ -12,6 +12,7 @@ from sqlalchemy.ext.asyncio import AsyncSession
 
 from app.db.models import ArxivRuntimeState
 from app.db.session import get_session_factory
+from app.logging_utils import structured_log
 from app.services.domains.arxiv.constants import (
     ARXIV_RATE_LIMIT_LOCK_KEY,
     ARXIV_RATE_LIMIT_LOCK_NAMESPACE,
@@ -83,14 +84,12 @@ async def _run_serialized_fetch(
                 response_status=int(response.status_code),
                 source_path=source_path,
             )
-            _log_request_completed(
-                response_status=int(response.status_code),
+            structured_log(
+                logger, "info", "arxiv.request_completed",
+                status_code=int(response.status_code),
                 wait_seconds=wait_seconds,
+                cooldown_remaining_seconds=_cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=datetime.now(timezone.utc)),
                 source_path=source_path,
-                cooldown_remaining_seconds=_cooldown_remaining_seconds(
-                    runtime_state.cooldown_until,
-                    now_utc=datetime.now(timezone.utc),
-                ),
             )
             return response, hit_rate_limit
 
@@ -128,18 +127,10 @@ async def _wait_for_allowed_slot_or_raise(
     now_utc = datetime.now(timezone.utc)
     cooldown_seconds = _cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=now_utc)
     if cooldown_seconds > 0:
-        _log_request_scheduled(
-            wait_seconds=0.0,
-            source_path=source_path,
-            cooldown_remaining_seconds=cooldown_seconds,
-        )
+        structured_log(logger, "info", "arxiv.request_scheduled", wait_seconds=0.0, source_path=source_path, cooldown_remaining_seconds=cooldown_seconds)
         raise ArxivRateLimitError(f"arXiv global cooldown active ({cooldown_seconds:.0f}s remaining)")
     wait_seconds = _next_allowed_wait_seconds(runtime_state.next_allowed_at, now_utc=now_utc)
-    _log_request_scheduled(
-        wait_seconds=wait_seconds,
-        source_path=source_path,
-        cooldown_remaining_seconds=0.0,
-    )
+    structured_log(logger, "info", "arxiv.request_scheduled", wait_seconds=wait_seconds, source_path=source_path, cooldown_remaining_seconds=0.0)
     if wait_seconds > 0:
         await asyncio.sleep(wait_seconds)
     return wait_seconds
@@ -156,9 +147,10 @@ def _record_post_response_state(
     if response_status == 429:
         cooldown_seconds = _cooldown_seconds()
         runtime_state.cooldown_until = now_utc + timedelta(seconds=cooldown_seconds)
-        _log_cooldown_activated(
-            source_path=source_path,
+        structured_log(
+            logger, "warning", "arxiv.cooldown_activated",
             cooldown_remaining_seconds=cooldown_seconds,
+            source_path=source_path,
         )
         return True
     if _cooldown_remaining_seconds(runtime_state.cooldown_until, now_utc=now_utc) <= 0:
@@ -196,52 +188,3 @@ def _cooldown_seconds() -> float:
     return max(float(settings.arxiv_rate_limit_cooldown_seconds), 0.0)
 
 
-def _log_request_scheduled(
-    *,
-    wait_seconds: float,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.info(
-        "arxiv.request_scheduled",
-        extra={
-            "event": "arxiv.request_scheduled",
-            "wait_seconds": float(wait_seconds),
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-            "source_path": source_path,
-        },
-    )
-
-
-def _log_request_completed(
-    *,
-    response_status: int,
-    wait_seconds: float,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.info(
-        "arxiv.request_completed",
-        extra={
-            "event": "arxiv.request_completed",
-            "status_code": int(response_status),
-            "wait_seconds": float(wait_seconds),
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-            "source_path": source_path,
-        },
-    )
-
-
-def _log_cooldown_activated(
-    *,
-    source_path: str,
-    cooldown_remaining_seconds: float,
-) -> None:
-    logger.warning(
-        "arxiv.cooldown_activated",
-        extra={
-            "event": "arxiv.cooldown_activated",
-            "cooldown_remaining_seconds": float(cooldown_remaining_seconds),
-            "source_path": source_path,
-        },
-    )