sf-veritas 0.9.7__py3-none-any.whl

sf_veritas/patches/web_frameworks/quart.py

@@ -0,0 +1,155 @@
+"""
+• SFTracingQuartASGIMiddleware: pulls SAILFISH_TRACING_HEADER into your ContextVar.
+• patch_quart(): wraps Quart.__init__, installs middleware and
+  redefines .route so that each user-land view emits one NetworkHop.
+"""
+
+import asyncio
+import inspect
+import sysconfig
+from functools import lru_cache, wraps
+from typing import Any, Callable, Set, Tuple
+
+from ...constants import SAILFISH_TRACING_HEADER
+from ...custom_excepthook import custom_excepthook
+from ...regular_data_transmitter import NetworkHopsTransmitter
+from ...thread_local import get_or_set_sf_trace_id
+from .utils import _is_user_code, _unwrap_user_func  # your cached helpers
+
+try:
+    import quart
+    from quart.app import Quart
+    from quart.wrappers import Response
+except ImportError:
+    # Quart not installed → no-op
+    def patch_quart():
+        return
+
+else:
+    # ──────────────────────────────────────────────────────────
+    # 1) ASGI middleware to preserve SAILFISH_TRACING_HEADER in ContextVar
+    # ──────────────────────────────────────────────────────────
+    class SFTracingQuartASGIMiddleware:
+        """Wraps the ASGI app so inbound SAILFISH_TRACING_HEADER → ContextVar."""
+
+        def __init__(self, app):
+            self.app = app
+
+        async def __call__(self, scope, receive, send):
+            if scope.get("type") == "http":
+                for name, val in scope.get("headers", []):
+                    if name.decode("utf-8").lower() == SAILFISH_TRACING_HEADER.lower():
+                        get_or_set_sf_trace_id(
+                            val.decode("utf-8"), is_associated_with_inbound_request=True
+                        )
+                        break
+            await self.app(scope, receive, send)
+
+    # ──────────────────────────────────────────────────────────
+    # 2) Monkey-patch Quart to install our middleware + route wrapper
+    # ──────────────────────────────────────────────────────────
+    def patch_quart():
+        """
+        Patches Quart.__init__ so that:
+        1. the internal ASGI app is wrapped by SFTracingQuartASGIMiddleware
+            (captures inbound SAILFISH_TRACING_HEADER);
+        2. every @app.route handler is wrapped to emit one NetworkHop *and*
+            funnel **all** exceptions—*including* quart.exceptions.HTTPException—
+            through custom_excepthook, then re-raise so Quart still returns the
+            correct HTTP response.
+        """
+
+        original_init = Quart.__init__
+
+        def patched_init(self, *args, **kwargs):
+            # 1) call original ctor
+            original_init(self, *args, **kwargs)
+
+            # 2) wrap ASGI app for header propagation
+            self.asgi_app = SFTracingQuartASGIMiddleware(self.asgi_app)
+
+            # 3) patch .route decorator
+            original_route = self.route
+
+            def tracing_route(self, rule: str, **options):
+                """
+                Replacement for @app.route(...) → decorator(fn).
+                """
+                decorator = original_route(rule, **options)
+
+                def wrapper(fn: Callable[..., Any]) -> Callable[..., Any]:
+                    # unwrap any decorators/closures to find real user fn
+                    user_fn = _unwrap_user_func(fn)
+
+                    code = getattr(user_fn, "__code__", None)
+                    if not code or not _is_user_code(code.co_filename):
+                        return decorator(fn)  # non-user code → no hop/exception capture
+
+                    if getattr(user_fn, "__module__", "").startswith("strawberry"):
+                        return decorator(fn)  # skip Strawberry views
+
+                    filename = code.co_filename
+                    line_no = code.co_firstlineno
+                    name = user_fn.__name__
+                    sent: Set[Tuple[str, int]] = set()  # one-time hop flag
+
+                    # choose async vs sync wrapper based on endpoint type
+                    if asyncio.iscoroutinefunction(fn):
+
+                        @wraps(fn)
+                        async def wrapped(*a, **k):
+                            key = (filename, line_no)
+                            if key not in sent:
+                                _, session_id = get_or_set_sf_trace_id()
+                                NetworkHopsTransmitter().send(
+                                    session_id=session_id,
+                                    line=str(line_no),
+                                    column="0",
+                                    name=name,
+                                    entrypoint=filename,
+                                )
+                                sent.add(key)
+                            try:
+                                return await fn(*a, **k)
+                            except (
+                                Exception
+                            ) as exc:  # capture ALL exceptions, incl. HTTPException
+                                custom_excepthook(type(exc), exc, exc.__traceback__)
+                                raise
+
+                        wrapped_fn = wrapped
+                    else:
+
+                        @wraps(fn)
+                        def wrapped(*a, **k):
+                            key = (filename, line_no)
+                            if key not in sent:
+                                _, session_id = get_or_set_sf_trace_id()
+                                NetworkHopsTransmitter().send(
+                                    session_id=session_id,
+                                    line=str(line_no),
+                                    column="0",
+                                    name=name,
+                                    entrypoint=filename,
+                                )
+                                sent.add(key)
+                            try:
+                                return fn(*a, **k)
+                            except Exception as exc:
+                                custom_excepthook(type(exc), exc, exc.__traceback__)
+                                raise
+
+                        wrapped_fn = wrapped
+
+                    return decorator(wrapped_fn)
+
+                return wrapper
+
+            # rebind the instance's route method
+            self.route = tracing_route.__get__(self, Quart)
+
+        # apply the patch once
+        Quart.__init__ = patched_init
+
+    # expose the patch function
+    __all__ = ["patch_quart"]

