fastapi-radar 0.1.8__py3-none-any.whl → 0.3.1__py3-none-any.whl

fastapi_radar/__init__.py

@@ -1,6 +1,7 @@
 """FastAPI Radar - Debugging dashboard for FastAPI applications."""
 
 from .radar import Radar
+from .background import track_background_task
 
-__version__ = "0.1.8"
-__all__ = ["Radar"]
+__version__ = "0.3.1"
+__all__ = ["Radar", "track_background_task"]

fastapi_radar/api.py

@@ -1,14 +1,23 @@
 """API endpoints for FastAPI Radar dashboard."""
 
-from datetime import datetime, timedelta
+from datetime import datetime, timedelta, timezone
 from typing import Any, Dict, List, Optional, Union
+import uuid
 
 from fastapi import APIRouter, Depends, HTTPException, Query
 from pydantic import BaseModel
-from sqlalchemy import desc
+from sqlalchemy import case, desc, func
 from sqlalchemy.orm import Session
-
-from .models import CapturedRequest, CapturedQuery, CapturedException, Trace, Span
+import httpx
+
+from .models import (
+    CapturedRequest,
+    CapturedQuery,
+    CapturedException,
+    Trace,
+    Span,
+    BackgroundTask,
+)
 from .tracing import TracingManager
 
 
@@ -92,6 +101,19 @@ class TraceSummary(BaseModel):
     created_at: datetime
 
 
+class BackgroundTaskSummary(BaseModel):
+    id: int
+    task_id: str
+    request_id: Optional[str]
+    name: str
+    status: str
+    start_time: Optional[datetime]
+    end_time: Optional[datetime]
+    duration_ms: Optional[float]
+    error: Optional[str]
+    created_at: datetime
+
+
 class WaterfallSpan(BaseModel):
     span_id: str
     parent_span_id: Optional[str]
@@ -135,10 +157,16 @@ def create_api_router(get_session_context) -> APIRouter:
         status_code: Optional[int] = None,
         method: Optional[str] = None,
         search: Optional[str] = None,
+        start_time: Optional[datetime] = None,
+        end_time: Optional[datetime] = None,
         session: Session = Depends(get_db),
     ):
         query = session.query(CapturedRequest)
 
+        if start_time:
+            query = query.filter(CapturedRequest.created_at >= start_time)
+        if end_time:
+            query = query.filter(CapturedRequest.created_at <= end_time)
         if status_code:
             if status_code in [200, 300, 400, 500]:
                 # Filter by status code range
@@ -228,6 +256,124 @@ def create_api_router(get_session_context) -> APIRouter:
             ],
         )
 
