sf-veritas 0.9.7__py3-none-any.whl

sf_veritas/thread_local.py

@@ -0,0 +1,436 @@
+import builtins
+import threading
+import uuid
+from contextlib import contextmanager
+from contextvars import ContextVar
+from typing import Any, Dict, Optional, Set, Tuple, Union
+from uuid import UUID
+
+from . import app_config
+from .constants import NONSESSION_APPLOGS
+from .env_vars import SF_DEBUG
+
+# Define context variables
+# You CANNOT switch this for another type - this is the ONLY version that works as of October 2024.
+# Thread variables do not work, nor do globals.
+# See https://elshad-karimov.medium.com/pythons-contextvars-the-most-powerful-feature-you-ve-never-heard-of-d636f4d34030
+trace_id_ctx = ContextVar("trace_id", default=None)
+handled_exceptions_ctx = ContextVar("handled_exceptions", default=set())
+reentrancy_guard_logging_active_ctx = ContextVar(
+    "reentrancy_guard_logging_active", default=False
+)
+reentrancy_guard_logging_preactive_ctx = ContextVar(
+    "reentrancy_guard_logging_preactive", default=False
+)
+reentrancy_guard_print_active_ctx = ContextVar(
+    "reentrancy_guard_print_active", default=False
+)
+reentrancy_guard_print_preactive_ctx = ContextVar(
+    "reentrancy_guard_print_preactive", default=False
+)
+reentrancy_guard_exception_active_ctx = ContextVar(
+    "reentrancy_guard_exception_active", default=False
+)
+reentrancy_guard_exception_preactive_ctx = ContextVar(
+    "reentrancy_guard_exception_preactive", default=False
+)
+suppress_network_recording_ctx = ContextVar("suppress_network_recording", default=False)
+reentrancy_guard_sys_stdout_active_ctx = ContextVar(
+    "reentrancy_guard_sys_stdout_active", default=False
+)
+
+# Thread-local storage as a fallback
+_thread_locals = threading.local()
+
+_shared_trace_registry = {}
+_shared_trace_registry_lock = threading.RLock()
+
+
+def _set_shared_trace_id(trace_id: str) -> None:
+    with _shared_trace_registry_lock:
+        _shared_trace_registry["trace_id"] = trace_id
+
+
+def _get_shared_trace_id() -> Optional[str]:
+    with _shared_trace_registry_lock:
+        return _shared_trace_registry.get("trace_id")
+
+
+# Generalized get, set, and get_or_set functions for all properties
+def _get_context_or_thread_local(
+    ctx_var: ContextVar, attr_name: str, default: Any
+) -> Any:
+    return ctx_var.get() or getattr(_thread_locals, attr_name, default)
+
+
+def _set_context_and_thread_local(
+    ctx_var: ContextVar, attr_name: str, value: Any
+) -> Any:
+    ctx_var.set(value)
+    setattr(_thread_locals, attr_name, value)
+    return value
+
+
+def unset_sf_trace_id() -> None:
+    """
+    Fully unsets the Sailfish trace ID from contextvars, thread-local storage,
+    and the shared trace registry.
+    """
+    _set_shared_trace_id(None)
+    _set_context_and_thread_local(trace_id_ctx, "trace_id", None)
+    if SF_DEBUG:
+        print("[[DEBUG]] unset_sf_trace_id: trace_id cleared", log=False)
+
+
+def _get_or_set_context_and_thread_local(
+    ctx_var: ContextVar, attr_name: str, value_if_not_set
+) -> Tuple[bool, Any]:
+    value = ctx_var.get() or getattr(_thread_locals, attr_name, None)
+    if value is None:
+        return _set_context_and_thread_local(ctx_var, attr_name, value_if_not_set)
+    return value
+
+
+# Trace ID functions
+def get_sf_trace_id() -> Optional[Union[str, UUID]]:
+    shared_trace_id = _get_shared_trace_id()
+    if shared_trace_id:
+        return shared_trace_id
+    return _get_context_or_thread_local(trace_id_ctx, "trace_id", None)
+
+
+def set_sf_trace_id(trace_id: Union[str, UUID]) -> Union[str, UUID]:
+    _set_shared_trace_id(str(trace_id))
+    return _set_context_and_thread_local(trace_id_ctx, "trace_id", trace_id)
+
+
+def get_or_set_sf_trace_id(
+    new_trace_id_if_not_set: Optional[str] = None,
+    is_associated_with_inbound_request: bool = False,
+) -> Tuple[bool, Union[str, UUID]]:
+    if new_trace_id_if_not_set:
+        if SF_DEBUG:
+            print(
+                f"[trace_id] Setting new trace_id from argument: {new_trace_id_if_not_set}",
+                log=False,
+            )
+        set_sf_trace_id(new_trace_id_if_not_set)
+        return True, new_trace_id_if_not_set
+
+    trace_id = get_sf_trace_id()
+    if trace_id:
+        if SF_DEBUG:
+            print(f"[trace_id] Returning existing trace_id: {trace_id}", log=False)
+        return False, trace_id
+
+    if SF_DEBUG:
+        print("[trace_id] No trace_id found. Generating new trace_id.", log=False)
+    unique_id = uuid.uuid4()
+    trace_id = f"{NONSESSION_APPLOGS}-v3/{app_config._sailfish_api_key}/{unique_id}"
+    set_sf_trace_id(trace_id)
+    if SF_DEBUG:
+        print(f"[trace_id] Generated and set new trace_id: {trace_id}", log=False)
+    return True, trace_id
+
+
+# Handled exceptions functions
+def get_handled_exceptions() -> Set[Any]:
+    return _get_context_or_thread_local(
+        handled_exceptions_ctx, "handled_exceptions", set()
+    )
+
+
+def set_handled_exceptions(exceptions_set: Set[Any]) -> Set[Any]:
+    return _set_context_and_thread_local(
+        handled_exceptions_ctx, "handled_exceptions", exceptions_set
+    )
+
+
+def get_or_set_handled_exceptions(default: set = None) -> Tuple[bool, Set[Any]]:
+    if default is None:
+        default = set()
+    return _get_or_set_context_and_thread_local(
+        handled_exceptions_ctx, "handled_exceptions", default
+    )
+
+
+def mark_exception_handled(exception) -> None:
+    """
+    Marks an exception as handled to avoid duplicate processing.
+    """
+    handled_exceptions = get_handled_exceptions()
+    handled_exceptions.add(id(exception))
+    set_handled_exceptions(handled_exceptions)
+
+    # Set the `_handled` attribute on the exception if it exists
+    if hasattr(exception, "_handled"):
+        setattr(exception, "_handled", True)
+
+
+def has_handled_exception(exception) -> bool:
+    """
+    Checks if an exception has been handled.
+    """
+    # Check both thread-local context and the `_handled` attribute
+    return id(exception) in get_handled_exceptions() or getattr(
+        exception, "_handled", False
+    )
+
+
+def reset_handled_exceptions() -> Set[Any]:
+    return set_handled_exceptions(set())
+
+
+# Reentrancy guards functions (logging)
+def get_reentrancy_guard_logging_active() -> bool:
+    return _get_context_or_thread_local(
+        reentrancy_guard_logging_active_ctx, "reentrancy_guard_logging_active", False
+    )
+
+
+def set_reentrancy_guard_logging_active(value: bool) -> bool:
+    return _set_context_and_thread_local(
+        reentrancy_guard_logging_active_ctx, "reentrancy_guard_logging_active", value
+    )
+
+
+def get_or_set_reentrancy_guard_logging_active(
+    value_if_not_set: bool,
+) -> Tuple[bool, bool]:
+    return _get_or_set_context_and_thread_local(
+        reentrancy_guard_logging_active_ctx,
+        "reentrancy_guard_logging_active",
+        value_if_not_set,
+    )
+
+
+def activate_reentrancy_guards_logging() -> bool:
+    set_reentrancy_guard_logging_active(True)
+    set_reentrancy_guard_logging_preactive(True)
+    return True
+
+
+def get_reentrancy_guard_logging_preactive() -> bool:
+    return _get_context_or_thread_local(
+        reentrancy_guard_logging_preactive_ctx,
+        "reentrancy_guard_logging_preactive",
+        False,
+    )
+
+
+def set_reentrancy_guard_logging_preactive(value: bool) -> bool:
+    return _set_context_and_thread_local(
+        reentrancy_guard_logging_preactive_ctx,
+        "reentrancy_guard_logging_preactive",
+        value,
+    )
+
+
+def get_or_set_reentrancy_guard_logging_preactive(
+    value_if_not_set: bool,
+) -> Tuple[bool, bool]:
+    return _get_or_set_context_and_thread_local(
+        reentrancy_guard_logging_preactive_ctx,
+        "reentrancy_guard_logging_preactive",
+        value_if_not_set,
+    )
+
+
+def activate_reentrancy_guards_logging_preactive() -> bool:
+    return set_reentrancy_guard_logging_preactive(True)
+
+
+# Reentrancy guards functions (stdout)
+def get_reentrancy_guard_sys_stdout_active() -> bool:
+    return _get_context_or_thread_local(
+        reentrancy_guard_sys_stdout_active_ctx,
+        "reentrancy_guard_sys_stdout_active",
+        False,
+    )
+
+
+def set_reentrancy_guard_sys_stdout_active(value: bool) -> bool:
+    return _set_context_and_thread_local(
+        reentrancy_guard_sys_stdout_active_ctx,
+        "reentrancy_guard_sys_stdout_active",
+        value,
+    )
+
+
+def activate_reentrancy_guards_sys_stdout() -> bool:
+    set_reentrancy_guard_sys_stdout_active(True)
+    return True
+
+
+# Reentrancy guards functions (print)
+def get_reentrancy_guard_print_active() -> bool:
+    return _get_context_or_thread_local(
+        reentrancy_guard_print_active_ctx, "reentrancy_guard_print_active", False
+    )
+
+
+def set_reentrancy_guard_print_active(value: bool) -> bool:
+    return _set_context_and_thread_local(
+        reentrancy_guard_print_active_ctx, "reentrancy_guard_print_active", value
+    )
+
+
+def get_or_set_reentrancy_guard_print_active(
+    value_if_not_set: bool,
+) -> Tuple[bool, bool]:
+    return _get_or_set_context_and_thread_local(
+        reentrancy_guard_print_active_ctx,
+        "reentrancy_guard_print_active",
+        value_if_not_set,
+    )
+
+
+def activate_reentrancy_guards_print() -> bool:
+    set_reentrancy_guard_print_active(True)
+    set_reentrancy_guard_print_preactive(True)
+    return True
+
+
+def get_reentrancy_guard_print_preactive() -> bool:
+    return _get_context_or_thread_local(
+        reentrancy_guard_print_preactive_ctx, "reentrancy_guard_print_preactive", False
+    )
+
+
+def set_reentrancy_guard_print_preactive(value: bool) -> bool:
+    return _set_context_and_thread_local(
+        reentrancy_guard_print_preactive_ctx, "reentrancy_guard_print_preactive", value
+    )
+
+
+def get_or_set_reentrancy_guard_print_preactive(
+    value_if_not_set: bool,
+) -> Tuple[bool, bool]:
+    return _get_or_set_context_and_thread_local(
+        reentrancy_guard_print_preactive_ctx,
+        "reentrancy_guard_print_preactive",
+        value_if_not_set,
+    )
+
+
+def activate_reentrancy_guards_print_preactive() -> bool:
+    return set_reentrancy_guard_print_preactive(True)
+
+
+# Reentrancy guards functions (exception)
+def get_reentrancy_guard_exception_active() -> bool:
+    return _get_context_or_thread_local(
+        reentrancy_guard_exception_active_ctx,
+        "reentrancy_guard_exception_active",
+        False,
+    )
+
+
+def set_reentrancy_guard_exception_active(value: bool) -> bool:
+    return _set_context_and_thread_local(
+        reentrancy_guard_exception_active_ctx,
+        "reentrancy_guard_exception_active",
+        value,
+    )
+
+
+def get_or_set_reentrancy_guard_exception_active(
+    value_if_not_set: bool,
+) -> Tuple[bool, bool]:
+    return _get_or_set_context_and_thread_local(
+        reentrancy_guard_exception_active_ctx,
+        "reentrancy_guard_exception_active",
+        value_if_not_set,
+    )
+
+
+def activate_reentrancy_guards_exception() -> bool:
+    set_reentrancy_guard_exception_active(True)
+    set_reentrancy_guard_exception_preactive(True)
+    return True
+
+
+def get_reentrancy_guard_exception_preactive() -> bool:
+    return _get_context_or_thread_local(
+        reentrancy_guard_exception_preactive_ctx,
+        "reentrancy_guard_exception_preactive",
+        False,
+    )
+
+
+def set_reentrancy_guard_exception_preactive(value: bool) -> bool:
+    return _set_context_and_thread_local(
+        reentrancy_guard_exception_preactive_ctx,
+        "reentrancy_guard_exception_preactive",
+        value,
+    )
+
+
+def get_or_set_reentrancy_guard_exception_preactive(
+    value_if_not_set: bool,
+) -> Tuple[bool, bool]:
+    return _get_or_set_context_and_thread_local(
+        reentrancy_guard_exception_preactive_ctx,
+        "reentrancy_guard_exception_preactive",
+        value_if_not_set,
+    )
+
+
+def activate_reentrancy_guards_exception_preactive() -> bool:
+    return set_reentrancy_guard_exception_preactive(True)
+
+
+# Get and set context
+def get_context() -> Dict[str, Any]:
+    """Get the current context values for all properties."""
+    return {
+        "trace_id": get_sf_trace_id(),
+        "handled_exceptions": get_handled_exceptions(),
+        "reentrancy_guard_logging_active": get_reentrancy_guard_logging_active(),
+        "reentrancy_guard_logging_preactive": get_reentrancy_guard_logging_preactive(),
+        "reentrancy_guard_print_active": get_reentrancy_guard_print_active(),
+        "reentrancy_guard_print_preactive": get_reentrancy_guard_print_preactive(),
+        "reentrancy_guard_exception_active": get_reentrancy_guard_exception_active(),
+        "reentrancy_guard_exception_preactive": get_reentrancy_guard_exception_preactive(),
+        "reentrancy_guard_sys_stdout_active": get_reentrancy_guard_sys_stdout_active(),
+    }
+
+
+def set_context(context) -> None:
+    """Set the current context values for all properties."""
+    set_sf_trace_id(context.get("trace_id"))
+    set_handled_exceptions(context.get("handled_exceptions", set()))
+    set_reentrancy_guard_logging_active(
+        context.get("reentrancy_guard_logging_active", False)
+    )
+    set_reentrancy_guard_logging_preactive(
+        context.get("reentrancy_guard_logging_preactive", False)
+    )
+    set_reentrancy_guard_print_active(
+        context.get("reentrancy_guard_print_active", False)
+    )
+    set_reentrancy_guard_print_preactive(
+        context.get("reentrancy_guard_print_preactive", False)
+    )
+    set_reentrancy_guard_exception_active(
+        context.get("reentrancy_guard_exception_active", False)
+    )
+    set_reentrancy_guard_exception_preactive(
+        context.get("reentrancy_guard_exception_preactive", False)
+    )
+    set_reentrancy_guard_sys_stdout_active(
+        context.get("reentrancy_guard_sys_stdout_active", False)
+    )
+
+
+@contextmanager
+def suppress_network_recording():
+    token = suppress_network_recording_ctx.set(True)
+    try:
+        yield
+    finally:
+        suppress_network_recording_ctx.reset(token)
+
+
+def is_network_recording_suppressed() -> bool:
+    return suppress_network_recording_ctx.get()

