sf-veritas 0.9.7__py3-none-any.whl

sf_veritas/infra_details/kubernetes/get_cluster_name.py

@@ -0,0 +1,147 @@
+import os
+import socket
+
+import requests
+
+DEFAULT_CLUSTER_NAME = "UNKNOWN"
+
+# ─── 1. ConfigMap (optional) ─────────────────────────────────
+
+
+def get_from_config_map(path: str = "/etc/cluster-info/cluster-name"):
+    """If you’ve mounted a ConfigMap at this path, read it."""
+    try:
+        with open(path, "r") as f:
+            name = f.read().strip()
+            if name:
+                return name
+    except IOError:
+        pass
+
+
+# ─── 2. Cloud Metadata ────────────────────────────────────────
+
+
+def get_gke_cluster_name(timeout: float = 1.0):
+    """GKE nodes automatically get a 'cluster-name' instance attribute."""
+    try:
+        resp = requests.get(
+            "http://metadata.google.internal/computeMetadata/v1/instance/attributes/cluster-name",
+            headers={"Metadata-Flavor": "Google"},
+            timeout=timeout,
+        )
+        if resp.ok and resp.text:
+            return resp.text
+    except requests.RequestException:
+        pass
+
+
+def get_eks_cluster_name(timeout: float = 1.0):
+    """EKS-backed EC2 instances are tagged 'eks:cluster-name'."""
+    try:
+        # 1) fetch IMDSv2 token
+        token = requests.put(
+            "http://169.254.169.254/latest/api/token",
+            headers={"X-aws-ec2-metadata-token-ttl-seconds": "21600"},
+            timeout=timeout,
+        ).text
+        # 2) read the eks:cluster-name tag
+        resp = requests.get(
+            "http://169.254.169.254/latest/meta-data/tags/instance/eks:cluster-name",
+            headers={"X-aws-ec2-metadata-token": token},
+            timeout=timeout,
+        )
+        if resp.ok and resp.text:
+            return resp.text
+    except requests.RequestException:
+        pass
+
+
+def get_aks_cluster_name(timeout: float = 1.0):
+    """AKS nodes live in a VM RG named MC_<resourceGroup>_<clusterName>_<zone>."""
+    try:
+        resp = requests.get(
+            "http://169.254.169.254/metadata/instance",
+            params={"api-version": "2021-02-01", "format": "json"},
+            headers={"Metadata": "true"},
+            timeout=timeout,
+        )
+        if resp.ok:
+            compute = resp.json().get("compute", {})
+            rg = compute.get("resourceGroupName", "")
+            parts = rg.split("_")
+            if len(parts) >= 3:
+                return parts[2]
+    except requests.RequestException:
+        pass
+
+
+# ─── 3. Kubernetes API fallback ────────────────────────────────
+
+
+def get_via_k8s_api(timeout: float = 1.0):
+    """
+    If you’re running in K8s and have in‑cluster RBAC, try:
+      A) ClusterProperty CRD (KEP‑2149)
+      B) Node labels on your own Pod’s node
+    """
+    try:
+        from kubernetes import client, config
+    except ImportError:
+        return
+
+    try:
+        # load service account creds
+        config.load_incluster_config()
+
+        # A) ClusterProperty CRD
+        co = client.CustomObjectsApi()
+        props = co.list_cluster_custom_object(
+            group="multicluster.k8s.io",
+            version="v1alpha6",
+            plural="clusterproperties",
+        ).get("items", [])
+        if props:
+            name = props[0].get("spec", {}).get("clusterName")
+            if name:
+                return name
+
+        # B) read this Pod → its Node → cluster label
+        v1 = client.CoreV1Api()
+        # Pod name = hostname in K8s
+        pod_name = socket.gethostname()
+        ns = (
+            open("/var/run/secrets/kubernetes.io/serviceaccount/namespace")
+            .read()
+            .strip()
+        )
+        pod = v1.read_namespaced_pod(
+            name=pod_name, namespace=ns, _request_timeout=timeout
+        )
+        node = v1.read_node(pod.spec.node_name, _request_timeout=timeout)
+        labels = node.metadata.labels or {}
+        for key in ("cluster.x-k8s.io/cluster-name", "topology.kubernetes.io/cluster"):
+            if labels.get(key):
+                return labels[key]
+    except Exception:
+        pass
+
+
+# ─── 4. Aggregator ────────────────────────────────────────────
+
+
+def get_cluster_name():
+    for fn in (
+        get_from_config_map,
+        get_gke_cluster_name,
+        get_eks_cluster_name,
+        get_aks_cluster_name,
+        get_via_k8s_api,
+    ):
+        try:
+            name = fn()
+            if name:
+                return name
+        except Exception:
+            continue
+    return DEFAULT_CLUSTER_NAME

