sf-veritas 0.9.7__py3-none-any.whl

sf_veritas/patches/web_frameworks/strawberry.py

@@ -0,0 +1,269 @@
+import inspect
+import logging
+import sys
+from importlib.util import find_spec
+from typing import Any, Callable, Set, Tuple
+
+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 _is_user_code, _unwrap_user_func
+
+logger = logging.getLogger(__name__)
+
+# Track if Strawberry has already been patched to prevent multiple patches
+_is_strawberry_patched = False
+
+
+def get_extension():
+    from strawberry.extensions import SchemaExtension
+
+    class CustomErrorHandlingExtension(SchemaExtension):
+        def __init__(self, *, execution_context):
+            self.execution_context = execution_context
+
+        def on_request_start(self):
+            if SF_DEBUG:
+                print("Starting GraphQL request", log=False)
+
+        def on_request_end(self):
+            if SF_DEBUG:
+                print("Ending GraphQL request", log=False)
+            if not self.execution_context.errors:
+                return
+            for error in self.execution_context.errors:
+                if SF_DEBUG:
+                    print(f"Handling GraphQL error: {error}", log=False)
+                custom_excepthook(type(error), error, error.__traceback__)
+
+        def on_validation_start(self):
+            if SF_DEBUG:
+                print("Starting validation of GraphQL request", log=False)
+
+        def on_validation_end(self):
+            if SF_DEBUG:
+                print("Ending validation of GraphQL request", log=False)
+
+        def on_execution_start(self):
+            if SF_DEBUG:
+                print("Starting execution of GraphQL request", log=False)
+
+        def on_resolver_start(self, resolver, obj, info, **kwargs):
+            if SF_DEBUG:
+                print(f"Starting resolver {resolver.__name__}", log=False)
+
+        def on_resolver_end(self, resolver, obj, info, **kwargs):
+            if SF_DEBUG:
+                print(f"Ending resolver {resolver.__name__}", log=False)
+
+        def on_error(self, error: Exception):
+            if SF_DEBUG:
+                print(f"Handling error in resolver: {error}", log=False)
+            custom_excepthook(type(error), error, error.__traceback__)
+
+    return CustomErrorHandlingExtension
+
+
+def get_network_hop_extension() -> "type[SchemaExtension]":
+    """
+    Strawberry SchemaExtension that emits a collectNetworkHops mutation for the
+    *first* user-land frame executed inside every resolver (sync or async).
+    """
+
+    from strawberry.extensions import SchemaExtension
+
+    # --------------------------------------------------------------------- #
+    # Helper predicates
+    # --------------------------------------------------------------------- #
+    # Extended dig:  __wrapped__, closure cells *and* common attribute names
+    # --------------------------------------------------------------------- #
+    # Extension class
+    # --------------------------------------------------------------------- #
+    class NetworkHopExtension(SchemaExtension):
+        supports_sync = supports_async = True
+        _sent: Set[Tuple[str, int]] = set()  # class-level: de-dupe per request
+
+        # ---------------- internal emit helper ---------------- #
+        @staticmethod
+        def _emit(frame, info):
+            filename, line_no, func_name = (
+                frame.f_code.co_filename,
+                frame.f_lineno,
+                frame.f_code.co_name,
+            )
+            if (filename, line_no) in NetworkHopExtension._sent:
+                return
+            _, session_id = get_or_set_sf_trace_id()
+            if SF_DEBUG:
+                print(
+                    f"[[NetworkHopExtension]] SEND → {func_name} "
+                    f"({filename}:{line_no}) session={session_id}",
+                    log=False,
+                )
+            NetworkHopsTransmitter().send(
+                session_id=session_id,
+                line=str(line_no),
+                column="0",
+                name=func_name,
+                entrypoint=filename,
+            )
+
+        # ---------------- tracer factory ---------------- #
+        def _make_tracer(self, info):
+            def tracer(frame, event, arg):
+                if event.startswith("c_"):
+                    return
+                if event == "call":
+                    if _is_user_code(frame.f_code.co_filename):
+
+                        self._emit(frame, info)
+                        sys.setprofile(None)
+                        return
+                    return tracer  # keep tracing until we hit user code
+
+            return tracer
+
+        # ---------------- wrappers ---------------- #
+        def resolve(self, _next, root, info, *args, **kwargs):
+            user_fn = _unwrap_user_func(_next)
+            tracer = self._make_tracer(info)
+            sys.setprofile(tracer)
+            try:
+                return _next(root, info, *args, **kwargs)
+            finally:
+                sys.setprofile(None)  # safety-net
+
+        async def resolve_async(self, _next, root, info, *args, **kwargs):
+            user_fn = _unwrap_user_func(_next)
+            tracer = self._make_tracer(info)
+            sys.setprofile(tracer)
+            try:
+                return await _next(root, info, *args, **kwargs)
+            finally:
+                sys.setprofile(None)
+
+    return NetworkHopExtension
+
+
+def patch_strawberry_module(strawberry):
+    """Patch Strawberry to ensure exceptions go through the custom excepthook."""
+    global _is_strawberry_patched
+    if _is_strawberry_patched:
+        if SF_DEBUG:
+            print(
+                "[[DEBUG]] Strawberry has already been patched, skipping. [[/DEBUG]]",
+                log=False,
+            )
+        return
+
+    try:
+        # Backup the original execute method from Strawberry
+        original_execute = strawberry.execution.execute.execute
+
+        async def custom_execute(*args, **kwargs):
+            try:
+                if SF_DEBUG:
+                    print(
+                        "[[DEBUG]] Executing patched Strawberry execute function. [[/DEBUG]]",
+                        log=False,
+                    )
+                return await original_execute(*args, **kwargs)
+            except Exception as e:
+                if SF_DEBUG:
+                    print(
+                        "[[DEBUG]] Intercepted exception in Strawberry execute. [[/DEBUG]]",
+                        log=False,
+                    )
+                # Invoke custom excepthook globally
+                sys.excepthook(type(e), e, e.__traceback__)
+                raise
+
+        # Replace Strawberry's execute function with the patched version
+        strawberry.execution.execute.execute = custom_execute
+        _is_strawberry_patched = True
+        if SF_DEBUG:
+            print(
+                "[[DEBUG]] Successfully patched Strawberry execute function. [[/DEBUG]]",
+                log=False,
+            )
+    except Exception as error:
+        if SF_DEBUG:
+            print(
+                f"[[DEBUG]] Failed to patch Strawberry: {error}. [[/DEBUG]]", log=False
+            )
+
+
+class CustomImportHook:
+    """Import hook to intercept the import of 'strawberry' modules."""
+
+    def find_spec(self, fullname, path, target=None):
+        global _is_strawberry_patched
+        if fullname == "strawberry" and not _is_strawberry_patched:
+            if SF_DEBUG:
+                print(
+                    f"[[DEBUG]] Intercepting import of {fullname}. [[/DEBUG]]",
+                    log=False,
+                )
+            return find_spec(fullname)
+        if fullname.startswith("strawberry_django"):
+            return None  # Let default import handle strawberry_django
+
+    def exec_module(self, module):
+        if SF_DEBUG:
+            print(
+                f"[[DEBUG]] Executing module: {module.__name__}. [[/DEBUG]]", log=False
+            )
+        # Execute the module normally
+        module_spec = module.__spec__
+        if module_spec and module_spec.loader:
+            module_spec.loader.exec_module(module)
+        # Once strawberry is loaded, patch it
+        if module.__name__ == "strawberry" and not _is_strawberry_patched:
+            patch_strawberry_module(module)
+
+
+def patch_strawberry_schema():
+    """Patch strawberry.Schema to include both Sailfish and NetworkHop extensions by default."""
+    try:
+        import strawberry
+
+        original_schema_init = strawberry.Schema.__init__
+
+        def patched_schema_init(self, *args, extensions=None, **kwargs):
+            if extensions is None:
+                extensions = []
+
+            # Add the custom error handling extension
+            sailfish_ext = get_extension()
+            if sailfish_ext not in extensions:
+                extensions.append(sailfish_ext)
+
+            # Add the network hop extension
+            hop_ext = get_network_hop_extension()
+            if hop_ext not in extensions:
+                extensions.append(hop_ext)
+
+            # Call the original constructor
+            original_schema_init(self, *args, extensions=extensions, **kwargs)
+
+            if SF_DEBUG:
+                print(
+                    "[[DEBUG]] Patched strawberry.Schema to include Sailfish & NetworkHop extensions. [[/DEBUG]]",
+                    log=False,
+                )
+
+        # Apply the patch
+        strawberry.Schema.__init__ = patched_schema_init
+
+        if SF_DEBUG:
+            print(
+                "[[DEBUG]] Successfully patched strawberry.Schema. [[/DEBUG]]",
+                log=False,
+            )
+    except ImportError:
+        if SF_DEBUG:
+            print(
+                "[[DEBUG]] Strawberry is not installed. Skipping schema patching. [[/DEBUG]]",
+                log=False,
+            )

