PyPI - fastapi-radar - Versions diffs - 0.1.6__py3-none-any.whl → 0.3.1__py3-none-any.whl - Mend

fastapi-radar 0.1.6py3-none-any.whl → 0.3.1py3-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.

Files changed (24) hide show

fastapi_radar/__init__.py +3 -2
fastapi_radar/api.py +383 -37
fastapi_radar/background.py +120 -0
fastapi_radar/capture.py +101 -16
fastapi_radar/dashboard/dist/assets/index-8Om0PGu6.js +326 -0
fastapi_radar/dashboard/dist/assets/index-D51YrvFG.css +1 -0
fastapi_radar/dashboard/dist/assets/index-p3czTzXB.js +361 -0
fastapi_radar/dashboard/dist/index.html +2 -2
fastapi_radar/dashboard/node_modules/flatted/python/flatted.py +149 -0
fastapi_radar/middleware.py +115 -17
fastapi_radar/models.py +143 -19
fastapi_radar/radar.py +138 -44
fastapi_radar/tracing.py +258 -0
fastapi_radar/utils.py +26 -1
{fastapi_radar-0.1.6.dist-info → fastapi_radar-0.3.1.dist-info}/METADATA +58 -15
fastapi_radar-0.3.1.dist-info/RECORD +19 -0
{fastapi_radar-0.1.6.dist-info → fastapi_radar-0.3.1.dist-info}/top_level.txt +0 -1
fastapi_radar/dashboard/dist/assets/index-BJa0l2JD.js +0 -313
fastapi_radar/dashboard/dist/assets/index-DCxkDBhr.css +0 -1
fastapi_radar-0.1.6.dist-info/RECORD +0 -17
tests/__init__.py +0 -1
tests/test_radar.py +0 -65
{fastapi_radar-0.1.6.dist-info → fastapi_radar-0.3.1.dist-info}/WHEEL +0 -0
{fastapi_radar-0.1.6.dist-info → fastapi_radar-0.3.1.dist-info}/licenses/LICENSE +0 -0

fastapi_radar/dashboard/dist/index.html CHANGED Viewed

@@ -4,8 +4,8 @@
     <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-BJa0l2JD.js"></script>
-    <link rel="stylesheet" crossorigin href="/__radar/assets/index-DCxkDBhr.css">
+    <script type="module" crossorigin src="/__radar/assets/index-8Om0PGu6.js"></script>
+    <link rel="stylesheet" crossorigin href="/__radar/assets/index-XlGcZj49.css">
   </head>
   <body>
     <div id="root"></div>

fastapi_radar/dashboard/node_modules/flatted/python/flatted.py ADDED Viewed

