(3) Move tracing related functions from Hub to Scope

sentry_sdk/api.py

@@ -82,31 +82,31 @@ def capture_event(
     event,  # type: Event
     hint=None,  # type: Optional[Hint]
     scope=None,  # type: Optional[Any]
-    **scope_args  # type: Any
+    **scope_kwargs  # type: Any
 ):
     # type: (...) -> Optional[str]
-    return Hub.current.capture_event(event, hint, scope=scope, **scope_args)
+    return Hub.current.capture_event(event, hint, scope=scope, **scope_kwargs)
 
 
 @hubmethod
 def capture_message(
     message,  # type: str
     level=None,  # type: Optional[str]
     scope=None,  # type: Optional[Any]
-    **scope_args  # type: Any
+    **scope_kwargs  # type: Any
 ):
     # type: (...) -> Optional[str]
-    return Hub.current.capture_message(message, level, scope=scope, **scope_args)
+    return Hub.current.capture_message(message, level, scope=scope, **scope_kwargs)
 
 
 @hubmethod
 def capture_exception(
     error=None,  # type: Optional[Union[BaseException, ExcInfo]]
     scope=None,  # type: Optional[Any]
-    **scope_args  # type: Any
+    **scope_kwargs  # type: Any
 ):
     # type: (...) -> Optional[str]
-    return Hub.current.capture_exception(error, scope=scope, **scope_args)
+    return Hub.current.capture_exception(error, scope=scope, **scope_kwargs)
 
 
 @hubmethod

sentry_sdk/client.py

@@ -1,5 +1,7 @@
 from importlib import import_module
+import copy
 import os
+import sys
 import uuid
 import random
 import socket
@@ -9,6 +11,8 @@
     capture_internal_exceptions,
     current_stacktrace,
     disable_capture_event,
+    event_from_exception,
+    exc_info_from_error,
     format_timestamp,
     get_sdk_name,
     get_type_name,
@@ -43,9 +47,12 @@
     from typing import Dict
     from typing import Optional
     from typing import Sequence
+    from typing import Type
+    from typing import Union
 
+    from sentry_sdk.integrations import Integration
     from sentry_sdk.scope import Scope
-    from sentry_sdk._types import Event, Hint
+    from sentry_sdk._types import Event, ExcInfo, Hint
     from sentry_sdk.session import Session
 
 
@@ -140,6 +147,24 @@ def _get_options(*args, **kwargs):
     return rv
 
 
+def _update_scope(base, scope_change, scope_kwargs):
+    # type: (Scope, Optional[Any], Dict[str, Any]) -> Scope
+    if scope_change and scope_kwargs:
+        raise TypeError("cannot provide scope and kwargs")
+    if scope_change is not None:
+        final_scope = copy.copy(base)
+        if callable(scope_change):
+            scope_change(final_scope)
+        else:
+            final_scope.update_from_scope(scope_change)
+    elif scope_kwargs:
+        final_scope = copy.copy(base)
+        final_scope.update_from_kwargs(**scope_kwargs)
+    else:
+        final_scope = base
+    return final_scope
+
+
 try:
     # Python 3.6+
     module_not_found_error = ModuleNotFoundError
@@ -541,6 +566,7 @@ def capture_event(
         event,  # type: Event
         hint=None,  # type: Optional[Hint]
         scope=None,  # type: Optional[Scope]
+        **scope_kwargs  # type: Any
     ):
         # type: (...) -> Optional[str]
         """Captures an event.
@@ -552,11 +578,18 @@ def capture_event(
         :param scope: An optional scope to use for determining whether this event
             should be captured.
 
+        :param scope_kwargs: For supported `**scope_kwargs` see
+            :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
+
         :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.
         """
         if disable_capture_event.get(False):
             return None
 
+        if scope_kwargs is not None and "top_scope" in scope_kwargs:
+            top_scope = scope_kwargs.pop("top_scope")
+            scope = _update_scope(top_scope, scope, scope_kwargs)
+
         if hint is None:
             hint = {}
         event_id = event.get("event_id")
@@ -644,6 +677,66 @@ def capture_event(
 
         return event_id
 
+    def capture_message(self, message, level=None, scope=None, **scope_kwargs):
+        # type: (str, Optional[str], Optional[Scope], Any) -> Optional[str]
+        """
+        Captures a message.
+
+        :param message: The string to send as the message.
+
+        :param level: If no level is provided, the default level is `info`.
+
+        :param scope: An optional :py:class:`sentry_sdk.Scope` to use.
+
+        :param scope_kwargs: For supported `**scope_kwargs` see
+            :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
+
+        :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.Client.capture_event`).
+        """
+        if level is None:
+            level = "info"
+
+        return self.capture_event(
+            {"message": message, "level": level}, scope=scope, **scope_kwargs
+        )
+
+    def capture_exception(self, error=None, scope=None, **scope_kwargs):
+        # type: (Optional[Union[BaseException, ExcInfo]], Optional[Scope], Any) -> Optional[str]
+        """Captures an exception.
+
+        :param error: An exception to catch. If `None`, `sys.exc_info()` will be used.
+
+        :param scope_kwargs: For supported `**scope_kwargs` see
+            :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
+
+        :returns: An `event_id` if the SDK decided to send the event (see :py:meth:`sentry_sdk.Client.capture_event`).
+        """
+        if error is not None:
+            exc_info = exc_info_from_error(error)
+        else:
+            exc_info = sys.exc_info()
+
+        event, hint = event_from_exception(exc_info, client_options=self.options)
+
+        try:
+            return self.capture_event(event, hint=hint, scope=scope, **scope_kwargs)
+        except Exception:
+            self._capture_internal_exception(sys.exc_info())
+
+        return None
+
+    def _capture_internal_exception(
+        self, exc_info  # type: Any
+    ):
+        # type: (...) -> Any
+        """
+        Capture an exception that is likely caused by a bug in the SDK
+        itself.
+
+        These exceptions do not end up in Sentry and are just logged instead.
+        """
+        logger.error("Internal error in sentry_sdk", exc_info=exc_info)
+
     def capture_session(
         self, session  # type: Session
     ):
@@ -653,6 +746,22 @@ def capture_session(
         else:
             self.session_flusher.add_session(session)
 
+    def get_integration(
+        self, name_or_class  # type: Union[str, Type[Integration]]
+    ):
+        # type: (...) -> Any
+        """Returns the integration for this client by name or class.
+        If the client does not have that integration then `None` is returned.
+        """
+        if isinstance(name_or_class, str):
+            integration_name = name_or_class
+        elif name_or_class.identifier is not None:
+            integration_name = name_or_class.identifier
+        else:
+            raise ValueError("Integration has no name")
+
+        return self.integrations.get(integration_name)
+
     def close(
         self,
         timeout=None,  # type: Optional[float]