sf_veritas/patches/web_frameworks/robyn.py

@@ -0,0 +1,114 @@
+import functools
+import inspect
+import sys
+import sysconfig
+from functools import lru_cache
+from typing import Any, Callable, Optional, Set
+
+from ...constants import SAILFISH_TRACING_HEADER
+from ...custom_excepthook import custom_excepthook
+from ...env_vars import SF_DEBUG
+from ...regular_data_transmitter import NetworkHopsTransmitter
+from ...thread_local import get_or_set_sf_trace_id
+from ..constants import supported_network_verbs as HTTP_METHODS
+from .utils import _is_user_code, _unwrap_user_func
+
+_stdlib = sysconfig.get_paths()["stdlib"]
+
+
+@lru_cache(maxsize=512)
+def _is_user_code(path: Optional[str]) -> bool:
+    """
+    True only for “application” files (not stdlib or site-packages).
+    """
+    if not path or path.startswith("<"):
+        return False
+    if path.startswith(_stdlib):
+        return False
+    if "site-packages" in path or "dist-packages" in path:
+        return False
+    return True
+
+
+def patch_robyn():
+    """
+    Monkey-patch robyn.Robyn so that every Robyn() instance
+    auto-wraps route handlers with header propagation and network‐hop emission.
+    Safe no-op if Robyn isn't installed.
+    """
+    try:
+        import robyn
+    except ImportError:
+        return
+
+    for method_name in HTTP_METHODS:
+        if not hasattr(robyn.Robyn, method_name):
+            continue
+
+        original_factory = getattr(robyn.Robyn, method_name)
+
+        def make_patched(factory):
+            @functools.wraps(factory)
+            def patched(self, path: str, *args, **kwargs):
+                # original decorator returned by Robyn
+                decorator = factory(self, path, *args, **kwargs)
+
+                def custom_decorator(fn):
+                    real_fn = _unwrap_user_func(fn)
+
+                    @functools.wraps(fn)
+                    async def wrapped_handler(request, *a, **kw):
+                        # ──────────────────────────────────────────────────────────
+                        # 1) Capture inbound trace header
+                        # ──────────────────────────────────────────────────────────
+                        hdr = getattr(request, "headers", {}).get(
+                            SAILFISH_TRACING_HEADER
+                        )
+                        if hdr:
+                            get_or_set_sf_trace_id(
+                                hdr, is_associated_with_inbound_request=True
+                            )
+
+                        # ──────────────────────────────────────────────────────────
+                        # 2) Emit a single NetworkHop (user code only)
+                        # ──────────────────────────────────────────────────────────
+                        filename = real_fn.__code__.co_filename
+                        if _is_user_code(filename):
+                            line_no = real_fn.__code__.co_firstlineno
+                            _, session_id = get_or_set_sf_trace_id()
+
+                            if SF_DEBUG:
+                                print(
+                                    f"[[RobynHop]] {real_fn.__name__} @ {filename}:{line_no} "
+                                    f"session={session_id}",
+                                    log=False,
+                                )
+
+                            NetworkHopsTransmitter().send(
+                                session_id=session_id,
+                                line=str(line_no),
+                                column="0",
+                                name=real_fn.__name__,
+                                entrypoint=filename,
+                            )
+
+                        # ──────────────────────────────────────────────────────────
+                        # 3) Run user handler and funnel ANY exception (including
+                        #    robyn.HTTPException) through custom_excepthook
+                        # ──────────────────────────────────────────────────────────
+                        try:
+                            return await real_fn(request, *a, **kw)
+                        except Exception as exc:  # noqa: BLE001
+                            # Fast path: let custom_excepthook decide deduplication
+                            custom_excepthook(type(exc), exc, exc.__traceback__)
+                            raise  # Re-raise so Robyn still returns proper error
+
+                    # Register wrapped_handler in place of the original
+                    return decorator(wrapped_handler)
+
+                return custom_decorator
+
+            return patched
+
+        # bind a fresh patched_factory for each HTTP method
+        setattr(robyn.Robyn, method_name, make_patched(original_factory))

