sf-veritas 0.9.7__py3-none-any.whl

sf_veritas/patches/web_frameworks/async_websocket_consumer.py

@@ -0,0 +1,132 @@
+import inspect
+import sys
+import sysconfig
+from functools import lru_cache, wraps
+from typing import Any, Callable, Optional, Set, Tuple
+
+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
+from .utils import _unwrap_user_func
+
+# ────────────────────────────────────────────────────
+# User-code predicate: skip stdlib & site-packages
+# ────────────────────────────────────────────────────
+_STDLIB = sysconfig.get_paths()["stdlib"]
+_SITE_TAGS = ("site-packages", "dist-packages")
+_SKIP_PREFIXES = (_STDLIB, "/usr/local/lib/python", "/usr/lib/python")
+
+
+@lru_cache(maxsize=512)
+def _is_user_code(path: Optional[str] = None) -> bool:
+    """True only for your application files."""
+    if not path or path.startswith("<"):
+        return False
+    for p in _SKIP_PREFIXES:
+        if path.startswith(p):
+            return False
+    return not any(tag in path for tag in _SITE_TAGS)
+
+
+# ────────────────────────────────────────────────────
+# Patch AsyncConsumer.__call__ to hook connect + receive
+# ────────────────────────────────────────────────────
+def patch_async_consumer_call():
+    """
+    Wraps AsyncConsumer.__call__ so that for each HTTP or WebSocket
+    connection:
+      1) SAILFISH_TRACING_HEADER → ContextVar
+      2) Emit a NetworkHop at first user frame in websocket_connect
+      3) Dynamically wrap websocket_receive to emit a hop on first message
+      4) Forward any exception to custom_excepthook
+    """
+    try:
+        from channels.consumer import AsyncConsumer  # type: ignore
+
+        orig_call = AsyncConsumer.__call__
+    except:
+        if PRINT_CONFIGURATION_STATUSES:
+            print("Channels AsyncConsumer not found; skipping patch", log=False)
+        return
+
+    if PRINT_CONFIGURATION_STATUSES:
+        print("Patching AsyncConsumer.__call__ for NetworkHops", log=False)
+
+    @wraps(orig_call)
+    async def custom_call(self, scope, receive, send):
+        # — Propagate header into ContextVar —
+        header_val = None
+        if scope["type"] in ("http", "websocket"):
+            for name, val in scope.get("headers", []):
+                if name.lower() == SAILFISH_TRACING_HEADER.lower().encode():
+                    header_val = val.decode("utf-8")
+                    break
+        get_or_set_sf_trace_id(header_val, is_associated_with_inbound_request=True)
+
+        # — One-shot profiler for websocket_connect inside orig_call —
+        def tracer(frame, event, _arg):
+            if event == "call":
+                fn_path = frame.f_code.co_filename
+                if _is_user_code(fn_path):
+                    _, session = get_or_set_sf_trace_id()
+                    NetworkHopsTransmitter().send(
+                        session_id=session,
+                        line=str(frame.f_lineno),
+                        column="0",
+                        name=frame.f_code.co_name,
+                        entrypoint=fn_path,
+                    )
+                    sys.setprofile(None)
+                    return None
+            return tracer
+
+        sys.setprofile(tracer)
+
+        # — Dynamically wrap this instance's websocket_receive —
+        recv = getattr(self, "websocket_receive", None)
+        if recv and hasattr(self, "websocket_receive"):
+
+            @wraps(recv)
+            async def wrapped_receive(event):
+                # Emit first user-frame hop inside receive
+                def recv_tracer(fr, ev, _a):
+                    if ev == "call":
+                        path = fr.f_code.co_filename
+                        if _is_user_code(path):
+                            _, sess = get_or_set_sf_trace_id()
+                            NetworkHopsTransmitter().send(
+                                session_id=sess,
+                                line=str(fr.f_lineno),
+                                column="0",
+                                name=fr.f_code.co_name,
+                                entrypoint=path,
+                            )
+                            sys.setprofile(None)
+                            return None
+                    return recv_tracer
+
+                sys.setprofile(recv_tracer)
+                try:
+                    return await recv(event)
+                finally:
+                    sys.setprofile(None)
+
+            # override on this instance only
+            setattr(self, "websocket_receive", wrapped_receive)
+
+        # — Call through to original (handles connect, receive, disconnect) —
+        try:
+            await orig_call(self, scope, receive, send)
+        except Exception as exc:
+            custom_excepthook(type(exc), exc, exc.__traceback__)
+            raise
+        finally:
+            sys.setprofile(None)
+
+    # Apply the patch
+    AsyncConsumer.__call__ = custom_call
+
+    if PRINT_CONFIGURATION_STATUSES:
+        print("AsyncConsumer.__call__ patched successfully", log=False)