sf_veritas/timeutil.py

@@ -0,0 +1,114 @@
+import inspect
+import threading
+import time
+from datetime import datetime, timedelta, timezone
+from time import sleep
+from typing import Tuple
+
+import ntplib
+import requests
+from dateutil import parser
+from .env_vars import PRINT_CONFIGURATION_STATUSES
+
+
+def is_log_argument_supported():
+    try:
+        signature = inspect.signature(print)
+        return "log" in signature.parameters
+    except (TypeError, ValueError) as err:
+        return False
+
+
+# Determine if the `log` argument is supported
+PRINT_ARGS = {"log": False} if is_log_argument_supported() else {}
+
+
+class TimeSync:
+    _instance = None
+    _lock = threading.Lock()
+
+    @classmethod
+    def get_instance(cls):
+        if not cls._instance:
+            with cls._lock:
+                if not cls._instance:
+                    cls._instance = cls()  # Initialize singleton
+        return cls._instance
+
+    def __init__(self):
+        if getattr(self, "_initialized", False):  # Avoid reinitialization
+            return
+        if PRINT_CONFIGURATION_STATUSES:
+            print("Configurating global time lock", **PRINT_ARGS)
+        self.sync_utc_datetime, self.local_time_ms = self._fetch_utc_time()
+        self._initialized = True
+        if PRINT_CONFIGURATION_STATUSES:
+            print("Configurating global time lock...DONE", **PRINT_ARGS)
+
+    def _fetch_utc_time(self) -> Tuple[datetime, int]:
+        try:
+            return self._fetch_with_retries(self._fetch_ntp_time)
+        except Exception as e:
+            if PRINT_CONFIGURATION_STATUSES:
+                print(f"NTP sync failed: {e}. Falling back to HTTP APIs.", **PRINT_ARGS)
+            return self._fetch_with_retries(self._fetch_utc_time_from_apis)
+
+    def _fetch_with_retries(
+        self, fetch_func, retries=3, backoff_factor=1
+    ) -> Tuple[datetime, int]:
+        for attempt in range(retries):
+            try:
+                return fetch_func()
+            except Exception as e:
+                if PRINT_CONFIGURATION_STATUSES:
+                    print(f"Attempt {attempt + 1} failed: {e}", **PRINT_ARGS)
+                sleep(backoff_factor * (2**attempt))
+        raise Exception("All retries failed")
+
+    def _fetch_ntp_time(self) -> Tuple[datetime, int]:
+        client = ntplib.NTPClient()
+        response = client.request("pool.ntp.org", version=3)
+        utc_datetime = datetime.utcfromtimestamp(response.tx_time).replace(
+            tzinfo=timezone.utc
+        )
+        local_time_ms = int(time.time() * 1000)
+        if PRINT_CONFIGURATION_STATUSES:
+            print("Time successfully synced using NTP.", **PRINT_ARGS)
+        return utc_datetime, local_time_ms
+
+    def _fetch_utc_time_from_apis(self) -> Tuple[datetime, int]:
+        apis = [
+            "https://worldtimeapi.org/api/timezone/Etc/UTC",
+            "http://worldclockapi.com/api/json/utc/now",
+        ]
+        for api in apis:
+            try:
+                response = requests.get(api, timeout=5)
+                response.raise_for_status()
+                data = response.json()
+                if "datetime" in data:
+                    utc_datetime = parser.isoparse(data["datetime"])
+                elif "currentDateTime" in data:
+                    utc_datetime = parser.isoparse(data["currentDateTime"])
+                else:
+                    raise ValueError("Unexpected API response format")
+                local_time_ms = int(time.time() * 1000)
+                if PRINT_CONFIGURATION_STATUSES:
+                    print(f"Time successfully synced using {api}.", **PRINT_ARGS)
+                return utc_datetime, local_time_ms
+            except Exception as e:
+                if PRINT_CONFIGURATION_STATUSES:
+                    print(f"Failed to fetch time from {api}: {e}", **PRINT_ARGS)
+        if PRINT_CONFIGURATION_STATUSES:
+            print("All time sources failed. Falling back to system time.", **PRINT_ARGS)
+        utc_datetime = datetime.now(timezone.utc)
+        local_time_ms = int(time.time() * 1000)
+        return utc_datetime, local_time_ms
+
+    def get_utc_time_in_ms(self) -> int:
+        current_local_time_ms = int(time.time() * 1000)
+        elapsed_ms = current_local_time_ms - self.local_time_ms
+        current_utc_datetime = self.sync_utc_datetime + timedelta(
+            milliseconds=elapsed_ms
+        )
+        return int(current_utc_datetime.timestamp() * 1000)

