sf-veritas 0.11.10__cp314-cp314-manylinux_2_28_x86_64.whl

sf_veritas/custom_print.py

@@ -0,0 +1,153 @@
+# sf_veritas/custom_print.py
+import builtins
+import logging
+import os
+import sys
+
+from . import app_config, transmit_exception_to_sailfish
+from .env_vars import SF_DEBUG
+from .thread_local import activate_reentrancy_guards_sys_stdout, get_or_set_sf_trace_id
+
+logger = logging.getLogger(__name__)
+
+# --- Optional native fast path (C extension) ---
+try:
+    from . import _sffastlog  # compiled extension
+
+    _FAST_OK = True
+except Exception:  # pragma: no cover
+    _sffastlog = None
+    _FAST_OK = False
+
+# Keep an internal one-time init guard for the print fast path
+_FAST_PRINT_READY = False
+
+# GraphQL mutation for print statements (must match your server exactly)
+# Mirrors interceptors.PrintInterceptor._QUERY variables/shape.
+_COLLECT_PRINT_MUTATION = """
+mutation CollectPrintStatements(
+  $apiKey: String!,
+  $serviceUuid: String!,
+  $sessionId: String!,
+  $contents: String!,
+  $reentrancyGuardPreactive: Boolean!,
+  $library: String!,
+  $timestampMs: String!,
+  $version: String!
+) {
+  collectPrintStatements(
+    apiKey: $apiKey,
+    serviceUuid: $serviceUuid,
+    sessionId: $sessionId,
+    contents: $contents,
+    reentrancyGuardPreactive: $reentrancyGuardPreactive,
+    library: $library,
+    timestampMs: $timestampMs,
+    version: $version
+  )
+}
+""".strip()
+
+
+def _ensure_fast_print_initialized() -> bool:
+    """
+    Lazily initialize the native print path. Safe to call every print; it becomes a no-op after the first success.
+    """
+    global _FAST_PRINT_READY
+
+    if not _FAST_OK or _FAST_PRINT_READY:
+        return _FAST_PRINT_READY
+
+    # We require the same config used elsewhere in the package
+    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)
+    library = getattr(app_config, "library", "sailfish-python")
+    version = getattr(app_config, "version", "0.0.0")
+    http2 = 1 if os.getenv("SF_NBPOST_HTTP2", "0") == "1" else 0
+
+    if not (endpoint and api_key and service_uuid):
+        # Not configured yet; stay in Python fallback for now
+        return False
+
+    try:
+        ok = _sffastlog.init_print(
+            url=endpoint,
+            query=_COLLECT_PRINT_MUTATION,
+            api_key=str(api_key),
+            service_uuid=str(service_uuid),
+            library=str(library),
+            version=str(version),
+            http2=http2,
+        )
+        _FAST_PRINT_READY = bool(ok)
+    except Exception:
+        _FAST_PRINT_READY = False
+
+    return _FAST_PRINT_READY
+
+
+def custom_print(*args, log=True, **kwargs):
+    """
+    Custom print function to intercept print statements.
+    - Writes to real stdout (sys.__stdout__) to avoid recursion.
+    - If log=True, ships the message via native _sffastlog.print_ when available,
+      otherwise falls back to the Python interceptor path: sys.stdout.print_interceptor.do_send(...)
+    """
+    # Tag in debug without creating extra strings when not needed
+    activate_reentrancy_guards_sys_stdout()
+
+    # Build the message ONCE; use it for both console and network
+    if args:
+        # Fastest reasonable join; avoid f-strings on the hot path
+        msg = " ".join(map(str, args))
+    else:
+        msg = ""
+
+    # Write to the actual stdout (not our wrapper)
+    if SF_DEBUG:
+        # Keep your debug envelope; avoid doing any extra work when not in debug
+        builtins._original_print(  # pylint: disable=protected-access
+            "[[CUSTOM-PRINT]]", msg, "[[/CUSTOM-PRINT]]", file=sys.__stdout__, **kwargs
+        )
+    else:
+        builtins._original_print(  # pylint: disable=protected-access
+            msg, file=sys.__stdout__, **kwargs
+        )
+
+    # Optionally ship to backend
+    if not log:
+        return
+    if not msg.strip():
+        return
+
+    # Get (or set) trace id exactly the way you do elsewhere
+    _, trace_id = get_or_set_sf_trace_id()
+
+    # Try native fast path; otherwise Python fallback via the PrintInterceptor attached to sys.stdout
+    if _ensure_fast_print_initialized():
+        try:
+            # Your GraphQL schema includes "reentrancyGuardPreactive" for prints;
+            # keep it false here to mirror previous behavior.
+            _sffastlog.print_(contents=msg, session_id=str(trace_id), preactive=0)
+            return
+        except Exception as e:
+            logger.exception(e)
+            transmit_exception_to_sailfish(e)
+            # fall back below
+            pass
+
+    # Python fallback (existing path)
+    # NOTE: sys.stdout is replaced by UnifiedInterceptor, which carries `print_interceptor`.
+    # If you’re not using UnifiedInterceptor in a given environment, ensure sys.stdout provides it.
+    try:
+        sys.stdout.print_interceptor.do_send((msg, trace_id), trace_id)
+    except Exception:
+        logger.exception(e)
+        transmit_exception_to_sailfish(e)
+        # As a last resort, swallow to keep print() non-fatal
+        if SF_DEBUG:
+            builtins._original_print(
+                "[[CUSTOM-PRINT-FALLBACK-ERROR]] failed to send print payload [[/CUSTOM-PRINT-FALLBACK-ERROR]]",
+                file=sys.__stdout__,
+            )