@@ -0,0 +1,149 @@
+# ISC License
+#
+# Copyright (c) 2018-2025, Andrea Giammarchi, @WebReflection
+#
+# Permission to use, copy, modify, and/or distribute this software for any
+# purpose with or without fee is hereby granted, provided that the above
+# copyright notice and this permission notice appear in all copies.
+#
+# THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+# REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+# AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+# INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+# LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
+# OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+# PERFORMANCE OF THIS SOFTWARE.
+import json as _json
+class _Known:
+    def __init__(self):
+        self.key = []
+        self.value = []
+class _String:
+    def __init__(self, value):
+        self.value = value
+def _array_keys(value):
+    keys = []
+    i = 0
+    for _ in value:
+        keys.append(i)
+        i += 1
+    return keys
+def _object_keys(value):
+    keys = []
+    for key in value:
+        keys.append(key)
+    return keys
+def _is_array(value):
+    return isinstance(value, (list, tuple))
+def _is_object(value):
+    return isinstance(value, dict)
+def _is_string(value):
+    return isinstance(value, str)
+def _index(known, input, value):
+    input.append(value)
+    index = str(len(input) - 1)
+    known.key.append(value)
+    known.value.append(index)
+    return index
+def _loop(keys, input, known, output):
+    for key in keys:
+        value = output[key]
+        if isinstance(value, _String):
+            _ref(key, input[int(value.value)], input, known, output)
+    return output
+def _ref(key, value, input, known, output):
+    if _is_array(value) and value not in known:
+        known.append(value)
+        value = _loop(_array_keys(value), input, known, value)
+    elif _is_object(value) and value not in known:
+        known.append(value)
+        value = _loop(_object_keys(value), input, known, value)
+    output[key] = value
+def _relate(known, input, value):
+    if _is_string(value) or _is_array(value) or _is_object(value):
+        try:
+            return known.value[known.key.index(value)]
+        except:
+            return _index(known, input, value)
+    return value
+def _transform(known, input, value):
+    if _is_array(value):
+        output = []
+        for val in value:
+            output.append(_relate(known, input, val))
+        return output
+    if _is_object(value):
+        obj = {}
+        for key in value:
+            obj[key] = _relate(known, input, value[key])
+        return obj
+    return value
+def _wrap(value):
+    if _is_string(value):
+        return _String(value)
+    if _is_array(value):
+        i = 0
+        for val in value:
+            value[i] = _wrap(val)
+            i += 1
+    elif _is_object(value):
+        for key in value:
+            value[key] = _wrap(value[key])
+    return value
+def parse(value, *args, **kwargs):
+    json = _json.loads(value, *args, **kwargs)
+    wrapped = []
+    for value in json:
+        wrapped.append(_wrap(value))
+    input = []
+    for value in wrapped:
+        if isinstance(value, _String):
+            input.append(value.value)
+        else:
+            input.append(value)
+    value = input[0]
+    if _is_array(value):
+        return _loop(_array_keys(value), input, [value], value)
+    if _is_object(value):
+        return _loop(_object_keys(value), input, [value], value)
+    return value
+def stringify(value, *args, **kwargs):
+    known = _Known()
+    input = []
+    output = []
+    i = int(_index(known, input, value))
+    while i < len(input):
+        output.append(_transform(known, input, input[i]))
+        i += 1
+    return _json.dumps(output, *args, **kwargs)

fastapi_radar/middleware.py CHANGED Viewed

@@ -4,13 +4,27 @@ import json
 import time
 import traceback
 import uuid
-from typing import Optional, Callable
 from contextvars import ContextVar
+from typing import Callable, Optional
+from sqlalchemy.exc import SQLAlchemyError
 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
+from .utils import (
+    serialize_headers,
+    get_client_ip,
+    truncate_body,
+    redact_sensitive_data,
+)
+from .tracing import (
+    TraceContext,
+    TracingManager,
+    create_trace_context,
+    set_trace_context,
+)
 request_context: ContextVar[Optional[str]] = ContextVar("request_id", default=None)
@@ -23,12 +37,17 @@ class RadarMiddleware(BaseHTTPMiddleware):
         exclude_paths: list[str] = None,
         max_body_size: int = 10000,
         capture_response_body: bool = True,
+        enable_tracing: bool = True,
+        service_name: str = "fastapi-app",
     ):
         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
+        self.enable_tracing = enable_tracing
+        self.service_name = service_name
+        self.tracing_manager = TracingManager(get_session) if enable_tracing else None
     async def dispatch(self, request: Request, call_next) -> Response:
         if self._should_skip(request):
@@ -38,6 +57,43 @@ class RadarMiddleware(BaseHTTPMiddleware):
         request_context.set(request_id)
         start_time = time.time()
+        # Create tracing context for this request
+        trace_ctx = None
+        root_span_id = None
+        if self.enable_tracing and self.tracing_manager:
+            existing_trace_id = request.headers.get("x-trace-id")
+            parent_span_id = request.headers.get("x-parent-span-id")
+            if existing_trace_id:
+                # Child span for existing trace
+                trace_ctx = TraceContext(existing_trace_id, self.service_name)
+            else:
+                # Create a new trace
+                trace_ctx = create_trace_context(self.service_name)
+            # Set tracing context
+            set_trace_context(trace_ctx)
+            # Create root span
+            root_span_id = trace_ctx.create_span(
+                operation_name=f"{request.method} {request.url.path}",
+                parent_span_id=parent_span_id,
+                span_kind="server",
+                tags={
+                    "http.method": request.method,
+                    "http.url": str(request.url),
+                    "http.path": request.url.path,
+                    "http.query": (
+                        str(request.query_params) if request.query_params else None
+                    ),
+                    "user_agent": request.headers.get("user-agent"),
+                    "request_id": request_id,
+                },
+            )
+            trace_ctx.set_current_span(root_span_id)
         request_body = await self._get_request_body(request)
         captured_request = CapturedRequest(
@@ -48,7 +104,7 @@ class RadarMiddleware(BaseHTTPMiddleware):
             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)
