sentry-sdk 2.59.0a1__py3-none-any.whl

sentry_sdk/__init__.py

@@ -0,0 +1,70 @@
+from sentry_sdk import profiler
+from sentry_sdk import metrics
+from sentry_sdk.scope import Scope
+from sentry_sdk.transport import Transport, HttpTransport
+from sentry_sdk.client import Client
+
+from sentry_sdk.api import *  # noqa
+from sentry_sdk.consts import VERSION
+
+__all__ = [  # noqa
+    "Hub",
+    "Scope",
+    "Client",
+    "Transport",
+    "HttpTransport",
+    "VERSION",
+    "integrations",
+    # From sentry_sdk.api
+    "init",
+    "add_attachment",
+    "add_breadcrumb",
+    "capture_event",
+    "capture_exception",
+    "capture_message",
+    "configure_scope",
+    "continue_trace",
+    "flush",
+    "flush_async",
+    "get_baggage",
+    "get_client",
+    "get_global_scope",
+    "get_isolation_scope",
+    "get_current_scope",
+    "get_current_span",
+    "get_traceparent",
+    "is_initialized",
+    "isolation_scope",
+    "last_event_id",
+    "new_scope",
+    "push_scope",
+    "remove_attribute",
+    "set_attribute",
+    "set_context",
+    "set_extra",
+    "set_level",
+    "set_measurement",
+    "set_tag",
+    "set_tags",
+    "set_user",
+    "start_span",
+    "start_transaction",
+    "trace",
+    "monitor",
+    "logger",
+    "metrics",
+    "profiler",
+    "start_session",
+    "end_session",
+    "set_transaction_name",
+    "update_current_span",
+]
+
+# Initialize the debug support after everything is loaded
+from sentry_sdk.debug import init_debug_support
+
+init_debug_support()
+del init_debug_support
+
+# circular imports
+from sentry_sdk.hub import Hub

sentry_sdk/_batcher.py

