sentry-sdk 2.26.1__py2.py3-none-any.whl → 3.0.0a1__py2.py3-none-any.whl

sentry_sdk/transport.py

@@ -5,7 +5,6 @@ import gzip
 import socket
 import ssl
 import time
-import warnings
 from datetime import datetime, timedelta, timezone
 from collections import defaultdict
 from urllib.request import getproxies
@@ -18,7 +17,6 @@ except ImportError:
 import urllib3
 import certifi
 
-import sentry_sdk
 from sentry_sdk.consts import EndpointType
 from sentry_sdk.utils import Dsn, logger, capture_internal_exceptions
 from sentry_sdk.worker import BackgroundWorker
@@ -41,7 +39,7 @@ if TYPE_CHECKING:
     from urllib3.poolmanager import PoolManager
     from urllib3.poolmanager import ProxyManager
 
-    from sentry_sdk._types import Event, EventDataCategory
+    from sentry_sdk._types import EventDataCategory
 
 KEEP_ALIVE_SOCKET_OPTIONS = []
 for option in [
@@ -74,25 +72,6 @@ class Transport(ABC):
         else:
             self.parsed_dsn = None
 
-    def capture_event(self, event):
-        # type: (Self, Event) -> None
-        """
-        DEPRECATED: Please use capture_envelope instead.
-
-        This gets invoked with the event dictionary when an event should
-        be sent to sentry.
-        """
-
-        warnings.warn(
-            "capture_event is deprecated, please use capture_envelope instead!",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-
-        envelope = Envelope()
-        envelope.add_event(event)
-        self.capture_envelope(envelope)
-
     @abstractmethod
     def capture_envelope(self, envelope):
         # type: (Self, Envelope) -> None
@@ -178,17 +157,8 @@ def _parse_rate_limits(header, now=None):
 
             retry_after = now + timedelta(seconds=int(retry_after_val))
             for category in categories and categories.split(";") or (None,):
-                if category == "metric_bucket":
-                    try:
-                        namespaces = parameters[4].split(";")
-                    except IndexError:
-                        namespaces = []
-
-                    if not namespaces or "custom" in namespaces:
-                        yield category, retry_after  # type: ignore
-
-                else:
-                    yield category, retry_after  # type: ignore
+                category = cast("Optional[EventDataCategory]", category)
+                yield category, retry_after
         except (LookupError, ValueError):
             continue
 
@@ -217,9 +187,6 @@ class BaseHttpTransport(Transport):
 
         self._pool = self._make_pool()
 
-        # Backwards compatibility for deprecated `self.hub_class` attribute
-        self._hub_cls = sentry_sdk.Hub
-
         experiments = options.get("_experiments", {})
         compression_level = experiments.get(
             "transport_compression_level",
@@ -426,12 +393,6 @@ class BaseHttpTransport(Transport):
         # type: (str) -> bool
         def _disabled(bucket):
             # type: (Any) -> bool
-
-            # The envelope item type used for metrics is statsd
-            # whereas the rate limit category is metric_bucket
-            if bucket == "statsd":
-                bucket = "metric_bucket"
-
             ts = self._disabled_until.get(bucket)
             return ts is not None and ts > datetime.now(timezone.utc)
 
@@ -458,7 +419,7 @@ class BaseHttpTransport(Transport):
         new_items = []
         for item in envelope.items:
             if self._check_disabled(item.data_category):
-                if item.data_category in ("transaction", "error", "default", "statsd"):
+                if item.data_category in ("transaction", "error", "default"):
                     self.on_dropped_event("self_rate_limits")
                 self.record_lost_event("ratelimit_backoff", item=item)
             else:
@@ -587,30 +548,6 @@ class BaseHttpTransport(Transport):
         logger.debug("Killing HTTP transport")
         self._worker.kill()
 
-    @staticmethod
-    def _warn_hub_cls():
-        # type: () -> None
-        """Convenience method to warn users about the deprecation of the `hub_cls` attribute."""
-        warnings.warn(
-            "The `hub_cls` attribute is deprecated and will be removed in a future release.",
-            DeprecationWarning,
-            stacklevel=3,
-        )
-
-    @property
-    def hub_cls(self):
-        # type: (Self) -> type[sentry_sdk.Hub]
-        """DEPRECATED: This attribute is deprecated and will be removed in a future release."""
-        HttpTransport._warn_hub_cls()
-        return self._hub_cls
-
-    @hub_cls.setter
-    def hub_cls(self, value):
-        # type: (Self, type[sentry_sdk.Hub]) -> None
-        """DEPRECATED: This attribute is deprecated and will be removed in a future release."""
-        HttpTransport._warn_hub_cls()
-        self._hub_cls = value
-
 
 class HttpTransport(BaseHttpTransport):
     if TYPE_CHECKING:
@@ -862,35 +799,6 @@ else:
             return httpcore.ConnectionPool(**opts)
 
 
-class _FunctionTransport(Transport):
-    """
-    DEPRECATED: Users wishing to provide a custom transport should subclass
-    the Transport class, rather than providing a function.
-    """
-
-    def __init__(
-        self, func  # type: Callable[[Event], None]
-    ):
-        # type: (...) -> None
-        Transport.__init__(self)
-        self._func = func
-
-    def capture_event(
-        self, event  # type: Event
-    ):
-        # type: (...) -> None
-        self._func(event)
-        return None
-
-    def capture_envelope(self, envelope: Envelope) -> None:
-        # Since function transports expect to be called with an event, we need
-        # to iterate over the envelope and call the function for each event, via
-        # the deprecated capture_event method.
-        event = envelope.get_event()
-        if event is not None:
-            self.capture_event(event)
-
-
 def make_transport(options):
     # type: (Dict[str, Any]) -> Optional[Transport]
     ref_transport = options["transport"]
@@ -906,14 +814,6 @@ def make_transport(options):
         return ref_transport
     elif isinstance(ref_transport, type) and issubclass(ref_transport, Transport):
         transport_cls = ref_transport
-    elif callable(ref_transport):
-        warnings.warn(
-            "Function transports are deprecated and will be removed in a future release."
-            "Please provide a Transport instance or subclass, instead.",
-            DeprecationWarning,
-            stacklevel=2,
-        )
-        return _FunctionTransport(ref_transport)
 
     # if a transport class is given only instantiate it if the dsn is not
     # empty or None

sentry_sdk/types.py

@@ -11,15 +11,39 @@ releases.
 from typing import TYPE_CHECKING
 
 if TYPE_CHECKING:
-    from sentry_sdk._types import Event, EventDataCategory, Hint, Log
+    # Re-export types to make them available in the public API
+    from sentry_sdk._types import (
+        Breadcrumb,
+        BreadcrumbHint,
+        Event,
+        EventDataCategory,
+        Hint,
+        Log,
+        MonitorConfig,
+        SamplingContext,
+    )
 else:
     from typing import Any
 
     # The lines below allow the types to be imported from outside `if TYPE_CHECKING`
     # guards. The types in this module are only intended to be used for type hints.
+    Breadcrumb = Any
+    BreadcrumbHint = Any
     Event = Any
     EventDataCategory = Any
     Hint = Any
     Log = Any
+    MonitorConfig = Any
+    SamplingContext = Any
 
-__all__ = ("Event", "EventDataCategory", "Hint", "Log")
+
+__all__ = (
+    "Breadcrumb",
+    "BreadcrumbHint",
+    "Event",
+    "EventDataCategory",
+    "Hint",
+    "Log",
+    "MonitorConfig",
+    "SamplingContext",
+)

sentry_sdk/utils.py

@@ -25,11 +25,11 @@ except ImportError:
     BaseExceptionGroup = None  # type: ignore
 
 import sentry_sdk
-from sentry_sdk._compat import PY37
 from sentry_sdk.consts import (
     DEFAULT_ADD_FULL_STACK,
     DEFAULT_MAX_STACK_FRAMES,
     DEFAULT_MAX_VALUE_LENGTH,
+    SPANDATA,
     EndpointType,
 )
 from sentry_sdk._types import Annotated, AnnotatedValue, SENSITIVE_DATA_SUBSTITUTE
@@ -57,7 +57,8 @@ if TYPE_CHECKING:
         Union,
     )
 
-    from gevent.hub import Hub
+    from gevent.hub import Hub as GeventHub
+    from opentelemetry.util.types import AttributeValue
 
     from sentry_sdk._types import Event, ExcInfo
 
@@ -86,6 +87,13 @@ exceeds the default sys.getrecursionlimit() of 1000, so users will only
 be affected by this limit if they have a custom recursion limit.
 """
 
+MAX_EXCEPTIONS = 25
+"""Maximum number of exceptions in a chain or group to send to Sentry.
+
+This is a sanity limit to avoid ending in an infinite loop of exceptions when the same exception is in the root and a leave
+of the exception tree.
+"""
+
 
 def env_to_bool(value, *, strict=False):
     # type: (Any, Optional[bool]) -> bool | None
@@ -250,31 +258,6 @@ def format_timestamp(value):
     return utctime.strftime("%Y-%m-%dT%H:%M:%S.%fZ")
 
 
-ISO_TZ_SEPARATORS = frozenset(("+", "-"))
-
-
-def datetime_from_isoformat(value):
-    # type: (str) -> datetime
-    try:
-        result = datetime.fromisoformat(value)
-    except (AttributeError, ValueError):
-        # py 3.6
-        timestamp_format = (
-            "%Y-%m-%dT%H:%M:%S.%f" if "." in value else "%Y-%m-%dT%H:%M:%S"
-        )
-        if value.endswith("Z"):
-            value = value[:-1] + "+0000"
-
-        if value[-6] in ISO_TZ_SEPARATORS:
-            timestamp_format += "%z"
-            value = value[:-3] + value[-2:]
-        elif value[-5] in ISO_TZ_SEPARATORS:
-            timestamp_format += "%z"
-
-        result = datetime.strptime(value, timestamp_format)
-    return result.astimezone(timezone.utc)
-
-
 def event_hint_with_exc_info(exc_info=None):
     # type: (Optional[ExcInfo]) -> Dict[str, Optional[ExcInfo]]
     """Creates a hint with the exc info filled in."""
@@ -822,14 +805,17 @@ def exceptions_from_error(
 ):
     # type: (...) -> Tuple[int, List[Dict[str, Any]]]
     """
-    Creates the list of exceptions.
-    This can include chained exceptions and exceptions from an ExceptionGroup.
-
-    See the Exception Interface documentation for more details:
-    https://develop.sentry.dev/sdk/event-payloads/exception/
+    Converts the given exception information into the Sentry structured "exception" format.
+    This will return a list of exceptions (a flattened tree of exceptions) in the
+    format of the Exception Interface documentation:
+    https://develop.sentry.dev/sdk/data-model/event-payloads/exception/
+
+    This function can handle:
+    - simple exceptions
+    - chained exceptions (raise .. from ..)
+    - exception groups
     """
-
-    parent = single_exception_from_error_tuple(
+    base_exception = single_exception_from_error_tuple(
         exc_type=exc_type,
         exc_value=exc_value,
         tb=tb,
@@ -840,64 +826,79 @@ def exceptions_from_error(
         source=source,
         full_stack=full_stack,
     )
-    exceptions = [parent]
+    exceptions = [base_exception]
 
     parent_id = exception_id
     exception_id += 1
 
-    should_supress_context = hasattr(exc_value, "__suppress_context__") and exc_value.__suppress_context__  # type: ignore
-    if should_supress_context:
-        # Add direct cause.
-        # The field `__cause__` is set when raised with the exception (using the `from` keyword).
-        exception_has_cause = (
+    if exception_id > MAX_EXCEPTIONS - 1:
+        return (exception_id, exceptions)
+
+    causing_exception = None
+    exception_source = None
+
+    # Add any causing exceptions, if present.
+    should_suppress_context = hasattr(exc_value, "__suppress_context__") and exc_value.__suppress_context__  # type: ignore
+    # Note: __suppress_context__ is True if the exception is raised with the `from` keyword.
+    if should_suppress_context:
+        # Explicitly chained exceptions (Like: raise NewException() from OriginalException())
+        # The field `__cause__` is set to OriginalException
+        has_explicit_causing_exception = (
             exc_value
             and hasattr(exc_value, "__cause__")
             and exc_value.__cause__ is not None
         )
-        if exception_has_cause:
-            cause = exc_value.__cause__  # type: ignore
-            (exception_id, child_exceptions) = exceptions_from_error(
-                exc_type=type(cause),
-                exc_value=cause,
-                tb=getattr(cause, "__traceback__", None),
-                client_options=client_options,
-                mechanism=mechanism,
-                exception_id=exception_id,
-                source="__cause__",
-                full_stack=full_stack,
-            )
-            exceptions.extend(child_exceptions)
-
+        if has_explicit_causing_exception:
+            exception_source = "__cause__"
+            causing_exception = exc_value.__cause__  # type: ignore
     else:
-        # Add indirect cause.
-        # The field `__context__` is assigned if another exception occurs while handling the exception.
-        exception_has_content = (
+        # Implicitly chained exceptions (when an exception occurs while handling another exception)
+        # The field `__context__` is set in the exception that occurs while handling another exception,
+        # to the other exception.
+        has_implicit_causing_exception = (
             exc_value
             and hasattr(exc_value, "__context__")
             and exc_value.__context__ is not None
         )
-        if exception_has_content:
-            context = exc_value.__context__  # type: ignore
-            (exception_id, child_exceptions) = exceptions_from_error(
-                exc_type=type(context),
-                exc_value=context,
-                tb=getattr(context, "__traceback__", None),
-                client_options=client_options,
-                mechanism=mechanism,
-                exception_id=exception_id,
-                source="__context__",
-                full_stack=full_stack,
-            )
-            exceptions.extend(child_exceptions)
+        if has_implicit_causing_exception:
+            exception_source = "__context__"
+            causing_exception = exc_value.__context__  # type: ignore
+
+    if causing_exception:
+        # Some frameworks (e.g. FastAPI) wrap the causing exception in an
+        # ExceptionGroup that only contain one exception: the causing exception.
+        # This would lead to an infinite loop, so we skip the causing exception
+        # in this case. (because it is the same as the base_exception above)
+        if (
+            BaseExceptionGroup is not None
+            and isinstance(causing_exception, BaseExceptionGroup)
+            and len(causing_exception.exceptions) == 1
+            and causing_exception.exceptions[0] == exc_value
+        ):
+            causing_exception = None
+
+    if causing_exception:
+        (exception_id, child_exceptions) = exceptions_from_error(
+            exc_type=type(causing_exception),
+            exc_value=causing_exception,
+            tb=getattr(causing_exception, "__traceback__", None),
+            client_options=client_options,
+            mechanism=mechanism,
+            exception_id=exception_id,
+            parent_id=parent_id,
+            source=exception_source,
+            full_stack=full_stack,
+        )
+        exceptions.extend(child_exceptions)
 
-    # Add exceptions from an ExceptionGroup.
+    # Add child exceptions from an ExceptionGroup.
     is_exception_group = exc_value and hasattr(exc_value, "exceptions")
     if is_exception_group:
-        for idx, e in enumerate(exc_value.exceptions):  # type: ignore
+        for idx, causing_exception in enumerate(exc_value.exceptions):  # type: ignore
             (exception_id, child_exceptions) = exceptions_from_error(
-                exc_type=type(e),
-                exc_value=e,
-                tb=getattr(e, "__traceback__", None),
+                exc_type=type(causing_exception),
+                exc_value=causing_exception,
+                tb=getattr(causing_exception, "__traceback__", None),
                 client_options=client_options,
                 mechanism=mechanism,
                 exception_id=exception_id,
@@ -917,38 +918,29 @@ def exceptions_from_error_tuple(
     full_stack=None,  # type: Optional[list[dict[str, Any]]]
 ):
     # type: (...) -> List[Dict[str, Any]]
+    """
+    Convert Python's exception information into Sentry's structured "exception" format in the event.
+    See https://develop.sentry.dev/sdk/data-model/event-payloads/exception/
+    This is the entry point for the exception handling.
+    """
+    # unpack the exception info tuple
     exc_type, exc_value, tb = exc_info
 
-    is_exception_group = BaseExceptionGroup is not None and isinstance(
-        exc_value, BaseExceptionGroup
+    # let exceptions_from_error do the actual work
+    _, exceptions = exceptions_from_error(
+        exc_type=exc_type,
+        exc_value=exc_value,
+        tb=tb,
+        client_options=client_options,
+        mechanism=mechanism,
+        exception_id=0,
+        parent_id=0,
+        full_stack=full_stack,
     )
 
-    if is_exception_group:
-        (_, exceptions) = exceptions_from_error(
-            exc_type=exc_type,
-            exc_value=exc_value,
-            tb=tb,
-            client_options=client_options,
-            mechanism=mechanism,
-            exception_id=0,
-            parent_id=0,
-            full_stack=full_stack,
-        )
-
-    else:
-        exceptions = []
-        for exc_type, exc_value, tb in walk_exception_chain(exc_info):
-            exceptions.append(
-                single_exception_from_error_tuple(
-                    exc_type=exc_type,
-                    exc_value=exc_value,
-                    tb=tb,
-                    client_options=client_options,
-                    mechanism=mechanism,
-                    full_stack=full_stack,
-                )
-            )
-
+    # make sure the exceptions are sorted
+    # from the innermost (oldest)
+    # to the outermost (newest) exception
     exceptions.reverse()
 
     return exceptions
@@ -1372,27 +1364,13 @@ def _get_contextvars():
     See https://docs.sentry.io/platforms/python/contextvars/ for more information.
     """
     if not _is_contextvars_broken():
-        # aiocontextvars is a PyPI package that ensures that the contextvars
-        # backport (also a PyPI package) works with asyncio under Python 3.6
-        #
-        # Import it if available.
-        if sys.version_info < (3, 7):
-            # `aiocontextvars` is absolutely required for functional
-            # contextvars on Python 3.6.
-            try:
-                from aiocontextvars import ContextVar
-
-                return True, ContextVar
-            except ImportError:
-                pass
-        else:
-            # On Python 3.7 contextvars are functional.
-            try:
-                from contextvars import ContextVar
+        # On Python 3.7+ contextvars are functional.
+        try:
+            from contextvars import ContextVar
 
-                return True, ContextVar
-            except ImportError:
-                pass
+            return True, ContextVar
+        except ImportError:
+            pass
 
     # Fall back to basic thread-local usage.
 
@@ -1792,7 +1770,7 @@ def ensure_integration_enabled(
     ```python
     @ensure_integration_enabled(MyIntegration, my_function)
     def patch_my_function():
-        with sentry_sdk.start_transaction(...):
+        with sentry_sdk.start_span(...):
             return my_function()
     ```
     """
@@ -1818,19 +1796,6 @@ def ensure_integration_enabled(
     return patcher
 
 
-if PY37:
-
-    def nanosecond_time():
-        # type: () -> int
-        return time.perf_counter_ns()
-
-else:
-
-    def nanosecond_time():
-        # type: () -> int
-        return int(time.perf_counter() * 1e9)
-
-
 def now():
     # type: () -> float
     return time.perf_counter()
@@ -1842,9 +1807,9 @@ try:
 except ImportError:
 
     # it's not great that the signatures are different, get_hub can't return None
-    # consider adding an if TYPE_CHECKING to change the signature to Optional[Hub]
+    # consider adding an if TYPE_CHECKING to change the signature to Optional[GeventHub]
     def get_gevent_hub():  # type: ignore[misc]
-        # type: () -> Optional[Hub]
+        # type: () -> Optional[GeventHub]
         return None
 
     def is_module_patched(mod_name):
@@ -1909,6 +1874,56 @@ def get_current_thread_meta(thread=None):
     return None, None
 
 
+def _serialize_span_attribute(value):
+    # type: (Any) -> Optional[AttributeValue]
+    """Serialize an object so that it's OTel-compatible and displays nicely in Sentry."""
+    # check for allowed primitives
+    if isinstance(value, (int, str, float, bool)):
+        return value
+
+    # lists are allowed too, as long as they don't mix types
+    if isinstance(value, (list, tuple)):
+        for type_ in (int, str, float, bool):
+            if all(isinstance(item, type_) for item in value):
+                return list(value)
+
+    # if this is anything else, just try to coerce to string
+    # we prefer json.dumps since this makes things like dictionaries display
+    # nicely in the UI
+    try:
+        return json.dumps(value)
+    except TypeError:
+        try:
+            return str(value)
+        except Exception:
+            return None
+
+
+ISO_TZ_SEPARATORS = frozenset(("+", "-"))
+
+
+def datetime_from_isoformat(value):
+    # type: (str) -> datetime
+    try:
+        result = datetime.fromisoformat(value)
+    except (AttributeError, ValueError):
+        # py 3.6
+        timestamp_format = (
+            "%Y-%m-%dT%H:%M:%S.%f" if "." in value else "%Y-%m-%dT%H:%M:%S"
+        )
+        if value.endswith("Z"):
+            value = value[:-1] + "+0000"
+
+        if value[-6] in ISO_TZ_SEPARATORS:
+            timestamp_format += "%z"
+            value = value[:-3] + value[-2:]
+        elif value[-5] in ISO_TZ_SEPARATORS:
+            timestamp_format += "%z"
+
+        result = datetime.strptime(value, timestamp_format)
+    return result.astimezone(timezone.utc)
+
+
 def should_be_treated_as_error(ty, value):
     # type: (Any, Any) -> bool
     if ty == SystemExit and hasattr(value, "code") and value.code in (0, None):
@@ -1918,18 +1933,20 @@ def should_be_treated_as_error(ty, value):
     return True
 
 
-if TYPE_CHECKING:
-    T = TypeVar("T")
+def http_client_status_to_breadcrumb_level(status_code):
+    # type: (Optional[int]) -> str
+    if status_code is not None:
+        if 500 <= status_code <= 599:
+            return "error"
+        elif 400 <= status_code <= 499:
+            return "warning"
 
+    return "info"
 
-def try_convert(convert_func, value):
-    # type: (Callable[[Any], T], Any) -> Optional[T]
-    """
-    Attempt to convert from an unknown type to a specific type, using the
-    given function. Return None if the conversion fails, i.e. if the function
-    raises an exception.
-    """
-    try:
-        return convert_func(value)
-    except Exception:
-        return None
+
+def set_thread_info_from_span(data, span):
+    # type: (Dict[str, Any], sentry_sdk.tracing.Span) -> None
+    if span.get_attribute(SPANDATA.THREAD_ID) is not None:
+        data[SPANDATA.THREAD_ID] = span.get_attribute(SPANDATA.THREAD_ID)
+        if span.get_attribute(SPANDATA.THREAD_NAME) is not None:
+            data[SPANDATA.THREAD_NAME] = span.get_attribute(SPANDATA.THREAD_NAME)