update

Author: sentrivana

sentry_sdk/integrations/graphql/__init__.py

@@ -1 +0,0 @@
-from . import AriadneIntegration, GrapheneIntegration  # noqa

sentry_sdk/integrations/graphql/ariadne.py

@@ -1,3 +1,5 @@
+from importlib import import_module
+
 from sentry_sdk.hub import Hub, _should_send_default_pii
 from sentry_sdk.integrations import DidNotEnable, Integration
 from sentry_sdk.utils import parse_version
@@ -9,26 +11,36 @@
     raise DidNotEnable("graphql-core not installed")
 
 try:
-    import ariadne
+    ariadne_graphql = import_module(
+        "ariadne.graphql"
+    )  # necessary because of some name shadowing shenanigans in ariadne
+    # XXX verify again
+    from ariadne.asgi import GraphQL as ASGIGraphQL
+    from ariadne.asgi.handlers import GraphQLHTTPHandler
+    from ariadne.asgi.handlers import http as ariadne_http
+    from ariadne.types import Extension
+    from ariadne.wsgi import GraphQL as WSGIGraphQL
 except ImportError:
     raise DidNotEnable("ariadne not installed")
 
 
 if TYPE_CHECKING:
-    from typing import Any
-    from ariadne.graphql import GraphQLSchema
-    from ariadne.types import GraphQLResult
+    from typing import Any, List
+    from ariadne.types import ContextValue, GraphQLError, GraphQLResult, GraphQLSchema
     from sentry_sdk._types import EventProcessor
 
 
 class AriadneIntegration(Integration):
     identifier = "ariadne"
 
+    # XXX add an option to turn on error monitoring so that people who are instrumenting
+    # both the server and the client side can turn one of them off if they want
+    # XXX double patching
+
     @staticmethod
     def setup_once():
         # type: () -> None
         # XXX version guard for ariadne
-        # guard for double patching
         version = parse_version(GRAPHQL_CORE_VERSION)
 
         if version is None:
@@ -39,54 +51,156 @@ def setup_once():
         if version < (3, 2):
             raise DidNotEnable("graphql-core 3.2 or newer required.")
 
-        old_graphql_sync = ariadne.graphql_sync
-        old_graphql_async = ariadne.graphql
+        _patch_graphql()
+        _inject_tracing_extension()
+
+
+def _patch_graphql():
+    # type: () -> None
+    old_graphql_sync = ariadne_graphql.graphql_sync
+    old_graphql_async = ariadne_graphql.graphql
 
-        def _sentry_patched_graphql_sync(schema, data, *args, **kwargs):
-            # type: (GraphQLSchema, Any, Any, Any) -> GraphQLResult
-            hub = Hub.current
-            integration = hub.get_integration(AriadneIntegration)
-            if integration is None or hub.client is None:
-                return old_graphql_sync(schema, data, *args, **kwargs)
+    def _sentry_patched_graphql_sync(schema, data, *args, **kwargs):
+        # type: (GraphQLSchema, Any, Any, Any) -> GraphQLResult
+        hub = Hub.current
+        integration = hub.get_integration(AriadneIntegration)
 
-            result = old_graphql_sync(schema, data, *args, **kwargs)
+        if integration is None or hub.client is None:
+            return old_graphql_sync(schema, data, *args, **kwargs)
 
-            _raise_errors(result, hub)
+        scope = hub.scope  # XXX
+        if scope is not None:
+            event_processor = _make_event_processor(schema, data)
+            scope.add_event_processor(event_processor)
 
-            return result
+        result = old_graphql_sync(schema, data, *args, **kwargs)
+
+        _capture_graphql_errors(result, hub)
+
+        return result
 
-        async def _sentry_patched_graphql_async(schema, data, *args, **kwargs):
-            # type: (GraphQLSchema, Any, Any, Any) -> GraphQLResult
-            hub = Hub.current
-            integration = hub.get_integration(AriadneIntegration)
-            if integration is None or hub.client is None:
-                return await old_graphql_async(schema, data, *args, **kwargs)
+    async def _sentry_patched_graphql_async(schema, data, *args, **kwargs):
+        # type: (GraphQLSchema, Any, Any, Any) -> GraphQLResult
+        hub = Hub.current
+        integration = hub.get_integration(AriadneIntegration)
 
-            result = await old_graphql_async(schema, data, *args, **kwargs)
+        if integration is None or hub.client is None:
+            return await old_graphql_async(schema, data, *args, **kwargs)
 
-            _raise_errors(result, hub)
+        scope = hub.scope  # XXX
+        if scope is not None:
+            event_processor = _make_event_processor(schema, data)
+            scope.add_event_processor(event_processor)
 
-            return result
+        result = await old_graphql_async(schema, data, *args, **kwargs)
+        # XXX no result available in event processor like this
 
-        ariadne.graphql_sync = _sentry_patched_graphql_sync
-        ariadne.graphql_async = _sentry_patched_graphql_async
+        # XXX two options.
+        # a) Handle the exceptions in has_errors. Then it's actual exceptions that
+        #    can be raised properly. But there is no response and it'd have to be
+        #    constructed manually
+        # b) Handle the exceptions here once they've already been formatted. Then
+        #    we need to reconstruct the exceptions instead before raising them.
+        # c?) Remember the exception somehow
+        # d) monkeypatch handle_graphql_errors
 
+        _capture_graphql_errors(result, hub)
 
-def _raise_errors(result, hub):
-    # type: (GraphQLResult, Hub) -> None
-    data = result[1]
-    if not isinstance(data, dict) or not data.get("errors"):
         return result
 