@@ -0,0 +1,183 @@
+import os
+import random
+import threading
+from datetime import datetime, timezone
+from typing import TYPE_CHECKING, TypeVar, Generic
+import weakref
+
+from sentry_sdk.utils import format_timestamp
+from sentry_sdk.envelope import Envelope, Item, PayloadRef
+
+if TYPE_CHECKING:
+    from typing import Optional, Callable, Any
+
+T = TypeVar("T")
+
+
+class Batcher(Generic[T]):
+    MAX_BEFORE_FLUSH = 100
+    MAX_BEFORE_DROP = 1_000
+    FLUSH_WAIT_TIME = 5.0
+
+    TYPE = ""
+    CONTENT_TYPE = ""
+
+    def __init__(
+        self,
+        capture_func: "Callable[[Envelope], None]",
+        record_lost_func: "Callable[..., None]",
+    ) -> None:
+        self._buffer: "list[T]" = []
+        self._capture_func = capture_func
+        self._record_lost_func = record_lost_func
+        self._running = True
+        self._lock = threading.Lock()
+        self._active: "threading.local" = threading.local()
+
+        self._flush_event: "threading.Event" = threading.Event()
+
+        self._flusher: "Optional[threading.Thread]" = None
+        self._flusher_pid: "Optional[int]" = None
+
+        # See https://github.com/getsentry/sentry-python/blob/051cc01640a29bfd64b1f1e2e3414c02f027dd1b/sentry_sdk/monitor.py#L41-L50
+        if hasattr(os, "register_at_fork"):
+            weak_reset = weakref.WeakMethod(self._reset_thread_state)
+
+            def _reset_in_child() -> None:
+                method = weak_reset()
+                if method is not None:
+                    method()
+
+            os.register_at_fork(after_in_child=_reset_in_child)
+
+    def _reset_thread_state(self) -> None:
+        self._buffer = []
+        self._running = True
+        self._lock = threading.Lock()
+        self._active = threading.local()
+        self._flush_event = threading.Event()
+        self._flusher = None
+        self._flusher_pid = None
+
+    def _ensure_thread(self) -> bool:
+        """For forking processes we might need to restart this thread.
+        This ensures that our process actually has that thread running.
+        """
+        if not self._running:
+            return False
+
+        pid = os.getpid()
+        if self._flusher_pid == pid:
+            return True
+
+        with self._lock:
+            # Recheck to make sure another thread didn't get here and start the
+            # the flusher in the meantime
+            if self._flusher_pid == pid:
+                return True
+
+            self._flusher_pid = pid
+
+            self._flusher = threading.Thread(target=self._flush_loop)
+            self._flusher.daemon = True
+
+            try:
+                self._flusher.start()
+            except RuntimeError:
+                # Unfortunately at this point the interpreter is in a state that no
+                # longer allows us to spawn a thread and we have to bail.
+                self._running = False
+                return False
+
+        return True
+
+    def _flush_loop(self) -> None:
+        # Mark the flush-loop thread as active for its entire lifetime so
+        # that any re-entrant add() triggered by GC warnings during wait(),
+        # flush(), or Event operations is silently dropped instead of
+        # deadlocking on internal locks.
+        self._active.flag = True
+        while self._running:
+            self._flush_event.wait(self.FLUSH_WAIT_TIME + random.random())
+            self._flush_event.clear()
+            self._flush()
+
+    def add(self, item: "T") -> None:
+        # Bail out if the current thread is already executing batcher code.
+        # This prevents deadlocks when code running inside the batcher (e.g.
+        # _add_to_envelope during flush, or _flush_event.wait/set) triggers
+        # a GC-emitted warning that routes back through the logging
+        # integration into add().
+        if getattr(self._active, "flag", False):
+            return None
+
+        self._active.flag = True
+        try:
+            if not self._ensure_thread() or self._flusher is None:
+                return None
+
+            with self._lock:
+                if len(self._buffer) >= self.MAX_BEFORE_DROP:
+                    self._record_lost(item)
+                    return None
+
+                self._buffer.append(item)
+                if len(self._buffer) >= self.MAX_BEFORE_FLUSH:
+                    self._flush_event.set()
+        finally:
+            self._active.flag = False
+
+    def kill(self) -> None:
+        if self._flusher is None:
+            return
+
+        self._running = False
+        self._flush_event.set()
+        self._flusher = None
+
+    def flush(self) -> None:
+        was_active = getattr(self._active, "flag", False)
+        self._active.flag = True
+        try:
+            self._flush()
+        finally:
+            self._active.flag = was_active
+
+    def _add_to_envelope(self, envelope: "Envelope") -> None:
+        envelope.add_item(
+            Item(
+                type=self.TYPE,
+                content_type=self.CONTENT_TYPE,
+                headers={
+                    "item_count": len(self._buffer),
+                },
+                payload=PayloadRef(
+                    json={
+                        "items": [
+                            self._to_transport_format(item) for item in self._buffer
+                        ]
+                    }
+                ),
+            )
+        )
+
+    def _flush(self) -> "Optional[Envelope]":
+        envelope = Envelope(
+            headers={"sent_at": format_timestamp(datetime.now(timezone.utc))}
+        )
+        with self._lock:
+            if len(self._buffer) == 0:
+                return None
+
+            self._add_to_envelope(envelope)
+            self._buffer.clear()
+
+        self._capture_func(envelope)
+        return envelope
+
+    def _record_lost(self, item: "T") -> None:
+        pass
+
+    @staticmethod
+    def _to_transport_format(item: "T") -> "Any":
+        pass

sentry_sdk/_compat.py

