sf-veritas 0.10.3__cp311-cp311-manylinux_2_28_x86_64.whl

sf_veritas/exception_metaclass.py

@@ -0,0 +1,69 @@
+from abc import ABCMeta
+
+from .custom_excepthook import transmit_exception
+
+
+class ExceptionMeta(ABCMeta):
+    """
+    Metaclass to add `capture_even_if_caught` functionality to exceptions
+    and provide a `transmit_to_sailfish` method for all exceptions.
+    """
+
+    def __new__(cls, name, bases, dct):
+        # Wrap or define the `__init__` method
+        if "__init__" in dct:
+            original_init = dct["__init__"]
+
+            def wrapped_init(self, *args, **kwargs):
+                # Add the `capture_even_if_caught` attribute
+                self.capture_even_if_caught = kwargs.pop(
+                    "capture_even_if_caught", False
+                )
+                self._handled = False  # Ensure `_handled` is initialized
+                original_init(self, *args, **kwargs)
+
+            dct["__init__"] = wrapped_init
+        else:
+
+            def default_init(self, *args, **kwargs):
+                # Add the `capture_even_if_caught` attribute
+                self.capture_even_if_caught = kwargs.pop(
+                    "capture_even_if_caught", False
+                )
+                self._handled = False  # Ensure `_handled` is initialized
+                super(Exception, self).__init__(*args, **kwargs)
+
+            dct["__init__"] = default_init
+
+        # Add `transmit_to_sailfish` method to all exceptions
+        def transmit_to_sailfish(self, was_caught: bool = False):
+            """
+            Transmit this exception to Sailfish.
+            """
+            if not getattr(self, "_handled", False):
+                transmit_exception(type(self), self, self.__traceback__, was_caught)
+                setattr(
+                    self, "_handled", True
+                )  # Mark as handled to prevent duplication
+
+        dct["transmit_to_sailfish"] = transmit_to_sailfish
+
+        return super().__new__(cls, name, bases, dct)
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Intercept exception instantiation to handle `capture_even_if_caught`.
+        """
+        instance = super().__call__(*args, **kwargs)
+        # Automatically handle `capture_even_if_caught` exceptions
+        if getattr(instance, "capture_even_if_caught", False):
+            instance.transmit_to_sailfish()
+        return instance
+
+
+class PatchedException(Exception, metaclass=ExceptionMeta):
+    """
+    A patched version of the built-in Exception class with universal interception capabilities.
+    """
+
+    pass

sf_veritas/fast_frame_info.py

@@ -0,0 +1,116 @@
+"""
+Ultra-fast frame introspection using C extension.
+Falls back to Python if C extension is not available.
+"""
+
+import sysconfig
+from functools import lru_cache
+from typing import Optional, Tuple
+
+# Try to import C extension
+try:
+    from . import _sfframeinfo
+
+    _FAST_FRAME_OK = True
+except ImportError:
+    _sfframeinfo = None
+    _FAST_FRAME_OK = False
+
+# Fallback Python implementation
+_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_py(path: Optional[str]) -> bool:
+    """Python fallback for checking if path is user code."""
+    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)
+
+
+def get_code_info(func) -> Optional[Tuple[str, int, str]]:
+    """
+    Extract (filename, lineno, name) from a function object.
+    Returns None if not user code or extraction fails.
+
+    Uses C extension if available for ~10x speedup.
+    """
+    if _FAST_FRAME_OK:
+        try:
+            result = _sfframeinfo.get_code_info(func)
+            if result:
+                # Result is (filename, lineno, name, is_user)
+                return (result[0], result[1], result[2])
+            return None
+        except Exception:
+            pass  # Fall back to Python
+
+    # Python fallback
+    try:
+        code = getattr(func, "__code__", None)
+        if not code:
+            return None
+
+        filename = code.co_filename
+        if not _is_user_code_py(filename):
+            return None
+
+        return (filename, code.co_firstlineno, func.__name__)
+    except Exception:
+        return None
+
+
+def get_frame_info(frame) -> Optional[Tuple[str, int, str]]:
+    """
+    Extract (filename, lineno, name) from a frame object.
+    Returns None if not user code or extraction fails.
+
+    Uses C extension if available for ~10x speedup.
+    """
+    if _FAST_FRAME_OK:
+        try:
+            result = _sfframeinfo.get_frame_info(frame)
+            if result:
+                # Result is (filename, lineno, name, is_user)
+                return (result[0], result[1], result[2])
+            return None
+        except Exception:
+            pass  # Fall back to Python
+
+    # Python fallback
+    try:
+        code = frame.f_code
+        filename = code.co_filename
+        if not _is_user_code_py(filename):
+            return None
+
+        return (filename, frame.f_lineno, code.co_name)
+    except Exception:
+        return None
+
+
+def is_user_code_func(func) -> bool:
+    """
+    Quick check if function is user code.
+
+    Uses C extension if available for ~10x speedup.
+    """
+    if _FAST_FRAME_OK:
+        try:
+            return bool(_sfframeinfo.is_user_code_func(func))
+        except Exception:
+            pass
+
+    # Python fallback
+    try:
+        code = getattr(func, "__code__", None)
+        if not code:
+            return False
+        return _is_user_code_py(code.co_filename)
+    except Exception:
+        return False

sf_veritas/fast_network_hop.py

@@ -0,0 +1,293 @@
+"""
+Ultra-fast network hop sender using C extension with endpoint pre-registration.
+"""
+
+import os
+from logging import getLogger
+from typing import Optional, Tuple
+
+from .regular_data_transmitter import NetworkHopsTransmitter
+from .thread_local import is_network_recording_suppressed
+
+logger = getLogger(__name__)
+
+# Optional native fast path for network hops (C extension)
+# LAZY IMPORT: Don't import at module level to avoid circular import
+# Import will happen in _ensure_fast_networkhop_initialized() when first needed
+_sfnetworkhop = None
+_NETWORKHOP_FAST_OK = None  # None = not yet attempted, True = success, False = failed
+
+_FAST_NETWORKHOP_READY = False  # one-time guard for native networkhop init
+
+# GraphQL mutation string for network hops (with optional body/header capture)
+_COLLECT_NETWORKHOP_MUTATION = (
+    "mutation collectNetworkHops("
+    "$apiKey: String!,"
+    "$sessionId: String!,"
+    "$timestampMs: String!,"
+    "$line: String!,"
+    "$column: String!,"
+    "$name: String!,"
+    "$entrypoint: String!,"
+    "$route: String,"
+    "$queryParams: String,"
+    "$serviceUuid: String,"
+    "$requestHeaders: String,"
+    "$requestBody: String,"
+    "$responseHeaders: String,"
+    "$responseBody: String"
+    "){collectNetworkHops("
+    "apiKey:$apiKey,sessionId:$sessionId,timestampMs:$timestampMs,"
+    "line:$line,column:$column,name:$name,entrypoint:$entrypoint,"
+    "route:$route,queryParams:$queryParams,serviceUuid:$serviceUuid,requestHeaders:$requestHeaders,"
+    "requestBody:$requestBody,responseHeaders:$responseHeaders,"
+    "responseBody:$responseBody)}"
+)
+
+
+def _ensure_fast_networkhop_initialized() -> bool:
+    global _FAST_NETWORKHOP_READY, _sfnetworkhop, _NETWORKHOP_FAST_OK
+
+    SF_DEBUG = os.getenv("SF_DEBUG", "false").lower() == "true"
+
+    # PERFORMANCE: Skip network hop extension when testing network library only
+    if os.getenv("TESTING_NETWORK_LIBRARY_ONLY", "0") == "1":
+        if SF_DEBUG:
+            print(
+                "[[_ensure_fast_networkhop_initialized]] Network hop extension disabled (TESTING_NETWORK_LIBRARY_ONLY=1)",
+                log=False,
+            )
+        return False
+
+    # LAZY IMPORT: Try to import C extension on first use
+    if _NETWORKHOP_FAST_OK is None:
+        try:
+            from . import _sfnetworkhop as _sfnh_module
+
+            _sfnetworkhop = _sfnh_module
+            _NETWORKHOP_FAST_OK = True
+            if SF_DEBUG:
+                print(
+                    f"[[_ensure_fast_networkhop_initialized]] Successfully imported _sfnetworkhop C extension",
+                    log=False,
+                )
+        except Exception as e:
+            if SF_DEBUG:
+                print(
+                    f"[[_ensure_fast_networkhop_initialized]] Failed to import _sfnetworkhop C extension: {e}",
+                    log=False,
+                )
+            _sfnetworkhop = None
+            _NETWORKHOP_FAST_OK = False
+
+    if not _NETWORKHOP_FAST_OK:
+        if SF_DEBUG:
+            print(
+                f"[[_ensure_fast_networkhop_initialized]] C extension not available (_NETWORKHOP_FAST_OK=False)",
+                log=False,
+            )
+        return False
+
+    if _FAST_NETWORKHOP_READY:
+        if SF_DEBUG:
+            print(
+                f"[[_ensure_fast_networkhop_initialized]] Already initialized, returning True",
+                log=False,
+            )
+        return True
+
+    from . import app_config
+
+    endpoint = getattr(app_config, "_sailfish_graphql_endpoint", None)
+    api_key = getattr(app_config, "_sailfish_api_key", None)
+    service_uuid = getattr(app_config, "_service_uuid", None)
+    http2 = 1 if os.getenv("SF_NBPOST_HTTP2", "0") == "1" else 0
+
+    if SF_DEBUG:
+        print(
+            f"[[_ensure_fast_networkhop_initialized]] Config: endpoint={bool(endpoint)}, api_key={bool(api_key)}, service_uuid={bool(service_uuid)}",
+            log=False,
+        )
+
+    if not (endpoint and api_key and service_uuid):
+        if SF_DEBUG:
+            print(
+                f"[[_ensure_fast_networkhop_initialized]] Missing required config, returning False",
+                log=False,
+            )
+        return False
+
+    try:
+        if SF_DEBUG:
+            print(
+                f"[[_ensure_fast_networkhop_initialized]] Calling _sfnetworkhop.init() with url={endpoint}",
+                log=False,
+            )
+        ok = _sfnetworkhop.init(
+            url=endpoint,
+            query=_COLLECT_NETWORKHOP_MUTATION,
+            api_key=str(api_key),
+            service_uuid=str(service_uuid),
+            http2=http2,
+        )
+        _FAST_NETWORKHOP_READY = bool(ok)
+        if SF_DEBUG:
+            print(
+                f"[[_ensure_fast_networkhop_initialized]] _sfnetworkhop.init() returned {ok}, _FAST_NETWORKHOP_READY={_FAST_NETWORKHOP_READY}",
+                log=False,
+            )
+    except Exception as e:
+        if SF_DEBUG:
+            print(
+                f"[[_ensure_fast_networkhop_initialized]] _sfnetworkhop.init() raised exception: {e}",
+                log=False,
+            )
+        _FAST_NETWORKHOP_READY = False
+
+    return _FAST_NETWORKHOP_READY
+
+
+def register_endpoint(
+    line: str, column: str, name: str, entrypoint: str, route: str = None
+) -> int:
+    """
+    Register a web framework endpoint's invariant fields once.
+    Returns an endpoint_id usable with fast_send_network_hop_fast(...).
+
+    Args:
+        line: Line number where the endpoint is defined
+        column: Column number (typically "0")
+        name: Function name of the endpoint
+        entrypoint: File path where the endpoint is defined
+        route: Route pattern (e.g., "/api/users/{id}") - optional
+    """
+    SF_DEBUG = os.getenv("SF_DEBUG", "false").lower() == "true"
+
+    if SF_DEBUG:
+        print(
+            f"[[register_endpoint]] Called for {name} @ {entrypoint}:{line} (route={route})",
+            log=False,
+        )
+
+    if not _ensure_fast_networkhop_initialized():
+        if SF_DEBUG:
+            print(
+                f"[[register_endpoint]] _ensure_fast_networkhop_initialized() returned False, returning -1",
+                log=False,
+            )
+        return -1
+    try:
+        eid = _sfnetworkhop.register_endpoint(
+            line=line, column=column, name=name, entrypoint=entrypoint, route=route
+        )
+        if SF_DEBUG:
+            print(
+                f"[[register_endpoint]] _sfnetworkhop.register_endpoint() returned {eid}",
+                log=False,
+            )
+        return int(eid)
+    except Exception as e:
+        if SF_DEBUG:
+            print(
+                f"[[register_endpoint]] _sfnetworkhop.register_endpoint() raised exception: {e}",
+                log=False,
+            )
+        return -1
+
+
+def fast_send_network_hop_fast(
+    session_id: str,
+    endpoint_id: int,
+    raw_path: str = None,
+    raw_query_string: bytes = None,
+    request_headers: dict = None,
+    request_body: bytes = None,
+    response_headers: dict = None,
+    response_body: bytes = None,
+) -> None:
+    """
+    ULTRA-FAST PATH: Assumes initialization already happened (checked once at startup).
+    Optionally accepts request/response headers and body for capture.
+
+    Args:
+        session_id: Unique session identifier
+        endpoint_id: Pre-registered endpoint ID
+        raw_path: Optional actual request path (e.g., "/log") - passed to C for JSON escaping
+        raw_query_string: Optional raw query string bytes (e.g., b"foo=5") - passed to C for decoding/escaping
+        request_headers: Optional dict of request headers
+        request_body: Optional request body (bytes, str, or list of chunks)
+        response_headers: Optional dict of response headers
+        response_body: Optional response body (bytes, str, or list of chunks)
+    """
+    # Check if network recording is suppressed (e.g., by @skip_network_tracing decorator)
+    if is_network_recording_suppressed():
+        return
+
+    # HOT PATH OPTIMIZATION: Skip initialization check after first successful init
+    if not _FAST_NETWORKHOP_READY:
+        if not _ensure_fast_networkhop_initialized():
+            return
+
+    # Direct C call - no exception handling (C code is bulletproof)
+    if endpoint_id >= 0:
+        # Check if we need the extended path (with route/query/body/header capture)
+        has_extended_data = (
+            raw_path is not None
+            or raw_query_string is not None
+            or request_headers is not None
+            or request_body is not None
+            or response_headers is not None
+            or response_body is not None
+        )
+
+        if has_extended_data:
+            # Use extended capture path - C handles all decoding/escaping
+            _sfnetworkhop.networkhop_with_bodies(
+                session_id=session_id,
+                endpoint_id=endpoint_id,
+                raw_path=raw_path,
+                raw_query_string=raw_query_string,
+                request_headers=request_headers,
+                request_body=request_body,
+                response_headers=response_headers,
+                response_body=response_body,
+            )
+        else:
+            # Ultra-fast path with NO extra data
+            _sfnetworkhop.networkhop_fast(
+                session_id=session_id, endpoint_id=endpoint_id
+            )
+
+
+def fast_send_network_hop(
+    session_id: str, line: str, column: str, name: str, entrypoint: str
+):
+    """
+    Backward-compatible API (not used by patched FastAPI; kept for other callers).
+    """
+    # Check if network recording is suppressed (e.g., by @skip_network_tracing decorator)
+    if is_network_recording_suppressed():
+        return
+
+    if _ensure_fast_networkhop_initialized():
+        try:
+            # Old slow path in C; kept for compatibility
+            _sfnetworkhop.networkhop(
+                session_id=session_id,
+                line=line,
+                column=column,
+                name=name,
+                entrypoint=entrypoint,
+            )
+            return
+        except Exception:
+            pass
+
+    # Fallback to Python transmitter
+    NetworkHopsTransmitter().send(
+        session_id=session_id,
+        line=line,
+        column=column,
+        name=name,
+        entrypoint=entrypoint,
+    )

sf_veritas/frame_tools.py

@@ -0,0 +1,112 @@
+import sys
+from typing import Any, Iterable, List
+
+from .env_vars import (
+    SAILFISH_EXCEPTION_LOCALS_HIDE_DUNDER,
+    SAILFISH_EXCEPTION_LOCALS_HIDE_SELF,
+    SAILFISH_EXCEPTION_LOCALS_HIDE_SUNDER,
+    SAILFISH_EXCEPTION_LOCALS_TYPES_TO_IGNORE,
+)
+
+
+def import_type(module_name: str, type_name: str):
+    try:
+        exec(  # pylint: disable=exec-used
+            f"from {module_name} import {type_name}",
+            globals(),
+        )
+        return globals().get(type_name, None)
+    except ImportError:
+        return None
+
+
+def get_types_from_str(types_str: str) -> List[type]:
+    types_list = []
+    if types_str:
+        for type_path in types_str.split(","):
+            type_path_fixed = type_path.replace(" ", "")
+            module_name, type_name = type_path_fixed.rsplit(".", 1)
+            type_obj = import_type(module_name, type_name)
+            if type_obj:
+                types_list.append(type_obj)
+    return types_list
+
+
+EXCEPTION_LOCALS_TYPES_TO_IGNORE = get_types_from_str(
+    SAILFISH_EXCEPTION_LOCALS_TYPES_TO_IGNORE
+)
+
+
+def get_current_frame():
+    return sys._getframe(1)  # pylint: disable=protected-access
+
+
+def value_type_to_be_ignored(value: Any) -> bool:
+    return any(
+        isinstance(value, type_obj) for type_obj in EXCEPTION_LOCALS_TYPES_TO_IGNORE
+    )
+
+
+def key_is_str_to_be_ignored(
+    key: Any, locals_hide_self: bool, locals_hide_dunder: bool, locals_hide_sunder: bool
+) -> bool:
+    return (
+        (locals_hide_self and key == "self")
+        or (locals_hide_dunder and key.startswith("__"))
+        or (locals_hide_sunder and key.startswith("_"))
+    )
+
+
+def filter_locals(
+    iter_locals: Iterable[tuple[str, object]],
+    locals_hide_self: bool,
+    locals_hide_dunder: bool,
+    locals_hide_sunder: bool,
+) -> Iterable[tuple[str, object]]:
+    for key, value in iter_locals:
+        if not isinstance(key, str):
+            if value_type_to_be_ignored(value):
+                continue
+        else:
+            if key_is_str_to_be_ignored(
+                key, locals_hide_self, locals_hide_dunder, locals_hide_sunder
+            ):
+                continue
+            if value_type_to_be_ignored(value):
+                continue
+            if key in ("args", "field_args") and isinstance(value, list):
+                value = list(
+                    filter_locals(
+                        enumerate(value),
+                        locals_hide_self,
+                        locals_hide_dunder,
+                        locals_hide_sunder,
+                    )
+                )
+            if key in ("kwargs", "field_kwargs") and isinstance(value, dict):
+                value = dict(
+                    filter_locals(
+                        value.items(),
+                        locals_hide_self,
+                        locals_hide_dunder,
+                        locals_hide_sunder,
+                    )
+                )
+        yield key, value
+
+
+def get_locals(
+    iter_locals: Iterable[tuple[str, object]],
+    locals_hide_self: bool = SAILFISH_EXCEPTION_LOCALS_HIDE_SELF,
+    locals_hide_dunder: bool = SAILFISH_EXCEPTION_LOCALS_HIDE_DUNDER,
+    locals_hide_sunder: bool = SAILFISH_EXCEPTION_LOCALS_HIDE_SUNDER,
+) -> Iterable[tuple[str, object]]:
+    """Extract locals from an iterator of key pairs."""
+    if not (locals_hide_dunder or locals_hide_sunder):
+        yield from iter_locals
+        return
+    iter_locals_filtered = filter_locals(
+        iter_locals, locals_hide_self, locals_hide_dunder, locals_hide_sunder
+    )
+    for key, value in iter_locals_filtered:
+        yield key, value