sentry-sdk 3.0.0a2__py2.py3-none-any.whl → 3.0.0a4__py2.py3-none-any.whl

sentry_sdk/client.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import uuid
 import random
@@ -5,7 +6,7 @@ import socket
 from collections.abc import Mapping
 from datetime import datetime, timezone
 from importlib import import_module
-from typing import TYPE_CHECKING, List, Dict, cast, overload
+from typing import TYPE_CHECKING, overload
 
 import sentry_sdk
 from sentry_sdk._compat import check_uwsgi_thread_support
@@ -45,16 +46,18 @@ from sentry_sdk.profiler.transaction_profiler import (
 )
 from sentry_sdk.scrubber import EventScrubber
 from sentry_sdk.monitor import Monitor
-from sentry_sdk.spotlight import setup_spotlight
 
 if TYPE_CHECKING:
-    from typing import Any
-    from typing import Callable
-    from typing import Optional
-    from typing import Sequence
-    from typing import Type
-    from typing import Union
-    from typing import TypeVar
+    from typing import (
+        Any,
+        Callable,
+        Optional,
+        Sequence,
+        Type,
+        Union,
+        TypeVar,
+        Dict,
+    )
 
     from sentry_sdk._types import Event, Hint, SDKInfo, Log
     from sentry_sdk.integrations import Integration
@@ -64,22 +67,22 @@ if TYPE_CHECKING:
     from sentry_sdk.transport import Transport
     from sentry_sdk._log_batcher import LogBatcher
 
-    I = TypeVar("I", bound=Integration)  # noqa: E741
+    IntegrationType = TypeVar("IntegrationType", bound=Integration)  # noqa: E741
+
 
 _client_init_debug = ContextVar("client_init_debug")
 
 
-SDK_INFO = {
+SDK_INFO: SDKInfo = {
     "name": "sentry.python",  # SDK name will be overridden after integrations have been loaded with sentry_sdk.integrations.setup_integrations()
     "version": VERSION,
     "packages": [{"name": "pypi:sentry-sdk", "version": VERSION}],
-}  # type: SDKInfo
+}
 
 
-def _get_options(*args, **kwargs):
-    # type: (*Optional[str], **Any) -> Dict[str, Any]
+def _get_options(*args: Optional[str], **kwargs: Any) -> Dict[str, Any]:
     if args and (isinstance(args[0], (bytes, str)) or args[0] is None):
-        dsn = args[0]  # type: Optional[str]
+        dsn: Optional[str] = args[0]
         args = args[1:]
     else:
         dsn = None
@@ -149,37 +152,31 @@ class BaseClient:
     The basic definition of a client that is used for sending data to Sentry.
     """
 
-    spotlight = None  # type: Optional[SpotlightClient]
+    spotlight: Optional[SpotlightClient] = None
 
-    def __init__(self, options=None):
-        # type: (Optional[Dict[str, Any]]) -> None
-        self.options = (
+    def __init__(self, options: Optional[Dict[str, Any]] = None) -> None:
+        self.options: Dict[str, Any] = (
             options if options is not None else DEFAULT_OPTIONS
-        )  # type: Dict[str, Any]
+        )
 
-        self.transport = None  # type: Optional[Transport]
-        self.monitor = None  # type: Optional[Monitor]
-        self.log_batcher = None  # type: Optional[LogBatcher]
+        self.transport: Optional[Transport] = None
+        self.monitor: Optional[Monitor] = None
+        self.log_batcher: Optional[LogBatcher] = None
 
-    def __getstate__(self, *args, **kwargs):
-        # type: (*Any, **Any) -> Any
+    def __getstate__(self, *args: Any, **kwargs: Any) -> Any:
         return {"options": {}}
 
-    def __setstate__(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
+    def __setstate__(self, *args: Any, **kwargs: Any) -> None:
         pass
 
     @property
-    def dsn(self):
-        # type: () -> Optional[str]
+    def dsn(self) -> Optional[str]:
         return None
 
-    def should_send_default_pii(self):
-        # type: () -> bool
+    def should_send_default_pii(self) -> bool:
         return False
 
-    def is_active(self):
-        # type: () -> bool
+    def is_active(self) -> bool:
         """
         .. versionadded:: 2.0.0
 