+    @router.get("/requests/{request_id}/curl")
+    async def get_request_as_curl(request_id: str, session: Session = Depends(get_db)):
+        request = (
+            session.query(CapturedRequest)
+            .filter(CapturedRequest.request_id == request_id)
+            .first()
+        )
+
+        if not request:
+            raise HTTPException(status_code=404, detail="Request not found")
+
+        # Build cURL command
+        parts = [f"curl -X {request.method}"]
+
+        # Add headers
+        if request.headers:
+            for key, value in request.headers.items():
+                if key.lower() not in ["host", "content-length"]:
+                    parts.append(f"-H '{key}: {value}'")
+
+        # Add body
+        if request.body:
+            parts.append(f"-d '{request.body}'")
+
+        # Add URL (use full URL if available, otherwise construct from path)
+        url = request.url if request.url else request.path
+        parts.append(f"'{url}'")
+
+        return {"curl": " ".join(parts)}
+
+    @router.post("/requests/{request_id}/replay")
+    async def replay_request(
+        request_id: str,
+        body: Optional[Dict[str, Any]] = None,
+        session: Session = Depends(get_db),
+    ):
+        """Replay a captured request with optional body override.
+
+        WARNING: This endpoint replays HTTP requests. Use with caution in production.
+        Consider adding authentication and rate limiting.
+        """
+        request = (
+            session.query(CapturedRequest)
+            .filter(CapturedRequest.request_id == request_id)
+            .first()
+        )
+
+        if not request:
+            raise HTTPException(status_code=404, detail="Request not found")
+
+        # Security: Validate URL to prevent SSRF attacks
+        # Note: This is basic protection. For production, consider:
+        # 1. Whitelist allowed domains
+        # 2. Add authentication to this endpoint
+        # 3. Add rate limiting
+        # For dev/testing, allow localhost. For production, consider blocking.
+        # Example: Uncomment below to block all internal IPs:
+        # from urllib.parse import urlparse
+        # parsed = urlparse(request.url)
+        # if parsed.hostname in ["localhost", "127.0.0.1", "0.0.0.0", "::1", "::ffff:127.0.0.1"]:
+        #     raise HTTPException(status_code=403, detail="Replay to localhost is disabled")
+
+        # Build replay request
+        headers = dict(request.headers) if request.headers else {}
+        # Remove hop-by-hop headers
+        headers.pop("host", None)
+        headers.pop("content-length", None)
+        headers.pop("connection", None)
+        headers.pop("keep-alive", None)
+        headers.pop("transfer-encoding", None)
+
+        request_body = body if body is not None else request.body
+
+        try:
+            async with httpx.AsyncClient(
+                timeout=30.0, follow_redirects=False
+            ) as client:
+                response = await client.request(
+                    method=request.method,
+                    url=request.url,
+                    headers=headers,
+                    content=(
+                        request_body if isinstance(request_body, (str, bytes)) else None
+                    ),
+                    json=request_body if isinstance(request_body, dict) else None,
+                )
+
+                # Store the replayed request
+                replayed_request = CapturedRequest(
+                    request_id=str(uuid.uuid4()),
+                    method=request.method,
+                    url=request.url,
+                    path=request.path,
+                    query_params=request.query_params,
+                    headers=dict(response.request.headers),
+                    body=request_body if isinstance(request_body, str) else None,
+                    status_code=response.status_code,
+                    response_body=response.text[:10000] if response.text else None,
+                    response_headers=dict(response.headers),
+                    duration_ms=response.elapsed.total_seconds() * 1000,
+                    client_ip="replay",
+                )
+                session.add(replayed_request)
+                session.commit()
+                session.refresh(replayed_request)
+
+                return {
+                    "status_code": response.status_code,
+                    "headers": dict(response.headers),
+                    "body": response.text,
+                    "elapsed_ms": response.elapsed.total_seconds() * 1000,
+                    "original_status": request.status_code,
+                    "original_duration_ms": request.duration_ms,
+                    "new_request_id": replayed_request.request_id,
+                }
+        except httpx.RequestError as e:
+            raise HTTPException(status_code=500, detail=f"Replay failed: {str(e)}")
+
     @router.get("/queries", response_model=List[QueryDetail])
     async def get_queries(
         limit: int = Query(100, ge=1, le=1000),
@@ -302,45 +448,43 @@ def create_api_router(get_session_context) -> APIRouter:
         slow_threshold: int = Query(100),
         session: Session = Depends(get_db),
     ):
-        since = datetime.utcnow() - timedelta(hours=hours)
+        since = datetime.now(timezone.utc) - timedelta(hours=hours)
 
         requests = (
-            session.query(CapturedRequest)
+            session.query(
+                func.count().label("total_requests"),
+                func.avg(CapturedRequest.duration_ms).label("avg_response_time"),
+            )
             .filter(CapturedRequest.created_at >= since)
-            .all()
+            .one()
         )
 
         queries = (
-            session.query(CapturedQuery).filter(CapturedQuery.created_at >= since).all()
+            session.query(
+                func.count().label("total_queries"),
+                func.avg(CapturedQuery.duration_ms).label("avg_query_time"),
+                func.sum(
+                    case((CapturedQuery.duration_ms >= slow_threshold, 1), else_=0)
+                ).label("slow_queries"),
+            )
+            .filter(CapturedQuery.created_at >= since)
+            .one()
         )
 
         exceptions = (
-            session.query(CapturedException)
+            session.query(func.count().label("total_exceptions"))
             .filter(CapturedException.created_at >= since)
-            .all()
+            .one()
         )
 
-        total_requests = len(requests)
-        avg_response_time = None
-        if requests:
-            valid_times = [r.duration_ms for r in requests if r.duration_ms is not None]
-            if valid_times:
-                avg_response_time = sum(valid_times) / len(valid_times)
-
-        total_queries = len(queries)
-        avg_query_time = None
-        slow_queries = 0
-        if queries:
-            valid_times = [q.duration_ms for q in queries if q.duration_ms is not None]
-            if valid_times:
-                avg_query_time = sum(valid_times) / len(valid_times)
-            slow_queries = len(
-                [
-                    q
-                    for q in queries
-                    if q.duration_ms and q.duration_ms >= slow_threshold
-                ]
-            )
+        total_requests = requests.total_requests
+        avg_response_time = requests.avg_response_time
+
+        total_queries = queries.total_queries
+        avg_query_time = queries.avg_query_time
+        slow_queries = queries.slow_queries or 0
+
+        total_exceptions = exceptions.total_exceptions
 
         requests_per_minute = total_requests / (hours * 60)
 
@@ -349,7 +493,7 @@ def create_api_router(get_session_context) -> APIRouter:
             avg_response_time=round_float(avg_response_time),
             total_queries=total_queries,
             avg_query_time=round_float(avg_query_time),
-            total_exceptions=len(exceptions),
+            total_exceptions=total_exceptions,
             slow_queries=slow_queries,
             requests_per_minute=round_float(requests_per_minute),
         )
