sf-veritas 0.10.3__cp311-cp311-manylinux_2_28_x86_64.whl

sf_veritas/custom_log_handler.py

@@ -0,0 +1,129 @@
+import logging
+from typing import Optional
+
+from . import app_config
+from .env_vars import PRINT_CONFIGURATION_STATUSES, SF_DEBUG
+from .interceptors import LogInterceptor
+from .thread_local import get_or_set_sf_trace_id, get_reentrancy_guard_logging_preactive
+
+# Try native fast path (compiled C extension). If missing, we fall back.
+try:
+    from . import _sffastlog as _FASTMOD
+
+    _FAST_OK = True
+except Exception:
+    _FASTMOD = None
+    _FAST_OK = False
+
+# Small constant table avoids attribute access for levelname on hot path
+_LEVEL_NAME = {
+    50: "CRITICAL",
+    40: "ERROR",
+    30: "WARNING",
+    20: "INFO",
+    10: "DEBUG",
+    0: "NOTSET",
+}
+
+
+class CustomLogHandler(logging.Handler, LogInterceptor):
+    """
+    Ultra-light log handler:
+      - Avoid Formatter unless explicitly set.
+      - Avoid %-formatting if record.args is empty.
+      - Prefer levelno→name map (micro faster than attribute lookup).
+      - Fetch/generate trace_id once per emit (unchanged).
+      - DIRECT native send via _sffastlog when available; Python fallback otherwise.
+    """
+
+    def __init__(self):
+        logging.Handler.__init__(self)
+        LogInterceptor.__init__(self, api_key=app_config._sailfish_api_key)
+        if PRINT_CONFIGURATION_STATUSES:
+            print("Intercepting log statements")
+
+    def emit(self, record: logging.LogRecord, trace_id: Optional[str] = None):
+        # Bind frequently used symbols to locals to reduce attribute/global lookups
+        _formatter = self.formatter
+        _get_tid = get_or_set_sf_trace_id
+        _get_preactive = get_reentrancy_guard_logging_preactive
+        _debug = SF_DEBUG
+        _level_table = _LEVEL_NAME
+        _fast = _FASTMOD
+        _fast_ok = _FAST_OK
+        _do_send = self.do_send  # Python fallback
+
+        try:
+            # FAST PATH message extraction:
+            # - If a formatter is attached, defer to it (caller explicitly wants decorations)
+            # - Otherwise:
+            #     - If there are args, we must perform %-format (getMessage)
+            #     - If no args and msg is already a str, reuse it directly (no str() allocation)
+            #     - Else fall back to str(msg)
+            if _formatter is None:
+                if record.args:
+                    log_entry = record.getMessage()
+                else:
+                    msg = record.msg
+                    log_entry = msg if (msg.__class__ is str) else str(msg)
+            else:
+                log_entry = self.format(record)
+
+            # Cheap ignore check (lives on LogInterceptor); skip everything if ignored
+            # Keeps semantics identical while saving work on hot path
+            try:
+                if self.check_if_contents_should_be_ignored(log_entry):
+                    return
+            except AttributeError:
+                # If not defined for some reason, proceed (older builds)
+                pass
+
+            # CHEAP LEVEL NAME:
+            lvlno = record.levelno
+            log_level = _level_table.get(lvlno)
+            if log_level is None:  # uncommon/3rd-party custom levels
+                log_level = record.levelname
+
+            # TRACE ID ONCE (unchanged contract)
+            if trace_id is None:
+                _, trace_id = _get_tid(None)
+
+            # Debug printing (rarely enabled)
+            if _debug:
+                # Avoid f-strings to skip extra work when disabled
+                print(
+                    "[[DEBUG custom_log_handler]]",
+                    "trace_id=" + str(trace_id),
+                    "[[" + log_level + "]]",
+                    log_entry,
+                    "[[/DEBUG]]",
+                    log=False,
+                )
+
+            # ---------- Native fast path ----------
+            if _fast_ok and _fast is not None:
+                try:
+                    preactive = bool(_get_preactive())
+                    # Single C call → copy → enqueue → return; HTTP happens on native thread
+                    _fast.log(
+                        level=log_level or "UNKNOWN",
+                        contents=log_entry,
+                        session_id=str(trace_id),
+                        preactive=preactive,
+                    )
+                    return
+                except Exception as _e:
+                    print(
+                        "[_sffastlog] fast-path failed; falling back:",
+                        _e,
+                        log=False,
+                    )
+                    # fall through to Python path
+
+            # ---------- Python fallback (deferred batching/async) ----------
+            _do_send((log_level, log_entry, trace_id), trace_id)
+
+        except Exception as e:  # keep lean; avoid storms on storms
+            if _debug:
+                print("CustomLogHandler.emit error:", e)
+            self.handleError(record)