@@ -187,48 +184,40 @@ class BaseClient:
         """
         return False
 
-    def capture_event(self, *args, **kwargs):
-        # type: (*Any, **Any) -> Optional[str]
+    def capture_event(self, *args: Any, **kwargs: Any) -> Optional[str]:
         return None
 
-    def _capture_experimental_log(self, log):
-        # type: (Log) -> None
+    def _capture_experimental_log(self, log: "Log") -> None:
         pass
 
-    def capture_session(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
+    def capture_session(self, *args: Any, **kwargs: Any) -> None:
         return None
 
     if TYPE_CHECKING:
 
         @overload
-        def get_integration(self, name_or_class):
-            # type: (str) -> Optional[Integration]
-            ...
+        def get_integration(self, name_or_class: str) -> Optional[Integration]: ...
 
         @overload
-        def get_integration(self, name_or_class):
-            # type: (type[I]) -> Optional[I]
-            ...
+        def get_integration(
+            self, name_or_class: type[IntegrationType]
+        ) -> Optional[IntegrationType]: ...
 
-    def get_integration(self, name_or_class):
-        # type: (Union[str, type[Integration]]) -> Optional[Integration]
+    def get_integration(
+        self, name_or_class: Union[str, type[Integration]]
+    ) -> Optional[Integration]:
         return None
 
-    def close(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
+    def close(self, *args: Any, **kwargs: Any) -> None:
         return None
 
-    def flush(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
+    def flush(self, *args: Any, **kwargs: Any) -> None:
         return None
 
-    def __enter__(self):
-        # type: () -> BaseClient
+    def __enter__(self) -> BaseClient:
         return self
 
-    def __exit__(self, exc_type, exc_value, tb):
-        # type: (Any, Any, Any) -> None
+    def __exit__(self, exc_type: Any, exc_value: Any, tb: Any) -> None:
         return None
 
 
@@ -252,22 +241,20 @@ class _Client(BaseClient):
     Alias of :py:class:`sentry_sdk.Client`. (Was created for better intelisense support)
     """
 
-    def __init__(self, *args, **kwargs):
-        # type: (*Any, **Any) -> None
-        super(_Client, self).__init__(options=get_options(*args, **kwargs))
+    def __init__(self, *args: Any, **kwargs: Any) -> None:
+        super(_Client, self).__init__(options=_get_options(*args, **kwargs))
         self._init_impl()
 
-    def __getstate__(self):
-        # type: () -> Any
+    def __getstate__(self) -> Any:
         return {"options": self.options}
 
-    def __setstate__(self, state):
-        # type: (Any) -> None
+    def __setstate__(self, state: Any) -> None:
         self.options = state["options"]
         self._init_impl()
 
-    def _setup_instrumentation(self, functions_to_trace):
-        # type: (Sequence[Dict[str, str]]) -> None
+    def _setup_instrumentation(
+        self, functions_to_trace: Sequence[Dict[str, str]]
+    ) -> None:
         """
         Instruments the functions given in the list `functions_to_trace` with the `@sentry_sdk.tracing.trace` decorator.
         """
@@ -317,12 +304,10 @@ class _Client(BaseClient):
                     e,
                 )
 
-    def _init_impl(self):
-        # type: () -> None
+    def _init_impl(self) -> None:
         old_debug = _client_init_debug.get(False)
 
-        def _capture_envelope(envelope):
-            # type: (Envelope) -> None
+        def _capture_envelope(envelope: Envelope) -> None:
             if self.transport is not None:
                 self.transport.capture_envelope(envelope)
 
@@ -337,9 +322,9 @@ class _Client(BaseClient):
 
             self.session_flusher = SessionFlusher(capture_func=_capture_envelope)
 
-            experiments = self.options.get("_experiments", {})
             self.log_batcher = None
-            if experiments.get("enable_logs", False):
+
+            if self.options.get("enable_logs") is True:
                 from sentry_sdk._log_batcher import LogBatcher
 
                 self.log_batcher = LogBatcher(capture_func=_capture_envelope)