-    for error in data["errors"]:
+    ariadne_graphql.graphql_sync = _sentry_patched_graphql_sync
+    ariadne_graphql.graphql = _sentry_patched_graphql_async
+    ariadne_http.graphql = _sentry_patched_graphql_async
+
+
+def _inject_tracing_extension():
+    # type: () -> None
+    old_asgi_http_handler_init = GraphQLHTTPHandler.__init__
+    old_asgi_init = ASGIGraphQL.__init__
+    old_wsgi_init = WSGIGraphQL.__init__
+
+    def _sentry_asgi_http_handler_wrapper(self, *args, **kwargs):
+        # type: (GraphQLHTTPHandler, Any, Any) -> None
+        extensions = kwargs.get("extensions") or []
+        extensions.append(SentryTracingExtension)
+        kwargs["extensions"] = extensions
+        old_asgi_http_handler_init(self, *args, **kwargs)
+
+    def _sentry_asgi_wrapper(self, *args, **kwargs):
+        # type: (ASGIGraphQL, Any, Any) -> None
+        http_handler = kwargs.get("http_handler")
+        if http_handler is None:
+            http_handler = GraphQLHTTPHandler()
+        kwargs["http_handler"] = http_handler
+        old_asgi_init(self, *args, **kwargs)
+
+    def _sentry_wsgi_wrapper(self, *args, **kwargs):
+        # type: (WSGIGraphQL, Any, Any) -> None
+        extensions = kwargs.get("extensions") or []
+        extensions.append(SentryTracingExtension)
+        kwargs["extensions"] = extensions
+        old_wsgi_init(self, *args, **kwargs)
+
+    GraphQLHTTPHandler.__init__ = _sentry_asgi_http_handler_wrapper
+    ASGIGraphQL.__init__ = _sentry_asgi_wrapper
+    WSGIGraphQL.__init__ = _sentry_wsgi_wrapper
+
+
+class SentryTracingExtension(Extension):
+    def __init__(self):
+        pass
+
+    def request_started(self, context):
+        # type: (ContextValue) -> None
+        print("req started ctx", context)
+        hub = Hub.current
+        integration = hub.get_integration(AriadneIntegration)
+        if integration is None:
+            return
+
+    def request_finished(self, context):
+        # type: (ContextValue) -> None
+        print("req finished ctx", context)
+        hub = Hub.current
+        integration = hub.get_integration(AriadneIntegration)
+        if integration is None or hub.client is None:
+            return
+
+    def has_errors(self, errors, context):
+        # type: (List[GraphQLError], ContextValue) -> None
+        # XXX could use this to capture exceptions but we don't have access
+        # to the response here
+        print("has errors ctx", context)
+        hub = Hub.current
+        integration = hub.get_integration(AriadneIntegration)
+        if integration is None or hub.client is None:
+            return
+
+    # XXX def resolve()
+
+
+def _capture_graphql_errors(result, hub):
+    result = result[1]
+    if not isinstance(result, dict):
+        return
+
+    for error in result.get("errors") or []:
+        # have to reconstruct the exceptions here since they've already been
+        # formatted
         hub.capture_exception(error)
 
 
-def _make_event_processor():
-    # type: () -> EventProcessor
+def _make_event_processor(schema, data):
+    # type: (GraphQLSchema, Any) -> EventProcessor
     def inner(event, hint):
+        print("in event processor")
+        print(schema)
+        print(data)
         if _should_send_default_pii():
-            pass
+            if isinstance(data, dict) and data.get("query"):
+                request_info = event.setdefault("request", {})
+                request_info["api_target"] = "graphql"
+                request_info["data"] = str(data["query"])
 
         return event
 

sentry_sdk/integrations/graphql/graphene.py

@@ -26,6 +26,9 @@
 class GrapheneIntegration(Integration):
     identifier = "graphene"
 
+    # XXX add an option to turn on error monitoring so that people who are instrumenting
+    # both the server and the client side can turn one of them off if they want
+
     @staticmethod
     def setup_once():
         # type: () -> None
@@ -41,22 +44,22 @@ def setup_once():
             raise DidNotEnable("graphql-core 3.2 or newer required.")
 
         # XXX: a guard against patching multiple times?
-        old_execute_sync = graphene_schema.graphql_sync
-        old_execute_async = graphene_schema.graphql
+        old_graphql_sync = graphene_schema.graphql_sync
+        old_graphql_async = graphene_schema.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)
             if integration is None or hub.client is None:
-                return old_execute_sync(schema, source, *args, **kwargs)
+                return old_graphql_sync(schema, source, *args, **kwargs)
 
             scope = hub.scope  # XXX
             if scope is not None:
                 event_processor = _make_event_processor(source)
                 scope.add_event_processor(event_processor)
 
-            result = old_execute_sync(schema, source, *args, **kwargs)
+            result = old_graphql_sync(schema, source, *args, **kwargs)
 
             _raise_graphql_errors(result)
 
@@ -67,14 +70,14 @@ async def _sentry_patched_graphql_async(schema, source, *args, **kwargs):
             hub = Hub.current
             integration = hub.get_integration(GrapheneIntegration)
             if integration is None or hub.client is None:
-                return await old_execute_async(schema, source, *args, **kwargs)
+                return await old_graphql_async(schema, source, *args, **kwargs)
 
             scope = hub.scope  # XXX
             if scope is not None:
                 event_processor = _make_event_processor(source)
                 scope.add_event_processor(event_processor)
 
-            result = await old_execute_async(schema, source, *args, **kwargs)
+            result = await old_graphql_async(schema, source, *args, **kwargs)
 
             _raise_graphql_errors(result)