sentry-sdk 3.0.0a1__py2.py3-none-any.whl → 3.0.0a3__py2.py3-none-any.whl

sentry_sdk/client.py

@@ -1,3 +1,4 @@
+from __future__ import annotations
 import os
 import uuid
 import random
@@ -5,8 +6,9 @@ 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
 from sentry_sdk.utils import (
     AnnotatedValue,
@@ -47,13 +49,16 @@ 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
@@ -63,22 +68,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
@@ -107,7 +112,7 @@ def _get_options(*args, **kwargs):
         rv["environment"] = os.environ.get("SENTRY_ENVIRONMENT") or "production"
 
     if rv["debug"] is None:
-        rv["debug"] = env_to_bool(os.environ.get("SENTRY_DEBUG", "False"), strict=True)
+        rv["debug"] = env_to_bool(os.environ.get("SENTRY_DEBUG"), strict=True) or False
 
     if rv["server_name"] is None and hasattr(socket, "gethostname"):
         rv["server_name"] = socket.gethostname()
@@ -133,6 +138,11 @@ def _get_options(*args, **kwargs):
         )
         rv["socket_options"] = None
 
+    if rv["keep_alive"] is None:
+        rv["keep_alive"] = (
+            env_to_bool(os.environ.get("SENTRY_KEEP_ALIVE"), strict=True) or False
+        )
+
     return rv
 
 
@@ -143,37 +153,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
 
@@ -181,48 +185,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, scope, log):
-        # type: (Scope, 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
 
 
@@ -246,22 +242,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.
         """
@@ -311,12 +305,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)
 
@@ -400,6 +392,8 @@ class _Client(BaseClient):
 
             patch_readable_span()
             setup_sentry_tracing()
+
+            logger.debug("[Tracing] Finished setting up OpenTelemetry")
         finally:
             _client_init_debug.set(old_debug)
 
@@ -415,8 +409,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
 
@@ -424,8 +417,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
 
@@ -434,28 +426,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
@@ -473,16 +463,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:
@@ -554,14 +542,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"]
@@ -570,7 +555,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:
@@ -587,7 +572,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 (
@@ -596,7 +581,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:
@@ -611,20 +596,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
@@ -647,11 +629,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:
@@ -669,10 +650,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):
@@ -717,10 +697,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
@@ -756,11 +735,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.
@@ -771,7 +749,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
@@ -806,10 +784,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
@@ -839,12 +817,13 @@ class _Client(BaseClient):
 
         return return_value
 
-    def _capture_experimental_log(self, current_scope, log):
-        # type: (Scope, Log) -> None
+    def _capture_experimental_log(self, log: Log) -> None:
         logs_enabled = self.options["_experiments"].get("enable_logs", False)
         if not logs_enabled:
             return
-        isolation_scope = current_scope.get_isolation_scope()
+
+        current_scope = sentry_sdk.get_current_scope()
+        isolation_scope = sentry_sdk.get_isolation_scope()
 
         log["attributes"]["sentry.sdk.name"] = SDK_INFO["name"]
         log["attributes"]["sentry.sdk.version"] = SDK_INFO["version"]
@@ -873,6 +852,21 @@ class _Client(BaseClient):
             elif propagation_context is not None:
                 log["trace_id"] = propagation_context.trace_id
 
+        # The user, if present, is always set on the isolation scope.
+        if isolation_scope._user is not None:
+            for log_attribute, user_attribute in (
+                ("user.id", "id"),
+                ("user.name", "username"),
+                ("user.email", "email"),
+            ):
+                if (
+                    user_attribute in isolation_scope._user
+                    and log_attribute not in log["attributes"]
+                ):
+                    log["attributes"][log_attribute] = isolation_scope._user[
+                        user_attribute
+                    ]
+
         # If debug is enabled, log the log to the console
         debug = self.options.get("debug", False)
         if debug:
@@ -889,10 +883,7 @@ class _Client(BaseClient):
         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:
@@ -901,19 +892,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.
         """
@@ -928,10 +916,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`.
@@ -952,10 +939,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.
 
@@ -973,17 +959,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.