PyPI - fastapi-radar - Versions diffs - 0.1.0__py3-none-any.whl - Mend

fastapi-radar 0.1.0__py3-none-any.whl

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.

This version of fastapi-radar might be problematic. Click here for more details.

Files changed (17) hide show

fastapi_radar/__init__.py +6 -0
fastapi_radar/api.py +310 -0
fastapi_radar/capture.py +105 -0
fastapi_radar/dashboard/dist/assets/index-BK3IXW8U.css +1 -0
fastapi_radar/dashboard/dist/assets/index-DS-t-RQ1.js +268 -0
fastapi_radar/dashboard/dist/index.html +13 -0
fastapi_radar/middleware.py +142 -0
fastapi_radar/models.py +66 -0
fastapi_radar/radar.py +295 -0
fastapi_radar/utils.py +59 -0
fastapi_radar-0.1.0.dist-info/METADATA +165 -0
fastapi_radar-0.1.0.dist-info/RECORD +17 -0
fastapi_radar-0.1.0.dist-info/WHEEL +5 -0
fastapi_radar-0.1.0.dist-info/licenses/LICENSE +21 -0
fastapi_radar-0.1.0.dist-info/top_level.txt +2 -0
tests/__init__.py +1 -0
tests/test_radar.py +66 -0

fastapi_radar/dashboard/dist/index.html ADDED Viewed

@@ -0,0 +1,13 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>FastAPI Radar - Debugging Dashboard</title>
+    <script type="module" crossorigin src="/__radar/assets/index-DS-t-RQ1.js"></script>
+    <link rel="stylesheet" crossorigin href="/__radar/assets/index-BK3IXW8U.css">
+  </head>
+  <body>
+    <div id="root"></div>
+  </body>
+</html>

fastapi_radar/middleware.py ADDED Viewed

@@ -0,0 +1,142 @@
+"""Middleware for capturing HTTP requests and responses."""
+import json
+import time
+import traceback
+import uuid
+from typing import Optional, Callable
+from contextvars import ContextVar
+from starlette.middleware.base import BaseHTTPMiddleware
+from starlette.requests import Request
+from starlette.responses import Response, StreamingResponse
+from .models import CapturedRequest, CapturedException
+from .utils import serialize_headers, get_client_ip, truncate_body
+request_context: ContextVar[Optional[str]] = ContextVar("request_id", default=None)
+class RadarMiddleware(BaseHTTPMiddleware):
+    def __init__(
+        self,
+        app,
+        get_session: Callable,
+        exclude_paths: list[str] = None,
+        max_body_size: int = 10000,
+        capture_response_body: bool = True,
+    ):
+        super().__init__(app)
+        self.get_session = get_session
+        self.exclude_paths = exclude_paths or []
+        self.max_body_size = max_body_size
+        self.capture_response_body = capture_response_body
+    async def dispatch(self, request: Request, call_next) -> Response:
+        if self._should_skip(request):
+            return await call_next(request)
+        request_id = str(uuid.uuid4())
+        request_context.set(request_id)
+        start_time = time.time()
+        request_body = await self._get_request_body(request)
+        captured_request = CapturedRequest(
+            request_id=request_id,
+            method=request.method,
+            url=str(request.url),
+            path=request.url.path,
+            query_params=dict(request.query_params) if request.query_params else None,
+            headers=serialize_headers(request.headers),
+            body=(
+                truncate_body(request_body, self.max_body_size)
+                if request_body
+                else None
+            ),
+            client_ip=get_client_ip(request),
+        )
+        response = None
+        exception_occurred = False
+        try:
+            response = await call_next(request)
+            captured_request.status_code = response.status_code
+            captured_request.response_headers = serialize_headers(response.headers)
+            if self.capture_response_body and not isinstance(
+                response, StreamingResponse
+            ):
+                response_body = b""
+                async for chunk in response.body_iterator:
+                    response_body += chunk
+                captured_request.response_body = truncate_body(
+                    response_body.decode("utf-8", errors="ignore"), self.max_body_size
+                )
+                response = Response(
+                    content=response_body,
+                    status_code=response.status_code,
+                    headers=dict(response.headers),
+                    media_type=response.media_type,
+                )
+        except Exception as e:
+            exception_occurred = True
+            self._capture_exception(request_id, e)
+            raise
+        finally:
+            duration = (time.time() - start_time) * 1000
+            captured_request.duration_ms = duration
+            with self.get_session() as session:
+                session.add(captured_request)
+                if exception_occurred:
+                    exception_data = self._get_exception_data(request_id)
+                    if exception_data:
+                        session.add(exception_data)
+                session.commit()
+            request_context.set(None)
+        return response
+    def _should_skip(self, request: Request) -> bool:
+        path = request.url.path
+        for exclude_path in self.exclude_paths:
+            if path.startswith(exclude_path):
+                return True
+        return False
+    async def _get_request_body(self, request: Request) -> Optional[str]:
+        try:
+            body = await request.body()
+            if body:
+                content_type = request.headers.get("content-type", "")
+                if "application/json" in content_type:
+                    try:
+                        return json.dumps(json.loads(body), indent=2)
+                    except (json.JSONDecodeError, UnicodeDecodeError):
+                        pass
+                return body.decode("utf-8", errors="ignore")
+        except Exception:
+            pass
+        return None
+    def _capture_exception(self, request_id: str, exception: Exception) -> None:
+        self._exception_cache = {
+            "request_id": request_id,
+            "exception_type": type(exception).__name__,
+            "exception_value": str(exception),
+            "traceback": traceback.format_exc(),
+        }
+    def _get_exception_data(self, request_id: str) -> Optional[CapturedException]:
+        if (
+            hasattr(self, "_exception_cache")
+            and self._exception_cache.get("request_id") == request_id
+        ):
+            return CapturedException(**self._exception_cache)
+        return None

