sf-veritas 0.9.7__py3-none-any.whl

sf_veritas/custom_log_handler.py

@@ -0,0 +1,53 @@
+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
+
+
+class CustomLogHandler(logging.Handler, LogInterceptor):
+    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, trace_id: Optional[str] = None):
+        if isinstance(record, logging.LogRecord):
+            try:
+                log_entry = self.format(record)
+                log_level = record.levelname
+
+                if SF_DEBUG:
+                    print(
+                        "[[DEBUG custom_log_handler]]",
+                        f"trace_id={trace_id}",
+                        f"[[{log_level}]]",
+                        log_entry,
+                        "[[/DEBUG]]",
+                        log=False,
+                    )
+
+                if SF_DEBUG:
+                    print(
+                        "CustomLogHandler...SENDING DATA...do_send args=",
+                        (log_level, log_entry, trace_id),
+                        trace_id,
+                        log=False,
+                    )
+                _, trace_id = get_or_set_sf_trace_id(trace_id)
+                if SF_DEBUG:
+                    print(
+                        "CustomLogHandler...SENDING DATA...do_send args=",
+                        (log_level, log_entry, trace_id),
+                        trace_id,
+                        log=False,
+                    )
+                self.do_send((log_level, log_entry, trace_id), trace_id)
+
+            except Exception as e:  # pylint: disable=broad-exception-caught
+                # TODO - Sibyl post-launch - disable this print??
+                print("There's an error when emitting!!!!!\n", e)
+                self.handleError(record)

sf_veritas/custom_output_wrapper.py

@@ -0,0 +1,107 @@
+import re
+import sys
+import threading
+
+# from ._to_be_deleted__custom_output_wrapper_stderr import CustomOutputWrapperStdErr
+from .env_vars import PRINT_CONFIGURATION_STATUSES, SF_DEBUG
+from .interceptors import PrintInterceptor
+from .thread_local import _thread_locals, get_or_set_sf_trace_id
+
+
+class CustomOutputWrapper:
+    def __init__(self, original):
+        self.original = original
+        self.print_interceptor = PrintInterceptor()
+        self._lock = threading.Lock()
+
+    def write(self, msg):
+        if (
+            hasattr(_thread_locals, "reentrancy_guard_logging_active")
+            and _thread_locals.reentrancy_guard_logging_active
+        ):
+            self.original.write(msg)
+            self.original.flush()
+            return
+
+        with self._lock:
+            # Add custom tags if SF_DEBUG is enabled
+            msg_with_tags = (
+                f"[[CUSTOM-OUTPUT]] {msg} [[/CUSTOM-OUTPUT]]\n" if SF_DEBUG else msg
+            )
+            self.original.write(msg_with_tags)
+            self.original.flush()
+
+            # Intercept the message and log it
+            # self.print_interceptor.send(msg_with_tags)
+            pattern = r"HTTP\s(POST|GET)\s(\/healthz|\/graphql\/)\s.*"
+            if re.match(pattern, msg):
+                return
+
+            _, trace_id = get_or_set_sf_trace_id()
+            if SF_DEBUG:
+                print(
+                    "CustomOutputWrapper...SENDING DATA...args=",
+                    (msg_with_tags, trace_id),
+                    trace_id,
+                    log=False,
+                )
+            self.print_interceptor.do_send((msg_with_tags, trace_id), trace_id)
+
+    def __getattr__(self, attr):
+        return getattr(self.original, attr)
+
+
+def setup_custom_output_wrappers():
+    if PRINT_CONFIGURATION_STATUSES:
+        print("setup_custom_output_wrappers")
+    sys.stdout = CustomOutputWrapper(sys.stdout)
+    # sys.stderr = CustomOutputWrapperStdErr(sys.stderr)  # TODO - uncomment
+    if PRINT_CONFIGURATION_STATUSES:
+        print("setup_custom_output_wrappers...DONE")
+
+
+def get_custom_output_wrapper_django():
+    from django.core.management.base import OutputWrapper
+
+    class CustomOutputWrapperDjango(OutputWrapper):
+        def __init__(self, *args, **kwargs):
+            super().__init__(*args, **kwargs)
+            self.print_interceptor = PrintInterceptor()
+
+        def write(self, msg="", style_func=None, ending=None):
+            if (
+                hasattr(_thread_locals, "reentrancy_guard_logging_active")
+                and _thread_locals.reentrancy_guard_logging_active
+            ):
+                super().write(msg, style_func, ending)
+                return
+
+            # Add custom tags if SF_DEBUG is enabled
+            if style_func is None:
+                style_func = lambda x: (
+                    f"[[CUSTOM-OUTPUT-DJANGO]] {x} [[/CUSTOM-OUTPUT-DJANGO]]\n"
+                    if SF_DEBUG
+                    else x
+                )
+
+            # Use the original write method
+            super().write(msg, style_func, ending)
+
+            pattern = r"HTTP\s(POST|GET)\s(\/healthz|\/graphql\/)\s.*"
+            if re.match(pattern, msg):
+                return
+
+            # Intercept the message and log it
+            message = msg if ending is None else msg + ending
+
+            _, trace_id = get_or_set_sf_trace_id()
+            if SF_DEBUG:
+                print(
+                    "get_custom_output_wrapper_django...SENDING DATA...",
+                    message,
+                    trace_id,
+                    log=False,
+                )
+            self.print_interceptor.do_send((message, trace_id), trace_id)
+
+    return CustomOutputWrapperDjango