sf_veritas/patches/web_frameworks/tornado.py

@@ -0,0 +1,129 @@
+import inspect
+import site
+import sysconfig
+from functools import lru_cache
+from typing import Any, Callable, 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
+
+
+def patch_tornado():
+    """
+    Monkey-patch tornado.web.RequestHandler so that every request:
+
+      1. Propagates SAILFISH_TRACING_HEADER into the ContextVar.
+      2. Emits ONE NetworkHop when user-land verb handler starts.
+      3. Funnels *all* exceptions—including tornado.web.HTTPError—through
+         custom_excepthook before Tornado's own error machinery runs.
+
+    Safe no-op if Tornado isn't installed.
+    """
+    try:
+        import tornado.web
+    except ImportError:  # Tornado not installed
+        return
+
+    # --------------------------------------------------------------- #
+    # a)  Header capture + hop emission (prepare) – unchanged logic
+    # --------------------------------------------------------------- #
+    original_prepare = tornado.web.RequestHandler.prepare
+
+    def patched_prepare(self, *args, **kwargs):
+        # -- 1) Header propagation
+        header_val = self.request.headers.get(SAILFISH_TRACING_HEADER)
+        if header_val:
+            get_or_set_sf_trace_id(header_val, is_associated_with_inbound_request=True)
+
+        # -- 2) Emit hop once per request for the actual HTTP verb handler
+        method_name = self.request.method.lower()
+        handler_fn = getattr(self, method_name, None)
+
+        if callable(handler_fn):
+            module = getattr(handler_fn, "__module__", "")
+            if not module.startswith("strawberry"):
+                real_fn = _unwrap_user_func(handler_fn)
+                code_obj = getattr(real_fn, "__code__", None)
+                if code_obj and _is_user_code(code_obj.co_filename):
+                    key = (code_obj.co_filename, code_obj.co_firstlineno)
+                    if key not in SailfishHandlerPatch._sent:
+                        _, session_id = get_or_set_sf_trace_id()
+                        if SF_DEBUG:
+                            print(
+                                f"[[TornadoHop]] {real_fn.__name__} "
+                                f"({code_obj.co_filename}:{code_obj.co_firstlineno}) "
+                                f"session={session_id}",
+                                log=False,
+                            )
+                        NetworkHopsTransmitter().send(
+                            session_id=session_id,
+                            line=str(code_obj.co_firstlineno),
+                            column="0",
+                            name=real_fn.__name__,
+                            entrypoint=code_obj.co_filename,
+                        )
+                        SailfishHandlerPatch._sent.add(key)
+
+        return original_prepare(self, *args, **kwargs)
+
+    tornado.web.RequestHandler.prepare = patched_prepare
+
+    # --------------------------------------------------------------- #
+    # b)  Exception capture – patch _execute and write_error
+    # --------------------------------------------------------------- #
+    original_execute = tornado.web.RequestHandler._execute
+    original_write_error = tornado.web.RequestHandler.write_error
+
+    async def patched_execute(self, *args, **kwargs):
+        try:
+            return await original_execute(self, *args, **kwargs)
+        except Exception as exc:  # HTTPError included
+            custom_excepthook(type(exc), exc, exc.__traceback__)
+            raise  # let Tornado handle 500/4xx
+
+    def patched_write_error(self, status_code, **kwargs):
+        """
+        Tornado calls write_error for HTTPError and uncaught exceptions.
+        Capture the exception (when provided) before rendering.
+        """
+        exc_info = kwargs.get("exc_info")
+        if exc_info and isinstance(exc_info, tuple) and exc_info[1]:
+            exc_type, exc_val, exc_tb = exc_info
+            custom_excepthook(exc_type, exc_val, exc_tb)
+        # Fallback: still call original renderer
+        return original_write_error(self, status_code, **kwargs)
+
+    tornado.web.RequestHandler._execute = patched_execute
+    tornado.web.RequestHandler.write_error = patched_write_error
+
+
+class SailfishHandlerPatch:
+    """
+    Helper to hold our per-request dedupe set.
+    We clear this once per IOLoop iteration via on_finish().
+    """
+
+    _sent: Set[Tuple[str, int]] = set()
+
+    @staticmethod
+    def clear_sent():
+        SailfishHandlerPatch._sent.clear()
+
+
+# Hook into on_finish to reset dedupe for the next request
+try:
+    import tornado.web
+
+    original_on_finish = tornado.web.RequestHandler.on_finish
+
+    def patched_on_finish(self):
+        SailfishHandlerPatch.clear_sent()
+        return original_on_finish(self)
+
+    tornado.web.RequestHandler.on_finish = patched_on_finish
+except ImportError:
+    pass