fastapi_radar/models.py ADDED Viewed

@@ -0,0 +1,66 @@
+"""Storage models for FastAPI Radar."""
+from datetime import datetime
+from sqlalchemy import Column, String, Integer, Float, Text, DateTime, ForeignKey, JSON
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship
+Base = declarative_base()
+class CapturedRequest(Base):
+    __tablename__ = "radar_requests"
+    id = Column(Integer, primary_key=True, index=True)
+    request_id = Column(String(36), unique=True, index=True, nullable=False)
+    method = Column(String(10), nullable=False)
+    url = Column(String(500), nullable=False)
+    path = Column(String(500), nullable=False)
+    query_params = Column(JSON)
+    headers = Column(JSON)
+    body = Column(Text)
+    status_code = Column(Integer)
+    response_body = Column(Text)
+    response_headers = Column(JSON)
+    duration_ms = Column(Float)
+    client_ip = Column(String(50))
+    created_at = Column(DateTime, default=datetime.utcnow, index=True)
+    queries = relationship(
+        "CapturedQuery", back_populates="request", cascade="all, delete-orphan"
+    )
+    exceptions = relationship(
+        "CapturedException", back_populates="request", cascade="all, delete-orphan"
+    )
+class CapturedQuery(Base):
+    __tablename__ = "radar_queries"
+    id = Column(Integer, primary_key=True, index=True)
+    request_id = Column(
+        String(36), ForeignKey("radar_requests.request_id", ondelete="CASCADE")
+    )
+    sql = Column(Text, nullable=False)
+    parameters = Column(JSON)
+    duration_ms = Column(Float)
+    rows_affected = Column(Integer)
+    connection_name = Column(String(100))
+    created_at = Column(DateTime, default=datetime.utcnow, index=True)
+    request = relationship("CapturedRequest", back_populates="queries")
+class CapturedException(Base):
+    __tablename__ = "radar_exceptions"
+    id = Column(Integer, primary_key=True, index=True)
+    request_id = Column(
+        String(36), ForeignKey("radar_requests.request_id", ondelete="CASCADE")
+    )
+    exception_type = Column(String(100), nullable=False)
+    exception_value = Column(Text)
+    traceback = Column(Text, nullable=False)
+    created_at = Column(DateTime, default=datetime.utcnow, index=True)
+    request = relationship("CapturedRequest", back_populates="exceptions")