sf_veritas/patches/web_frameworks/sanic.py

@@ -0,0 +1,120 @@
+import inspect
+import sysconfig
+from functools import lru_cache
+
+from ...constants import SAILFISH_TRACING_HEADER
+from ...custom_excepthook import custom_excepthook
+from ...env_vars import SF_DEBUG
+from ...regular_data_transmitter import NetworkHopsTransmitter
+from ...thread_local import get_or_set_sf_trace_id
+from .utils import _is_user_code, _unwrap_user_func
+
+
+def patch_sanic():
+    """
+    If Sanic is installed, monkey-patch Sanic.__init__ so every app:
+      1) request middleware: pulls SAILFISH_TRACING_HEADER → ContextVar
+      2) response middleware: emits exactly one NetworkHop from the
+         first user-land frame of the handler that just ran.
+    Safe no-op if Sanic isn't present.
+    """
+    print("[[patch_sanic]] patching sanic...", log=False)
+    try:
+        from sanic import Sanic
+    except ImportError:
+        return
+    print("[[patch_sanic]] patching sanic...about to start", log=False)
+
+    # ----------------------------------------------------------------- #
+    # Patch __init__: install two middleware
+    # ----------------------------------------------------------------- #
+    orig_init = Sanic.__init__
+
+    def patched_init(self, *args, **kwargs):
+        """
+        After the original Sanic app is created we attach:
+        • request-middleware – capture `SAILFISH_TRACING_HEADER`
+        • response-middleware – emit one NetworkHop
+        • *NEW* universal exception handler – funnels every Exception
+          (including Sanic HTTP errors) through `custom_excepthook`
+          and then delegates to Sanic's default error handling chain.
+        """
+        # ---------------------------------------------------------------- #
+        # Let Sanic build the app normally
+        # ---------------------------------------------------------------- #
+        orig_init(self, *args, **kwargs)
+
+        # ─────────────────── 1) Inbound header capture ─────────────────── #
+        async def _push_trace_id(request):
+            hdr = request.headers.get(SAILFISH_TRACING_HEADER)
+            if hdr:
+                get_or_set_sf_trace_id(hdr, is_associated_with_inbound_request=True)
+
+        try:
+            self.register_middleware(_push_trace_id, attach_to="request")
+        except TypeError:  # Sanic<22 compatibility
+            self.register_middleware(_push_trace_id, "request")
+
+        # ─────────────────── 2) NetworkHop emission ────────────────────── #
+        async def _emit_hop(request, response):
+            handler = getattr(request, "route", None)
+            if not handler:
+                return
+            fn = getattr(handler, "handler", None)
+            if not fn:
+                return
+
+            real_fn = _unwrap_user_func(fn)
+            code = getattr(real_fn, "__code__", None)
+            path = getattr(code, "co_filename", None)
+            if not _is_user_code(path):
+                return
+
+            line_no = code.co_firstlineno
+            name = real_fn.__name__
+            _, session_id = get_or_set_sf_trace_id()  # already seeded
+
+            if SF_DEBUG:
+                print(
+                    f"[[Sanic-hop]] {name} ({path}:{line_no}) session={session_id}",
+                    log=False,
+                )
+
+            NetworkHopsTransmitter().send(
+                session_id=session_id,
+                line=str(line_no),
+                column="0",
+                name=name,
+                entrypoint=path,
+            )
+
+        try:
+            self.register_middleware(_emit_hop, attach_to="response")
+        except TypeError:
+            self.register_middleware(_emit_hop, "response")
+
+        # ─────────────────── 3) Universal exception hook  NEW ──────────── #
+        async def _capture_exception(request, exception):
+            """
+            Called for *any* exception – user errors, `abort|HTTPException`,
+            or Sanic-specific errors. We forward to `custom_excepthook`
+            and then fall back to Sanic's default error handler so
+            behaviour is unchanged.
+            """
+            custom_excepthook(type(exception), exception, exception.__traceback__)
+            # Delegate to default handler to keep standard 4xx/5xx payload
+            response = request.app.error_handler.default(request, exception)
+            if inspect.isawaitable(response):
+                response = await response
+            return response
+
+        # Register for the base `Exception` class to catch everything
+        self.error_handler.add(Exception, _capture_exception)
+
+        if SF_DEBUG:
+            print(
+                "[[patch_sanic]] tracing middlewares + exception handler added",
+                log=False,
+            )
+
+    Sanic.__init__ = patched_init

