ref(sanic): Use new scopes API (#2875)

Author: sentrivana

sentry_sdk/integrations/sanic.py

@@ -3,9 +3,12 @@
 from inspect import isawaitable
 from urllib.parse import urlsplit
 
+import sentry_sdk
 from sentry_sdk import continue_trace
 from sentry_sdk.consts import OP
-from sentry_sdk.hub import Hub
+from sentry_sdk.integrations import Integration, DidNotEnable
+from sentry_sdk.integrations._wsgi_common import RequestExtractor, _filter_headers
+from sentry_sdk.integrations.logging import ignore_logger
 from sentry_sdk.tracing import TRANSACTION_SOURCE_COMPONENT, TRANSACTION_SOURCE_URL
 from sentry_sdk.scope import Scope
 from sentry_sdk.utils import (
@@ -16,10 +19,6 @@
     parse_version,
     reraise,
 )
-from sentry_sdk.integrations import Integration, DidNotEnable
-from sentry_sdk.integrations._wsgi_common import RequestExtractor, _filter_headers
-from sentry_sdk.integrations.logging import ignore_logger
-
 from sentry_sdk._types import TYPE_CHECKING
 
 if TYPE_CHECKING:
@@ -162,13 +161,13 @@ async def _startup(self):
     # type: (Sanic) -> None
     # This happens about as early in the lifecycle as possible, just after the
     # Request object is created. The body has not yet been consumed.
-    self.signal("http.lifecycle.request")(_hub_enter)
+    self.signal("http.lifecycle.request")(_context_enter)
 
     # This happens after the handler is complete. In v21.9 this signal is not
     # dispatched when there is an exception. Therefore we need to close out
-    # and call _hub_exit from the custom exception handler as well.
+    # and call _context_exit from the custom exception handler as well.
     # See https://github.com/sanic-org/sanic/issues/2297
-    self.signal("http.lifecycle.response")(_hub_exit)
+    self.signal("http.lifecycle.response")(_context_exit)
 
     # This happens inside of request handling immediately after the route
     # has been identified by the router.
@@ -178,23 +177,20 @@ async def _startup(self):
     await old_startup(self)
 
 
-async def _hub_enter(request):
+async def _context_enter(request):
     # type: (Request) -> None
-    hub = Hub.current
     request.ctx._sentry_do_integration = (
-        hub.get_integration(SanicIntegration) is not None
+        sentry_sdk.get_client().get_integration(SanicIntegration) is not None
     )
 
     if not request.ctx._sentry_do_integration:
         return
 
     weak_request = weakref.ref(request)
-    request.ctx._sentry_hub = Hub(hub)
-    request.ctx._sentry_hub.__enter__()
-
-    with request.ctx._sentry_hub.configure_scope() as scope:
-        scope.clear_breadcrumbs()
-        scope.add_event_processor(_make_request_processor(weak_request))
+    request.ctx._sentry_scope = sentry_sdk.isolation_scope()
+    scope = request.ctx._sentry_scope.__enter__()
+    scope.clear_breadcrumbs()
+    scope.add_event_processor(_make_request_processor(weak_request))
 
     transaction = continue_trace(
         dict(request.headers),
@@ -203,18 +199,20 @@ async def _hub_enter(request):
         name=request.path,
         source=TRANSACTION_SOURCE_URL,
     )
-    request.ctx._sentry_transaction = request.ctx._sentry_hub.start_transaction(
+    request.ctx._sentry_transaction = sentry_sdk.start_transaction(
         transaction
     ).__enter__()
 
 
-async def _hub_exit(request, response=None):
+async def _context_exit(request, response=None):
     # type: (Request, Optional[BaseHTTPResponse]) -> None
     with capture_internal_exceptions():
         if not request.ctx._sentry_do_integration:
             return
 
-        integration = Hub.current.get_integration(SanicIntegration)  # type: Integration
+        integration = sentry_sdk.get_client().get_integration(
+            SanicIntegration
+        )  # type: Integration
 
         response_status = None if response is None else response.status
 
@@ -228,7 +226,7 @@ async def _hub_exit(request, response=None):
             )
             request.ctx._sentry_transaction.__exit__(None, None, None)
 
-        request.ctx._sentry_hub.__exit__(None, None, None)
+        request.ctx._sentry_scope.__exit__(None, None, None)
 
 
 async def _set_transaction(request, route, **_):
@@ -248,7 +246,7 @@ def _sentry_error_handler_lookup(self, exception, *args, **kwargs):
     if old_error_handler is None:
         return None
 
-    if Hub.current.get_integration(SanicIntegration) is None:
+    if sentry_sdk.get_client().get_integration(SanicIntegration) is None:
         return old_error_handler
 
     async def sentry_wrapped_error_handler(request, exception):
@@ -269,23 +267,21 @@ async def sentry_wrapped_error_handler(request, exception):
             # As mentioned in previous comment in _startup, this can be removed
             # after https://github.com/sanic-org/sanic/issues/2297 is resolved
             if SanicIntegration.version and SanicIntegration.version == (21, 9):
-                await _hub_exit(request)
+                await _context_exit(request)
 
     return sentry_wrapped_error_handler
 
 
 async def _legacy_handle_request(self, request, *args, **kwargs):
     # type: (Any, Request, *Any, **Any) -> Any
-    hub = Hub.current
-    if hub.get_integration(SanicIntegration) is None:
+    if sentry_sdk.get_client().get_integration(SanicIntegration) is None:
         return old_handle_request(self, request, *args, **kwargs)
 
     weak_request = weakref.ref(request)
 
-    with Hub(hub) as hub:
-        with hub.configure_scope() as scope:
-            scope.clear_breadcrumbs()
-            scope.add_event_processor(_make_request_processor(weak_request))
+    with sentry_sdk.isolation_scope() as scope:
+        scope.clear_breadcrumbs()
+        scope.add_event_processor(_make_request_processor(weak_request))
 
         response = old_handle_request(self, request, *args, **kwargs)
         if isawaitable(response):
@@ -297,51 +293,47 @@ async def _legacy_handle_request(self, request, *args, **kwargs):
 def _legacy_router_get(self, *args):
     # type: (Any, Union[Any, Request]) -> Any
     rv = old_router_get(self, *args)
-    hub = Hub.current
-    if hub.get_integration(SanicIntegration) is not None:
+    if sentry_sdk.get_client().get_integration(SanicIntegration) is not None:
         with capture_internal_exceptions():
-            with hub.configure_scope() as scope:
-                if SanicIntegration.version and SanicIntegration.version >= (21, 3):
-                    # Sanic versions above and including 21.3 append the app name to the
-                    # route name, and so we need to remove it from Route name so the
-                    # transaction name is consistent across all versions
-                    sanic_app_name = self.ctx.app.name
-                    sanic_route = rv[0].name
-
-                    if sanic_route.startswith("%s." % sanic_app_name):
-                        # We add a 1 to the len of the sanic_app_name because there is a dot
-                        # that joins app name and the route name
-                        # Format: app_name.route_name
-                        sanic_route = sanic_route[len(sanic_app_name) + 1 :]
-
-                    scope.set_transaction_name(
-                        sanic_route, source=TRANSACTION_SOURCE_COMPONENT
-                    )
-                else:
-                    scope.set_transaction_name(
-                        rv[0].__name__, source=TRANSACTION_SOURCE_COMPONENT
-                    )
+            scope = Scope.get_isolation_scope()
+            if SanicIntegration.version and SanicIntegration.version >= (21, 3):
+                # Sanic versions above and including 21.3 append the app name to the
+                # route name, and so we need to remove it from Route name so the
+                # transaction name is consistent across all versions
+                sanic_app_name = self.ctx.app.name
+                sanic_route = rv[0].name
+
+                if sanic_route.startswith("%s." % sanic_app_name):
+                    # We add a 1 to the len of the sanic_app_name because there is a dot
+                    # that joins app name and the route name
+                    # Format: app_name.route_name
+                    sanic_route = sanic_route[len(sanic_app_name) + 1 :]
+
+                scope.set_transaction_name(
+                    sanic_route, source=TRANSACTION_SOURCE_COMPONENT
+                )
+            else:
+                scope.set_transaction_name(
+                    rv[0].__name__, source=TRANSACTION_SOURCE_COMPONENT
+                )
 
     return rv
 
 
 def _capture_exception(exception):
     # type: (Union[Tuple[Optional[type], Optional[BaseException], Any], BaseException]) -> None
-    hub = Hub.current
-    integration = hub.get_integration(SanicIntegration)
+    client = sentry_sdk.get_client()
+    integration = client.get_integration(SanicIntegration)
     if integration is None:
         return
 
-    # If an integration is there, a client has to be there.
-    client = hub.client  # type: Any
-
     with capture_internal_exceptions():
         event, hint = event_from_exception(
             exception,
             client_options=client.options,
             mechanism={"type": "sanic", "handled": False},
         )
-        hub.capture_event(event, hint=hint)
+        sentry_sdk.capture_event(event, hint=hint)
 
 
 def _make_request_processor(weak_request):

tests/integrations/sanic/test_sanic.py

@@ -7,8 +7,9 @@
 
 import pytest
 
-from sentry_sdk import capture_message, configure_scope
+from sentry_sdk import capture_message
 from sentry_sdk.integrations.sanic import SanicIntegration
+from sentry_sdk.scope import Scope
 from sentry_sdk.tracing import TRANSACTION_SOURCE_COMPONENT, TRANSACTION_SOURCE_URL
 
 from sanic import Sanic, request, response, __version__ as SANIC_VERSION_RAW
@@ -233,13 +234,13 @@ def test_concurrency(sentry_init, app):
 
     @app.route("/context-check/<i>")
     async def context_check(request, i):
-        with configure_scope() as scope:
-            scope.set_tag("i", i)
+        scope = Scope.get_isolation_scope()
+        scope.set_tag("i", i)
 
         await asyncio.sleep(random.random())
 
-        with configure_scope() as scope:
-            assert scope._tags["i"] == i
+        scope = Scope.get_isolation_scope()
+        assert scope._tags["i"] == i
 
         return response.text("ok")
 
@@ -328,8 +329,8 @@ async def runner():
     else:
         asyncio.run(runner())
 
-    with configure_scope() as scope:
-        assert not scope._tags
+    scope = Scope.get_isolation_scope()
+    assert not scope._tags
 
 
 class TransactionTestConfig: