feat(middleware): add request ID logging and error handling

app/api/v1/summarize.py

@@ -2,6 +2,7 @@
 Summarization endpoints.
 """
 from fastapi import APIRouter, HTTPException
+import httpx
 from app.api.v1.schemas import SummarizeRequest, SummarizeResponse
 from app.services.summarizer import ollama_service
 
@@ -18,7 +19,8 @@ async def summarize(payload: SummarizeRequest) -> SummarizeResponse:
             prompt=payload.prompt or "Summarize the following text concisely:",
         )
         return SummarizeResponse(**result)
-    except Exception as e:
+    except httpx.HTTPError as e:
+        # Upstream (Ollama) error
         raise HTTPException(status_code=502, detail=f"Summarization failed: {str(e)}")
 
 

app/core/errors.py

@@ -0,0 +1,26 @@
+"""
+Exception handlers and error response shaping.
+"""
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+
+from app.api.v1.schemas import ErrorResponse
+from app.core.logging import get_logger
+
+
+logger = get_logger(__name__)
+
+
+def init_exception_handlers(app: FastAPI) -> None:
+    @app.exception_handler(Exception)
+    async def unhandled_exception_handler(request: Request, exc: Exception):
+        request_id = getattr(request.state, "request_id", None)
+        logger.exception(f"Unhandled error: {exc}")
+        payload = ErrorResponse(
+            detail="Internal server error",
+            code="INTERNAL_ERROR",
+            request_id=request_id,
+        ).dict()
+        return JSONResponse(status_code=500, content=payload)
+
+

app/core/middleware.py

@@ -0,0 +1,42 @@
+"""
+Custom middlewares for request ID and timing/logging.
+"""
+import time
+import uuid
+from typing import Callable
+
+from fastapi import Request, Response
+
+from app.core.logging import get_logger, RequestLogger
+
+
+logger = get_logger(__name__)
+request_logger = RequestLogger(logger)
+
+
+async def request_context_middleware(request: Request, call_next: Callable) -> Response:
+    """Attach a request id and perform basic request/response logging."""
+    request_id = request.headers.get("X-Request-ID") or str(uuid.uuid4())
+    request.state.request_id = request_id
+
+    start = time.time()
+    request_logger.log_request(request.method, request.url.path, request_id)
+    try:
+        response = await call_next(request)
+    except Exception as exc:  # Let exception handlers format the response
+        request_logger.log_error(request_id, str(exc))
+        raise
+    finally:
+        duration_ms = (time.time() - start) * 1000
+        # Note: response may not exist if exception raised; guarded above
+        try:
+            status = getattr(locals().get("response", None), "status_code", 500)
+            request_logger.log_response(request_id, status, duration_ms)
+        except Exception:
+            pass
+
+    # propagate request id header
+    response.headers["X-Request-ID"] = request_id
+    return response
+
+

app/main.py

@@ -7,6 +7,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from app.core.config import settings
 from app.core.logging import setup_logging, get_logger
 from app.api.v1.routes import api_router
+from app.core.middleware import request_context_middleware
+from app.core.errors import init_exception_handlers
 
 # Set up logging
 setup_logging()
@@ -30,6 +32,12 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+# Add request context middleware
+app.middleware("http")(request_context_middleware)
+
+# Initialize exception handlers
+init_exception_handlers(app)
+
 # Include API routes
 app.include_router(api_router, prefix="/api/v1")
 

tests/conftest.py

@@ -5,7 +5,7 @@ import pytest
 import asyncio
 from typing import AsyncGenerator, Generator
 from httpx import AsyncClient
-from fastapi.testclient import TestClient
+from starlette.testclient import TestClient
 
 from app.main import app
 

tests/test_api.py

@@ -3,7 +3,7 @@ Integration tests for API endpoints.
 """
 import pytest
 from unittest.mock import patch
-from fastapi.testclient import TestClient
+from starlette.testclient import TestClient
 from app.main import app
 
 from tests.test_services import StubAsyncClient, StubAsyncResponse

tests/test_api_errors.py

@@ -0,0 +1,35 @@
+"""
+Tests for error handling and request id propagation.
+"""
+import pytest
+from unittest.mock import patch
+from starlette.testclient import TestClient
+from app.main import app
+
+from tests.test_services import StubAsyncClient
+
+
+client = TestClient(app)
+
+
+@pytest.mark.integration
+def test_httpx_error_returns_502():
+    """Test that httpx errors return 502 status."""
+    # This will fail to connect to Ollama, triggering httpx.HTTPError
+    resp = client.post("/api/v1/summarize/", json={"text": "hi"})
+    assert resp.status_code == 502
+    data = resp.json()
+    assert "Summarization failed" in data["detail"]
+
+
+def test_request_id_header_propagated(sample_text, mock_ollama_response):
+    """Verify X-Request-ID appears in response headers."""
+    from tests.test_services import StubAsyncResponse
+
+    stub_response = StubAsyncResponse(json_data=mock_ollama_response)
+    with patch('httpx.AsyncClient', return_value=StubAsyncClient(post_result=stub_response)):
+        resp = client.post("/api/v1/summarize/", json={"text": sample_text})
+        assert resp.status_code == 200
+        assert resp.headers.get("X-Request-ID")
+
+