@@ -0,0 +1,94 @@
+import sys
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+    from typing import TypeVar
+
+    T = TypeVar("T")
+
+
+PY37 = sys.version_info[0] == 3 and sys.version_info[1] >= 7
+PY38 = sys.version_info[0] == 3 and sys.version_info[1] >= 8
+PY310 = sys.version_info[0] == 3 and sys.version_info[1] >= 10
+PY311 = sys.version_info[0] == 3 and sys.version_info[1] >= 11
+
+
+def with_metaclass(meta: "Any", *bases: "Any") -> "Any":
+    class MetaClass(type):
+        def __new__(metacls: "Any", name: "Any", this_bases: "Any", d: "Any") -> "Any":
+            return meta(name, bases, d)
+
+    return type.__new__(MetaClass, "temporary_class", (), {})
+
+
+def check_uwsgi_thread_support() -> bool:
+    # We check two things here:
+    #
+    # 1. uWSGI doesn't run in threaded mode by default -- issue a warning if
+    #    that's the case.
+    #
+    # 2. Additionally, if uWSGI is running in preforking mode (default), it needs
+    #    the --py-call-uwsgi-fork-hooks option for the SDK to work properly. This
+    #    is because any background threads spawned before the main process is
+    #    forked are NOT CLEANED UP IN THE CHILDREN BY DEFAULT even if
+    #    --enable-threads is on. One has to explicitly provide
+    #    --py-call-uwsgi-fork-hooks to force uWSGI to run regular cpython
+    #    after-fork hooks that take care of cleaning up stale thread data.
+    try:
+        from uwsgi import opt  # type: ignore
+    except ImportError:
+        return True
+
+    from sentry_sdk.consts import FALSE_VALUES
+
+    def enabled(option: str) -> bool:
+        value = opt.get(option, False)
+        if isinstance(value, bool):
+            return value
+
+        if isinstance(value, bytes):
+            try:
+                value = value.decode()
+            except Exception:
+                pass
+
+        return value and str(value).lower() not in FALSE_VALUES
+
+    # When `threads` is passed in as a uwsgi option,
+    # `enable-threads` is implied on.
+    threads_enabled = "threads" in opt or enabled("enable-threads")
+    fork_hooks_on = enabled("py-call-uwsgi-fork-hooks")
+    lazy_mode = enabled("lazy-apps") or enabled("lazy")
+
+    if lazy_mode and not threads_enabled:
+        from warnings import warn
+
+        warn(
+            Warning(
+                "IMPORTANT: "
+                "We detected the use of uWSGI without thread support. "
+                "This might lead to unexpected issues. "
+                'Please run uWSGI with "--enable-threads" for full support.'
+            )
+        )
+
+        return False
+
+    elif not lazy_mode and (not threads_enabled or not fork_hooks_on):
+        from warnings import warn
+
+        warn(
+            Warning(
+                "IMPORTANT: "
+                "We detected the use of uWSGI in preforking mode without "
+                "thread support. This might lead to crashing workers. "
+                'Please run uWSGI with both "--enable-threads" and '
+                '"--py-call-uwsgi-fork-hooks" for full support.'
+            )
+        )
+
+        return False
+
+    return True

sentry_sdk/_init_implementation.py

@@ -0,0 +1,79 @@
+import warnings
+
+from typing import TYPE_CHECKING
+
+import sentry_sdk
+
+if TYPE_CHECKING:
+    from typing import Any, ContextManager, Optional
+
+    import sentry_sdk.consts
+
+
+class _InitGuard:
+    _CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE = (
+        "Using the return value of sentry_sdk.init as a context manager "
+        "and manually calling the __enter__ and __exit__ methods on the "
+        "return value are deprecated. We are no longer maintaining this "
+        "functionality, and we will remove it in the next major release."
+    )
+
+    def __init__(self, client: "sentry_sdk.Client") -> None:
+        self._client = client
+
+    def __enter__(self) -> "_InitGuard":
+        warnings.warn(
+            self._CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE,
+            stacklevel=2,
+            category=DeprecationWarning,
+        )
+
+        return self
+
+    def __exit__(self, exc_type: "Any", exc_value: "Any", tb: "Any") -> None:
+        warnings.warn(
+            self._CONTEXT_MANAGER_DEPRECATION_WARNING_MESSAGE,
+            stacklevel=2,
+            category=DeprecationWarning,
+        )
+
+        c = self._client
+        if c is not None:
+            c.close()
+
+
+def _check_python_deprecations() -> None:
+    # Since we're likely to deprecate Python versions in the future, I'm keeping
+    # this handy function around. Use this to detect the Python version used and
+    # to output logger.warning()s if it's deprecated.
+    pass
+
+
+def _init(*args: "Optional[str]", **kwargs: "Any") -> "ContextManager[Any]":
+    """Initializes the SDK and optionally integrations.
+
+    This takes the same arguments as the client constructor.
+    """
+    client = sentry_sdk.Client(*args, **kwargs)
+    sentry_sdk.get_global_scope().set_client(client)
+    _check_python_deprecations()
+    rv = _InitGuard(client)
+    return rv
+
+
+if TYPE_CHECKING:
+    # Make mypy, PyCharm and other static analyzers think `init` is a type to
+    # have nicer autocompletion for params.
+    #
+    # Use `ClientConstructor` to define the argument types of `init` and
+    # `ContextManager[Any]` to tell static analyzers about the return type.
+
+    class init(sentry_sdk.consts.ClientConstructor, _InitGuard):  # noqa: N801
+        pass
+
+else:
+    # Alias `init` for actual usage. Go through the lambda indirection to throw
+    # PyCharm off of the weakly typed signature (it would otherwise discover
+    # both the weakly typed signature of `_init` and our faked `init` type).
+
+    init = (lambda: _init)()

sentry_sdk/_log_batcher.py

