feat: configure_scope callbacks

Author: untitaker

README.md

@@ -51,6 +51,29 @@ Scopes can be nested. If you call ``push_scope`` inside of the
 ``with``-statement again, that scope will be pushed onto a stack. It will also
 inherit all data from the outer scope.
 
+### Scopes in unconfigured environments
+
+If you never call ``init``, no data will ever get sent to any server. In such
+situations, code like this is essentially deadweight:
+
+    with sentry_sdk.configure_scope() as scope:
+        scope.user = _get_user_data()
+
+Sentry-Python supports an alternative syntax for configuring a scope that
+solves this problem:
+
+    @sentry_sdk.configure_scope
+    def _(scope):
+        scope.user = _get_user_data()
+
+Your function will just not be executed if there is no client configured.
+
+In your testing and development environment you still might want to run that
+code without sending any events. In that case, simply call ``init`` without a
+DSN:
+
+    sentry_sdk.init()
+
 ### Breadcrumbs
 
 Breadcrumbs also live on the stack. By default any (non-debug) log message

sentry_minimal.py

@@ -38,14 +38,17 @@ def add_breadcrumb(*args, **kwargs):
 
 
 @public
-@contextmanager
-def configure_scope():
+def configure_scope(callback=None):
     hub = Hub.current
     if hub is not None:
-        with hub.configure_scope() as scope:
-            yield scope
-    else:
-        yield Scope()
+        return hub.configure_scope(callback)
+    elif callback is None:
+
+        @contextmanager
+        def inner():
+            yield Scope()
+
+        return inner()
 
 
 @public

sentry_sdk/api.py

@@ -17,8 +17,7 @@ def __exit__(self, exc_type, exc_value, tb):
 
 def init(*args, **kwargs):
     client = Client(*args, **kwargs)
-    if client.dsn is not None:
-        Hub.main.bind_client(client)
+    Hub.main.bind_client(client)
     return _InitGuard(client)
 
 

sentry_sdk/hub.py

@@ -184,10 +184,22 @@ def pop_scope_unsafe(self):
         assert self._stack
         return rv
 
-    @contextmanager
-    def configure_scope(self):
+    def configure_scope(self, callback=None):
         """Reconfigures the scope."""
-        yield self._stack[-1][1]
+        client, scope = self._stack[-1]
+        if callback is not None:
+            if client is not None and scope is not None:
+                callback(scope)
+        else:
+
+            @contextmanager
+            def inner():
+                if client is not None and scope is not None:
+                    yield scope
+                else:
+                    yield Scope()
+
+            return inner()
 
     def _flush_event_processors(self):
         rv = self._pending_processors

tests/test_client.py

@@ -3,7 +3,8 @@
 import sys
 import subprocess
 from textwrap import dedent
-from sentry_sdk import Client
+from sentry_sdk import init, Hub, Client, configure_scope
+from sentry_sdk.hub import HubMeta
 from sentry_sdk.transport import Transport
 from sentry_sdk.utils import Event, Dsn
 
@@ -77,3 +78,46 @@ def send_event(pool, event, auth):
     end = time.time()
     assert int(end - start) == num_messages / 10
     assert output.count(b"HI") == num_messages
+
+
+def test_configure_scope_available(request, monkeypatch):
+    # Test that scope is configured if client is configured
+    init()
+    request.addfinalizer(lambda: Hub.current.bind_client(None))
+
+    with configure_scope() as scope:
+        assert scope is Hub.current._stack[-1][1]
+        scope.set_tag("foo", "bar")
+
+    calls = []
+
+    def callback(scope):
+        calls.append(scope)
+        scope.set_tag("foo", "bar")
+
+    assert configure_scope(callback) is None
+    assert len(calls) == 1
+    assert calls[0] is Hub.current._stack[-1][1]
+
+
+@pytest.mark.parametrize("no_sdk", (True, False))
+def test_configure_scope_unavailable(no_sdk, monkeypatch):
+    if no_sdk:
+        # Emulate sentry_minimal without SDK installation: callbacks are not called
+        monkeypatch.setattr(HubMeta, "current", None)
+        assert not Hub.current
+    else:
+        # Still, no client configured
+        assert Hub.current
+
+    calls = []
+
+    def callback(scope):
+        calls.append(scope)
+        scope.set_tag("foo", "bar")
+
+    with configure_scope() as scope:
+        scope.set_tag("foo", "bar")
+
+    assert configure_scope(callback) is None
+    assert not calls