sf_veritas/custom_print.py

@@ -0,0 +1,34 @@
+import builtins
+import sys
+
+from .env_vars import SF_DEBUG
+from .thread_local import (
+    _thread_locals,
+    activate_reentrancy_guards_sys_stdout,
+    get_or_set_sf_trace_id,
+)
+
+
+def custom_print(*args, log=True, **kwargs):
+    """
+    Custom print function to intercept print statements.
+    """
+    # Prepare the message to print
+    print_args = ("[[CUSTOM-PRINT]]", *args, "[[/CUSTOM-PRINT]]") if SF_DEBUG else args
+    activate_reentrancy_guards_sys_stdout()
+    builtins._original_print(  # pylint: disable=protected-access; This is added by our interceptor
+        *print_args, file=sys.__stdout__, **kwargs
+    )
+
+    message = " ".join(map(str, args))
+    # If log is True, send the message to the logging system
+    if log and message.strip():
+        _, trace_id = get_or_set_sf_trace_id()
+        if SF_DEBUG:
+            print(
+                "UnifiedInterceptor.custom_print...SENDING DATA...args=",
+                (message, trace_id),
+                trace_id,
+                log=False,
+            )
+        sys.stdout.print_interceptor.do_send((message, trace_id), trace_id)

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,83 @@
+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"))
+PRINT_CONFIGURATION_STATUSES = strtobool(
+    os.getenv("PRINT_CONFIGURATION_STATUSES", "false")
+)
+# 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()

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)

sf_veritas/exception_metaclass.py

@@ -0,0 +1,69 @@
+from abc import ABCMeta
+
+from .custom_excepthook import transmit_exception
+
+
+class ExceptionMeta(ABCMeta):
+    """
+    Metaclass to add `capture_even_if_caught` functionality to exceptions
+    and provide a `transmit_to_sailfish` method for all exceptions.
+    """
+
+    def __new__(cls, name, bases, dct):
+        # Wrap or define the `__init__` method
+        if "__init__" in dct:
+            original_init = dct["__init__"]
+
+            def wrapped_init(self, *args, **kwargs):
+                # Add the `capture_even_if_caught` attribute
+                self.capture_even_if_caught = kwargs.pop(
+                    "capture_even_if_caught", False
+                )
+                self._handled = False  # Ensure `_handled` is initialized
+                original_init(self, *args, **kwargs)
+
+            dct["__init__"] = wrapped_init
+        else:
+
+            def default_init(self, *args, **kwargs):
+                # Add the `capture_even_if_caught` attribute
+                self.capture_even_if_caught = kwargs.pop(
+                    "capture_even_if_caught", False
+                )
+                self._handled = False  # Ensure `_handled` is initialized
+                super(Exception, self).__init__(*args, **kwargs)
+
+            dct["__init__"] = default_init
+
+        # Add `transmit_to_sailfish` method to all exceptions
+        def transmit_to_sailfish(self, was_caught: bool = False):
+            """
+            Transmit this exception to Sailfish.
+            """
+            if not getattr(self, "_handled", False):
+                transmit_exception(type(self), self, self.__traceback__, was_caught)
+                setattr(
+                    self, "_handled", True
+                )  # Mark as handled to prevent duplication
+
+        dct["transmit_to_sailfish"] = transmit_to_sailfish
+
+        return super().__new__(cls, name, bases, dct)
+
+    def __call__(cls, *args, **kwargs):
+        """
+        Intercept exception instantiation to handle `capture_even_if_caught`.
+        """
+        instance = super().__call__(*args, **kwargs)
+        # Automatically handle `capture_even_if_caught` exceptions
+        if getattr(instance, "capture_even_if_caught", False):
+            instance.transmit_to_sailfish()
+        return instance
+
+
+class PatchedException(Exception, metaclass=ExceptionMeta):
+    """
+    A patched version of the built-in Exception class with universal interception capabilities.
+    """
+
+    pass

sf_veritas/frame_tools.py

@@ -0,0 +1,112 @@
+import sys
+from typing import Any, Iterable, List
+
+from .env_vars import (
+    SAILFISH_EXCEPTION_LOCALS_HIDE_DUNDER,
+    SAILFISH_EXCEPTION_LOCALS_HIDE_SELF,
+    SAILFISH_EXCEPTION_LOCALS_HIDE_SUNDER,
+    SAILFISH_EXCEPTION_LOCALS_TYPES_TO_IGNORE,
+)
+
+
+def import_type(module_name: str, type_name: str):
+    try:
+        exec(  # pylint: disable=exec-used
+            f"from {module_name} import {type_name}",
+            globals(),
+        )
+        return globals().get(type_name, None)
+    except ImportError:
+        return None
+
+
+def get_types_from_str(types_str: str) -> List[type]:
+    types_list = []
+    if types_str:
+        for type_path in types_str.split(","):
+            type_path_fixed = type_path.replace(" ", "")
+            module_name, type_name = type_path_fixed.rsplit(".", 1)
+            type_obj = import_type(module_name, type_name)
+            if type_obj:
+                types_list.append(type_obj)
+    return types_list
+
+
+EXCEPTION_LOCALS_TYPES_TO_IGNORE = get_types_from_str(
+    SAILFISH_EXCEPTION_LOCALS_TYPES_TO_IGNORE
+)
+
+
+def get_current_frame():
+    return sys._getframe(1)  # pylint: disable=protected-access
+
+
+def value_type_to_be_ignored(value: Any) -> bool:
+    return any(
+        isinstance(value, type_obj) for type_obj in EXCEPTION_LOCALS_TYPES_TO_IGNORE
+    )
+
+
+def key_is_str_to_be_ignored(
+    key: Any, locals_hide_self: bool, locals_hide_dunder: bool, locals_hide_sunder: bool
+) -> bool:
+    return (
+        (locals_hide_self and key == "self")
+        or (locals_hide_dunder and key.startswith("__"))
+        or (locals_hide_sunder and key.startswith("_"))
+    )
+
+
+def filter_locals(
+    iter_locals: Iterable[tuple[str, object]],
+    locals_hide_self: bool,
+    locals_hide_dunder: bool,
+    locals_hide_sunder: bool,
+) -> Iterable[tuple[str, object]]:
+    for key, value in iter_locals:
+        if not isinstance(key, str):
+            if value_type_to_be_ignored(value):
+                continue
+        else:
+            if key_is_str_to_be_ignored(
+                key, locals_hide_self, locals_hide_dunder, locals_hide_sunder
+            ):
+                continue
+            if value_type_to_be_ignored(value):
+                continue
+            if key in ("args", "field_args") and isinstance(value, list):
+                value = list(
+                    filter_locals(
+                        enumerate(value),
+                        locals_hide_self,
+                        locals_hide_dunder,
+                        locals_hide_sunder,
+                    )
+                )
+            if key in ("kwargs", "field_kwargs") and isinstance(value, dict):
+                value = dict(
+                    filter_locals(
+                        value.items(),
+                        locals_hide_self,
+                        locals_hide_dunder,
+                        locals_hide_sunder,
+                    )
+                )
+        yield key, value
+
+
+def get_locals(
+    iter_locals: Iterable[tuple[str, object]],
+    locals_hide_self: bool = SAILFISH_EXCEPTION_LOCALS_HIDE_SELF,
+    locals_hide_dunder: bool = SAILFISH_EXCEPTION_LOCALS_HIDE_DUNDER,
+    locals_hide_sunder: bool = SAILFISH_EXCEPTION_LOCALS_HIDE_SUNDER,
+) -> Iterable[tuple[str, object]]:
+    """Extract locals from an iterator of key pairs."""
+    if not (locals_hide_dunder or locals_hide_sunder):
+        yield from iter_locals
+        return
+    iter_locals_filtered = filter_locals(
+        iter_locals, locals_hide_self, locals_hide_dunder, locals_hide_sunder
+    )
+    for key, value in iter_locals_filtered:
+        yield key, value

