sf-veritas 0.9.7__py3-none-any.whl

sf_veritas/patches/web_frameworks/django.py

@@ -0,0 +1,307 @@
+import asyncio
+import inspect
+
+try:
+    from django.utils.deprecation import MiddlewareMixin
+except ImportError:
+    MiddlewareMixin = object  # fallback for non-Django environments
+
+from ...constants import SAILFISH_TRACING_HEADER
+from ...custom_excepthook import custom_excepthook
+from ...env_vars import PRINT_CONFIGURATION_STATUSES, SF_DEBUG
+from ...regular_data_transmitter import NetworkHopsTransmitter
+from ...thread_local import get_or_set_sf_trace_id
+
+
+def find_and_modify_output_wrapper():
+    if PRINT_CONFIGURATION_STATUSES:
+        print("find_and_modify_output_wrapper", log=False)
+    try:
+        import django
+        import django.core.management.base
+
+        base_path = inspect.getfile(django.core.management.base)
+        setup_code = """
+from sf_veritas.custom_output_wrapper import get_custom_output_wrapper_django
+
+get_custom_output_wrapper_django()
+"""
+
+        with open(base_path, "r+") as f:
+            content = f.read()
+            if "get_custom_output_wrapper_django()" not in content:
+                f.write("\n" + setup_code)
+                if PRINT_CONFIGURATION_STATUSES:
+                    print("Custom output wrapper injected into Django.", log=False)
+    except ModuleNotFoundError:
+        if PRINT_CONFIGURATION_STATUSES:
+            print(
+                "Django not found; skipping output-wrapper injection",
+                log=False,
+            )
+    except PermissionError:
+        if PRINT_CONFIGURATION_STATUSES:
+            print(
+                "Permission error injecting output wrapper; skipping",
+                log=False,
+            )
+    if PRINT_CONFIGURATION_STATUSES:
+        print("find_and_modify_output_wrapper...DONE", log=False)
+
+
+class SailfishMiddleware(MiddlewareMixin):
+    """
+    • process_request   – capture inbound SAILFISH_TRACING_HEADER header.
+    • process_view      – emit one NetworkHop per view (skip Strawberry).
+    • __call__ override – last-chance catcher for uncaught exceptions.
+    • got_request_exception signal – main hook for 500-level errors.
+    • process_exception – fallback for view-raised exceptions.
+    """
+
+    # ------------------------------------------------------------------ #
+    # 0 | Signal registration (called once at server start-up)
+    # ------------------------------------------------------------------ #
+    def __init__(self, get_response):
+        super().__init__(get_response)
+
+        # Attach to Django's global exception signal so we ALWAYS
+        # see real exceptions that become HTTP-500 responses.
+        from django.core.signals import got_request_exception
+
+        got_request_exception.disconnect(  # avoid dupes on reload
+            self._on_exception_signal, dispatch_uid="sf_veritas_signal"
+        )
+        got_request_exception.connect(
+            self._on_exception_signal,
+            weak=False,
+            dispatch_uid="sf_veritas_signal",
+        )
+
+    # ------------------------------------------------------------------ #
+    # 1 | Signal handler  ← FIXED
+    # ------------------------------------------------------------------ #
+    def _on_exception_signal(self, sender, request, **kwargs):
+        """
+        Handle django.core.signals.got_request_exception.
+
+        The signal doesn't pass the exception object; per Django's own
+        implementation (and Sentry's approach) we fetch it from
+        sys.exc_info().
+        """
+        import sys
+
+        exc_type, exc_value, exc_tb = sys.exc_info()
+
+        if SF_DEBUG:
+            print(
+                f"[[SailfishMiddleware._on_exception_signal]] "
+                f"exc_value={exc_value!r}",
+                log=False,
+            )
+
+        if exc_value:
+            custom_excepthook(exc_type, exc_value, exc_tb)
+
+    # ------------------------------------------------------------------ #
+    # 2 | Last-chance wrapper (rarely triggered in WSGI but free)
+    # ------------------------------------------------------------------ #
+    def __call__(self, request):
+        try:
+            return super().__call__(request)
+        except Exception as exc:
+            custom_excepthook(type(exc), exc, exc.__traceback__)
+            raise  # preserve default Django 500
+
+    # ------------------------------------------------------------------ #
+    # 3 | Header capture
+    # ------------------------------------------------------------------ #
+    def process_request(self, request):
+        header_key = f"HTTP_{SAILFISH_TRACING_HEADER.upper().replace('-', '_')}"
+        inbound = request.META.get(header_key)
+        get_or_set_sf_trace_id(inbound, is_associated_with_inbound_request=True)
+        if SF_DEBUG:
+            print(
+                f"[[SailfishMiddleware.process_request]] "
+                f"key={header_key}, inbound={inbound}",
+                log=False,
+            )
+
+    # ------------------------------------------------------------------ #
+    # 4 | Network-hop emission  (unchanged)
+    # ------------------------------------------------------------------ #
+    def process_view(self, request, view_func, view_args, view_kwargs):
+        module = getattr(view_func, "__module__", "")
+        if module.startswith("strawberry"):
+            return None
+
+        code = getattr(view_func, "__code__", None)
+        if not code:
+            return None
+
+        fname, lno = code.co_filename, code.co_firstlineno
+        hop_key = (fname, lno)
+
+        sent = getattr(request, "_sf_hops_sent", set())
+        if hop_key not in sent:
+            _, session_id = get_or_set_sf_trace_id()
+            NetworkHopsTransmitter().send(
+                session_id=session_id,
+                line=str(lno),
+                column="0",
+                name=view_func.__name__,
+                entrypoint=fname,
+            )
+            sent.add(hop_key)
+            setattr(request, "_sf_hops_sent", sent)
+
+    # ------------------------------------------------------------------ #
+    # 5 | View-level exception hook (unchanged)
+    # ------------------------------------------------------------------ #
+    def process_exception(self, request, exception):
+        print("[[SailfishMiddleware.process_exception]]", log=False)
+        custom_excepthook(type(exception), exception, exception.__traceback__)
+
+
+# --------------------------------------------------------------------------- #
+# Helper – patch django.core.wsgi.get_wsgi_application once
+# --------------------------------------------------------------------------- #
+# --------------------------------------------------------------------------- #
+# Helper – patch django.core.wsgi.get_wsgi_application once
+# --------------------------------------------------------------------------- #
+def _patch_get_wsgi_application() -> None:
+    """
+    Replace ``django.core.wsgi.get_wsgi_application`` with a wrapper that:
+
+    1. Runs ``django.setup()`` (as the original does),
+    2. **Then** injects ``SailfishMiddleware`` into *settings.MIDDLEWARE*
+       *after* settings are configured but *before* the first ``WSGIHandler``
+       is built,
+    3. Wraps the returned handler in our ``CustomExceptionMiddleware`` so we
+       still have a last-chance catcher outside Django's stack.
+
+    This mirrors the flow used by Sentry's Django integration.
+    """
+    try:
+        from django.core import wsgi as _wsgi_mod
+    except ImportError:  # pragma: no cover
+        return
+
+    if getattr(_wsgi_mod, "_sf_patched", False):
+        return  # idempotent
+
+    _orig_get_wsgi = _wsgi_mod.get_wsgi_application
+    _MW_PATH = "sf_veritas.patches.web_frameworks.django.SailfishMiddleware"
+
+    def _sf_get_wsgi_application(*args, **kwargs):
+        # --- Step 1: exactly replicate original behaviour -----------------
+        import django
+
+        django.setup(set_prefix=False)  # configures settings & apps
+
+        # --- Step 2: inject middleware *now* (settings are configured) ----
+        from django.conf import settings
+
+        if (
+            hasattr(settings, "MIDDLEWARE")
+            and isinstance(settings.MIDDLEWARE, list)
+            and _MW_PATH not in settings.MIDDLEWARE
+        ):
+            settings.MIDDLEWARE.insert(0, _MW_PATH)
+
+        # --- Step 3: build handler and wrap for last-chance exceptions ----
+        from django.core.handlers.wsgi import WSGIHandler
+        from sf_veritas.patches.web_frameworks.django import CustomExceptionMiddleware
+
+        handler = WSGIHandler()
+        return CustomExceptionMiddleware(handler)
+
+    _wsgi_mod.get_wsgi_application = _sf_get_wsgi_application
+    _wsgi_mod._sf_patched = True
+
+
+def patch_django_middleware() -> None:
+    """
+    Public entry-point called by ``setup_interceptors``.
+
+    • Inserts ``SailfishMiddleware`` for *already-configured* settings
+      (run-server or ASGI).
+    • Patches ``get_wsgi_application`` so *future* WSGI handlers created
+      by third-party code inherit the middleware without relying on a
+      configured settings object at import time.
+    """
+
+    try:
+        from django.conf import settings
+        from django.core.exceptions import ImproperlyConfigured
+    except ImportError:  # Django not installed
+        return
+
+    _MW_PATH = "sf_veritas.patches.web_frameworks.django.SailfishMiddleware"
+
+    # ---------- If settings are *already* configured, patch immediately ---
+    try:
+        if settings.configured and isinstance(
+            getattr(settings, "MIDDLEWARE", None), list
+        ):
+            if _MW_PATH not in settings.MIDDLEWARE:
+                settings.MIDDLEWARE.insert(0, _MW_PATH)
+    except ImproperlyConfigured:
+        # Settings not yet configured – safe to ignore; the WSGI patch below
+        # will handle insertion once ``django.setup()`` runs.
+        pass
+
+    # ---------- Always patch get_wsgi_application (idempotent) ------------
+    _patch_get_wsgi_application()
+
+    if SF_DEBUG:
+        print(
+            "[[patch_django_middleware]] Sailfish Django integration ready", log=False
+        )
+
+
+class CustomExceptionMiddleware:
+    """
+    A universal last-chance exception wrapper that works for either
+    • ASGI call signature:   (scope, receive, send)  → coroutine
+    • WSGI call signature:   (environ, start_response) → iterable
+    Every un-handled exception is funneled through ``custom_excepthook`` once.
+    """
+
+    def __init__(self, app):
+        self.app = app
+
+    # ------------------------------------------------------------------ #
+    # Dispatcher – routes ASGI vs WSGI based on arity / argument shape
+    # ------------------------------------------------------------------ #
+    def __call__(self, *args, **kwargs):
+        if len(args) == 3:
+            # Heuristic: (scope, receive, send) for ASGI
+            return self._asgi_call(*args)  # returns coroutine
+        # Else assume classic WSGI: (environ, start_response)
+        return self._wsgi_call(*args)  # returns iterable
+
+    # ------------------------------------------------------------------ #
+    # ASGI branch
+    # ------------------------------------------------------------------ #
+    async def _asgi_call(self, scope, receive, send):
+        try:
+            await self.app(scope, receive, send)
+        except Exception as exc:  # noqa: BLE001
+            custom_excepthook(type(exc), exc, exc.__traceback__)
+            raise
+
+    # ------------------------------------------------------------------ #
+    # WSGI branch
+    # ------------------------------------------------------------------ #
+    def _wsgi_call(self, environ, start_response):
+        try:
+            return self.app(environ, start_response)
+        except Exception as exc:  # noqa: BLE001
+            custom_excepthook(type(exc), exc, exc.__traceback__)
+            raise
+
+    # ------------------------------------------------------------------ #
+    # Delegate attribute access so the wrapped app still behaves normally
+    # ------------------------------------------------------------------ #
+    def __getattr__(self, attr):
+        return getattr(self.app, attr)

sf_veritas/patches/web_frameworks/eve.py

@@ -0,0 +1,138 @@
+from functools import wraps
+from typing import Callable, Set, Tuple
+
+from ...constants import SAILFISH_TRACING_HEADER
+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  # shared helpers
+
+
+# ──────────────────────────────────────────────────────────────
+# Header propagation  (still one before_request handler)
+# ──────────────────────────────────────────────────────────────
+def _install_header_middleware(app):
+    from flask import request
+
+    @app.before_request
+    def _extract_sf_header():
+        rid = request.headers.get(SAILFISH_TRACING_HEADER)
+        if rid:
+            get_or_set_sf_trace_id(rid, is_associated_with_inbound_request=True)
+
+
+# ──────────────────────────────────────────────────────────────
+# Per-view hop wrapper
+# ──────────────────────────────────────────────────────────────
+def _hop_wrapper(view_fn: Callable):
+    """
+    Return a wrapped callable that fires NetworkHopsTransmitter.send()
+    once per request (de-duped via flask.g).
+    """
+    from flask import g
+
+    real_fn = _unwrap_user_func(view_fn)
+
+    # Skip Strawberry handlers – handled by Strawberry extension
+    if real_fn.__module__.startswith("strawberry"):
+        return view_fn
+
+    code = getattr(real_fn, "__code__", None)
+    if not code or not _is_user_code(code.co_filename):
+        return view_fn
+
+    hop_key = (code.co_filename, code.co_firstlineno)
+    fn_name = real_fn.__name__
+    filename = code.co_filename
+    line_no = code.co_firstlineno
+
+    @wraps(view_fn)
+    def _wrapped(*args, **kwargs):
+        _, session_id = get_or_set_sf_trace_id()
+
+        sent: Set[Tuple[str, int]] = getattr(g, "_sf_hops_sent", set())
+        if hop_key not in sent:
+            if SF_DEBUG:
+                print(
+                    f"[[SFTracingEve]] hop → {fn_name} "
+                    f"({filename}:{line_no}) session={session_id}",
+                    log=False,
+                )
+
+            NetworkHopsTransmitter().send(
+                session_id=session_id,
+                line=str(line_no),
+                column="0",
+                name=fn_name,
+                entrypoint=filename,
+            )
+            sent.add(hop_key)
+            g._sf_hops_sent = sent
+
+        return view_fn(*args, **kwargs)
+
+    return _wrapped
+
+
+def _patch_add_url_rule(cls):
+    """
+    Patch add_url_rule on *cls* (cls is Eve or Blueprint) so that the final
+    stored endpoint function is wrapped *after* Flask has done its own
+    bookkeeping.  This catches:
+      • Eve resource endpoints created internally via register_resource()
+      • Manual @app.route() decorators
+      • Blueprints, CBVs, etc.
+    """
+    original_add = cls.add_url_rule
+
+    def patched_add(
+        self, rule, endpoint=None, view_func=None, **options
+    ):  # noqa: ANN001
+        # let Eve/Flask register the route first
+        original_add(self, rule, endpoint=endpoint, view_func=view_func, **options)
+
+        ep = endpoint or (view_func and view_func.__name__)
+        if not ep:  # defensive
+            return
+
+        target = self.view_functions.get(ep)
+        if callable(target):
+            self.view_functions[ep] = _hop_wrapper(target)
+
+    cls.add_url_rule = patched_add
+
+
+# ──────────────────────────────────────────────────────────────
+# Public entry-point
+# ──────────────────────────────────────────────────────────────
+def patch_eve():
+    """
+    • Adds ContextVar propagation middleware
+    • Wraps every Eve endpoint (and Blueprint endpoints) to emit one hop
+    """
+    try:
+        import eve
+        from flask import Blueprint  # Eve relies on Flask blueprints
+    except ImportError:
+        return
+
+    # Guard against double-patching
+    if getattr(eve.Eve, "__sf_tracing_patched__", False):
+        return
+
+    # 1.  Patch Eve.add_url_rule *and* Blueprint.add_url_rule
+    _patch_add_url_rule(eve.Eve)
+    _patch_add_url_rule(Blueprint)
+
+    # 2.  Patch Eve.__init__ to install before_request middleware
+    original_init = eve.Eve.__init__
+
+    def patched_init(self, *args, **kwargs):
+        original_init(self, *args, **kwargs)
+        _install_header_middleware(self)
+
+    eve.Eve.__init__ = patched_init
+    eve.Eve.__sf_tracing_patched__ = True
+
+    if SF_DEBUG:
+        print("[[patch_eve]] header middleware + hop wrapper installed", log=False)

sf_veritas/patches/web_frameworks/falcon.py

@@ -0,0 +1,229 @@
+"""
+• SFTracingFalconMiddleware  – propagates SAILFISH_TRACING_HEADER → ContextVar.
+• per-responder wrapper      – emits ONE NetworkHop per request for
+  user-land Falcon responders (sync & async), skipping Strawberry.
+• patch_falcon()             – monkey-patches both falcon.App (WSGI) and
+  falcon.asgi.App (ASGI) so the above logic is automatic.
+
+This patch adds <1 µs overhead per request on CPython 3.11.
+"""
+
+from __future__ import annotations
+
+import functools
+import inspect
+from types import MethodType
+from typing import Any, Callable, List, Set, Tuple
+
+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  # shared helpers
+
+# ---------------------------------------------------------------------------
+# 1 | Context-propagation middleware
+# ---------------------------------------------------------------------------
+
+
+class SFTracingFalconMiddleware:
+    """Works for BOTH WSGI and ASGI flavours of Falcon."""
+
+    # synchronous apps
+    def process_request(self, req, resp):  # noqa: D401
+        hdr = req.get_header(SAILFISH_TRACING_HEADER)
+        if hdr:
+            get_or_set_sf_trace_id(hdr, is_associated_with_inbound_request=True)
+
+    # asynchronous apps
+    async def process_request_async(self, req, resp):  # noqa: D401
+        hdr = req.get_header(SAILFISH_TRACING_HEADER)
+        if hdr:
+            get_or_set_sf_trace_id(hdr, is_associated_with_inbound_request=True)
+
+
+# ---------------------------------------------------------------------------
+# 2 | Hop-emission helper
+# ---------------------------------------------------------------------------
+
+
+def _hop_once(
+    req, hop_key: Tuple[str, int], fname: str, lno: int, responder_name: str
+) -> None:
+    sent: Set[Tuple[str, int]] = getattr(req.context, "_sf_hops_sent", set())
+    if hop_key in sent:
+        return
+
+    _, session_id = get_or_set_sf_trace_id()
+    if SF_DEBUG:
+        print(
+            f"[[FalconHop]] {responder_name} ({fname}:{lno}) session={session_id}",
+            log=False,
+        )
+
+    NetworkHopsTransmitter().send(
+        session_id=session_id,
+        line=str(lno),
+        column="0",
+        name=responder_name,
+        entrypoint=fname,
+    )
+    sent.add(hop_key)
+    req.context._sf_hops_sent = sent
+
+
+def _make_wrapper(base_fn: Callable) -> Callable:
+    """Return a hop-emitting, exception-capturing wrapper around *base_fn*."""
+
+    real_fn = _unwrap_user_func(base_fn)
+
+    # Ignore non-user and Strawberry handlers
+    if real_fn.__module__.startswith("strawberry") or not _is_user_code(
+        real_fn.__code__.co_filename
+    ):
+        return base_fn
+
+    fname = real_fn.__code__.co_filename
+    lno = real_fn.__code__.co_firstlineno
+    hop_key = (fname, lno)
+    responder_name = real_fn.__name__
+
+    # ---------------- asynchronous responders ------------------------- #
+    if inspect.iscoroutinefunction(base_fn):
+
+        async def _async_wrapped(self, req, resp, *args, **kwargs):  # noqa: D401
+            _hop_once(req, hop_key, fname, lno, responder_name)
+            try:
+                return await base_fn(self, req, resp, *args, **kwargs)
+            except Exception as exc:  # catches falcon.HTTPError too
+                custom_excepthook(type(exc), exc, exc.__traceback__)
+                raise
+
+        return _async_wrapped
+
+    # ---------------- synchronous responders -------------------------- #
+    def _sync_wrapped(self, req, resp, *args, **kwargs):  # noqa: D401
+        _hop_once(req, hop_key, fname, lno, responder_name)
+        try:
+            return base_fn(self, req, resp, *args, **kwargs)
+        except Exception as exc:  # catches falcon.HTTPError too
+            custom_excepthook(type(exc), exc, exc.__traceback__)
+            raise
+
+    return _sync_wrapped
+
+
+# ---------------------------------------------------------------------------
+# 3 | Attach wrapper to every on_<METHOD> responder in a resource
+# ---------------------------------------------------------------------------
+
+
+def _wrap_resource(resource: Any) -> None:
+    for attr in dir(resource):
+        if not attr.startswith("on_"):
+            continue
+
+        handler = getattr(resource, attr)
+        if not callable(handler) or getattr(handler, "__sf_hop_wrapped__", False):
+            continue
+
+        base_fn = handler.__func__ if isinstance(handler, MethodType) else handler
+        wrapped_fn = _make_wrapper(base_fn)
+        setattr(wrapped_fn, "__sf_hop_wrapped__", True)
+
+        # Bind to the *instance* so Falcon passes (req, resp, …) correctly
+        bound = MethodType(wrapped_fn, resource)
+        setattr(resource, attr, bound)
+
+
+# ---------------------------------------------------------------------------
+# 4 | Middleware merge utility (unchanged from earlier patch)
+# ---------------------------------------------------------------------------
+
+
+def _middleware_pos(cls) -> int:
+    sig = inspect.signature(cls.__init__)
+    params = [p for p in sig.parameters.values() if p.name != "self"]
+    try:
+        return [p.name for p in params].index("middleware")
+    except ValueError:
+        return -1
+
+
+def _merge_middleware(args, kwargs, mw_pos):
+    pos = list(args)
+    kw = dict(kwargs)
+    existing, used = None, None
+
+    if "middleware" in kw:
+        existing = kw.pop("middleware")
+    if existing is None and mw_pos >= 0 and mw_pos < len(pos):
+        cand = pos[mw_pos]
+        # Not the Response class?
+        if not inspect.isclass(cand):
+            existing, used = cand, mw_pos
+    if existing is None and len(pos) == 1:
+        existing, used = pos[0], 0
+
+    merged: List[Any] = []
+    if existing is not None:
+        merged = list(existing) if isinstance(existing, (list, tuple)) else [existing]
+    merged.insert(0, SFTracingFalconMiddleware())
+
+    if used is not None:
+        pos[used] = merged
+    else:
+        kw["middleware"] = merged
+
+    return tuple(pos), kw
+
+
+# ---------------------------------------------------------------------------
+# 5 | Patch helpers
+# ---------------------------------------------------------------------------
+
+
+def _patch_app_class(app_cls) -> None:
+    mw_pos = _middleware_pos(app_cls)
+    orig_init = app_cls.__init__
+    orig_add = app_cls.add_route
+
+    @functools.wraps(orig_init)
+    def patched_init(self, *args, **kwargs):
+        new_args, new_kwargs = _merge_middleware(args, kwargs, mw_pos)
+        orig_init(self, *new_args, **new_kwargs)
+
+    def patched_add_route(self, uri_template, resource, **kwargs):
+        _wrap_resource(resource)
+        return orig_add(self, uri_template, resource, **kwargs)
+
+    app_cls.__init__ = patched_init
+    app_cls.add_route = patched_add_route
+
+
+# ---------------------------------------------------------------------------
+# 6 | Public entry point
+# ---------------------------------------------------------------------------
+
+
+def patch_falcon() -> None:
+    """Activate tracing for both WSGI and ASGI Falcon apps."""
+    try:
+        import falcon
+    except ImportError:  # pragma: no cover
+        return
+
+    # Patch synchronous WSGI app
+    _patch_app_class(falcon.App)
+
+    # Patch asynchronous ASGI app, if available
+    try:
+        from falcon.asgi import App as ASGIApp  # type: ignore
+
+        _patch_app_class(ASGIApp)
+    except ImportError:
+        pass
+
+    if SF_DEBUG:
+        print("[[patch_falcon]] Falcon tracing middleware installed", log=False)