sf_veritas/django_app.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class SFVeritasConfig(AppConfig):
+    name = "sf_veritas"

sf_veritas/env_vars.py

@@ -0,0 +1,186 @@
+import logging
+import os
+
+from .utils import strtobool
+
+LITE_DEBUGGING = strtobool(os.getenv("LITE_DEBUGGING", "false"))
+SF_DEBUG = strtobool(os.getenv("SF_DEBUG", "false"))
+SF_DEBUG_TRACES = strtobool(os.getenv("SF_DEBUG_TRACES", "false"))
+SF_INTERNAL = strtobool(os.getenv("SF_INTERNAL", "false"))
+IS_SAILFISH_COLLECTOR = strtobool(os.getenv("IS_SAILFISH_COLLECTOR", "false"))
+STRAWBERRY_DEBUG = strtobool(os.getenv("STRAWBERRY_DEBUG", "false"))
+CAPTURE_STRAWBERRY_ERRORS_WITH_DATA = strtobool(
+    os.getenv("CAPTURE_STRAWBERRY_ERRORS_WITH_DATA", "false")
+)
+
+# Log filtering - regex pattern to suppress logs from being sent to Sailfish
+# Default: suppress successful (2xx) requests to /healthz and /graphql/ endpoints
+SF_LOG_IGNORE_REGEX = os.getenv(
+    "SF_LOG_IGNORE_REGEX", r"HTTP\s(POST|GET)\s(\/healthz|\/graphql\/)\s2\d{2}\s.*"
+)
+PRINT_CONFIGURATION_STATUSES = strtobool(
+    os.getenv("PRINT_CONFIGURATION_STATUSES", "false")
+)
+
+# Parent death signal control (Linux only)
+# Disables automatic registration for SIGTERM on parent process death
+# Useful if customers have custom signal handling that conflicts
+SF_DISABLE_PARENT_DEATH_SIGNAL = strtobool(
+    os.getenv("SF_DISABLE_PARENT_DEATH_SIGNAL", "false")
+)
+
+# Parent process monitoring (cross-platform)
+# Interval in milliseconds to check if parent process has died (orphaned)
+# Lower = faster detection, higher = less CPU overhead
+# Set to 0 to disable orphan detection
+SF_PARENT_MONITOR_INTERVAL_MS = int(
+    os.getenv("SF_PARENT_MONITOR_INTERVAL_MS", "100")  # Default: check every 100ms
+)
+
+# Exception Tools
+SAILFISH_EXCEPTION_LOCALS_HIDE_SELF = strtobool(
+    os.getenv("SAILFISH_EXCEPTION_LOCALS_HIDE_SELF", "true")
+)
+SAILFISH_EXCEPTION_LOCALS_HIDE_DUNDER = strtobool(
+    os.getenv("SAILFISH_EXCEPTION_LOCALS_HIDE_DUNDER", "true")
+)
+SAILFISH_EXCEPTION_LOCALS_HIDE_SUNDER = strtobool(
+    os.getenv("SAILFISH_EXCEPTION_LOCALS_HIDE_SUNDER", "true")
+)
+SAILFISH_EXCEPTION_STACK_DEPTH_LOCALS = int(
+    os.getenv("SAILFISH_EXCEPTION_STACK_DEPTH_LOCALS", "5")
+)
+SAILFISH_EXCEPTION_STACK_DEPTH_CODE_TRACE_DEPTH = os.getenv(
+    "SAILFISH_EXCEPTION_STACK_DEPTH_CODE_TRACE_DEPTH", "full"
+)
+SAILFISH_EXCEPTION_STACK_DEPTH_CODE_TRACE_TYPE = os.getenv(
+    "SAILFISH_EXCEPTION_STACK_DEPTH_CODE_TRACE_TYPE", "line"
+)
+SAILFISH_EXCEPTION_STACK_DEPTH_CODE_TRACE_TYPE_AT_OFFENSIVE_CALL = os.getenv(
+    "SAILFISH_EXCEPTION_STACK_DEPTH_CODE_TRACE_TYPE_AT_OFFENSIVE_CALL", "line"
+)
+SAILFISH_EXCEPTION_STACK_DEPTH_CODE_VALUES_AT_FULL_DEPTH_EXCEPTION = strtobool(
+    os.getenv(
+        "SAILFISH_EXCEPTION_STACK_DEPTH_CODE_VALUES_AT_FULL_DEPTH_EXCEPTION", "false"
+    )
+)
+SAILFISH_EXCEPTION_LOCALS_TYPES_TO_IGNORE = os.getenv(
+    "SAILFISH_EXCEPTION_LOCALS_TYPES_TO_IGNORE",
+    "strawberry.types.info.Info,graphql.type.definition.GraphQLResolveInfo,strawberry.field.StrawberryField",
+)
+SAILFISH_EXCEPTION_FETCH_BEYOND_OFFENDER_DEPTH = int(
+    os.getenv("SAILFISH_EXCEPTION_FETCH_BEYOND_OFFENDER_DEPTH", "3")
+)
+SAILFISH_EXCEPTION_FETCH_LOCALS_BEYOND_OFFENDER_DEPTH = int(
+    os.getenv(
+        "SAILFISH_EXCEPTION_FETCH_LOCALS_BEYOND_OFFENDER_DEPTH", "5"
+    )  # Sibyl launch - lower this
+)
+SAILFISH_EXCEPTION_FETCH_ABOVE_OFFENDER_DEPTH = int(
+    os.getenv(
+        "SAILFISH_EXCEPTION_FETCH_ABOVE_OFFENDER_DEPTH", "3"
+    )  # Sibyl launch - lower this
+)
+SAILFISH_EXCEPTION_FETCH_LOCALS_ABOVE_OFFENDER_DEPTH = int(
+    os.getenv(
+        "SAILFISH_EXCEPTION_FETCH_LOCALS_ABOVE_OFFENDER_DEPTH", "-1"
+    )  # Sibyl launch - lower this
+)
+SAILFISH_EXCEPTION_FETCH_ABOVE_OFFENDER_INCLUDE_INSTALLED_PACKAGES = strtobool(
+    os.getenv(
+        "SAILFISH_EXCEPTION_FETCH_ABOVE_OFFENDER_INCLUDE_INSTALLED_PACKAGES", "false"
+    )
+)
+
+
+def get_log_level():
+    if LOG_LEVEL_ENV_VAR == "DEBUG":
+        return logging.DEBUG
+    if LOG_LEVEL_ENV_VAR == "INFO":
+        return logging.INFO
+    if LOG_LEVEL_ENV_VAR == "WARN":
+        return logging.WARN
+    if LOG_LEVEL_ENV_VAR == "ERROR":
+        return logging.ERROR
+    return logging.CRITICAL
+
+
+LOG_LEVEL_ENV_VAR = os.getenv("LOG_LEVEL", "INFO")
+LOG_LEVEL = get_log_level()
+
+# Function Span Serialization
+SF_FUNCSPAN_PARSE_JSON_STRINGS = strtobool(
+    os.getenv("SF_FUNCSPAN_PARSE_JSON_STRINGS", "true")
+)
+
+# Function Span Capture Control - Granular configuration
+SF_FUNCSPAN_CAPTURE_ARGUMENTS = strtobool(
+    os.getenv("SF_FUNCSPAN_CAPTURE_ARGUMENTS", "true")
+)
+SF_FUNCSPAN_CAPTURE_RETURN_VALUE = strtobool(
+    os.getenv("SF_FUNCSPAN_CAPTURE_RETURN_VALUE", "true")
+)
+
+# Separate size limits for arguments vs return values
+SF_FUNCSPAN_ARG_LIMIT_MB = int(os.getenv("SF_FUNCSPAN_ARG_LIMIT_MB", "1"))
+SF_FUNCSPAN_RETURN_LIMIT_MB = int(os.getenv("SF_FUNCSPAN_RETURN_LIMIT_MB", "1"))
+
+# Auto-capture child functions (default: true)
+# When false, only capture top-level functions, not their children
+SF_FUNCSPAN_AUTOCAPTURE_ALL_CHILD_FUNCTIONS = strtobool(
+    os.getenv("SF_FUNCSPAN_AUTOCAPTURE_ALL_CHILD_FUNCTIONS", "true")
+)
+
+# Two-tier profiler control:
+# SF_ENABLE_PROFILER: Gates installation of profiler hooks (default: false)
+# SF_ENABLE_FUNCTION_SPANS: Master kill switch for capture/transmission (default: true)
+SF_ENABLE_PROFILER = strtobool(os.getenv("SF_ENABLE_PROFILER", "false"))
+
+# Include Django view functions in tracing (default: false)
+# Django view functions are typically framework entry points and already traced by web framework instrumentation
+# Set to true if you want detailed function-level tracing inside Django views
+SF_FUNCSPAN_INCLUDE_DJANGO_VIEW_FUNCTIONS = strtobool(
+    os.getenv("SF_FUNCSPAN_INCLUDE_DJANGO_VIEW_FUNCTIONS", "false")
+)
+
+# Capture spans from installed packages (site-packages, stdlib, etc.) (default: false)
+# When false, only captures user code; when true, also captures installed libraries
+SF_FUNCSPAN_CAPTURE_INSTALLED_PACKAGES = strtobool(
+    os.getenv("SF_FUNCSPAN_CAPTURE_INSTALLED_PACKAGES", "false")
+)
+
+# Capture spans from sf_veritas telemetry code itself (default: false)
+# When false, skips sf_veritas code; when true, captures our own telemetry code
+SF_FUNCSPAN_CAPTURE_SF_VERITAS = strtobool(
+    os.getenv("SF_FUNCSPAN_CAPTURE_SF_VERITAS", "false")
+)
+
+# Network Hop I/O Capture - OTEL-style defaults (bodies OFF for performance)
+SF_NETWORKHOP_CAPTURE_ENABLED = strtobool(
+    os.getenv("SF_NETWORKHOP_CAPTURE_ENABLED", "true")  # OTEL doesn't capture bodies
+)
+SF_NETWORKHOP_CAPTURE_REQUEST_HEADERS = strtobool(
+    os.getenv("SF_NETWORKHOP_CAPTURE_REQUEST_HEADERS", "false")
+)
+SF_NETWORKHOP_CAPTURE_REQUEST_BODY = strtobool(
+    os.getenv(
+        "SF_NETWORKHOP_CAPTURE_REQUEST_BODY", "false"
+    )  # OTEL doesn't capture bodies
+)
+SF_NETWORKHOP_CAPTURE_RESPONSE_HEADERS = strtobool(
+    os.getenv("SF_NETWORKHOP_CAPTURE_RESPONSE_HEADERS", "false")
+)
+SF_NETWORKHOP_CAPTURE_RESPONSE_BODY = strtobool(
+    os.getenv(
+        "SF_NETWORKHOP_CAPTURE_RESPONSE_BODY", "false"
+    )  # OTEL doesn't capture bodies
+)
+SF_NETWORKHOP_REQUEST_LIMIT_MB = int(os.getenv("SF_NETWORKHOP_REQUEST_LIMIT_MB", "1"))
+SF_NETWORKHOP_RESPONSE_LIMIT_MB = int(os.getenv("SF_NETWORKHOP_RESPONSE_LIMIT_MB", "1"))
+
+# Route-based suppression for inbound network tracing (comma-separated route patterns with wildcard support)
+# Example: "/healthz, /metrics, /admin/*, /api/v1/status*"
+# Supports wildcards: * (matches any sequence) and ? (matches single character)
+SF_DISABLE_INBOUND_NETWORK_TRACING_ON_ROUTES = os.getenv(
+    "SF_DISABLE_INBOUND_NETWORK_TRACING_ON_ROUTES", ""
+)

sf_veritas/exception_handling_middleware.py

@@ -0,0 +1,18 @@
+import sys
+
+from .custom_excepthook import custom_excepthook
+
+
+class CustomExceptionMiddleware:
+    def __init__(self, app):
+        self.app = app
+
+    async def __call__(self, scope, receive, send):
+        try:
+            await self.app(scope, receive, send)
+        except Exception as exc:
+            exc_type, exc_value, exc_traceback = sys.exc_info()
+            custom_excepthook(exc_type, exc_value, exc_traceback)
+
+    def __getattr__(self, attr):
+        return getattr(self.original, attr)

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