sf_veritas/transmit_exception_to_sailfish.py

@@ -0,0 +1,28 @@
+from .custom_excepthook import transmit_exception
+
+
+def transmit_exception_to_sailfish(
+    exc: BaseException,
+    force_transmit: bool = False,
+):
+    """
+    Transmit an exception to Sailfish using the original traceback captured at the
+    point the exception was raised.
+
+    :param exc: The exception instance.
+    :param force_transmit: If True, will transmit even if the exception might
+                           have already been handled or flagged.
+    """
+    # Get the exception type and traceback from the exception itself
+    exc_type = type(exc)
+    exc_traceback = exc.__traceback__  # Automatically fetch the original traceback
+
+    # In some implementations, you might keep a `_handled` attribute to avoid double transmission.
+    if not force_transmit and getattr(exc, "_handled", False):
+        return  # Already transmitted
+
+    # Actually send it over to Sailfish
+    transmit_exception(exc_type, exc, exc_traceback)
+
+    # Mark as handled to avoid re-transmission
+    setattr(exc, "_handled", True)

sf_veritas/transmitter.py

@@ -0,0 +1,58 @@
+from typing import Any, Dict, Optional
+
+from .env_vars import SF_DEBUG
+from .interceptors import CollectMetadataTransmitter
+from .thread_local import get_or_set_sf_trace_id
+
+collect_metadata_transmitter = CollectMetadataTransmitter()
+
+
+class SailfishTransmitter(object):
+    @classmethod
+    def identify(
+        cls,
+        user_id: str,
+        traits: Optional[Dict[str, Any]] = None,
+        traits_json: Optional[str] = None,
+        override: bool = False,
+    ) -> None:
+        if traits is not None or traits_json is not None:
+            return cls.add_or_update_metadata(user_id, traits, traits_json, override)
+        return cls.add_or_update_metadata(user_id, dict(), override=override)
+
+    @classmethod
+    def add_or_update_metadata(
+        cls,
+        user_id: str,
+        traits: Optional[Dict[str, Any]] = None,
+        traits_json: Optional[str] = None,
+        override: bool = False,
+    ) -> None:
+        """
+        Sets traits and sends to the Sailfish AI backend
+
+        Args:
+            user_id: unique identifier for the user; common uses are username or email
+            traits: dictionary of contents to add or update in the user's traits. Defaults to None.
+            traits_json: json string of contents to add or update in the user's traits. Defaults to None.
+        """
+        if traits is None and traits_json is None:
+            raise Exception(
+                'Must pass in either traits or traits_json to "add_or_update_traits"'
+            )
+        if SF_DEBUG:
+            print(
+                "[[DEBUG - add_or_update_traits]] starting thread [[/DEBUG]]", log=False
+            )
+
+        _, trace_id = get_or_set_sf_trace_id()
+        if SF_DEBUG:
+            print(
+                "add_or_update_metadata...SENDING DATA...args=",
+                (user_id, traits, traits_json, override, trace_id),
+                trace_id,
+                log=False,
+            )
+        collect_metadata_transmitter.do_send(
+            (user_id, traits, traits_json, override, trace_id), trace_id
+        )

sf_veritas/types.py

@@ -0,0 +1,44 @@
+import json
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class FrameInfo:
+    file: str
+    line: int
+    function: str
+    code: str
+    locals: Optional[Dict[str, Any]] = field(default_factory=dict)
+    offender: Optional[bool] = False
+
+    def to_dict(self) -> Dict[str, Any]:
+        frame_info_dict = {
+            "file": self.file,
+            "line": self.line,
+            "function": self.function,
+            "code": self.code,
+        }
+        if self.locals:
+            frame_info_dict["locals"] = {k: str(v) for k, v in self.locals.items()}
+        if self.offender:
+            frame_info_dict["offender"] = self.offender
+        return frame_info_dict
+
+    def to_json(self) -> str:
+        return json.dumps(self.to_dict())
+
+
+def get_trace_from_json(data_json) -> List[FrameInfo]:
+    data = json.loads(data_json)
+    return [FrameInfo(**item) for item in data]
+
+
+class CustomJSONEncoderForFrameInfo(json.JSONEncoder):
+    def default(self, obj):
+        if isinstance(obj, FrameInfo):
+            return obj.to_dict()
+        try:
+            return super().default(obj)
+        except TypeError:
+            return str(obj)