sf-veritas 0.11.10__cp314-cp314-manylinux_2_28_x86_64.whl

sf_veritas/custom_excepthook.py

@@ -0,0 +1,304 @@
+import inspect
+
+# import linecache
+import logging
+import re
+import sys
+import threading
+from types import FrameType, TracebackType
+from typing import List, Optional
+
+from . import app_config
+from .env_vars import (
+    SAILFISH_EXCEPTION_FETCH_BEYOND_OFFENDER_DEPTH,
+    SAILFISH_EXCEPTION_FETCH_LOCALS_BEYOND_OFFENDER_DEPTH,
+    SF_DEBUG,
+    SF_DEBUG_TRACES,
+)
+
+# from .frame_tools import get_locals
+from .interceptors import ExceptionInterceptor
+from .local_env_detect import sf_is_local_dev_environment
+from .thread_local import (
+    get_or_set_sf_trace_id,
+    has_handled_exception,
+    mark_exception_handled,
+)
+from .types import FrameInfo
+
+REGEX_EVERYTHING_BEFORE_PYTHON_PACKAGE_NAME_WHEN_EXAMINING_FILENAME = (
+    r".*\/(site|dist)-packages\/"
+)
+REGEX_EVERYTHING_AFTER_NEXT_SLASH = r"\/.*"
+
+logger = logging.getLogger(__name__)
+
+# Profiling data structure to collect function call information
+call_hierarchy = []
+
+# Lock to manage thread-safe access to profiling data
+call_hierarchy_lock = threading.Lock()
+
+_original_excepthook = sys.excepthook
+
+
+def custom_thread_excepthook(args):
+    sys.excepthook(args.exc_type, args.exc_value, args.exc_traceback)
+
+
+def process_traceback_only(
+    exc_value: Exception, exc_traceback: TracebackType, was_caught: bool = True
+):
+    """
+    Processes only the traceback information for an exception.
+
+    Args:
+        exc_value (Exception): The exception value.
+        exc_traceback (TracebackType): The traceback object for the exception.
+    """
+    trace = extract_trace(exc_traceback)
+    except_interceptor = ExceptionInterceptor()
+    _, trace_id = get_or_set_sf_trace_id()
+    if SF_DEBUG:
+        print(
+            "process_traceback_only...SENDING DATA...do_send args=",
+            (str(exc_value), trace, trace_id, was_caught),
+            trace_id,
+            log=False,
+        )
+    except_interceptor.do_send(
+        (str(exc_value), trace, trace_id, was_caught, sf_is_local_dev_environment()[0]),
+        trace_id,
+    )
+
+
+# Usage example in the custom_excepthook function:
+def custom_excepthook(
+    exc_type, exc_value, exc_traceback: TracebackType, raise_original: bool = True
+):
+    if has_handled_exception(exc_value):
+        return
+    mark_exception_handled(exc_value)
+
+    if SF_DEBUG:
+        print(f"custom_excepthook -> raise_original={raise_original}", log=False)
+
+    transmit_exception(exc_type, exc_value, exc_traceback)
+
+    if raise_original:
+        _original_excepthook(exc_type, exc_value, exc_traceback)
+
+
+def transmit_exception(exc_type, exc_value, exc_traceback, was_caught: bool = True):
+    """
+    Handles transmitting exception information based on profiling mode.
+
+    Args:
+        exc_type: The type of the exception.
+        exc_value: The exception instance.
+        exc_traceback: The traceback object for the exception.
+    """
+    if app_config._profiling_mode_enabled:
+        threading.Thread(
+            target=process_profiling_data,
+            args=(exc_type, exc_value, exc_traceback, was_caught),
+        ).start()
+        return
+    process_traceback_only(exc_value, exc_traceback, was_caught)
+
+
+def profiling_function(frame: FrameType, event: str, arg):
+    if not app_config._profiling_mode_enabled:
+        return
+
+    if event in ["call", "return"]:
+        code = frame.f_code
+        function_name = code.co_name
+        filename = code.co_filename
+        line_no = frame.f_lineno
+        class_name = None
+
+        # Try to determine if we're inside a method of a class
+        if "self" in frame.f_locals:
+            class_name = type(frame.f_locals["self"]).__name__
+
+        call_info = {
+            "event": event,
+            "function": function_name,
+            "class": class_name,
+            "file": filename,
+            "line_no": line_no,
+        }
+
+        # Add profiling data to call hierarchy with a lock for thread safety
+        with call_hierarchy_lock:
+            if len(call_hierarchy) < app_config._profiling_max_depth:
+                call_hierarchy.append(call_info)
+
+
+def process_profiling_data(exc_type, exc_value, exc_traceback, was_caught: bool = True):
+    # Extract the traceback and process detailed information
+    trace = extract_trace(exc_traceback)
+
+    # Process profiling data
+    with call_hierarchy_lock:
+        if SF_DEBUG and SF_DEBUG_TRACES:
+            print("=" * 40, log=False)
+            print("Printing the complete call hierarchy after exception...", log=False)
+            print("=" * 40, log=False)
+
+        for entry in call_hierarchy:
+            if entry["event"] == "call":
+                class_name = f"{entry['class']}." if entry["class"] else ""
+                if SF_DEBUG and SF_DEBUG_TRACES:
+                    print(
+                        f"Called: {class_name}{entry['function']} (File: {entry['file']}, Line: {entry['line_no']})",
+                        log=False,
+                    )
+            elif entry["event"] == "return":
+                if SF_DEBUG and SF_DEBUG_TRACES:
+                    print(f"Return from: {entry['function']}", log=False)
+
+        if SF_DEBUG and SF_DEBUG_TRACES:
+            print("-" * 40, log=False)
+
+        # Clear profiling data after processing
+        call_hierarchy.clear()
+
+    # Send the extracted traceback data to the exception interceptor
+    except_interceptor = ExceptionInterceptor()
+    _, trace_id = get_or_set_sf_trace_id()
+    if SF_DEBUG:
+        print(
+            "process_traceback_only...SENDING DATA...do_send args=",
+            (str(exc_value), trace, trace_id, was_caught),
+            trace_id,
+            log=False,
+        )
+    except_interceptor.do_send(
+        (str(exc_value), trace, trace_id, was_caught, sf_is_local_dev_environment()[0]),
+        trace_id,
+    )
+
+
+def safe_repr(value):
+    try:
+        return repr(value)
+    except Exception:
+        return f"<unrepresentable: {type(value).__name__}>"
+
+
+def extract_trace(tb: Optional[TracebackType] = None) -> List[FrameInfo]:
+    tb_list = []
+
+    # Collect all traceback frames in natural order (most recent last)
+    while tb is not None:
+        tb_list.append(tb)
+        tb = tb.tb_next
+
+    if not tb_list:
+        return []
+
+    frame_stack = []
+
+    # Iterate through the traceback, capturing frame information
+    for tb in tb_list:
+        frame = tb.tb_frame
+        frame_info = inspect.getframeinfo(frame)
+        filename = frame_info.filename
+        function_name = frame_info.function
+        line_no = frame_info.lineno
+        code_context = (
+            frame_info.code_context[0].strip()
+            if frame_info.code_context
+            else "No code context"
+        )
+
+        frame_info_obj = FrameInfo(
+            file=filename,
+            line=line_no,
+            function=function_name,
+            code=code_context,
+        )
+
+        # Capture ALL local variables at each frame - no depth or package restrictions
+        frame_info_obj.locals = {k: safe_repr(v) for k, v in frame.f_locals.items()}
+
+        frame_stack.append(frame_info_obj)
+
+    frame_stack[-1].offender = True
+    return frame_stack
+
+
+def start_profiling():
+    """Start profiling to collect call hierarchy information if profiling is enabled."""
+    from .env_vars import SF_DEBUG
+
+    if SF_DEBUG:
+        try:
+            print(
+                f"[[DEBUG]] start_profiling() called, _profiling_mode_enabled={app_config._profiling_mode_enabled}",
+                log=False,
+            )
+        except:
+            print(
+                f"[[DEBUG]] start_profiling() called, _profiling_mode_enabled={app_config._profiling_mode_enabled}"
+            )
+    if app_config._profiling_mode_enabled:
+        try:
+            print(
+                f"[[DEBUG]] Setting sys.setprofile to profiling_function, current={sys.getprofile()}",
+                log=False,
+            )
+        except:
+            print(
+                f"[[DEBUG]] Setting sys.setprofile to profiling_function, current={sys.getprofile()}"
+            )
+        sys.setprofile(profiling_function)
+        try:
+            print(
+                f"[[DEBUG]] After setting, sys.getprofile()={sys.getprofile()}",
+                log=False,
+            )
+        except:
+            print(f"[[DEBUG]] After setting, sys.getprofile()={sys.getprofile()}")
+
+
+def stop_profiling():
+    """Stop profiling to prevent collecting more call hierarchy data."""
+    sys.setprofile(None)
+
+
+def should_collect_local_variables_for_stack_item(filename: str) -> bool:
+    if "__all__" in app_config._site_and_dist_packages_to_collect_local_variables_on:
+        return True
+    return is_allowed_package(filename)
+
+
+def is_installed_package(filename: str) -> bool:
+    return bool(
+        re.search(
+            REGEX_EVERYTHING_BEFORE_PYTHON_PACKAGE_NAME_WHEN_EXAMINING_FILENAME,
+            filename,
+        )
+    )
+
+
+def get_package_name_from_site_or_dist_package(filename: str):
+    site_dist_packages_removed = re.sub(
+        REGEX_EVERYTHING_BEFORE_PYTHON_PACKAGE_NAME_WHEN_EXAMINING_FILENAME,
+        "",
+        filename,
+    )
+    package_installed_name = re.sub(
+        REGEX_EVERYTHING_AFTER_NEXT_SLASH, "", site_dist_packages_removed
+    )
+    return package_installed_name
+
+
+def is_allowed_package(filename: str) -> bool:
+    if not is_installed_package(filename):
+        return True
+
+    package = get_package_name_from_site_or_dist_package(filename)
+    return package in app_config._site_and_dist_packages_to_collect_local_variables_on

sf_veritas/custom_log_handler.py

@@ -0,0 +1,146 @@
+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_current_function_span_id,
+    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
+
+    if SF_DEBUG:
+        print("[[custom_log_handler]] _FASTMOD is okay")
+
+    _FAST_OK = True
+except Exception:
+    if SF_DEBUG:
+        print("[[custom_log_handler]] _FASTMOD != OK")
+    _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())
+                    # Capture parent_span_id IMMEDIATELY for async-safety
+                    parent_span_id = get_current_function_span_id()
+
+                    # DEBUG: Log what parent_span_id we captured (only for TEST_PARENT_SPAN logs)
+                    if "TEST_PARENT_SPAN" in log_entry:
+                        print(f"[LOG_HANDLER_DEBUG] parent_span_id={parent_span_id} for log: {log_entry[:80]}", log=False)
+
+                    # 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,
+                        parent_span_id=parent_span_id,
+                    )
+                    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,153 @@
+# 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_current_function_span_id,
+    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!,"
+        "$parentSpanId: String"
+        "){collectPrintStatements("
+        "apiKey:$apiKey,serviceUuid:$serviceUuid,sessionId:$sessionId,"
+        "contents:$contents,reentrancyGuardPreactive:$reentrancyGuardPreactive,"
+        "library:$library,timestampMs:$timestampMs,version:$version,"
+        "parentSpanId:$parentSpanId)}"
+    )
+
+    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:
+                # Capture parent_span_id IMMEDIATELY for async-safety
+                parent_span_id = get_current_function_span_id()
+
+                _sffastlog.print_(
+                    contents=message, session_id=str(trace_id), preactive=0, parent_span_id=parent_span_id
+                )
+                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()