@@ -372,6 +357,10 @@ class _Client(BaseClient):
                 )
 
             if self.options.get("spotlight"):
+                # This is intentionally here to prevent setting up spotlight
+                # stuff we don't need unless spotlight is explicitly enabled
+                from sentry_sdk.spotlight import setup_spotlight
+
                 self.spotlight = setup_spotlight(self.options)
                 if not self.options["dsn"]:
                     sample_all = lambda *_args, **_kwargs: 1.0
@@ -423,8 +412,7 @@ class _Client(BaseClient):
             # need to check if it's safe to use them.
             check_uwsgi_thread_support()
 
-    def is_active(self):
-        # type: () -> bool
+    def is_active(self) -> bool:
         """
         .. versionadded:: 2.0.0
 
@@ -432,8 +420,7 @@ class _Client(BaseClient):
         """
         return True
 
-    def should_send_default_pii(self):
-        # type: () -> bool
+    def should_send_default_pii(self) -> bool:
         """
         .. versionadded:: 2.0.0
 
@@ -442,28 +429,26 @@ class _Client(BaseClient):
         return self.options.get("send_default_pii") or False
 
     @property
-    def dsn(self):
-        # type: () -> Optional[str]
+    def dsn(self) -> Optional[str]:
         """Returns the configured DSN as string."""
         return self.options["dsn"]
 
     def _prepare_event(
         self,
-        event,  # type: Event
-        hint,  # type: Hint
-        scope,  # type: Optional[Scope]
-    ):
-        # type: (...) -> Optional[Event]
+        event: Event,
+        hint: Hint,
+        scope: Optional[Scope],
+    ) -> Optional[Event]:
 
-        previous_total_spans = None  # type: Optional[int]
-        previous_total_breadcrumbs = None  # type: Optional[int]
+        previous_total_spans: Optional[int] = None
+        previous_total_breadcrumbs: Optional[int] = None
 
         if event.get("timestamp") is None:
             event["timestamp"] = datetime.now(timezone.utc)
 
         if scope is not None:
             is_transaction = event.get("type") == "transaction"
-            spans_before = len(cast(List[Dict[str, object]], event.get("spans", [])))
+            spans_before = len(event.get("spans", []))
             event_ = scope.apply_to_event(event, hint, self.options)
 
             # one of the event/error processors returned None
@@ -481,16 +466,14 @@ class _Client(BaseClient):
                         )
                 return None
 
-            event = event_  # type: Optional[Event]  # type: ignore[no-redef]
-            spans_delta = spans_before - len(
-                cast(List[Dict[str, object]], event.get("spans", []))
-            )
+            event = event_
+            spans_delta = spans_before - len(event.get("spans", []))
             if is_transaction and spans_delta > 0 and self.transport is not None:
                 self.transport.record_lost_event(
                     "event_processor", data_category="span", quantity=spans_delta
                 )
 
-            dropped_spans = event.pop("_dropped_spans", 0) + spans_delta  # type: int
+            dropped_spans: int = event.pop("_dropped_spans", 0) + spans_delta
             if dropped_spans > 0:
                 previous_total_spans = spans_before + dropped_spans
             if scope._n_breadcrumbs_truncated > 0:
@@ -562,14 +545,11 @@ class _Client(BaseClient):
         # Postprocess the event here so that annotated types do
         # generally not surface in before_send
         if event is not None:
-            event = cast(
-                "Event",
-                serialize(
-                    cast("Dict[str, Any]", event),
-                    max_request_body_size=self.options.get("max_request_body_size"),
-                    max_value_length=self.options.get("max_value_length"),
-                    custom_repr=self.options.get("custom_repr"),
-                ),
+            event: Event = serialize(  # type: ignore[no-redef]
+                event,
+                max_request_body_size=self.options.get("max_request_body_size"),
+                max_value_length=self.options.get("max_value_length"),
+                custom_repr=self.options.get("custom_repr"),
             )
 
         before_send = self.options["before_send"]
@@ -578,7 +558,7 @@ class _Client(BaseClient):
             and event is not None
             and event.get("type") != "transaction"
         ):
-            new_event = None  # type: Optional[Event]
+            new_event: Optional["Event"] = None
             with capture_internal_exceptions():
                 new_event = before_send(event, hint or {})
             if new_event is None:
@@ -595,7 +575,7 @@ class _Client(BaseClient):
                 if event.get("exception"):
                     DedupeIntegration.reset_last_seen()
 
-            event = new_event  # type: Optional[Event]  # type: ignore[no-redef]
+            event = new_event
 
         before_send_transaction = self.options["before_send_transaction"]
         if (
@@ -604,7 +584,7 @@ class _Client(BaseClient):
             and event.get("type") == "transaction"
         ):
             new_event = None
-            spans_before = len(cast(List[Dict[str, object]], event.get("spans", [])))
+            spans_before = len(event.get("spans", []))
             with capture_internal_exceptions():
                 new_event = before_send_transaction(event, hint or {})
             if new_event is None:
@@ -619,20 +599,17 @@ class _Client(BaseClient):
                         quantity=spans_before + 1,  # +1 for the transaction itself
                     )
             else:
-                spans_delta = spans_before - len(
-                    cast(List[Dict[str, object]], new_event.get("spans", []))
-                )
+                spans_delta = spans_before - len(new_event.get("spans", []))
                 if spans_delta > 0 and self.transport is not None:
                     self.transport.record_lost_event(
                         reason="before_send", data_category="span", quantity=spans_delta
                     )
 
-            event = new_event  # type: Optional[Event]  # type: ignore[no-redef]
+            event = new_event
 
         return event
 
-    def _is_ignored_error(self, event, hint):
-        # type: (Event, Hint) -> bool
+    def _is_ignored_error(self, event: Event, hint: Hint) -> bool:
         exc_info = hint.get("exc_info")
         if exc_info is None:
             return False
@@ -655,11 +632,10 @@ class _Client(BaseClient):
 
     def _should_capture(
         self,
-        event,  # type: Event
-        hint,  # type: Hint
-        scope=None,  # type: Optional[Scope]
-    ):
-        # type: (...) -> bool
+        event: "Event",
+        hint: "Hint",
+        scope: Optional["Scope"] = None,
+    ) -> bool:
         # Transactions are sampled independent of error events.
         is_transaction = event.get("type") == "transaction"
         if is_transaction:
@@ -677,10 +653,9 @@ class _Client(BaseClient):
 
     def _should_sample_error(
         self,
-        event,  # type: Event
-        hint,  # type: Hint
-    ):
-        # type: (...) -> bool
+        event: Event,
+        hint: Hint,
+    ) -> bool:
         error_sampler = self.options.get("error_sampler", None)
 
         if callable(error_sampler):
@@ -725,10 +700,9 @@ class _Client(BaseClient):
 
     def _update_session_from_event(
         self,
-        session,  # type: Session
-        event,  # type: Event
-    ):
-        # type: (...) -> None
+        session: Session,
+        event: Event,
+    ) -> None:
 
         crashed = False
         errored = False
@@ -764,11 +738,10 @@ class _Client(BaseClient):
 
     def capture_event(
         self,
-        event,  # type: Event
-        hint=None,  # type: Optional[Hint]
-        scope=None,  # type: Optional[Scope]
-    ):
-        # type: (...) -> Optional[str]
+        event: Event,
+        hint: Optional[Hint] = None,
+        scope: Optional[Scope] = None,
+    ) -> Optional[str]:
         """Captures an event.
 
         :param event: A ready-made event that can be directly sent to Sentry.
