(2) Move capture_* from Hub to Client

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,14 +1,18 @@
 from importlib import import_module
 import os
+import sys
 import uuid
 import random
 import socket
 
 from sentry_sdk._compat import datetime_utcnow, string_types, text_type, iteritems
+from sentry_sdk.scope import _update_scope
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     current_stacktrace,
     disable_capture_event,
+    event_from_exception,
+    exc_info_from_error,
     format_timestamp,
     get_sdk_name,
     get_type_name,
@@ -48,7 +52,7 @@
 
     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
 
 
@@ -544,6 +548,8 @@ def capture_event(
         event,  # type: Event
         hint=None,  # type: Optional[Hint]
         scope=None,  # type: Optional[Scope]
+        top_scope=None,  # type: Optional[Scope]
+        **scope_kwargs  # type: Any
     ):
         # type: (...) -> Optional[str]
         """Captures an event.
@@ -552,14 +558,21 @@ def capture_event(
 
         :param hint: Contains metadata about the event that can be read from `before_send`, such as the original exception object or a HTTP request object.
 
-        :param scope: An optional scope to use for determining whether this event
-            should be captured.
+        :param scope: An optional scope to use for determining whether this event should be captured.
+
+        :param top_scope: An optional top scope that should also be merged into the scope to be applied to the event.
+
+        :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 is not None:
+            scope = _update_scope(top_scope, scope, scope_kwargs)
+
         if hint is None:
             hint = {}
         event_id = event.get("event_id")
@@ -647,6 +660,89 @@ def capture_event(
 
         return event_id
 
+    def capture_message(
+        self,
+        message,  # type: str
+        level=None,  # type: Optional[str]
+        scope=None,  # type: Optional[Scope]
+        top_scope=None,  # type: Optional[Scope]
+        **scope_kwargs  # type: Any
+    ):
+        # type: (...) -> 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 top_scope: An optional top scope that should also be merged into the scope to be applied to the event.
+
+        :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,
+            top_scope=top_scope,
+            **scope_kwargs
+        )
+
+    def capture_exception(
+        self,
+        error=None,  # type: Optional[Union[BaseException, ExcInfo]]
+        scope=None,  # type: Optional[Scope]
+        top_scope=None,  # type: Optional[Scope]
+        **scope_kwargs  # type: Any
+    ):
+        # type: (...) -> Optional[str]
+        """Captures an exception.
+
+        :param error: An exception to catch. If `None`, `sys.exc_info()` will be used.
+
+        :param scope: An optional :py:class:`sentry_sdk.Scope` to use.
+
+        :param top_scope: An optional top scope that should also be merged into the scope to be applied to the event.
+
+        :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, top_scope=top_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
     ):

sentry_sdk/hub.py

@@ -21,8 +21,6 @@
 )
 
 from sentry_sdk.utils import (
-    exc_info_from_error,
-    event_from_exception,
     logger,
     ContextVar,
 )
@@ -65,24 +63,6 @@ def overload(x):
 _local = ContextVar("sentry_current_hub")
 
 
-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
-
-
 def _should_send_default_pii():
     # type: () -> bool
     client = Hub.current.client
@@ -322,76 +302,86 @@ def bind_client(
         top = self._stack[-1]
         self._stack[-1] = (new, top[1])
 
-    def capture_event(self, event, hint=None, scope=None, **scope_args):
+    def capture_event(self, event, hint=None, scope=None, **scope_kwargs):
         # type: (Event, Optional[Hint], Optional[Scope], Any) -> Optional[str]
         """
         Captures an event.
 
         Alias of :py:meth:`sentry_sdk.Client.capture_event`.
 
-        :param scope_args: For supported `**scope_args` see
+        :param scope_kwargs: For supported `**scope_kwargs` see
             :py:meth:`sentry_sdk.Scope.update_from_kwargs`.
         """
         client, top_scope = self._stack[-1]
-        scope = _update_scope(top_scope, scope, scope_args)
-        if client is not None:
-            is_transaction = event.get("type") == "transaction"
-            rv = client.capture_event(event, hint, scope)
-            if rv is not None and not is_transaction:
-                self._last_event_id = rv
-            return rv
-        return None
+        if client is None:
+            return None
 
-    def capture_message(self, message, level=None, scope=None, **scope_args):
+        last_event_id = client.capture_event(
+            event, hint, scope=scope, top_scope=top_scope, **scope_kwargs
+        )
+
+        is_transaction = event.get("type") == "transaction"
+        if last_event_id is not None and not is_transaction:
+            self._last_event_id = last_event_id
+
+        return last_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.
 
+        Alias of :py:meth:`sentry_sdk.Client.capture_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_args: For supported `**scope_args` see
+        :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 self.client is None:
+        client, top_scope = self._stack[-1]
+        if client is None:
             return None
-        if level is None:
-            level = "info"
-        return self.capture_event(
-            {"message": message, "level": level}, scope=scope, **scope_args
+
+        last_event_id = client.capture_message(
+            message, level=level, scope=scope, top_scope=top_scope, **scope_kwargs
         )
 
-    def capture_exception(self, error=None, scope=None, **scope_args):
+        if last_event_id is not None:
+            self._last_event_id = last_event_id
+
+        return last_event_id
+
+    def capture_exception(self, error=None, scope=None, **scope_kwargs):
         # type: (Optional[Union[BaseException, ExcInfo]], Optional[Scope], Any) -> Optional[str]
         """Captures an exception.
 
+        Alias of :py:meth:`sentry_sdk.Client.capture_exception`.
+
         :param error: An exception to catch. If `None`, `sys.exc_info()` will be used.
 
-        :param scope_args: For supported `**scope_args` see
+        :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`).
         """
-        client = self.client
+        client, top_scope = self._stack[-1]
         if client is None:
             return None
-        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=client.options)
-        try:
-            return self.capture_event(event, hint=hint, scope=scope, **scope_args)
-        except Exception:
-            self._capture_internal_exception(sys.exc_info())
+        last_event_id = client.capture_exception(
+            error, scope=scope, top_scope=top_scope, **scope_kwargs
+        )
+
+        if last_event_id is not None:
+            self._last_event_id = last_event_id
 
-        return None
+        return last_event_id
 
     def _capture_internal_exception(
         self, exc_info  # type: Any
@@ -401,6 +391,8 @@ def _capture_internal_exception(
         Capture an exception that is likely caused by a bug in the SDK
         itself.
 
+        Duplicated in :py:meth:`sentry_sdk.Client._capture_internal_exception`.
+
         These exceptions do not end up in Sentry and are just logged instead.
         """
         logger.error("Internal error in sentry_sdk", exc_info=exc_info)

sentry_sdk/scope.py

@@ -81,6 +81,28 @@ def wrapper(self, *args, **kwargs):
     return wrapper  # type: ignore
 
 
+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(base)
+        if callable(scope_change):
+            scope_change(final_scope)
+        else:
+            final_scope.update_from_scope(scope_change)
+
+    elif scope_kwargs:
+        final_scope = copy(base)
+        final_scope.update_from_kwargs(**scope_kwargs)
+
+    else:
+        final_scope = base
+
+    return final_scope
+
+
 class Scope(object):
     """The scope holds extra information that should be sent with all
     events that belong to it.

tests/test_client.py

@@ -365,7 +365,7 @@ def raise_it(exc_info):
         reraise(*exc_info)
 
     sentry_init(ignore_errors=[ZeroDivisionError], transport=_TestTransport())
-    Hub.current._capture_internal_exception = raise_it
+    Hub.current.client._capture_internal_exception = raise_it
 
     def e(exc):
         try: