fastapi-radar 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

fastapi_radar/tracing.py

@@ -0,0 +1,258 @@
+"""Tracing core functionality module."""
+
+import uuid
+from datetime import datetime
+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.utcnow()
+
+    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.utcnow(),
+            "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.utcnow()
+        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.utcnow().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.utcnow()
+
+        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,9 @@
 """Utility functions for FastAPI Radar."""
 
 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]:

{fastapi_radar-0.1.5.dist-info → fastapi_radar-0.1.7.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fastapi-radar
-Version: 0.1.5
+Version: 0.1.7
 Summary: A debugging dashboard for FastAPI applications with real-time monitoring
 Home-page: https://github.com/doganarif/fastapi-radar
 Author: Arif Dogan
@@ -13,7 +13,6 @@ Keywords: fastapi,debugging,monitoring,dashboard,development-tools
 Classifier: Development Status :: 4 - Beta
 Classifier: Intended Audience :: Developers
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.8
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
@@ -24,19 +23,21 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: fastapi>=0.68.0
-Requires-Dist: sqlalchemy>=1.4.0
-Requires-Dist: pydantic>=1.8.0
-Requires-Dist: starlette>=0.14.2
+Requires-Dist: fastapi
+Requires-Dist: sqlalchemy>=2.0
+Requires-Dist: pydantic
+Requires-Dist: starlette
+Requires-Dist: duckdb==1.1.3
+Requires-Dist: duckdb-engine==0.17.0
 Provides-Extra: dev
-Requires-Dist: pytest>=7.0.0; extra == "dev"
-Requires-Dist: pytest-asyncio>=0.21.0; extra == "dev"
-Requires-Dist: uvicorn[standard]>=0.15.0; extra == "dev"
-Requires-Dist: black>=22.0.0; extra == "dev"
-Requires-Dist: isort>=5.10.0; extra == "dev"
-Requires-Dist: flake8>=4.0.0; extra == "dev"
-Requires-Dist: mypy>=0.950; extra == "dev"
-Requires-Dist: httpx>=0.28.1; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-asyncio; extra == "dev"
+Requires-Dist: uvicorn[standard]; extra == "dev"
+Requires-Dist: black; extra == "dev"
+Requires-Dist: isort; extra == "dev"
+Requires-Dist: flake8; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: httpx; extra == "dev"
 Dynamic: author
 Dynamic: home-page
 Dynamic: license-file

fastapi_radar-0.1.7.dist-info/RECORD

@@ -0,0 +1,18 @@
+fastapi_radar/__init__.py,sha256=RsHUtOtkoaufEyEeY9NyVFNLVyPhUppP2RR6iz9mTyY,137
+fastapi_radar/api.py,sha256=JYXYocgWdmjHbrfthpBuqXmIWH8ZNct4qA3WCbinL2o,16099
+fastapi_radar/capture.py,sha256=butzGPmjR8f3gdrNqh4iOlXD2WBD8Zh6CcSTDlnYR5o,5186
+fastapi_radar/middleware.py,sha256=v36cdUWRozkFs1MxG8piRzuazQZG5CHRVp_e7AWobbk,7684
+fastapi_radar/models.py,sha256=jsYakaDd3HRDdAI7SfXLL5fI_fAfVBBhcYq8ktDPfmk,4865
+fastapi_radar/radar.py,sha256=8bVoEY9zekgp4bU50fAftgFYc4CP_3t42J8dS4zduvQ,11218
+fastapi_radar/tracing.py,sha256=m0AEX4sa-VUu5STezhpa51BZQ7R8Ax9u2zry2JSF3hQ,8743
+fastapi_radar/utils.py,sha256=82cNXjbtm7oTaNRwrSy2fPWDVGi8XSk56C_8o7N7oRQ,1516
+fastapi_radar/dashboard/dist/index.html,sha256=-Dx0Jw0WDyD29adrACqarkIq_XlUDo7BzqHmt3_mAkc,436
+fastapi_radar/dashboard/dist/assets/index-By5DXl8Z.js,sha256=D4jEA0Ep4L7PXXo8rZ_saAQIWhl43aAfIdjI6b4eotQ,833887
+fastapi_radar/dashboard/dist/assets/index-XlGcZj49.css,sha256=z2yLr4jYQoOM7KQ2aw5zrPpMlkr9dRvwBSGaxjzZNnc,35552
+fastapi_radar-0.1.7.dist-info/licenses/LICENSE,sha256=0ga4BB6q-nqx6xlDRhtrgKrYs0HgX02PQyIzNFRK09Q,1067
+tests/__init__.py,sha256=kAWaI50iJRZ4JlAdyt7FICgm8MsloZz0ZlsmhgLXBas,31
+tests/test_radar.py,sha256=3F-_zdemPcgQnjP4kzCa7GhMxNJNYU0SgSWprctyXiA,2374
+fastapi_radar-0.1.7.dist-info/METADATA,sha256=fdCi6WDOrkSyPoxQmH0OgWdFdDNjUUJ_q0E7hb7GLLc,5884
+fastapi_radar-0.1.7.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+fastapi_radar-0.1.7.dist-info/top_level.txt,sha256=M-bALM-KDkiLcATq2aAx-BnG59Nv-GdFBzuzkUhiCa0,20
+fastapi_radar-0.1.7.dist-info/RECORD,,

tests/test_radar.py

@@ -10,9 +10,12 @@ from fastapi_radar import Radar
 def test_radar_initialization():
     """Test that Radar can be initialized with a FastAPI app."""
     app = FastAPI()
+    # Use in-memory SQLite for test database (not for storage)
     engine = create_engine("sqlite:///:memory:")
+    # Use in-memory SQLite for storage as well to avoid DuckDB requirement in tests
+    storage_engine = create_engine("sqlite:///:memory:")
 
-    radar = Radar(app, db_engine=engine)
+    radar = Radar(app, db_engine=engine, storage_engine=storage_engine)
     assert radar is not None
     assert radar.app == app
     assert radar.db_engine == engine
@@ -22,8 +25,9 @@ def test_radar_creates_tables():
     """Test that Radar can create necessary database tables."""
     app = FastAPI()
     engine = create_engine("sqlite:///:memory:")
+    storage_engine = create_engine("sqlite:///:memory:")
 
-    radar = Radar(app, db_engine=engine)
+    radar = Radar(app, db_engine=engine, storage_engine=storage_engine)
     radar.create_tables()
 
     # Tables should be created without errors
@@ -34,8 +38,9 @@ def test_dashboard_mounted():
     """Test that the dashboard is mounted at the correct path."""
     app = FastAPI()
     engine = create_engine("sqlite:///:memory:")
+    storage_engine = create_engine("sqlite:///:memory:")
 
-    radar = Radar(app, db_engine=engine)
+    radar = Radar(app, db_engine=engine, storage_engine=storage_engine)
     radar.create_tables()
 
     client = TestClient(app)
@@ -50,16 +55,21 @@ def test_middleware_captures_requests():
     """Test that middleware captures HTTP requests."""
     app = FastAPI()
     engine = create_engine("sqlite:///:memory:")
+    # Use a file-based SQLite for storage to persist tables
+    import tempfile
 
-    radar = Radar(app, db_engine=engine)
-    radar.create_tables()
+    with tempfile.NamedTemporaryFile(suffix=".db") as temp_db:
+        storage_engine = create_engine(f"sqlite:///{temp_db.name}")
 
-    @app.get("/test")
-    async def test_endpoint():
-        return {"message": "test"}
+        radar = Radar(app, db_engine=engine, storage_engine=storage_engine)
+        radar.create_tables()
 
-    client = TestClient(app)
-    response = client.get("/test")
+        @app.get("/test")
+        async def test_endpoint():
+            return {"message": "test"}
+
+        client = TestClient(app)
+        response = client.get("/test")
 
-    assert response.status_code == 200
-    assert response.json() == {"message": "test"}
+        assert response.status_code == 200
+        assert response.json() == {"message": "test"}