fastapi_radar/radar.py ADDED Viewed

@@ -0,0 +1,295 @@
+"""Main Radar class for FastAPI Radar."""
+from typing import Optional, List
+from pathlib import Path
+from contextlib import contextmanager
+from fastapi import FastAPI
+from sqlalchemy import create_engine
+from sqlalchemy.engine import Engine
+from sqlalchemy.orm import sessionmaker, Session
+from .models import Base
+from .middleware import RadarMiddleware
+from .capture import QueryCapture
+from .api import create_api_router
+class Radar:
+    def __init__(
+        self,
+        app: FastAPI,
+        db_engine: Engine,
+        storage_engine: Optional[Engine] = None,
+        dashboard_path: str = "/__radar",
+        max_requests: int = 1000,
+        retention_hours: int = 24,
+        slow_query_threshold: int = 100,
+        capture_sql_bindings: bool = True,
+        exclude_paths: Optional[List[str]] = None,
+        theme: str = "auto",
+    ):
+        self.app = app
+        self.db_engine = db_engine
+        self.dashboard_path = dashboard_path
+        self.max_requests = max_requests
+        self.retention_hours = retention_hours
+        self.slow_query_threshold = slow_query_threshold
+        self.capture_sql_bindings = capture_sql_bindings
+        self.exclude_paths = exclude_paths or []
+        self.theme = theme
+        # Add dashboard path to excluded paths
+        self.exclude_paths.append(dashboard_path)
+        self.exclude_paths.append("/api/radar")
+        # Setup storage engine (default to SQLite)
+        if storage_engine:
+            self.storage_engine = storage_engine
+        else:
+            radar_db_path = Path.cwd() / "radar.db"
+            self.storage_engine = create_engine(
+                f"sqlite:///{radar_db_path}", connect_args={"check_same_thread": False}
+            )
+        # Create session maker for storage
+        self.SessionLocal = sessionmaker(
+            autocommit=False, autoflush=False, bind=self.storage_engine
+        )
+        # Initialize components
+        self._setup_middleware()
+        self._setup_query_capture()
+        self._setup_api()
+        self._setup_dashboard()
+    @contextmanager
+    def get_session(self) -> Session:
+        """Get a database session for radar storage."""
+        session = self.SessionLocal()
+        try:
+            yield session
+        finally:
+            session.close()
+    def _setup_middleware(self) -> None:
+        """Add request capture middleware."""
+        self.app.add_middleware(
+            RadarMiddleware,
+            get_session=self.get_session,
+            exclude_paths=self.exclude_paths,
+            max_body_size=10000,
+            capture_response_body=True,
+        )
+    def _setup_query_capture(self) -> None:
+        """Setup SQLAlchemy query capture."""
+        self.query_capture = QueryCapture(
+            get_session=self.get_session,
+            capture_bindings=self.capture_sql_bindings,
+            slow_query_threshold=self.slow_query_threshold,
+        )
+        self.query_capture.register(self.db_engine)
+    def _setup_api(self) -> None:
+        """Mount API endpoints."""
+        api_router = create_api_router(self.get_session)
+        self.app.include_router(api_router)
+    def _setup_dashboard(self) -> None:
+        """Mount dashboard static files."""
+        from fastapi.responses import FileResponse
+        from fastapi import Request
+        dashboard_dir = Path(__file__).parent / "dashboard" / "dist"
+        if not dashboard_dir.exists():
+            # Create placeholder dashboard for development
+            dashboard_dir.mkdir(parents=True, exist_ok=True)
+            self._create_placeholder_dashboard(dashboard_dir)
+            print("\n" + "=" * 60)
+            print("⚠️  FastAPI Radar: Dashboard not built")
+            print("=" * 60)
+            print("To use the full dashboard, build it with:")
+            print("  cd fastapi_radar/dashboard")
+            print("  npm install")
+            print("  npm run build")
+            print("=" * 60 + "\n")
+        # Add a catch-all route for the dashboard SPA
+        # This ensures all sub-routes under /__radar serve the index.html
+        @self.app.get(f"{self.dashboard_path}")
+        @self.app.get(f"{self.dashboard_path}/{{full_path:path}}")
+        async def serve_dashboard(request: Request, full_path: str = ""):
+            # Check if it's a request for a static asset
+            if full_path and any(
+                full_path.endswith(ext)
+                for ext in [
+                    ".js",
+                    ".css",
+                    ".ico",
+                    ".png",
+                    ".jpg",
+                    ".svg",
+                    ".woff",
+                    ".woff2",
+                    ".ttf",
+                ]
+            ):
+                file_path = dashboard_dir / full_path
+                if file_path.exists():
+                    return FileResponse(file_path)
+            # For all other routes, serve index.html (SPA behavior)
+            index_path = dashboard_dir / "index.html"
+            if index_path.exists():
+                return FileResponse(index_path)
+            else:
+                return {"error": "Dashboard not found. Please build the dashboard."}
+    def _create_placeholder_dashboard(self, dashboard_dir: Path) -> None:
+        """Create a placeholder dashboard for development."""
+        index_html = dashboard_dir / "index.html"
+        index_html.write_text(
+            """
+<!DOCTYPE html>
+<html lang="en" data-theme="{theme}">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>FastAPI Radar</title>
+    <style>
+        * {{ margin: 0; padding: 0; box-sizing: border-box; }}
+        body {{
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Arial;
+            background: linear-gradient(135deg, #667eea 0%, #764ba2 100%);
+            color: white;
+            min-height: 100vh;
+            display: flex;
+            align-items: center;
+            justify-content: center;
+            padding: 20px;
+        }}
+        .container {{
+            text-align: center;
+            max-width: 600px;
+        }}
+        h1 {{
+            font-size: 3rem;
+            margin-bottom: 1rem;
+            text-shadow: 2px 2px 4px rgba(0,0,0,0.2);
+        }}
+        p {{
+            font-size: 1.2rem;
+            margin-bottom: 2rem;
+            opacity: 0.95;
+        }}
+        .stats {{
+            display: grid;
+            grid-template-columns: repeat(auto-fit, minmax(150px, 1fr));
+            gap: 20px;
+            margin-top: 3rem;
+        }}
+        .stat {{
+            background: rgba(255, 255, 255, 0.1);
+            backdrop-filter: blur(10px);
+            padding: 20px;
+            border-radius: 10px;
+            border: 1px solid rgba(255, 255, 255, 0.2);
+        }}
+        .stat-value {{
+            font-size: 2rem;
+            font-weight: bold;
+            margin-bottom: 5px;
+        }}
+        .stat-label {{
+            font-size: 0.9rem;
+            opacity: 0.8;
+        }}
+        .loading {{ animation: pulse 2s infinite; }}
+        @keyframes pulse {{
+            0%, 100% {{ opacity: 1; }}
+            50% {{ opacity: 0.5; }}
+        }}
+    </style>
+</head>
+<body>
+    <div class="container">
+        <h1>🚀 FastAPI Radar</h1>
+        <p>Real-time debugging dashboard loading...</p>
+        <div class="stats">
+            <div class="stat">
+                <div class="stat-value loading">--</div>
+                <div class="stat-label">Requests</div>
+            </div>
+            <div class="stat">
+                <div class="stat-value loading">--</div>
+                <div class="stat-label">Queries</div>
+            </div>
+            <div class="stat">
+                <div class="stat-value loading">--</div>
+                <div class="stat-label">Avg Response</div>
+            </div>
+            <div class="stat">
+                <div class="stat-value loading">--</div>
+                <div class="stat-label">Exceptions</div>
+            </div>
+        </div>
+    </div>
+    <script>
+        // Fetch stats from API
+        async function loadStats() {{
+            try {{
+                const response = await fetch('/api/radar/stats?hours=1');
+                const data = await response.json();
+                document.querySelectorAll('.stat-value')[0].textContent = data.total_requests;
+                document.querySelectorAll('.stat-value')[1].textContent = data.total_queries;
+                document.querySelectorAll('.stat-value')[2].textContent =
+                    data.avg_response_time ? `${{data.avg_response_time.toFixed(1)}}ms` : '--';
+                document.querySelectorAll('.stat-value')[3].textContent = data.total_exceptions;
+                document.querySelectorAll('.stat-value').forEach(el => {{
+                    el.classList.remove('loading');
+                }});
+            }} catch (error) {{
+                console.error('Failed to load stats:', error);
+            }}
+        }}
+        // Load stats on page load
+        loadStats();
+        // Refresh stats every 5 seconds
+        setInterval(loadStats, 5000);
+    </script>
+</body>
+</html>
+        """.replace(
+                "{theme}", self.theme
+            )
+        )
+    def create_tables(self) -> None:
+        """Create radar storage tables."""
+        Base.metadata.create_all(bind=self.storage_engine)
+    def drop_tables(self) -> None:
+        """Drop radar storage tables."""
+        Base.metadata.drop_all(bind=self.storage_engine)
+    def cleanup(self, older_than_hours: Optional[int] = None) -> None:
+        """Clean up old captured data."""
+        from datetime import datetime, timedelta
+        from .models import CapturedRequest
+        with self.get_session() as session:
+            hours = older_than_hours or self.retention_hours
+            cutoff = datetime.utcnow() - timedelta(hours=hours)
+            deleted = (
+                session.query(CapturedRequest)
+                .filter(CapturedRequest.created_at < cutoff)
+                .delete()
+            )
+            session.commit()
+            return deleted