+                redact_sensitive_data(truncate_body(request_body, self.max_body_size))
                 if request_body
                 else None
             ),
@@ -59,24 +115,39 @@ class RadarMiddleware(BaseHTTPMiddleware):
         exception_occurred = False
         try:
-            response = await call_next(request)
+            response = original_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,
+            if self.capture_response_body:
+                async def capture_response():
+                    response_body = ""
+                    capturing = True
+                    async for chunk in original_response.body_iterator:
+                        yield chunk
+                        if capturing:
+                            response_body += chunk.decode("utf-8", errors="ignore")
+                            try:
+                                with self.get_session() as session:
+                                    captured_request.response_body = (
+                                        redact_sensitive_data(
+                                            truncate_body(
+                                                response_body, self.max_body_size
+                                            )
+                                        )
+                                    )
+                                    session.add(captured_request)
+                                    session.commit()
+                            except SQLAlchemyError:
+                                # CapturedRequest record has been deleted.
+                                capturing = False
+                            else:
+                                capturing = len(response_body) < self.max_body_size
+                response = StreamingResponse(
+                    content=capture_response(),
                     status_code=response.status_code,
                     headers=dict(response.headers),
                     media_type=response.media_type,
@@ -85,18 +156,45 @@ class RadarMiddleware(BaseHTTPMiddleware):
         except Exception as e:
             exception_occurred = True
             self._capture_exception(request_id, e)
+            # Record exception in span
+            if trace_ctx and root_span_id:
+                trace_ctx.add_span_log(
+                    root_span_id,
+                    f"Exception occurred: {str(e)}",
+                    level="error",
+                    exception_type=type(e).__name__,
+                )
             raise
         finally:
             duration = round((time.time() - start_time) * 1000, 2)
             captured_request.duration_ms = duration
+            # Finish span tracking
+            if trace_ctx and root_span_id:
+                status = "error" if exception_occurred else "ok"
+                trace_ctx.finish_span(
+                    root_span_id,
+                    status=status,
+                    tags={
+                        "http.status_code": response.status_code if response else None,
+                        "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)
+                # Persist trace data
+                if trace_ctx and self.tracing_manager:
+                    self.tracing_manager.save_trace_context(trace_ctx)
                 session.commit()
             request_context.set(None)

fastapi_radar/models.py CHANGED Viewed

@@ -1,9 +1,23 @@
 """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
+from datetime import datetime, timezone
+from sqlalchemy import (
+    Column,
+    String,
+    Integer,
+    Float,
+    Text,
+    DateTime,
+    JSON,
+    Sequence,
+)
+try:
+    from sqlalchemy.orm import declarative_base
+except ImportError:
+    from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import relationship, foreign  # noqa: F401
 Base = declarative_base()
@@ -11,7 +25,9 @@ Base = declarative_base()
 class CapturedRequest(Base):
     __tablename__ = "radar_requests"
-    id = Column(Integer, primary_key=True, index=True)
+    id = Column(
+        Integer, Sequence("radar_requests_id_seq"), 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)
@@ -24,43 +40,151 @@ class CapturedRequest(Base):
     response_headers = Column(JSON)
     duration_ms = Column(Float)
     client_ip = Column(String(50))
-    created_at = Column(DateTime, default=datetime.utcnow, index=True)
+    created_at = Column(
+        DateTime, default=lambda: datetime.now(timezone.utc), index=True
+    )
     queries = relationship(
-        "CapturedQuery", back_populates="request", cascade="all, delete-orphan"
+        "CapturedQuery",
+        back_populates="request",
+        primaryjoin="CapturedRequest.request_id == foreign(CapturedQuery.request_id)",
+        cascade="all, delete-orphan",
     )
     exceptions = relationship(
-        "CapturedException", back_populates="request", cascade="all, delete-orphan"
+        "CapturedException",
+        back_populates="request",
+        primaryjoin=(
+            "CapturedRequest.request_id == foreign(CapturedException.request_id)"
+        ),
+        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")
-    )
+    id = Column(Integer, Sequence("radar_queries_id_seq"), primary_key=True, index=True)
+    request_id = Column(String(36), index=True)
     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)
+    created_at = Column(
+        DateTime, default=lambda: datetime.now(timezone.utc), index=True
+    )
-    request = relationship("CapturedRequest", back_populates="queries")
+    request = relationship(
+        "CapturedRequest",
+        back_populates="queries",
+        primaryjoin="foreign(CapturedQuery.request_id) == CapturedRequest.request_id",
+    )
 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")
+    id = Column(
+        Integer, Sequence("radar_exceptions_id_seq"), primary_key=True, index=True
     )
+    request_id = Column(String(36), index=True)
     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)
+    created_at = Column(
+        DateTime, default=lambda: datetime.now(timezone.utc), index=True
+    )
+    request = relationship(
+        "CapturedRequest",
+        back_populates="exceptions",
+        primaryjoin=(
+            "foreign(CapturedException.request_id) == CapturedRequest.request_id"
+        ),
+    )
+class Trace(Base):
+    __tablename__ = "radar_traces"
+    trace_id = Column(String(32), primary_key=True, index=True)
+    service_name = Column(String(100), index=True)
+    operation_name = Column(String(200))
+    start_time = Column(
+        DateTime, default=lambda: datetime.now(timezone.utc), index=True
+    )
+    end_time = Column(DateTime)
+    duration_ms = Column(Float)
+    span_count = Column(Integer, default=0)
+    status = Column(String(20), default="ok")
+    tags = Column(JSON)
+    created_at = Column(
+        DateTime, default=lambda: datetime.now(timezone.utc), index=True
+    )
+    spans = relationship(
+        "Span",
+        back_populates="trace",
+        primaryjoin="Trace.trace_id == foreign(Span.trace_id)",
+        cascade="all, delete-orphan",
+    )
+class Span(Base):
+    __tablename__ = "radar_spans"
+    span_id = Column(String(16), primary_key=True, index=True)
+    trace_id = Column(String(32), index=True)
+    parent_span_id = Column(String(16), index=True, nullable=True)
+    operation_name = Column(String(200), nullable=False)
+    service_name = Column(String(100), index=True)
+    span_kind = Column(String(20), default="server")
+    start_time = Column(DateTime, nullable=False, index=True)
+    end_time = Column(DateTime)
+    duration_ms = Column(Float)
+    status = Column(String(20), default="ok")
+    tags = Column(JSON)
+    logs = Column(JSON)
+    created_at = Column(
+        DateTime, default=lambda: datetime.now(timezone.utc), index=True
+    )
+    trace = relationship(
+        "Trace",
+        back_populates="spans",
+        primaryjoin="foreign(Span.trace_id) == Trace.trace_id",
+    )
-    request = relationship("CapturedRequest", back_populates="exceptions")
+class SpanRelation(Base):
+    __tablename__ = "radar_span_relations"
+    id = Column(
+        Integer, Sequence("radar_span_relations_id_seq"), primary_key=True, index=True
+    )
+    trace_id = Column(String(32), index=True)
+    parent_span_id = Column(String(16), index=True)
+    child_span_id = Column(String(16), index=True)
+    depth = Column(Integer, default=0)
+    created_at = Column(DateTime, default=lambda: datetime.now(timezone.utc))
+class BackgroundTask(Base):
+    __tablename__ = "radar_background_tasks"
+    id = Column(
+        Integer, Sequence("radar_background_tasks_id_seq"), primary_key=True, index=True
+    )
+    task_id = Column(String(36), unique=True, index=True, nullable=False)
+    request_id = Column(String(36), index=True, nullable=True)
+    name = Column(String(200), nullable=False)
+    status = Column(
+        String(20), default="pending", index=True
+    )  # pending, running, completed, failed
+    start_time = Column(DateTime, index=True)
+    end_time = Column(DateTime)
+    duration_ms = Column(Float)
+    error = Column(Text)
+    created_at = Column(
+        DateTime, default=lambda: datetime.now(timezone.utc), index=True
+    )

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

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