sf_veritas/infra_details/kubernetes/get_details.py

@@ -0,0 +1,7 @@
+from typing import Any, Dict
+
+from .get_cluster_name import get_cluster_name
+
+
+def get_details() -> Dict[str, Any]:
+    return {"clusterName": get_cluster_name()}

sf_veritas/infra_details/running_on/__init__.py

@@ -0,0 +1,17 @@
+from enum import Enum
+
+from .kubernetes import kubernetes
+
+
+class System(Enum):
+    KUBERNETES = "Kubernetes"
+    UNKNOWN = "Unknown"
+
+
+def running_on() -> System:
+    if kubernetes():
+        return System.KUBERNETES
+    return System.UNKNOWN
+
+
+__all__ = ["running_on"]

sf_veritas/infra_details/running_on/kubernetes.py

@@ -0,0 +1,11 @@
+import os
+
+
+def kubernetes() -> bool:
+    # 1) service‐account token (default mount in every Pod)
+    if os.path.exists("/var/run/secrets/kubernetes.io/serviceaccount/token"):
+        return True
+    # 2) built‐in K8s env var
+    if os.getenv("KUBERNETES_SERVICE_HOST"):
+        return True
+    return False

sf_veritas/interceptors.py

@@ -0,0 +1,252 @@
+import json
+import logging
+import re
+import threading
+import time
+import uuid
+from typing import Any, Dict, List, Optional
+
+from . import app_config
+from .env_vars import SF_DEBUG
+from .package_metadata import PACKAGE_LIBRARY_TYPE, __version__
+from .regular_data_transmitter import ServiceIdentifier
+from .request_utils import non_blocking_post
+from .thread_local import (  # reentrancy_guard, activate_reentrancy_guards_logging_preactive,
+    activate_reentrancy_guards_logging,
+    get_or_set_sf_trace_id,
+)
+from .timeutil import TimeSync
+from .types import CustomJSONEncoderForFrameInfo, FrameInfo
+from .utils import serialize_json_with_exclusions, strtobool
+
+logger = logging.getLogger(__name__)
+
+
+class OutputInterceptor(object):
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key or app_config._sailfish_api_key
+        self.endpoint = app_config._sailfish_graphql_endpoint
+        self.operation_name: Optional[str] = ""
+        self.query_type = "mutation"
+        self.service_identifier = ServiceIdentifier()
+
+    @property
+    def query_name(self) -> str:
+        return (
+            self.operation_name[0].lower() + self.operation_name[1:]
+            if self.operation_name
+            else ""
+        )
+
+    def get_default_variables(self, session_id: Optional[str] = None):
+        trace_id = session_id
+        if not session_id:
+            _, trace_id = get_or_set_sf_trace_id(session_id)
+        timestamp_ms = TimeSync.get_instance().get_utc_time_in_ms()
+        return {
+            "apiKey": self.api_key,
+            "serviceUuid": app_config._service_uuid,
+            "library": PACKAGE_LIBRARY_TYPE,
+            "sessionId": trace_id,
+            "timestampMs": str(timestamp_ms),
+            "version": __version__,
+        }
+
+    def get_variables(
+        self,
+        additional_variables: Optional[Dict[str, Any]] = None,
+        session_id: Optional[str] = None,
+    ) -> Dict[str, Any]:
+        additional_variables = (
+            additional_variables if additional_variables is not None else {}
+        )
+        return {
+            **additional_variables,
+            **self.get_default_variables(session_id),
+        }
+
+    def check_if_contents_should_be_ignored(
+        self, contents
+    ):  # pylint: disable=unused-argument
+        return False
+
+    def _send_app_identifier(self, session_id: str) -> None:
+        if SF_DEBUG:
+            print(
+                "_send_app_identifier...SENDING DATA...args=",
+                set(),
+                log=False,
+            )
+        self.service_identifier.do_send(set())
+
+    def do_send(self, args, session_id: str) -> None:
+        self._send_app_identifier(session_id)
+        if SF_DEBUG:
+            print(f"[[OutputInterceptor.do_send]] session_id={session_id}", log=False)
+        try:
+            threading.Thread(target=self.send, args=args).start()
+        except RuntimeError:
+            return
+
+
+class LogInterceptor(OutputInterceptor):
+    def __init__(self, api_key: str = app_config._sailfish_api_key):
+        super().__init__(api_key)
+        self.operation_name = "CollectLogs"
+
+    def check_if_contents_should_be_ignored(self, contents):
+        if SF_DEBUG:
+            print(
+                "LogInterceptor...check_if_contents_should_be_ignored(self, contents)",
+                "||||",
+                contents,
+                "||||",
+                log=False,
+            )
+        pattern = r"HTTP\s(POST|GET)\s(\/healthz|\/graphql\/)\s.*"
+        result = re.match(pattern, contents)
+        return result is not None
+
+    def send(
+        self, level, contents, session_id: str
+    ):  # pylint: disable=arguments-differ
+        if SF_DEBUG:
+            print(f"LogInterceptor:  Running send, session_id={session_id}", log=False)
+        if self.check_if_contents_should_be_ignored(contents):
+            if SF_DEBUG:
+                print("LogInterceptor:  EARLY EXIT - contents:", contents, log=False)
+            return
+        query = f"""
+        {self.query_type} {self.operation_name}($apiKey: String!, $serviceUuid: String!, $sessionId: String!, $level: String!, $contents: String!, $reentrancyGuardPreactive: Boolean!, $library: String!, $timestampMs: String!, $version: String!) {{
+            {self.query_name}(apiKey: $apiKey, serviceUuid: $serviceUuid, sessionId: $sessionId, level: $level, contents: $contents, reentrancyGuardPreactive: $reentrancyGuardPreactive, library: $library, timestampMs: $timestampMs, version: $version)
+        }}
+        """
+        if SF_DEBUG:
+            print(
+                "LogInterceptor:  non_blocking_post is next",
+                "level",
+                level,
+                "contents:",
+                contents,
+                log=False,
+            )
+        non_blocking_post(
+            self.endpoint,
+            self.operation_name,
+            query,
+            self.get_variables(
+                {
+                    "level": level if level else "UNKNOWN",
+                    "contents": contents,
+                    "reentrancyGuardPreactive": False,
+                },
+                session_id,
+            ),
+        )
+
+
+class PrintInterceptor(OutputInterceptor):
+    def __init__(self, api_key: str = app_config._sailfish_api_key):
+        super().__init__(api_key)
+        self.operation_name = "CollectPrintStatements"
+
+    def send(self, contents, session_id: str):
+        if self.check_if_contents_should_be_ignored(contents):
+            return
+        query = f"""
+        {self.query_type} {self.operation_name}($apiKey: String!, $serviceUuid: String!, $sessionId: String!, $contents: String!, $reentrancyGuardPreactive: Boolean!, $library: String!, $timestampMs: String!, $version: String!) {{
+            {self.query_name}(apiKey: $apiKey, serviceUuid: $serviceUuid, sessionId: $sessionId, contents: $contents, reentrancyGuardPreactive: $reentrancyGuardPreactive, library: $library, timestampMs: $timestampMs, version: $version)
+        }}
+        """
+
+        non_blocking_post(
+            self.endpoint,
+            self.operation_name,
+            query,
+            self.get_variables(
+                {
+                    "contents": contents,
+                    "reentrancyGuardPreactive": False,
+                },
+                session_id,
+            ),
+        )
+
+
+class ExceptionInterceptor(OutputInterceptor):
+    def __init__(self, api_key: str = app_config._sailfish_api_key):
+        super().__init__(api_key)
+        self.operation_name = "CollectExceptions"
+
+    def send(
+        self,
+        exception_message: str,
+        trace: List[FrameInfo],
+        session_id: str,
+        was_caught: bool = True,
+        is_from_local_service: bool = False
+    ):
+        query = f"""
+        {self.query_type} {self.operation_name}($apiKey: String!, $serviceUuid: String!, $sessionId: String!, $exceptionMessage: String!, $wasCaught: Boolean!, $traceJson: String!, $reentrancyGuardPreactive: Boolean!, $library: String!, $timestampMs: String!, $version: String!, $isFromLocalService: Boolean!) {{
+            {self.query_name}(apiKey: $apiKey, serviceUuid: $serviceUuid, sessionId: $sessionId, exceptionMessage: $exceptionMessage, wasCaught: $wasCaught, traceJson: $traceJson, reentrancyGuardPreactive: $reentrancyGuardPreactive, library: $library, timestampMs: $timestampMs, version: $version, isFromLocalService: $isFromLocalService)
+        }}
+        """
+
+        if SF_DEBUG:
+            print("SENDING EXCEPTION...", log=False)
+        non_blocking_post(
+            self.endpoint,
+            self.operation_name,
+            query,
+            self.get_variables(
+                {
+                    "apiKey": self.api_key,
+                    "exceptionMessage": exception_message,
+                    "traceJson": json.dumps(trace, cls=CustomJSONEncoderForFrameInfo),
+                    "reentrancyGuardPreactive": False,
+                    "wasCaught": was_caught,
+                    "isFromLocalService": is_from_local_service
+                },
+                session_id,
+            ),
+        )
+
+
+class CollectMetadataTransmitter(OutputInterceptor):
+    def __init__(self, api_key: str = app_config._sailfish_api_key):
+        super().__init__(api_key)
+        self.operation_name = "CollectMetadata"
+
+    def send(
+        self,
+        user_id: str,
+        traits: Optional[Dict[str, Any]],
+        traits_json: Optional[str],
+        override: bool,
+        session_id: str,
+    ):
+        if traits is None and traits_json is None:
+            raise Exception(
+                'Must pass in either traits or traits_json to "add_or_update_traits"'
+            )
+        query = f"""
+        {self.query_type} {self.operation_name}($apiKey: String!, $serviceUuid: String!, $sessionId: String!, $userId: String!, $traitsJson: String!, $excludedFields: [String!]!, $library: String!, $timestampMs: String!, $version: String!, $override: Boolean!) {{
+            {self.query_name}(apiKey: $apiKey, serviceUuid: $serviceUuid, sessionId: $sessionId, userId: $userId, traitsJson: $traitsJson, excludedFields: $excludedFields, library: $library, timestampMs: $timestampMs, version: $version, override: $override)
+        }}
+        """
+
+        excluded_fields = []
+        if traits_json is None:
+            traits_json, excluded_fields = serialize_json_with_exclusions(traits)
+
+        variables = self.get_variables(
+            {
+                "userId": user_id,
+                "traitsJson": traits_json,
+                "excludedFields": excluded_fields,
+                "override": override,
+            },
+            session_id,
+        )
+
+        non_blocking_post(self.endpoint, self.operation_name, query, variables)

