refactor: implement logging for errors

Author: mairasalazar

app/main.py

@@ -3,10 +3,17 @@
 
 """FastAPI application entry point with multi-tenant auth."""
 
+import logging
 from contextlib import asynccontextmanager
 
-from fastapi import Depends, FastAPI
+from fastapi import Depends, FastAPI, Request
+from fastapi.exception_handlers import (
+    http_exception_handler,
+    request_validation_exception_handler,
+)
+from fastapi.exceptions import RequestValidationError
 from fastapi.middleware.cors import CORSMiddleware
+from starlette.exceptions import HTTPException as StarletteHTTPException
 from temporalio.client import Client
 from temporalio.contrib.pydantic import pydantic_data_converter
 
@@ -16,6 +23,8 @@
 from .routers import workflows
 from .tenants import TenantRegistry
 
+logger = logging.getLogger(__name__)
+
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
@@ -52,6 +61,32 @@ async def lifespan(app: FastAPI):
         allow_headers=["*"],
     )
 
+
+@app.exception_handler(StarletteHTTPException)
+async def custom_http_exception_handler(request, exc):
+    """Custom error handling for logging HTTP errors."""
+    logger.warning(
+        "HTTP %s on %s %s: %s",
+        exc.status_code,
+        request.method,
+        request.url.path,
+        exc.detail,
+    )
+    return await http_exception_handler(request, exc)
+
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    """Custom error handling for logging the Pydantic validation errors."""
+    logger.warning(
+        "Validation error on %s %s: %s",
+        request.method,
+        request.url.path,
+        exc.errors(),
+    )
+    return await request_validation_exception_handler(request, exc)
+
+
 app.include_router(workflows.router)
 
 

app/routers/workflows.py

@@ -4,6 +4,7 @@
 """Workflow API routes with tenant-scoped access control."""
 
 import asyncio
+import logging
 from typing import Any
 
 from fastapi import APIRouter, Depends, HTTPException, Request
@@ -20,6 +21,8 @@
 from app.workflows.registry import get_workflow_spec
 from app.workflows.specs import WorkflowContext
 
+logger = logging.getLogger(__name__)
+
 router = APIRouter(
     prefix="/workflows",
     tags=["workflows"],
@@ -108,8 +111,8 @@ async def create(
         session.add(workflow)
         session.commit()
         workflow_id = workflow.public_id
-    except SQLAlchemyError as e:
-        print("Error(create)", e)
+    except SQLAlchemyError:
+        logger.exception("Error creating workflow")
         raise HTTPException(status_code=500, detail="Could not create workflow")
 
     try:
@@ -126,8 +129,8 @@ async def create(
             id=f"{spec.id_prefix}-{workflow_id}",
             task_queue=spec.task_queue,
         )
-    except Exception as e:
-        print("Error(start_temporal_workflow)", e)
+    except Exception:
+        logger.exception("Error starting Temporal workflow")
         try:
             workflow.status = WorkflowStatus.ERROR
             session.commit()
@@ -153,8 +156,8 @@ async def read(
         workflow = session.exec(
             select(Workflow).where(Workflow.public_id == workflow_id)
         ).one()
-    except SQLAlchemyError as e:
-        print("Error(read)", e)
+    except SQLAlchemyError:
+        logger.exception("Error reading workflow")
         raise HTTPException(status_code=404, detail="Workflow not found")
 
     verify_tenant_owns_workflow(auth, workflow)
@@ -178,8 +181,8 @@ async def workflow_event(request: Request, workflow_id: str):
 
                 if status == "ERROR" or status == "SUCCESS":
                     break
-            except SQLAlchemyError as e:
-                print("Error(stream)", e)
+            except SQLAlchemyError:
+                logger.exception("Error streaming workflow status")
                 raise HTTPException(status_code=500)
 
         await asyncio.sleep(STREAM_DELAY)