@@ -359,7 +503,7 @@ def create_api_router(get_session_context) -> APIRouter:
         older_than_hours: Optional[int] = None, session: Session = Depends(get_db)
     ):
         if older_than_hours:
-            cutoff = datetime.utcnow() - timedelta(hours=older_than_hours)
+            cutoff = datetime.now(timezone.utc) - timedelta(hours=older_than_hours)
             session.query(CapturedRequest).filter(
                 CapturedRequest.created_at < cutoff
             ).delete()
@@ -382,7 +526,7 @@ def create_api_router(get_session_context) -> APIRouter:
         session: Session = Depends(get_db),
     ):
         """List traces."""
-        since = datetime.utcnow() - timedelta(hours=hours)
+        since = datetime.now(timezone.utc) - timedelta(hours=hours)
         query = session.query(Trace).filter(Trace.created_at >= since)
 
         if status:
@@ -491,4 +635,43 @@ def create_api_router(get_session_context) -> APIRouter:
             "created_at": span.created_at.isoformat(),
         }
 
+    @router.get("/background-tasks", response_model=List[BackgroundTaskSummary])
+    async def get_background_tasks(
+        limit: int = Query(100, ge=1, le=1000),
+        offset: int = Query(0, ge=0),
+        status: Optional[str] = None,
+        request_id: Optional[str] = None,
+        session: Session = Depends(get_db),
+    ):
+        """Get background tasks with optional filters."""
+        query = session.query(BackgroundTask)
+
+        if status:
+            query = query.filter(BackgroundTask.status == status)
+        if request_id:
+            query = query.filter(BackgroundTask.request_id == request_id)
+
+        tasks = (
+            query.order_by(desc(BackgroundTask.created_at))
+            .offset(offset)
+            .limit(limit)
+            .all()
+        )
+
+        return [
+            BackgroundTaskSummary(
+                id=task.id,
+                task_id=task.task_id,
+                request_id=task.request_id,
+                name=task.name,
+                status=task.status,
+                start_time=task.start_time,
+                end_time=task.end_time,
+                duration_ms=round_float(task.duration_ms),
+                error=task.error,
+                created_at=task.created_at,
+            )
+            for task in tasks
+        ]
+
     return router

fastapi_radar/background.py

@@ -0,0 +1,120 @@
+"""Background task monitoring for FastAPI Radar."""
+
+import inspect
+import time
+import uuid
+from datetime import datetime, timezone
+from functools import wraps
+from typing import Callable, Any
+
+from .models import BackgroundTask
+
+
+def track_background_task(get_session: Callable):
+    """Decorator to track background tasks.
+
+    Can optionally accept request_id as kwarg:
+    background_tasks.add_task(my_task, arg1, request_id="abc123")
+    """
+
+    def decorator(func: Callable) -> Callable:
+        @wraps(func)
+        async def async_wrapper(*args: Any, **kwargs: Any) -> Any:
+            task_id = str(uuid.uuid4())
+            # Extract request_id from kwargs if provided
+            req_id = kwargs.pop("_radar_request_id", None)
+            # Clean task name (just function name, not full module path)
+            task_name = func.__name__
+
+            # Create task record
+            with get_session() as session:
+                task = BackgroundTask(
+                    task_id=task_id,
+                    request_id=req_id,
+                    name=task_name,
+                    status="running",
+                    start_time=datetime.now(timezone.utc),
+                )
+                session.add(task)
+                session.commit()
+
+            start_time = time.time()
+            error = None
+
+            try:
+                result = await func(*args, **kwargs)
+                status = "completed"
+                return result
+            except Exception as e:
+                status = "failed"
+                error = str(e)
+                raise
+            finally:
+                duration_ms = (time.time() - start_time) * 1000
+
+                with get_session() as session:
+                    task = (
+                        session.query(BackgroundTask)
+                        .filter(BackgroundTask.task_id == task_id)
+                        .first()
+                    )
+                    if task:
+                        task.status = status
+                        task.end_time = datetime.now(timezone.utc)
+                        task.duration_ms = duration_ms
+                        task.error = error
+                        session.commit()
+
+        @wraps(func)
+        def sync_wrapper(*args: Any, **kwargs: Any) -> Any:
+            task_id = str(uuid.uuid4())
+            # Extract request_id from kwargs if provided
+            req_id = kwargs.pop("_radar_request_id", None)
+            # Clean task name (just function name, not full module path)
+            task_name = func.__name__
+
+            # Create task record
+            with get_session() as session:
+                task = BackgroundTask(
+                    task_id=task_id,
+                    request_id=req_id,
+                    name=task_name,
+                    status="running",
+                    start_time=datetime.now(timezone.utc),
+                )
+                session.add(task)
+                session.commit()
+
+            start_time = time.time()
+            error = None
+
+            try:
+                result = func(*args, **kwargs)
+                status = "completed"
+                return result
+            except Exception as e:
+                status = "failed"
+                error = str(e)
+                raise
+            finally:
+                duration_ms = (time.time() - start_time) * 1000
+
+                with get_session() as session:
+                    task = (
+                        session.query(BackgroundTask)
+                        .filter(BackgroundTask.task_id == task_id)
+                        .first()
+                    )
+                    if task:
+                        task.status = status
+                        task.end_time = datetime.now(timezone.utc)
+                        task.duration_ms = duration_ms
+                        task.error = error
+                        session.commit()
+
+        # Return appropriate wrapper based on function type
+        if inspect.iscoroutinefunction(func):
+            return async_wrapper
+        return sync_wrapper
+
+    return decorator