sf_veritas/local_env_detect.py

@@ -0,0 +1,118 @@
+from __future__ import annotations
+import os, sys, socket, urllib.request, urllib.error
+
+DEFAULT_TIMEOUT_S = 0.15
+
+def _quick_http(url: str, headers: dict[str, str] | None = None, timeout: float = DEFAULT_TIMEOUT_S) -> tuple[int | None, str]:
+    req = urllib.request.Request(url, headers=headers or {}, method="GET")
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            return resp.getcode(), "ok"
+    except urllib.error.HTTPError as e:
+        return e.code, "http_error"
+    except Exception as e:
+        return None, str(e)
+
+def _is_cloud_instance() -> tuple[bool, str]:
+    try:
+        import urllib.request as _u
+        tok_req = _u.Request(
+            "http://169.254.169.254/latest/api/token",
+            headers={"X-aws-ec2-metadata-token-ttl-seconds": "60"},
+            method="PUT",
+        )
+        with _u.urlopen(tok_req, timeout=DEFAULT_TIMEOUT_S) as r:
+            if r.getcode() == 200:
+                return True, "aws-imdsv2"
+    except urllib.error.HTTPError as e:
+        if e.code in (401, 403, 404, 405):
+            return True, f"aws-imds({e.code})"
+    except Exception:
+        pass
+
+    code, _ = _quick_http("http://169.254.169.254/latest/meta-data/")
+    if code == 200:
+        return True, "aws-imdsv1"
+
+    code, _ = _quick_http(
+        "http://169.254.169.254/computeMetadata/v1/instance/id",
+        headers={"Metadata-Flavor": "Google"},
+    )
+    if code == 200:
+        return True, "gcp-metadata"
+
+    code, _ = _quick_http(
+        "http://169.254.169.254/metadata/instance?api-version=2021-02-01",
+        headers={"Metadata": "true"},
+    )
+    if code == 200:
+        return True, "azure-imds"
+
+    return False, "no-cloud-metadata"
+
+def _resolves_host_docker_internal() -> bool:
+    try:
+        socket.gethostbyname("host.docker.internal")
+        return True
+    except Exception:
+        return False
+
+# ---- globals to hold state ----
+SF_IS_LOCAL_ENV: bool | None = None
+SF_LOCAL_ENV_REASON: str | None = None
+
+
+def _detect() -> tuple[bool, str]:
+    """Detect environment once. Raise nothing; always return a tuple."""
+    try:
+        if any(os.getenv(k) for k in (
+            "CI", "GITHUB_ACTIONS", "GITLAB_CI", "CIRCLECI",
+            "BUILDkite", "TEAMCITY_VERSION", "JENKINS_URL", "DRONE"
+        )):
+            return (False, "ci-env-detected")
+
+        on_cloud, cloud_reason = _is_cloud_instance()
+        if on_cloud:
+            return (False, cloud_reason)
+
+        if sys.platform in ("darwin", "win32"):
+            return (True, f"desktop-os:{sys.platform}")
+        try:
+            if "microsoft" in os.uname().release.lower() \
+               or "microsoft" in open("/proc/version", "rt", errors="ignore").read().lower():
+                return (True, "wsl-kernel")
+        except OSError:
+            pass
+
+        if _resolves_host_docker_internal():
+            return (True, "docker-desktop-dns")
+
+        return (True, "no-cloud-metadata-and-no-ci")
+
+    except Exception as e:
+        # fallback: treat as local if detection fails
+        return (True, f"detect-error:{type(e).__name__}")
+
+
+def set_sf_is_local_flag() -> None:
+    """
+    Run detection once and store results in global variables.
+    Call this at app startup. Never raises.
+    """
+    global SF_IS_LOCAL_ENV, SF_LOCAL_ENV_REASON
+    try:
+        SF_IS_LOCAL_ENV, SF_LOCAL_ENV_REASON = _detect()
+    except Exception as e:
+        # absolute fallback, so setup never fails
+        SF_IS_LOCAL_ENV, SF_LOCAL_ENV_REASON = True, f"setup-error:{type(e).__name__}"
+
+
+def sf_is_local_dev_environment() -> tuple[bool, str]:
+    """
+    Return cached values if sf_set_is_local_flag() has been called,
+    otherwise run detection on the fly. Never raises.
+    """
+    global SF_IS_LOCAL_ENV, SF_LOCAL_ENV_REASON
+    if SF_IS_LOCAL_ENV is None or SF_LOCAL_ENV_REASON is None:
+        set_sf_is_local_flag()
+    return SF_IS_LOCAL_ENV, SF_LOCAL_ENV_REASON