sf_veritas/patches/web_frameworks/blacksheep.py

@@ -0,0 +1,107 @@
+"""
+Context-var propagation  +  first-hop NetworkHop emission.
+"""
+
+# ------------------------------------------------------------------ #
+# Shared helpers (same as Django/FastAPI utils)
+# ------------------------------------------------------------------ #
+import inspect
+import sysconfig
+from functools import lru_cache
+from typing import Any, Callable, Optional, 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
+
+
+# ------------------------------------------------------------------ #
+# Middleware
+# ------------------------------------------------------------------ #
+async def _sf_tracing_middleware(request, handler):
+    """
+    BlackSheep function-style middleware that:
+    1. Propagates trace-id from SAILFISH_TRACING_HEADER.
+    2. Emits one NetworkHop for the first user-land handler.
+    3. Captures *any* exception (HTTPException, RuntimeError, etc.),
+       passes it to `custom_excepthook`, then re-raises so BlackSheep
+       can continue its normal error handling.
+    """
+
+    # 1. Header → ContextVar
+    raw_hdr = request.headers.get_first(SAILFISH_TRACING_HEADER.encode())
+    if raw_hdr:
+        try:
+            hdr_val = raw_hdr.decode()
+        except UnicodeDecodeError:
+            hdr_val = str(raw_hdr)
+        get_or_set_sf_trace_id(hdr_val, is_associated_with_inbound_request=True)
+
+    # 2. Hop capture (once per request)
+    if not getattr(request, "_sf_hop_sent", False):
+        user_fn = _unwrap_user_func(handler)
+        if (
+            inspect.isfunction(user_fn)
+            and _is_user_code(user_fn.__code__.co_filename)
+            and not user_fn.__module__.startswith("strawberry")
+        ):
+            filename = user_fn.__code__.co_filename
+            line_no = user_fn.__code__.co_firstlineno
+            fn_name = user_fn.__name__
+            _, session_id = get_or_set_sf_trace_id()
+
+            if SF_DEBUG:
+                print(
+                    f"[[BlackSheepHop]] {fn_name} ({filename}:{line_no}) "
+                    f"session={session_id}",
+                    log=False,
+                )
+
+            NetworkHopsTransmitter().send(
+                session_id=session_id,
+                line=str(line_no),
+                column="0",
+                name=fn_name,
+                entrypoint=filename,
+            )
+        request._sf_hop_sent = True  # mark as done
+
+    # 3. Continue down the chain and capture exceptions
+    try:
+        return await handler(request)
+    except Exception as exc:  # ← includes HTTPException & friends
+        custom_excepthook(type(exc), exc, exc.__traceback__)
+        raise  # Let BlackSheep build the response
+
+
+# ------------------------------------------------------------------ #
+# Monkey-patch Application.__init__
+# ------------------------------------------------------------------ #
+def patch_blacksheep():
+    """
+    Injects the tracing middleware into every BlackSheep Application.
+    Safe no-op if BlackSheep isn't installed or already patched.
+    """
+    try:
+        from blacksheep import Application
+    except ImportError:
+        return
+
+    if getattr(Application, "__sf_tracing_patched__", False):
+        return  # already patched
+
+    original_init = Application.__init__
+
+    def patched_init(self, *args, **kwargs):
+        original_init(self, *args, **kwargs)
+        # Put our middleware first so we run before user middlewares
+        self.middlewares.insert(0, _sf_tracing_middleware)
+
+    Application.__init__ = patched_init
+    Application.__sf_tracing_patched__ = True
+
+    if SF_DEBUG:
+        print("[[patch_blacksheep]] tracing middleware installed", log=False)

sf_veritas/patches/web_frameworks/bottle.py