fastapi_radar/capture.py

@@ -1,13 +1,18 @@
 """SQLAlchemy query capture for FastAPI Radar."""
 
 import time
-from typing import Any, Callable, Dict, List, Union
-
+from typing import Any, Callable, Dict, List, Optional, Union
 from sqlalchemy import event
 from sqlalchemy.engine import Engine
 
+try:  # SQLAlchemy async support is optional
+    from sqlalchemy.ext.asyncio import AsyncEngine
+except Exception:  # pragma: no cover - module might not exist in older SQLAlchemy
+    AsyncEngine = None  # type: ignore[assignment]
 from .middleware import request_context
 from .models import CapturedQuery
+
+
 from .utils import format_sql
 from .tracing import get_current_trace_context
 
@@ -23,14 +28,20 @@ class QueryCapture:
         self.capture_bindings = capture_bindings
         self.slow_query_threshold = slow_query_threshold
         self._query_start_times = {}
+        self._registered_engines: Dict[int, Engine] = {}
 
     def register(self, engine: Engine) -> None:
-        event.listen(engine, "before_cursor_execute", self._before_cursor_execute)
-        event.listen(engine, "after_cursor_execute", self._after_cursor_execute)
+        sync_engine = self._resolve_engine(engine)
+        event.listen(sync_engine, "before_cursor_execute", self._before_cursor_execute)
+        event.listen(sync_engine, "after_cursor_execute", self._after_cursor_execute)
+        self._registered_engines[id(engine)] = sync_engine
 
     def unregister(self, engine: Engine) -> None:
-        event.remove(engine, "before_cursor_execute", self._before_cursor_execute)
-        event.remove(engine, "after_cursor_execute", self._after_cursor_execute)
+        sync_engine = self._registered_engines.pop(id(engine), None)
+        if not sync_engine:
+            sync_engine = self._resolve_engine(engine)
+        event.remove(sync_engine, "before_cursor_execute", self._before_cursor_execute)
+        event.remove(sync_engine, "after_cursor_execute", self._after_cursor_execute)
 
     def _before_cursor_execute(
         self,
@@ -44,14 +55,14 @@ class QueryCapture:
         request_id = request_context.get()
         if not request_id:
             return
-
         context_id = id(context)
         self._query_start_times[context_id] = time.time()
-
+        setattr(context, "_radar_request_id", request_id)
         trace_ctx = get_current_trace_context()
         if trace_ctx:
             formatted_sql = format_sql(statement)
             operation_type = self._get_operation_type(statement)
+            db_tags = self._get_db_tags(conn)
             span_id = trace_ctx.create_span(
                 operation_name=f"DB {operation_type}",
                 span_kind="client",
@@ -59,6 +70,7 @@ class QueryCapture:
                     "db.statement": formatted_sql[:500],  # limit SQL length
                     "db.operation_type": operation_type,
                     "component": "database",
+                    **db_tags,
                 },
             )
             setattr(context, "_radar_span_id", span_id)
@@ -74,8 +86,9 @@ class QueryCapture:
     ) -> None:
         request_id = request_context.get()
         if not request_id:
-            return
-
+            request_id = getattr(context, "_radar_request_id", None)
+            if not request_id:
+                return
         start_time = self._query_start_times.pop(id(context), None)
         if start_time is None:
             return
@@ -160,3 +173,18 @@ class QueryCapture:
             return {k: str(v) for k, v in list(parameters.items())[:100]}
 
         return [str(parameters)]
+
+    def _resolve_engine(self, engine: Engine) -> Engine:
+        if AsyncEngine is not None and isinstance(engine, AsyncEngine):
+            return engine.sync_engine
+        return engine
+
+    def _get_db_tags(self, conn: Any) -> Dict[str, Optional[str]]:
+        tags: Dict[str, Optional[str]] = {}
+        engine = getattr(conn, "engine", None)
+        if engine and getattr(engine, "dialect", None):
+            tags["db.system"] = engine.dialect.name
+            url = getattr(engine, "url", None)
+            if url is not None:
+                tags["db.name"] = getattr(url, "database", None)
+        return tags