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

fastapi_radar/radar.py

@@ -1,17 +1,43 @@
 """Main Radar class for FastAPI Radar."""
 
-from typing import Optional, List
-from pathlib import Path
 from contextlib import contextmanager
+import os
+import sys
+import multiprocessing
+from pathlib import Path
+from typing import List, Optional
+
 from fastapi import FastAPI
 from sqlalchemy import create_engine
 from sqlalchemy.engine import Engine
-from sqlalchemy.orm import sessionmaker, Session
+from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.pool import StaticPool
 
-from .models import Base
-from .middleware import RadarMiddleware
-from .capture import QueryCapture
 from .api import create_api_router
+from .capture import QueryCapture
+from .middleware import RadarMiddleware
+from .models import Base
+
+
+def is_reload_worker() -> bool:
+    """Check if we're running in a reload worker process (used by fastapi dev)."""
+    if os.environ.get("UVICORN_RELOAD"):
+        return True
+
+    if os.environ.get("WERKZEUG_RUN_MAIN"):
+        return True
+
+    if hasattr(multiprocessing.current_process(), "name"):
+        process_name = multiprocessing.current_process().name
+        if process_name != "MainProcess" and "SpawnProcess" in process_name:
+            return True
+
+    return False
+
+
+def is_windows() -> bool:
+    """Check if we're running on Windows."""
+    return sys.platform.startswith("win")
 
 
 class Radar:
@@ -29,6 +55,10 @@ class Radar:
         capture_sql_bindings: bool = True,
         exclude_paths: Optional[List[str]] = None,
         theme: str = "auto",
+        enable_tracing: bool = True,
+        service_name: str = "fastapi-app",
+        include_in_schema: bool = True,
+        db_path: Optional[str] = None,
     ):
         self.app = app
         self.db_engine = db_engine
@@ -39,38 +69,94 @@ class Radar:
         self.capture_sql_bindings = capture_sql_bindings
         self.exclude_paths = exclude_paths or []
         self.theme = theme
-        self.query_capture = None  # Initialize to None
+        self.enable_tracing = enable_tracing
+        self.service_name = service_name
+        self.db_path = db_path
+        self.query_capture = None
 
-        # Add all radar paths to excluded paths - exclude everything under /__radar
         if dashboard_path not in self.exclude_paths:
             self.exclude_paths.append(dashboard_path)
-
-        # Exclude favicon.ico
         self.exclude_paths.append("/favicon.ico")
 
-        # 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}
-            )
+            storage_url = os.environ.get("RADAR_STORAGE_URL")
+            if storage_url:
+                if "duckdb" in storage_url:
+                    self.storage_engine = create_engine(
+                        storage_url, poolclass=StaticPool
+                    )
+                else:
+                    self.storage_engine = create_engine(storage_url)
+            else:
+                import duckdb_engine  # noqa: F401
+
+                if self.db_path:
+                    try:
+                        provided_path = Path(self.db_path).resolve()
+                        if provided_path.suffix.lower() == ".duckdb":
+                            radar_db_path = provided_path
+                            radar_db_path.parent.mkdir(parents=True, exist_ok=True)
+                        else:
+                            radar_db_path = provided_path / "radar.duckdb"
+                            provided_path.mkdir(parents=True, exist_ok=True)
+
+                    except Exception as e:
+                        import warnings
+
+                        warnings.warn(
+                            (
+                                f"Failed to create database path '{self.db_path}': {e}. "
+                                f"Using current directory."
+                            ),
+                            UserWarning,
+                        )
+
+                        radar_db_path = Path.cwd() / "radar.duckdb"
+                        radar_db_path.parent.mkdir(parents=True, exist_ok=True)
+                else:
+                    radar_db_path = Path.cwd() / "radar.duckdb"
+                    radar_db_path.parent.mkdir(parents=True, exist_ok=True)
+
+                if is_reload_worker():
+                    import warnings
+
+                    warnings.warn(
+                        "FastAPI Radar: Detected development mode with auto-reload. "
+                        "Using in-memory database to avoid file locking issues. "
+                        "Data will not persist between reloads.",
+                        UserWarning,
+                    )
+                    self.storage_engine = create_engine(
+                        "duckdb:///:memory:",
+                        connect_args={
+                            "read_only": False,
+                            "config": {"memory_limit": "500mb"},
+                        },
+                        poolclass=StaticPool,
+                    )
+                else:
+                    self.storage_engine = create_engine(
+                        f"duckdb:///{radar_db_path}",
+                        connect_args={
+                            "read_only": False,
+                            "config": {"memory_limit": "500mb"},
+                        },
+                        poolclass=StaticPool,
+                    )
 