sf_veritas/patches/web_frameworks/starlette.py

@@ -0,0 +1,144 @@
+"""
+• NetworkHopMiddleware: pure ASGI middleware that
+  - pulls SAILFISH_TRACING_HEADER → ContextVar
+  - installs a one-shot sys.setprofile tracer to catch the first user frame
+• patch_starlette(): idempotent—monkey-patches Starlette.__init__
+  to insert NetworkHopMiddleware on every app, before any routes fire.
+"""
+
+import inspect
+import sys
+import sysconfig
+from typing import Optional
+
+from ...constants import SAILFISH_TRACING_HEADER
+from ...custom_excepthook import custom_excepthook
+from ...env_vars import SF_DEBUG
+from ...regular_data_transmitter import NetworkHopsTransmitter
+from ...thread_local import get_or_set_sf_trace_id
+
+# Guard so we only patch once
+_starlette_patched = False
+
+try:
+    from starlette.applications import Starlette
+    from starlette.types import ASGIApp, Receive, Scope, Send
+except ImportError:
+
+    def patch_starlette():
+        return
+
+else:
+    # Pre-compute stdlib path for user-code checks
+    _STDLIB_PATH = sysconfig.get_paths()["stdlib"]
+
+    def _is_user_code(path: Optional[str] = None) -> bool:
+        """Return True if filename is in user code (not stdlib or site-packages)."""
+        if not path or path.startswith("<"):
+            return False
+        if path.startswith(_STDLIB_PATH):
+            return False
+        if "site-packages" in path or "dist-packages" in path:
+            return False
+        return True
+
+    def patch_starlette():
+        global _starlette_patched
+        if _starlette_patched:
+            return
+        _starlette_patched = True
+
+        # ----------------- profiler tracer factory -----------------
+        def _make_tracer(info_scope: Scope):
+            def tracer(frame, event, arg):
+                if event == "call" and _is_user_code(frame.f_code.co_filename):
+                    # First user frame: emit NetworkHop
+                    _, session_id = get_or_set_sf_trace_id()
+                    NetworkHopsTransmitter().send(
+                        session_id=session_id,
+                        line=str(frame.f_lineno),
+                        column="0",
+                        name=frame.f_code.co_name,
+                        entrypoint=frame.f_code.co_filename,
+                    )
+                    # Stop profiling this request
+                    sys.setprofile(None)
+                return tracer
+
+            return tracer
+
+        # ----------------- ASGI middleware -----------------
+        class NetworkHopMiddleware:
+            """
+            ASGI middleware that
+
+            1) Pulls the inbound SAILFISH_TRACING_HEADER → ContextVar.
+            2) Installs a one-shot ``sys.setprofile`` tracer to record the first
+            *user-land* frame in the request (sends a NetworkHop).
+            3) Funnels **all** exceptions - including Starlette/HTTPException - through
+            ``custom_excepthook`` before letting Starlette continue its normal
+            error handling.
+            """
+
+            def __init__(self, app: ASGIApp):
+                self.app = app
+
+            async def __call__(self, scope: Scope, receive: Receive, send: Send):
+                profiler_installed = False
+
+                if scope.get("type") == "http":
+                    # --- 1) header capture ---------------------------------------
+                    headers = {
+                        k.decode().lower(): v.decode()
+                        for k, v in scope.get("headers", [])
+                    }
+                    hdr = headers.get(SAILFISH_TRACING_HEADER.lower())
+                    if hdr:
+                        get_or_set_sf_trace_id(
+                            hdr, is_associated_with_inbound_request=True
+                        )
+
+                    # --- 2) install one-shot profiler ---------------------------
+                    import sys
+
+                    def _tracer(frame, event, arg):
+                        if event == "call" and _is_user_code(frame.f_code.co_filename):
+                            _, session_id = get_or_set_sf_trace_id()
+                            NetworkHopsTransmitter().send(
+                                session_id=session_id,
+                                line=str(frame.f_lineno),
+                                column="0",
+                                name=frame.f_code.co_name,
+                                entrypoint=frame.f_code.co_filename,
+                            )
+                            sys.setprofile(None)  # disable after first hop
+                        return _tracer
+
+                    sys.setprofile(_tracer)
+                    profiler_installed = True
+
+                # --- 3) run downstream app and trap *all* exceptions ------------
+                try:
+                    await self.app(scope, receive, send)
+                except Exception as exc:  # ← catches HTTPException too
+                    custom_excepthook(type(exc), exc, exc.__traceback__)
+                    raise  # Let Starlette build the 4xx/5xx response
+                finally:
+                    if profiler_installed:
+                        sys.setprofile(None)  # safety-net
+                    sys.setprofile(None)
+
+        # ----------------- patch Starlette init -----------------
+        original_init = Starlette.__init__
+
+        def patched_init(self, *args, **kwargs):
+            # 1) Run the original constructor
+            original_init(self, *args, **kwargs)
+
+            # 2) Insert our ASGI middleware at the top
+            self.add_middleware(NetworkHopMiddleware)
+
+            if SF_DEBUG:
+                print("[[patch_starlette]] Installed NetworkHopMiddleware", log=False)
+
+        Starlette.__init__ = patched_init