sf-veritas 0.10.3__cp313-cp313-manylinux_2_28_x86_64.whl

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,132 @@
+from typing import Any, Dict, Optional
+
+from .env_vars import SF_DEBUG
+from .thread_local import get_or_set_sf_trace_id
+
+# Try to import C extension for fast path
+try:
+    from . import _sfservice
+    _SFSERVICE_AVAILABLE = True
+except Exception:
+    _sfservice = None
+    _SFSERVICE_AVAILABLE = False
+
+# Always have Python fallback available (lazy-loaded when needed)
+collect_metadata_transmitter = None
+
+
+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 update_service_details(
+        cls,
+        service_identifier: Optional[str] = None,
+        service_version: Optional[str] = None,
+        service_additional_metadata: Optional[Dict[str, Any]] = None,
+        git_sha: Optional[str] = None,
+    ) -> None:
+        """
+        Updates service details with metadata.
+        Sends mutation updateServiceDetails (Python implementation - no C extension yet).
+
+        Args:
+            service_identifier: Service identifier string
+            service_version: Service version string
+            service_additional_metadata: Dictionary of additional metadata
+            git_sha: Git SHA hash
+        """
+        # Import here to avoid circular dependency
+        from .regular_data_transmitter import UpdateServiceIdentifierMetadata
+
+        transmitter = UpdateServiceIdentifierMetadata()
+        transmitter.send(
+            service_identifier=service_identifier,
+            service_version=service_version,
+            service_additional_metadata=service_additional_metadata,
+            git_sha=git_sha,
+        )
+
+        if SF_DEBUG:
+            print(f"[[DEBUG]] update_service_details sent: id={service_identifier}, version={service_version}, sha={git_sha}", log=False)
+
+    @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,
+            )
+
+        # Fast path: Use C extension if available
+        if _SFSERVICE_AVAILABLE and _sfservice:
+            try:
+                excluded_fields = []
+
+                # If traits is provided as dict, serialize it
+                if traits_json is None:
+                    from .utils import serialize_json_with_exclusions
+                    traits_json, excluded_fields = serialize_json_with_exclusions(traits)
+
+                # Call C extension
+                _sfservice.collect_metadata(
+                    session_id=str(trace_id),
+                    user_id=user_id,
+                    traits_json=traits_json,
+                    excluded_fields=excluded_fields,
+                    override=override,
+                )
+
+                if SF_DEBUG:
+                    print("[[DEBUG]] collect_metadata sent via _sfservice C extension", log=False)
+                return
+            except Exception as e:
+                if SF_DEBUG:
+                    print(f"[[DEBUG]] Failed to send via C extension: {e}, falling back to Python", log=False)
+                # Fall through to Python implementation
+
+        # Fallback: Use Python implementation (lazy-load if needed)
+        global collect_metadata_transmitter
+        if collect_metadata_transmitter is None:
+            from .interceptors import CollectMetadataTransmitter
+            collect_metadata_transmitter = CollectMetadataTransmitter()
+
+        collect_metadata_transmitter.do_send(
+            (user_id, traits, traits_json, override, trace_id), trace_id
+        )

sf_veritas/types.py

@@ -0,0 +1,47 @@
+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)
+    column: Optional[int] = None
+    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
+        if self.column is not None:
+            frame_info_dict["column"] = self.column
+        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)