sf_veritas/import_hook.py

@@ -0,0 +1,62 @@
+import importlib
+import importlib.util
+import sys
+from importlib.abc import MetaPathFinder
+
+from .custom_excepthook import custom_excepthook
+from .custom_output_wrapper import get_custom_output_wrapper_django
+from .env_vars import PRINT_CONFIGURATION_STATUSES
+
+
+class ImportInterceptor:
+    def __init__(self, module_name, callback):
+        self.module_name = module_name
+        self.callback = callback
+
+    def find_spec(self, fullname, path, target=None):
+        if fullname == self.module_name:
+            self.callback()
+            # Remove the interceptor once the callback has been called
+            sys.meta_path.remove(self)
+            return importlib.util.find_spec(fullname, path)
+        return None
+
+
+def setup_django_import_hook():
+    interceptor = ImportInterceptor(
+        "django.core.management", get_custom_output_wrapper_django
+    )
+    sys.meta_path.insert(0, interceptor)
+
+
+def wrap_excepthook(old_excepthook):
+    def custom_wrapper_excepthook(exc_type, exc_value, exc_traceback):
+        # Call your custom exception hook
+        custom_excepthook(exc_type, exc_value, exc_traceback)
+        # Call the original exception hook (which might be Sentry's)
+        if old_excepthook is not None:
+            old_excepthook(exc_type, exc_value, exc_traceback)
+
+    return custom_wrapper_excepthook
+
+
+def set_excepthook():
+    # Wrap the current excepthook
+    current_excepthook = sys.excepthook
+    wrapped_excepthook = wrap_excepthook(current_excepthook)
+    sys.excepthook = wrapped_excepthook
+    if PRINT_CONFIGURATION_STATUSES:
+        print("Patched sys.excepthook for custom exception handling.")
+
+
+class ExcepthookImportHook(MetaPathFinder):
+    def find_spec(self, fullname, path, target=None):
+        print("fullname", fullname, log=False)
+        if fullname in sys.modules:
+            print("\t> fullname in sys.modules", log=False)
+            set_excepthook()
+        return None
+
+
+def install_import_hook():
+    sys.meta_path.insert(0, ExcepthookImportHook())

sf_veritas/infra_details/__init__.py

@@ -0,0 +1,3 @@
+from .get_infra_details import get_infra_details
+
+__all__ = ["get_infra_details"]

sf_veritas/infra_details/get_infra_details.py

@@ -0,0 +1,24 @@
+from dataclasses import dataclass
+from typing import Any, Dict
+
+from .kubernetes import get_details as get_kubernetes_details
+from .running_on import System, running_on
+
+
+@dataclass
+class InfraDetails:
+    system: System
+    details: Dict[str, Any]
+
+
+def get_running_on_details(system: System) -> Dict[str, Any]:
+    if system == System.KUBERNETES:
+        return get_kubernetes_details()
+    if system == System.UNKNOWN:
+        return {}
+
+
+def get_infra_details() -> InfraDetails:
+    system = running_on()
+    details = get_running_on_details(system)
+    return InfraDetails(system=system, details=details)

sf_veritas/infra_details/kubernetes/__init__.py

@@ -0,0 +1,3 @@
+from .get_details import get_details
+
+__all__ = ["get_details"]