@@ -779,7 +752,7 @@ class _Client(BaseClient):
 
         :returns: An event ID. May be `None` if there is no DSN set or of if the SDK decided to discard the event for other reasons. In such situations setting `debug=True` on `init()` may help.
         """
-        hint = dict(hint or ())  # type: Hint
+        hint: Hint = dict(hint or ())
 
         if not self._should_capture(event, hint, scope):
             return None
@@ -814,10 +787,10 @@ class _Client(BaseClient):
         trace_context = event_opt.get("contexts", {}).get("trace") or {}
         dynamic_sampling_context = trace_context.pop("dynamic_sampling_context", {})
 
-        headers = {
+        headers: dict[str, object] = {
             "event_id": event_opt["event_id"],
             "sent_at": format_timestamp(datetime.now(timezone.utc)),
-        }  # type: dict[str, object]
+        }
 
         if dynamic_sampling_context:
             headers["trace"] = dynamic_sampling_context
@@ -847,10 +820,8 @@ class _Client(BaseClient):
 
         return return_value
 
-    def _capture_experimental_log(self, log):
-        # type: (Log) -> None
-        logs_enabled = self.options["_experiments"].get("enable_logs", False)
-        if not logs_enabled:
+    def _capture_experimental_log(self, log: Optional[Log]) -> None:
+        if self.options.get("enable_logs") is not True or log is None:
             return
 
         current_scope = sentry_sdk.get_current_scope()
@@ -905,19 +876,17 @@ class _Client(BaseClient):
                 f'[Sentry Logs] [{log.get("severity_text")}] {log.get("body")}'
             )
 
-        before_send_log = self.options["_experiments"].get("before_send_log")
+        before_send_log = self.options.get("before_send_log")
         if before_send_log is not None:
             log = before_send_log(log, {})
+
         if log is None:
             return
 
         if self.log_batcher:
             self.log_batcher.add(log)
 
-    def capture_session(
-        self, session  # type: Session
-    ):
-        # type: (...) -> None
+    def capture_session(self, session: Session) -> None:
         if not session.release:
             logger.info("Discarded session update because of missing release")
         else:
@@ -926,19 +895,16 @@ class _Client(BaseClient):
     if TYPE_CHECKING:
 
         @overload
-        def get_integration(self, name_or_class):
-            # type: (str) -> Optional[Integration]
-            ...
+        def get_integration(self, name_or_class: str) -> Optional[Integration]: ...
 
         @overload
-        def get_integration(self, name_or_class):
-            # type: (type[I]) -> Optional[I]
-            ...
+        def get_integration(
+            self, name_or_class: type[IntegrationType]
+        ) -> Optional[IntegrationType]: ...
 
     def get_integration(
-        self, name_or_class  # type: Union[str, Type[Integration]]
-    ):
-        # type: (...) -> Optional[Integration]
+        self, name_or_class: Union[str, Type[Integration]]
+    ) -> Optional[Integration]:
         """Returns the integration for this client by name or class.
         If the client does not have that integration then `None` is returned.
         """
@@ -953,10 +919,9 @@ class _Client(BaseClient):
 
     def close(
         self,
-        timeout=None,  # type: Optional[float]
-        callback=None,  # type: Optional[Callable[[int, float], None]]
-    ):
-        # type: (...) -> None
+        timeout: Optional[float] = None,
+        callback: Optional[Callable[[int, float], None]] = None,
+    ) -> None:
         """
         Close the client and shut down the transport. Arguments have the same
         semantics as :py:meth:`Client.flush`.
@@ -977,10 +942,9 @@ class _Client(BaseClient):
 
     def flush(
         self,
-        timeout=None,  # type: Optional[float]
-        callback=None,  # type: Optional[Callable[[int, float], None]]
-    ):
-        # type: (...) -> None
+        timeout: Optional[float] = None,
+        callback: Optional[Callable[[int, float], None]] = None,
+    ) -> None:
         """
         Wait for the current events to be sent.
 
@@ -998,17 +962,13 @@ class _Client(BaseClient):
 
             self.transport.flush(timeout=timeout, callback=callback)
 
-    def __enter__(self):
-        # type: () -> _Client
+    def __enter__(self) -> _Client:
         return self
 
-    def __exit__(self, exc_type, exc_value, tb):
-        # type: (Any, Any, Any) -> None
+    def __exit__(self, exc_type: Any, exc_value: Any, tb: Any) -> None:
         self.close()
 
 
-from typing import TYPE_CHECKING
-
 if TYPE_CHECKING:
     # Make mypy, PyCharm and other static analyzers think `get_options` is a
     # type to have nicer autocompletion for params.