@@ -0,0 +1,56 @@
+from typing import TYPE_CHECKING
+
+from sentry_sdk._batcher import Batcher
+from sentry_sdk.utils import serialize_attribute
+from sentry_sdk.envelope import Item, PayloadRef
+
+if TYPE_CHECKING:
+    from typing import Any
+    from sentry_sdk._types import Log
+
+
+class LogBatcher(Batcher["Log"]):
+    MAX_BEFORE_FLUSH = 100
+    MAX_BEFORE_DROP = 1_000
+    FLUSH_WAIT_TIME = 5.0
+
+    TYPE = "log"
+    CONTENT_TYPE = "application/vnd.sentry.items.log+json"
+
+    @staticmethod
+    def _to_transport_format(item: "Log") -> "Any":
+        if "sentry.severity_number" not in item["attributes"]:
+            item["attributes"]["sentry.severity_number"] = item["severity_number"]
+        if "sentry.severity_text" not in item["attributes"]:
+            item["attributes"]["sentry.severity_text"] = item["severity_text"]
+
+        res = {
+            "timestamp": int(item["time_unix_nano"]) / 1.0e9,
+            "trace_id": item.get("trace_id", "00000000-0000-0000-0000-000000000000"),
+            "span_id": item.get("span_id"),
+            "level": str(item["severity_text"]),
+            "body": str(item["body"]),
+            "attributes": {
+                k: serialize_attribute(v) for (k, v) in item["attributes"].items()
+            },
+        }
+
+        return res
+
+    def _record_lost(self, item: "Log") -> None:
+        # Construct log envelope item without sending it to report lost bytes
+        log_item = Item(
+            type=self.TYPE,
+            content_type=self.CONTENT_TYPE,
+            headers={
+                "item_count": 1,
+            },
+            payload=PayloadRef(json={"items": [self._to_transport_format(item)]}),
+        )
+
+        self._record_lost_func(
+            reason="queue_overflow",
+            data_category="log_item",
+            item=log_item,
+            quantity=1,
+        )

sentry_sdk/_lru_cache.py

@@ -0,0 +1,43 @@
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from typing import Any
+
+
+_SENTINEL = object()
+
+
+class LRUCache:
+    def __init__(self, max_size: int) -> None:
+        if max_size <= 0:
+            raise AssertionError(f"invalid max_size: {max_size}")
+        self.max_size = max_size
+        self._data: "dict[Any, Any]" = {}
+        self.hits = self.misses = 0
+        self.full = False
+
+    def set(self, key: "Any", value: "Any") -> None:
+        current = self._data.pop(key, _SENTINEL)
+        if current is not _SENTINEL:
+            self._data[key] = value
+        elif self.full:
+            self._data.pop(next(iter(self._data)))
+            self._data[key] = value
+        else:
+            self._data[key] = value
+        self.full = len(self._data) >= self.max_size
+
+    def get(self, key: "Any", default: "Any" = None) -> "Any":
+        try:
+            ret = self._data.pop(key)
+        except KeyError:
+            self.misses += 1
+            ret = default
+        else:
+            self.hits += 1
+            self._data[key] = ret
+
+        return ret
+
+    def get_all(self) -> "list[tuple[Any, Any]]":
+        return list(self._data.items())

sentry_sdk/_metrics_batcher.py

@@ -0,0 +1,45 @@
+from typing import TYPE_CHECKING
+
+from sentry_sdk._batcher import Batcher
+from sentry_sdk.utils import serialize_attribute
+
+if TYPE_CHECKING:
+    from typing import Any
+    from sentry_sdk._types import Metric
+
+
+class MetricsBatcher(Batcher["Metric"]):
+    MAX_BEFORE_FLUSH = 1000
+    MAX_BEFORE_DROP = 10_000
+    FLUSH_WAIT_TIME = 5.0
+
+    TYPE = "trace_metric"
+    CONTENT_TYPE = "application/vnd.sentry.items.trace-metric+json"
+
+    @staticmethod
+    def _to_transport_format(item: "Metric") -> "Any":
+        res = {
+            "timestamp": item["timestamp"],
+            "trace_id": item["trace_id"],
+            "name": item["name"],
+            "type": item["type"],
+            "value": item["value"],
+            "attributes": {
+                k: serialize_attribute(v) for (k, v) in item["attributes"].items()
+            },
+        }
+
+        if item.get("span_id") is not None:
+            res["span_id"] = item["span_id"]
+
+        if item.get("unit") is not None:
+            res["unit"] = item["unit"]
+
+        return res
+
+    def _record_lost(self, item: "Metric") -> None:
+        self._record_lost_func(
+            reason="queue_overflow",
+            data_category="trace_metric",
+            quantity=1,
+        )