ref(integrations): Use new scopes in Graphene, Strawberry (#2864)

---------

Co-authored-by: Anton Pirker <[email protected]>

Author: sentrivana

sentry_sdk/integrations/graphene.py

@@ -1,5 +1,6 @@
-from sentry_sdk.hub import Hub, _should_send_default_pii
+import sentry_sdk
 from sentry_sdk.integrations import DidNotEnable, Integration
+from sentry_sdk.scope import Scope, should_send_default_pii
 from sentry_sdk.utils import (
     capture_internal_exceptions,
     event_from_exception,
@@ -46,53 +47,55 @@ def _patch_graphql():
 
     def _sentry_patched_graphql_sync(schema, source, *args, **kwargs):
         # type: (GraphQLSchema, Union[str, Source], Any, Any) -> ExecutionResult
-        hub = Hub.current
-        integration = hub.get_integration(GrapheneIntegration)
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(GrapheneIntegration)
         if integration is None:
             return old_graphql_sync(schema, source, *args, **kwargs)
 
-        with hub.configure_scope() as scope:
-            scope.add_event_processor(_event_processor)
+        scope = Scope.get_isolation_scope()
+        scope.generate_propagation_context()
+        scope.add_event_processor(_event_processor)
 
         result = old_graphql_sync(schema, source, *args, **kwargs)
 
         with capture_internal_exceptions():
             for error in result.errors or []:
                 event, hint = event_from_exception(
                     error,
-                    client_options=hub.client.options if hub.client else None,
+                    client_options=client.options,
                     mechanism={
                         "type": integration.identifier,
                         "handled": False,
                     },
                 )
-                hub.capture_event(event, hint=hint)
+                sentry_sdk.capture_event(event, hint=hint)
 
         return result
 
     async def _sentry_patched_graphql_async(schema, source, *args, **kwargs):
         # type: (GraphQLSchema, Union[str, Source], Any, Any) -> ExecutionResult
-        hub = Hub.current
-        integration = hub.get_integration(GrapheneIntegration)
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(GrapheneIntegration)
         if integration is None:
             return await old_graphql_async(schema, source, *args, **kwargs)
 
-        with hub.configure_scope() as scope:
-            scope.add_event_processor(_event_processor)
+        scope = Scope.get_isolation_scope()
+        scope.generate_propagation_context()
+        scope.add_event_processor(_event_processor)
 
         result = await old_graphql_async(schema, source, *args, **kwargs)
 
         with capture_internal_exceptions():
             for error in result.errors or []:
                 event, hint = event_from_exception(
                     error,
-                    client_options=hub.client.options if hub.client else None,
+                    client_options=client.options,
                     mechanism={
                         "type": integration.identifier,
                         "handled": False,
                     },
                 )
-                hub.capture_event(event, hint=hint)
+                sentry_sdk.capture_event(event, hint=hint)
 
         return result
 
@@ -102,7 +105,7 @@ async def _sentry_patched_graphql_async(schema, source, *args, **kwargs):
 
 def _event_processor(event, hint):
     # type: (Event, Dict[str, Any]) -> Event
-    if _should_send_default_pii():
+    if should_send_default_pii():
         request_info = event.setdefault("request", {})
         request_info["api_target"] = "graphql"
 

sentry_sdk/integrations/strawberry.py

@@ -1,13 +1,15 @@
 import hashlib
 from inspect import isawaitable
 
-from sentry_sdk import configure_scope, start_span
+import sentry_sdk
 from sentry_sdk.consts import OP
 from sentry_sdk.integrations import Integration, DidNotEnable
 from sentry_sdk.integrations.logging import ignore_logger
-from sentry_sdk.hub import Hub, _should_send_default_pii
+from sentry_sdk.scope import Scope, should_send_default_pii
 from sentry_sdk.utils import (
     capture_internal_exceptions,
+    ensure_integration_enabled,
+    ensure_integration_enabled_async,
     event_from_exception,
     logger,
     package_version,
@@ -85,7 +87,7 @@ def _patch_schema_init():
 
     def _sentry_patched_schema_init(self, *args, **kwargs):
         # type: (Schema, Any, Any) -> None
-        integration = Hub.current.get_integration(StrawberryIntegration)
+        integration = sentry_sdk.get_client().get_integration(StrawberryIntegration)
         if integration is None:
             return old_schema_init(self, *args, **kwargs)
 
@@ -165,21 +167,20 @@ def on_operation(self):
         if self._operation_name:
             description += " {}".format(self._operation_name)
 
-        Hub.current.add_breadcrumb(
+        sentry_sdk.add_breadcrumb(
             category="graphql.operation",
             data={
                 "operation_name": self._operation_name,
                 "operation_type": operation_type,
             },
         )
 
-        with configure_scope() as scope:
-            if scope.span:
-                self.graphql_span = scope.span.start_child(
-                    op=op, description=description
-                )
-            else:
-                self.graphql_span = start_span(op=op, description=description)
+        scope = Scope.get_isolation_scope()
+        scope.generate_propagation_context()
+        if scope.span:
+            self.graphql_span = scope.span.start_child(op=op, description=description)
+        else:
+            self.graphql_span = sentry_sdk.start_span(op=op, description=description)
 
         self.graphql_span.set_data("graphql.operation.type", operation_type)
         self.graphql_span.set_data("graphql.operation.name", self._operation_name)
@@ -265,39 +266,29 @@ def _patch_execute():
     old_execute_async = strawberry_schema.execute
     old_execute_sync = strawberry_schema.execute_sync
 
+    @ensure_integration_enabled_async(StrawberryIntegration, old_execute_async)
     async def _sentry_patched_execute_async(*args, **kwargs):
         # type: (Any, Any) -> ExecutionResult
-        hub = Hub.current
-        integration = hub.get_integration(StrawberryIntegration)
-        if integration is None:
-            return await old_execute_async(*args, **kwargs)
-
         result = await old_execute_async(*args, **kwargs)
 
         if "execution_context" in kwargs and result.errors:
-            with hub.configure_scope() as scope:
-                event_processor = _make_request_event_processor(
-                    kwargs["execution_context"]
-                )
-                scope.add_event_processor(event_processor)
+            scope = Scope.get_isolation_scope()
+            scope.generate_propagation_context()
+            event_processor = _make_request_event_processor(kwargs["execution_context"])
+            scope.add_event_processor(event_processor)
 
         return result
 
+    @ensure_integration_enabled(StrawberryIntegration, old_execute_sync)
     def _sentry_patched_execute_sync(*args, **kwargs):
         # type: (Any, Any) -> ExecutionResult
-        hub = Hub.current
-        integration = hub.get_integration(StrawberryIntegration)
-        if integration is None:
-            return old_execute_sync(*args, **kwargs)
-
         result = old_execute_sync(*args, **kwargs)
 
         if "execution_context" in kwargs and result.errors:
-            with hub.configure_scope() as scope:
-                event_processor = _make_request_event_processor(
-                    kwargs["execution_context"]
-                )
-                scope.add_event_processor(event_processor)
+            scope = Scope.get_isolation_scope()
+            scope.generate_propagation_context()
+            event_processor = _make_request_event_processor(kwargs["execution_context"])
+            scope.add_event_processor(event_processor)
 
         return result
 
@@ -322,29 +313,30 @@ def _sentry_patched_sync_view_handle_errors(self, errors, response_data):
 
     def _sentry_patched_handle_errors(self, errors, response_data):
         # type: (Any, List[GraphQLError], GraphQLHTTPResponse) -> None
-        hub = Hub.current
-        integration = hub.get_integration(StrawberryIntegration)
+        client = sentry_sdk.get_client()
+        integration = client.get_integration(StrawberryIntegration)
         if integration is None:
             return
 
         if not errors:
             return
 
-        with hub.configure_scope() as scope:
-            event_processor = _make_response_event_processor(response_data)
-            scope.add_event_processor(event_processor)
+        scope = Scope.get_isolation_scope()
+        scope.generate_propagation_context()
+        event_processor = _make_response_event_processor(response_data)
+        scope.add_event_processor(event_processor)
 
         with capture_internal_exceptions():
             for error in errors:
                 event, hint = event_from_exception(
                     error,
-                    client_options=hub.client.options if hub.client else None,
+                    client_options=client.options,
                     mechanism={
                         "type": integration.identifier,
                         "handled": False,
                     },
                 )
-                hub.capture_event(event, hint=hint)
+                sentry_sdk.capture_event(event, hint=hint)
 
     async_base_view.AsyncBaseHTTPView._handle_errors = (
         _sentry_patched_async_view_handle_errors
@@ -360,7 +352,7 @@ def _make_request_event_processor(execution_context):
     def inner(event, hint):
         # type: (Event, dict[str, Any]) -> Event
         with capture_internal_exceptions():
-            if _should_send_default_pii():
+            if should_send_default_pii():
                 request_data = event.setdefault("request", {})
                 request_data["api_target"] = "graphql"
 
@@ -391,7 +383,7 @@ def _make_response_event_processor(response_data):
     def inner(event, hint):
         # type: (Event, dict[str, Any]) -> Event
         with capture_internal_exceptions():
-            if _should_send_default_pii():
+            if should_send_default_pii():
                 contexts = event.setdefault("contexts", {})
                 contexts["response"] = {"data": response_data}