-        # Create session maker for storage
         self.SessionLocal = sessionmaker(
             autocommit=False, autoflush=False, bind=self.storage_engine
         )
 
-        # Initialize components
         self._setup_middleware()
 
-        # Only setup query capture if db_engine is provided
         if self.db_engine:
             self._setup_query_capture()
 
-        self._setup_api()
-        self._setup_dashboard()
+        self._setup_api(include_in_schema=include_in_schema)
+        self._setup_dashboard(include_in_schema=include_in_schema)
 
     @contextmanager
     def get_session(self) -> Session:
@@ -89,6 +175,8 @@ class Radar:
             exclude_paths=self.exclude_paths,
             max_body_size=10000,
             capture_response_body=True,
+            enable_tracing=self.enable_tracing,
+            service_name=self.service_name,
         )
 
     def _setup_query_capture(self) -> None:
@@ -104,20 +192,19 @@ class Radar:
         )
         self.query_capture.register(self.db_engine)
 
-    def _setup_api(self) -> None:
+    def _setup_api(self, include_in_schema: bool) -> None:
         """Mount API endpoints."""
         api_router = create_api_router(self.get_session)
-        self.app.include_router(api_router)
+        self.app.include_router(api_router, include_in_schema=include_in_schema)
 
-    def _setup_dashboard(self) -> None:
+    def _setup_dashboard(self, include_in_schema: bool) -> None:
         """Mount dashboard static files."""
-        from fastapi.responses import FileResponse
         from fastapi import Request
+        from fastapi.responses import FileResponse
 
         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)
@@ -129,11 +216,11 @@ class Radar:
             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}/{{full_path:path}}")
+        @self.app.get(
+            f"{self.dashboard_path}/{{full_path:path}}",
+            include_in_schema=include_in_schema,
+        )
         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 [
@@ -152,7 +239,6 @@ class Radar:
                 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)