sf_veritas/patches/web_frameworks/utils.py

@@ -0,0 +1,55 @@
+import inspect
+import sysconfig
+from typing import Any, Callable, Optional, Set
+
+_stdlib = sysconfig.get_paths()["stdlib"]
+
+
+_ATTR_CANDIDATES = (
+    "resolver",
+    "func",
+    "python_func",
+    "_resolver",
+    "wrapped_func",
+    "__func",
+)
+
+
+def _is_user_code(path: Optional[str] = None) -> bool:
+    return (
+        bool(path)
+        and not path.startswith(_stdlib)
+        and "site-packages" not in path
+        and "dist-packages" not in path
+        and not path.startswith("<")
+    )
+
+
+def _unwrap_user_func(fn: Callable[..., Any]) -> Callable[..., Any]:
+    """Unwrap decorators & closures until we find your user function."""
+    seen: Set[int] = set()
+    queue = [fn]
+    while queue:
+        current = queue.pop()
+        if id(current) in seen:
+            continue
+        seen.add(id(current))
+
+        if inspect.isfunction(current) and _is_user_code(current.__code__.co_filename):
+            return current
+
+        inner = getattr(current, "__wrapped__", None)
+        if inner:
+            queue.append(inner)
+
+        for attr in _ATTR_CANDIDATES:
+            attr_val = getattr(current, attr, None)
+            if inspect.isfunction(attr_val):
+                queue.append(attr_val)
+
+        for cell in getattr(current, "__closure__", []) or []:
+            cc = cell.cell_contents
+            if inspect.isfunction(cc):
+                queue.append(cc)
+
+    return fn  # fallback

sf_veritas/print_override.py

@@ -0,0 +1,13 @@
+import builtins
+
+from .custom_print import SF_DEBUG, custom_print
+
+
+def override_print():
+    if hasattr(builtins, "_original_print"):
+        return
+    # Save the original print function
+    builtins._original_print = builtins.print
+
+    # Override the built-in print function
+    builtins.print = custom_print