fastapi_radar/utils.py ADDED Viewed

@@ -0,0 +1,59 @@
+"""Utility functions for FastAPI Radar."""
+from typing import Dict, Optional
+from starlette.requests import Request
+from starlette.datastructures import Headers
+def serialize_headers(headers: Headers) -> Dict[str, str]:
+    """Serialize headers to a dictionary, excluding sensitive data."""
+    sensitive_headers = {"authorization", "cookie", "x-api-key", "x-auth-token"}
+    result = {}
+    for key, value in headers.items():
+        if key.lower() in sensitive_headers:
+            result[key] = "***REDACTED***"
+        else:
+            result[key] = value
+    return result
+def get_client_ip(request: Request) -> str:
+    """Extract client IP from request."""
+    forwarded = request.headers.get("x-forwarded-for")
+    if forwarded:
+        return forwarded.split(",")[0].strip()
+    real_ip = request.headers.get("x-real-ip")
+    if real_ip:
+        return real_ip
+    if request.client:
+        return request.client.host
+    return "unknown"
+def truncate_body(body: Optional[str], max_size: int) -> Optional[str]:
+    """Truncate body content if it exceeds max size."""
+    if not body:
+        return None
+    if len(body) <= max_size:
+        return body
+    return body[:max_size] + f"... [truncated {len(body) - max_size} characters]"
+def format_sql(sql: str, max_length: int = 5000) -> str:
+    """Format SQL query for display."""
+    if not sql:
+        return ""
+    sql = sql.strip()
+    if len(sql) > max_length:
+        sql = sql[:max_length] + "... [truncated]"
+    return sql