@@ -160,7 +246,6 @@ class Radar:
                 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(
             """
@@ -249,17 +334,20 @@ class Radar:
         </div>
     </div>
     <script>
-        // Fetch stats from API
         async function loadStats() {{
             try {{
                 const response = await fetch('/__radar/api/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')[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;
+                    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');
@@ -269,9 +357,7 @@ class Radar:
             }}
         }}
 
-        // Load stats on page load
         loadStats();
-        // Refresh stats every 5 seconds
         setInterval(loadStats, 5000);
     </script>
 </body>
@@ -282,21 +368,29 @@ class Radar:
         )
 
     def create_tables(self) -> None:
-        """Create radar storage tables."""
-        Base.metadata.create_all(bind=self.storage_engine)
+        """Create database tables.
+
+        With dev mode (fastapi dev), this safely handles
+        multiple process attempts to create tables.
+        """
+        try:
+            Base.metadata.create_all(bind=self.storage_engine)
+        except Exception as e:
+            error_msg = str(e).lower()
+            if "already exists" not in error_msg and "lock" not in error_msg:
+                raise
 
     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 datetime import datetime, timedelta, timezone
+
         from .models import CapturedRequest
 
         with self.get_session() as session:
             hours = older_than_hours or self.retention_hours
-            cutoff = datetime.utcnow() - timedelta(hours=hours)
+            cutoff = datetime.now(timezone.utc) - timedelta(hours=hours)
 
             deleted = (
                 session.query(CapturedRequest)

fastapi_radar/tracing.py

@@ -0,0 +1,258 @@
+"""Tracing core functionality module."""
+
+import uuid
+from datetime import datetime, timezone
+from typing import Optional, Dict, Any, List
+from contextvars import ContextVar
+from sqlalchemy.orm import Session
+
+from .models import Trace, Span, SpanRelation
+
+# Trace context for the current request
+trace_context: ContextVar[Optional["TraceContext"]] = ContextVar(
+    "trace_context", default=None
+)
+
+
+class TraceContext:
+    """Tracing context that manages trace and span data for a request."""
+
+    def __init__(self, trace_id: str, service_name: str = "fastapi-app"):
+        self.trace_id = trace_id
+        self.service_name = service_name
+        self.root_span_id: Optional[str] = None
+        self.current_span_id: Optional[str] = None
+        self.spans: Dict[str, Dict[str, Any]] = {}
+        self.start_time = datetime.now(timezone.utc)
+
+    def create_span(
+        self,
+        operation_name: str,
+        parent_span_id: Optional[str] = None,
+        span_kind: str = "server",
+        tags: Optional[Dict[str, Any]] = None,
+    ) -> str:
+        """Create a new span."""
+        span_id = self._generate_span_id()
+
+        span_data = {
+            "span_id": span_id,
+            "trace_id": self.trace_id,
+            "parent_span_id": parent_span_id or self.current_span_id,
+            "operation_name": operation_name,
+            "service_name": self.service_name,
+            "span_kind": span_kind,
+            "start_time": datetime.now(timezone.utc),
+            "tags": tags or {},
+            "logs": [],
+            "status": "ok",
+        }
+
+        self.spans[span_id] = span_data
+
+        # Set root span if not already set
+        if self.root_span_id is None:
+            self.root_span_id = span_id
+
+        return span_id
+
+    def finish_span(
+        self, span_id: str, status: str = "ok", tags: Optional[Dict[str, Any]] = None
+    ):
+        """Finish a span."""
+        if span_id not in self.spans:
+            return
+
+        span_data = self.spans[span_id]
+        span_data["end_time"] = datetime.now(timezone.utc)
+        span_data["duration_ms"] = (
+            span_data["end_time"] - span_data["start_time"]
+        ).total_seconds() * 1000
+        span_data["status"] = status
+
+        if tags:
+            span_data["tags"].update(tags)
+
+    def add_span_log(self, span_id: str, message: str, level: str = "info", **fields):
+        """Add a log entry to a span."""
+        if span_id not in self.spans:
+            return
+
+        log_entry = {
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "level": level,
+            "message": message,
+            **fields,
+        }
+
+        self.spans[span_id]["logs"].append(log_entry)
+
+    def set_current_span(self, span_id: str):
+        """Set the current active span."""
+        self.current_span_id = span_id
+
+    def get_trace_summary(self) -> Dict[str, Any]:
+        """Return a trace summary for persistence and display."""
+        if not self.spans:
+            return {}
+
+        all_times = []
+        error_count = 0
+
+        for span in self.spans.values():
+            if span.get("start_time"):
+                all_times.append(span["start_time"])
+            if span.get("end_time"):
+                all_times.append(span["end_time"])
+            if span.get("status") == "error":
+                error_count += 1
+
+        start_time = min(all_times) if all_times else self.start_time
+        end_time = max(all_times) if all_times else datetime.now(timezone.utc)
+
+        return {
+            "trace_id": self.trace_id,
+            "service_name": self.service_name,
+            "operation_name": self.spans.get(self.root_span_id, {}).get(
+                "operation_name", "unknown"
+            ),
+            "start_time": start_time,
+            "end_time": end_time,
+            "duration_ms": (end_time - start_time).total_seconds() * 1000,
+            "span_count": len(self.spans),
+            "status": "error" if error_count > 0 else "ok",
+            "tags": {},
+        }
+
+    @staticmethod
+    def _generate_span_id() -> str:
+        """Generate a 16-character hexadecimal span ID."""
+        return uuid.uuid4().hex[:16]
+
+
+class TracingManager:
+    """Tracing manager responsible for persistence and querying."""
+
+    def __init__(self, get_session):
+        self.get_session = get_session
+
+    def save_trace_context(self, trace_ctx: TraceContext):
+        """Persist the trace context into the database."""
+        with self.get_session() as session:
+            # Save trace
+            trace_summary = trace_ctx.get_trace_summary()
+            trace = Trace(**trace_summary)
+            session.add(trace)
+
+            # Save spans
+            for span_data in trace_ctx.spans.values():
+                span = Span(**span_data)
+                session.add(span)
+
+            self._save_span_relations(session, trace_ctx)
+
+            session.commit()
+
+    def _save_span_relations(self, session: Session, trace_ctx: TraceContext):
+        """Store parent-child span relations for optimized querying."""
+
+        def calculate_depth(
+            span_id: str, spans: Dict[str, Dict], depth: int = 0
+        ) -> List[tuple]:
+            """Recursively compute span depth."""
+            relations = []
+            span = spans.get(span_id)
+            if not span:
+                return relations
+
+            # Find all child spans
+            for sid, s in spans.items():
+                if s.get("parent_span_id") == span_id:
+                    relations.append((span_id, sid, depth + 1))
+                    relations.extend(calculate_depth(sid, spans, depth + 1))
+
+            return relations
+
+        # Start from the root span
+        if trace_ctx.root_span_id:
+            relations = calculate_depth(trace_ctx.root_span_id, trace_ctx.spans)
+
+            for parent_id, child_id, depth in relations:
+                relation = SpanRelation(
+                    trace_id=trace_ctx.trace_id,
+                    parent_span_id=parent_id,
+                    child_span_id=child_id,
+                    depth=depth,
+                )
+                session.add(relation)
+
+    def get_waterfall_data(self, trace_id: str) -> List[Dict[str, Any]]:
+        """Return data for the waterfall view."""
+        with self.get_session() as session:
+            # Query optimized for DuckDB
+            from sqlalchemy import text
+
+            waterfall_query = text(
+                """
+                WITH span_timeline AS (
+                    SELECT
+                        s.span_id,
+                        s.parent_span_id,
+                        s.operation_name,
+                        s.service_name,
+                        s.start_time,
+                        s.end_time,
+                        s.duration_ms,
+                        s.status,
+                        s.tags,
+                        COALESCE(r.depth, 0) as depth,
+                        -- Offset relative to trace start
+                        EXTRACT(EPOCH FROM (
+                            s.start_time - MIN(s.start_time)
+                                OVER (PARTITION BY s.trace_id)
+                        )) * 1000 as offset_ms
+                    FROM radar_spans s
+                    LEFT JOIN radar_span_relations r ON s.span_id = r.child_span_id
+                    WHERE s.trace_id = :trace_id
+                )
+                SELECT * FROM span_timeline
+                ORDER BY offset_ms, depth
+            """
+            )
+
+            result = session.execute(waterfall_query, {"trace_id": trace_id})
+
+            return [
+                {
+                    "span_id": row.span_id,
+                    "parent_span_id": row.parent_span_id,
+                    "operation_name": row.operation_name,
+                    "service_name": row.service_name,
+                    "start_time": (
+                        row.start_time.isoformat() if row.start_time else None
+                    ),
+                    "end_time": row.end_time.isoformat() if row.end_time else None,
+                    "duration_ms": row.duration_ms,
+                    "status": row.status,
+                    "tags": row.tags,
+                    "depth": row.depth,
+                    "offset_ms": float(row.offset_ms) if row.offset_ms else 0.0,
+                }
+                for row in result
+            ]
+
+
+def get_current_trace_context() -> Optional[TraceContext]:
+    """Get the current trace context."""
+    return trace_context.get()
+
+
+def set_trace_context(ctx: TraceContext):
+    """Set the current trace context."""
+    trace_context.set(ctx)
+
+
+def create_trace_context(service_name: str = "fastapi-app") -> TraceContext:
+    """Create a new trace context."""
+    trace_id = uuid.uuid4().hex
+    return TraceContext(trace_id, service_name)

fastapi_radar/utils.py

@@ -1,8 +1,10 @@
 """Utility functions for FastAPI Radar."""
 
+import re
 from typing import Dict, Optional
-from starlette.requests import Request
+
 from starlette.datastructures import Headers
+from starlette.requests import Request
 
 
 def serialize_headers(headers: Headers) -> Dict[str, str]:
@@ -57,3 +59,26 @@ def format_sql(sql: str, max_length: int = 5000) -> str:
         sql = sql[:max_length] + "... [truncated]"
 
     return sql
+
+
+def redact_sensitive_data(text: Optional[str]) -> Optional[str]:
+    """Redact sensitive data from text (body content)."""
+    if not text:
+        return text
+
+    # Patterns for sensitive data
+    patterns = [
+        (r'"(password|passwd|pwd)"\s*:\s*"[^"]*"', r'"\1": "***REDACTED***"'),
+        (
+            r'"(token|api_key|apikey|secret|auth)"\s*:\s*"[^"]*"',
+            r'"\1": "***REDACTED***"',
+        ),
+        (r'"(credit_card|card_number|cvv)"\s*:\s*"[^"]*"', r'"\1": "***REDACTED***"'),
+        (r"Bearer\s+[A-Za-z0-9\-_\.]+", "Bearer ***REDACTED***"),
+    ]
+
+    result = text
+    for pattern, replacement in patterns:
+        result = re.sub(pattern, replacement, result, flags=re.IGNORECASE)
+
+    return result