@@ -0,0 +1,142 @@
+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  # cached helpers
+
+
+# ------------------------------------------------------------------------------------
+# 1. Hop-capturing plugin ----------------------------------------------------------------
+# ------------------------------------------------------------------------------------
+class _SFTracingPlugin:
+    """Bottle plugin (API v2) – wraps each route callback exactly once."""
+
+    name = "sf_network_hop"
+    api = 2
+
+    def apply(self, callback, route):
+        # 1. Resolve real user function
+        real_fn = _unwrap_user_func(callback)
+        mod = real_fn.__module__
+        code = getattr(real_fn, "__code__", None)
+
+        # 2. Skip library frames and Strawberry GraphQL handlers
+        if (
+            not code
+            or not _is_user_code(code.co_filename)
+            or mod.startswith("strawberry")
+        ):
+            return callback  # no wrapping
+
+        filename, line_no, fn_name = (
+            code.co_filename,
+            code.co_firstlineno,
+            real_fn.__name__,
+        )
+        hop_key = (filename, line_no)
+
+        # 3. Wrapper that emits exactly one hop per request
+        from bottle import request  # local to avoid hard dep
+
+        def _wrapped(*args, **kwargs):  # noqa: ANN001
+            sent = request.environ.setdefault("_sf_hops_sent", set())
+            if hop_key not in sent:
+                _, session_id = get_or_set_sf_trace_id()
+
+                if SF_DEBUG:
+                    print(
+                        f"[[SFTracingBottle]] 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)
+
+            return callback(*args, **kwargs)
+
+        return _wrapped
+
+
+# ------------------------------------------------------------------------------------
+# 2. Context-propagation hook ---------------------------------------------------------
+# ------------------------------------------------------------------------------------
+def _install_before_request(app):
+    from bottle import request
+
+    @app.hook("before_request")
+    def _extract_sf_trace_id():
+        if hdr := request.headers.get(SAILFISH_TRACING_HEADER):
+            get_or_set_sf_trace_id(hdr, is_associated_with_inbound_request=True)
+
+
+# ------------------------------------------------------------------------------------
+# NEW: Global error-handler wrapper for Bottle
+# ------------------------------------------------------------------------------------
+def _install_error_handler(app):
+    """
+    Replace ``app.default_error_handler`` so *any* exception or HTTPError
+    (including those raised via ``abort()`` or ``HTTPError(status=500)``)
+    is reported to ``custom_excepthook`` before Bottle builds the response.
+
+    Bottle always funnels errors through this function, regardless of debug
+    mode. See Bottle docs on *Error Handlers*.
+    """
+    original_handler = app.default_error_handler
+
+    def _sf_error_handler(error):
+        # Forward full traceback (HTTPError keeps it on .__traceback__)
+        custom_excepthook(type(error), error, getattr(error, "__traceback__", None))
+        return original_handler(error)
+
+    app.default_error_handler = _sf_error_handler
+
+
+# ------------------------------------------------------------------------------------
+# 3. Public patch function – call this once at startup
+# ------------------------------------------------------------------------------------
+def patch_bottle():
+    """
+    • Adds before_request header propagation.
+    • Installs NetworkHop plugin (covers all current & future routes).
+    • Wraps default_error_handler so exceptions (incl. HTTPError 500) are captured.
+    Safe no-op if Bottle is not installed or already patched.
+    """
+    try:
+        import bottle
+    except ImportError:  # Bottle absent
+        return
+
+    if getattr(bottle.Bottle, "__sf_tracing_patched__", False):
+        return
+
+    # ---- patch Bottle.__init__ ----------------------------------------------------
+    original_init = bottle.Bottle.__init__
+
+    def patched_init(self, *args, **kwargs):
+        original_init(self, *args, **kwargs)
+
+        # ContextVar propagation
+        _install_before_request(self)
+
+        # Install hop plugin (Plugin API v2 ― applies to all routes, past & future)
+        self.install(_SFTracingPlugin())
+
+        # Exception capture (HTTPError 500 or any uncaught Exception)
+        _install_error_handler(self)
+
+        if SF_DEBUG:
+            print(
+                "[[patch_bottle]] tracing hook + plugin + error handler installed",
+                log=False,
+            )
+
+    bottle.Bottle.__init__ = patched_init
+    bottle.Bottle.__sf_tracing_patched__ = True

sf_veritas/patches/web_frameworks/cherrypy.py

@@ -0,0 +1,246 @@
+"""
+• Header propagation via Application.__call__               (unchanged).
+• Global CherryPy Tool (‘before_handler') → 1 NetworkHop    (fixed).
+"""
+
+import inspect
+import types
+from typing import Any, Callable, Iterable, Set
+
+from ...constants import SAILFISH_TRACING_HEADER
+from ...custom_excepthook import custom_excepthook  # ← NEW
+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
+
+# ------------------------------------------------------------------ #
+#  Robust un-wrapper (handles LateParamPageHandler, etc.)
+# ------------------------------------------------------------------ #
+_ATTR_CANDIDATES: Iterable[str] = (
+    "resolver",
+    "func",
+    "python_func",
+    "_resolver",
+    "wrapped_func",
+    "__func",
+    "callable",  # CherryPy handlers
+)
+
+
+def _unwrap_user_func(fn: Callable[..., Any]) -> Callable[..., Any]:
+    """
+    Walk through the layers of wrappers/decorators/handler objects around *fn*
+    and return the first plain Python *function* object that:
+        • lives in user-land code (per _is_user_code)
+        • has a real __code__ object.
+    The search is breadth-first and robust to cyclic references.
+    """
+    seen: Set[int] = set()
+    queue = [fn]
+
+    while queue:
+        current = queue.pop()
+        cid = id(current)
+        if cid in seen:
+            continue
+        seen.add(cid)
+
+        # ── 1. Bound methods (types.MethodType) ──────────────────────────
+        # CherryPy's LateParamPageHandler.callable is usually a bound method.
+        if isinstance(current, types.MethodType):
+            queue.append(current.__func__)
+            continue  # don't inspect the MethodType itself any further
+
+        # ── 2. Plain user function?  ─────────────────────────────────────
+        if inspect.isfunction(current) and _is_user_code(
+            getattr(current.__code__, "co_filename", "")
+        ):
+            return current
+
+        # ── 3. CherryPy PageHandler exposes `.callable` ──────────────────
+        target = getattr(current, "callable", None)
+        if callable(target):
+            queue.append(target)
+
+        # ── 4. functools.wraps chain (`__wrapped__`) ─────────────────────
+        wrapped = getattr(current, "__wrapped__", None)
+        if callable(wrapped):
+            queue.append(wrapped)
+
+        # ── 5. Other common wrapper attributes ───────────────────────────
+        for attr in _ATTR_CANDIDATES:
+            val = getattr(current, attr, None)
+            if callable(val):
+                queue.append(val)
+
+        # ── 6. Objects with a user-defined __call__ method ───────────────
+        call_attr = getattr(current, "__call__", None)
+        if (
+            callable(call_attr)
+            and inspect.isfunction(call_attr)
+            and _is_user_code(getattr(call_attr.__code__, "co_filename", ""))
+        ):
+            queue.append(call_attr)
+
+        # ── 7. Closure cells inside functions / inner scopes ─────────────
+        code_obj = getattr(current, "__code__", None)
+        clos = getattr(current, "__closure__", None)
+        if code_obj and clos:
+            for cell in clos:
+                cell_val = cell.cell_contents
+                if callable(cell_val):
+                    queue.append(cell_val)
+
+    # Fallback: return the original callable (likely framework code)
+    return fn
+
+
+# 2b.  Exception-capture tool  (runs *after* an error is detected)
+def _exception_capture_tool():
+    """
+    CherryPy calls the ‘before_error_response' hook whenever it is about to
+    finalise an error page, regardless of whether the error is a framework
+    HTTPError/HTTPRedirect or an uncaught Python exception.
+    We tap that hook and forward the traceback to Sailfish.
+    """
+    import sys
+
+    exc_type, exc_value, exc_tb = sys.exc_info()
+    if exc_value:
+        if SF_DEBUG:
+            print(
+                f"[[SFTracingCherryPy]] captured exception: {exc_value!r}",
+                log=False,
+            )
+        custom_excepthook(exc_type, exc_value, exc_tb)
+
+
+# ------------------------------------------------------------------ #
+#  Main patch entry-point
+# ------------------------------------------------------------------ #
+def patch_cherrypy():
+    """
+    • Propagate SAILFISH_TRACING_HEADER header → ContextVar.
+    • Emit one NetworkHop for the first *user* handler frame in each request.
+    • Capture **all** CherryPy exceptions (HTTPError, HTTPRedirect, uncaught
+      Python errors) and forward them to `custom_excepthook`.
+    """
+    try:
+        import cherrypy  # CherryPy may not be installed
+    except ImportError:
+        return
+
+    # ──────────────────────────────────────────────────────────────────
+    # 1.  Header propagation – monkey-patch Application.__call__
+    # ──────────────────────────────────────────────────────────────────
+    env_key = "HTTP_" + SAILFISH_TRACING_HEADER.upper().replace("-", "_")
+    if not getattr(cherrypy.Application, "__sf_hdr_patched__", False):
+        orig_call = cherrypy.Application.__call__
+
+        def patched_call(self, environ, start_response):
+            hdr = environ.get(env_key)
+            if hdr:
+                get_or_set_sf_trace_id(hdr, is_associated_with_inbound_request=True)
+            return orig_call(self, environ, start_response)
+
+        cherrypy.Application.__call__ = patched_call
+        cherrypy.Application.__sf_hdr_patched__ = True
+
+    # ──────────────────────────────────────────────────────────────────
+    # 2a.  Network-hop tool  (runs before each handler)
+    # ──────────────────────────────────────────────────────────────────
+    def _network_hop_tool():
+        req = cherrypy.serving.request  # thread-local current request
+        handler = getattr(req, "handler", None)
+        if not callable(handler):
+            return
+
+        real_fn = _unwrap_user_func(handler)
+        # Skip GraphQL (Strawberry) or non-user code
+        if real_fn.__module__.startswith("strawberry"):
+            return
+        code = getattr(real_fn, "__code__", None)
+        if not code or not _is_user_code(code.co_filename):
+            return
+
+        hop_key = (code.co_filename, code.co_firstlineno)
+        sent = getattr(req, "_sf_hops_sent", set())
+        if hop_key in sent:
+            return
+
+        _, session_id = get_or_set_sf_trace_id()
+        if SF_DEBUG:
+            print(
+                f"[[SFTracingCherryPy]] hop → {real_fn.__name__} "
+                f"({code.co_filename}:{code.co_firstlineno}) "
+                f"session={session_id}",
+                log=False,
+            )
+
+        NetworkHopsTransmitter().send(
+            session_id=session_id,
+            line=str(code.co_firstlineno),
+            column="0",
+            name=real_fn.__name__,
+            entrypoint=code.co_filename,
+        )
+        sent.add(hop_key)
+        req._sf_hops_sent = sent
+
+    if not hasattr(cherrypy.tools, "sf_network_hop"):
+        cherrypy.tools.sf_network_hop = cherrypy.Tool(
+            "before_handler", _network_hop_tool, priority=5
+        )
+
+    # ──────────────────────────────────────────────────────────────────
+    # 2b.  Exception-capture tool  (runs before error response)
+    # ──────────────────────────────────────────────────────────────────
+    def _exception_capture_tool():
+        import sys
+
+        exc_type, exc_value, exc_tb = sys.exc_info()
+        if exc_value:
+            if SF_DEBUG:
+                print(
+                    f"[[SFTracingCherryPy]] captured exception: {exc_value!r}",
+                    log=False,
+                )
+            custom_excepthook(exc_type, exc_value, exc_tb)
+
+    if not hasattr(cherrypy.tools, "sf_exception_capture"):
+        cherrypy.tools.sf_exception_capture = cherrypy.Tool(
+            "before_error_response", _exception_capture_tool, priority=100
+        )
+
+    # ──────────────────────────────────────────────────────────────────
+    # 3.  Enable both tools globally
+    # ──────────────────────────────────────────────────────────────────
+    cherrypy.config.update(
+        {
+            "tools.sf_network_hop.on": True,
+            "tools.sf_exception_capture.on": True,
+        }
+    )
+
+    # ──────────────────────────────────────────────────────────────────
+    # 4️⃣  Ensure every new Application inherits the tool settings
+    # ──────────────────────────────────────────────────────────────────
+    if not getattr(cherrypy.Application, "__sf_app_patched__", False):
+        orig_app_init = cherrypy.Application.__init__
+
+        def patched_app_init(self, root, script_name="", config=None):
+            config = config or {}
+            root_conf = config.setdefault("/", {})
+            root_conf.setdefault("tools.sf_network_hop.on", True)
+            root_conf.setdefault("tools.sf_exception_capture.on", True)
+            orig_app_init(self, root, script_name, config)
+
+        cherrypy.Application.__init__ = patched_app_init
+        cherrypy.Application.__sf_app_patched__ = True
+
+    if SF_DEBUG:
+        print(
+            "[[patch_cherrypy]] NetworkHop & Exception tools globally enabled",
+            log=False,
+        )