sf_veritas/custom_output_wrapper.py

@@ -0,0 +1,144 @@
+# sf_veritas/custom_output_wrapper.py
+import os
+import sys
+
+from . import app_config
+from .env_vars import PRINT_CONFIGURATION_STATUSES
+from .interceptors import PrintInterceptor
+from .thread_local import _thread_locals, get_or_set_sf_trace_id
+
+# ---- optional native fast path (C extension) ----
+try:
+    from . import _sffastlog  # compiled extension with ring + libcurl sender
+
+    _FAST_OK = True
+except Exception:  # pragma: no cover
+    _sffastlog = None
+    _FAST_OK = False
+
+_FAST_PRINT_READY = False  # one-time init guard
+
+
+def _ensure_fast_print_initialized() -> bool:
+    """Idempotent, cheap check to init native print path once."""
+    global _FAST_PRINT_READY
+    if not _FAST_OK or _FAST_PRINT_READY:
+        return _FAST_PRINT_READY
+
+    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):
+        return False  # not configured yet
+
+    # GraphQL mutation for print statements (must match server)
+    query = (
+        "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)}"
+    )
+
+    try:
+        ok = _sffastlog.init_print(
+            url=endpoint,
+            query=query,
+            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
+
+
+class CustomOutputWrapper:
+    """
+    Ultra-thin sys.stdout wrapper:
+      - Writes straight to the real stream to preserve console output.
+      - If native fast path is ready, send to C ring immediately.
+      - Otherwise, fall back to PrintInterceptor (Python path).
+      - No locks, no regex, no unconditional flush.
+    """
+
+    __slots__ = ("original", "print_interceptor")
+
+    def __init__(self, original):
+        self.original = original
+        self.print_interceptor = PrintInterceptor()
+
+    def write(self, msg):
+        # Respect your reentrancy guard quickly
+        if getattr(_thread_locals, "reentrancy_guard_logging_active", False):
+            self.original.write(msg)
+            return
+
+        # Always write to the real stream first (don’t flush unless caller asks)
+        self.original.write(msg)
+
+        # Cheap ignore cases (optional): skip totally empty or pure newline
+        if not msg or msg == "\n":
+            return
+
+        # Build once
+        message = msg
+        _, trace_id = get_or_set_sf_trace_id()
+
+        # Native fast path (C) — lowest overhead
+        if _ensure_fast_print_initialized():
+            try:
+                _sffastlog.print_(
+                    contents=message, session_id=str(trace_id), preactive=0
+                )
+                return
+            except Exception:
+                pass  # fall through to Python fallback
+
+        # Python fallback path
+        self.print_interceptor.do_send((message, trace_id), trace_id)
+
+    def flush(self):
+        # Only flush when caller flushes (keeps latency down)
+        self.original.flush()
+
+    def __getattr__(self, attr):
+        return getattr(self.original, attr)
+
+
+def setup_custom_output_wrappers():
+    # Import here to avoid circular dependency
+    from .print_override import override_print
+
+    if PRINT_CONFIGURATION_STATUSES:
+        sys.__stdout__.write("setup_custom_output_wrappers\n")
+
+    # First override print to support log=True/False parameter
+    override_print()
+
+    # Then wrap stdout for interception
+    sys.stdout = CustomOutputWrapper(sys.stdout)
+
+    if PRINT_CONFIGURATION_STATUSES:
+        sys.__stdout__.write("setup_custom_output_wrappers...DONE\n")
+
+
+def get_custom_output_wrapper_django():
+    """Django-specific wrapper setup function called by Django patch."""
+    setup_custom_output_wrappers()

sf_veritas/custom_print.py

@@ -0,0 +1,146 @@
+# sf_veritas/custom_print.py
+import builtins
+import os
+import sys
+
+from . import app_config
+from .env_vars import SF_DEBUG
+from .thread_local import activate_reentrancy_guards_sys_stdout, get_or_set_sf_trace_id
+
+# --- 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:
+            # 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:
+        # 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)