sf_veritas/package_metadata.py

@@ -0,0 +1,6 @@
+import importlib.metadata
+
+PACKAGE_LIBRARY_TYPE = "PYTHON"
+PACKAGE_NAME = "sf-veritas"
+
+__version__ = importlib.metadata.version(PACKAGE_NAME)

sf_veritas/patches/concurrent_futures.py

@@ -0,0 +1,19 @@
+from concurrent.futures import ThreadPoolExecutor, ProcessPoolExecutor
+from ..thread_local import get_context, set_context
+
+_original_submit = ThreadPoolExecutor.submit
+
+
+def patched_submit(self, fn, *args, **kwargs):
+    current_context = get_context()
+
+    def wrapped_fn(*fn_args, **fn_kwargs):
+        set_context(current_context)
+        fn(*fn_args, **fn_kwargs)
+
+    return _original_submit(self, wrapped_fn, *args, **kwargs)
+
+
+def patch_concurrent_futures():
+    ThreadPoolExecutor.submit = patched_submit
+    ProcessPoolExecutor.submit = patched_submit

sf_veritas/patches/constants.py

@@ -0,0 +1 @@
+supported_network_verbs = ("get", "post", "put", "patch", "delete", "head", "options")

sf_veritas/patches/exceptions.py

@@ -0,0 +1,82 @@
+import importlib.util
+import sys
+import threading
+import time
+from importlib import abc
+
+from ..env_vars import PRINT_CONFIGURATION_STATUSES
+
+# Thread-local storage to avoid re-entry problems
+patch_lock = threading.local()
+
+
+def patch_exceptions(module):
+    if hasattr(patch_lock, "active"):
+        return
+    patch_lock.active = True
+
+
+class ExceptionPatchingFinder(abc.MetaPathFinder):
+    def find_spec(self, fullname, path, target=None):
+        if hasattr(patch_lock, "loading") and patch_lock.loading:
+            return None
+        try:
+            patch_lock.loading = True
+            original_spec = importlib.util.find_spec(fullname, path)
+            if original_spec:
+                return importlib.util.spec_from_loader(
+                    fullname,
+                    ExceptionPatchingLoader(original_spec.loader),
+                    origin=original_spec.origin,
+                )
+            return None
+        finally:
+            patch_lock.loading = False
+
+
+class ExceptionPatchingLoader(abc.Loader):
+    def __init__(self, loader):
+        self._original_loader = loader
+
+    def create_module(self, spec):
+        return self._original_loader.create_module(spec)
+
+    def exec_module(self, module):
+        self._original_loader.exec_module(module)
+        patch_exceptions(module)
+
+
+def install_import_hook():
+    if PRINT_CONFIGURATION_STATUSES:
+        print("EXCEPTIONS - install_import_hook", log=False)
+    sys.meta_path.insert(0, ExceptionPatchingFinder())
+    if PRINT_CONFIGURATION_STATUSES:
+        print("EXCEPTIONS - install_import_hook...DONE", log=False)
+
+
+# Initially store the current state of sys.excepthook
+original_excepthook = sys.excepthook
+
+
+def monitor_excepthook(interval=1):
+    global original_excepthook
+
+    while True:
+        current_hook = sys.excepthook
+        if current_hook != original_excepthook and PRINT_CONFIGURATION_STATUSES:
+            if PRINT_CONFIGURATION_STATUSES:
+                print("sys.excepthook has been modified!")
+            original_excepthook = current_hook
+            continue
+        if PRINT_CONFIGURATION_STATUSES:
+            print("No change detected in sys.excepthook.")
+
+        # Pause for the specified interval before the next check
+        time.sleep(interval)
+
+
+# Function to start monitoring in a separate thread
+def start_monitoring(interval=2):
+    thread = threading.Thread(target=monitor_excepthook, args=(interval,))
+    # thread.daemon = True  # This makes the thread exit when the main program exits
+    thread.start()