[WIP] Wrap apollo resolvers.

Author: onurtemizkan

packages/tracing/src/hubextensions.ts

@@ -237,6 +237,12 @@ function _autoloadDatabaseIntegrations(): void {
   }
 
   const packageToIntegrationMapping: Record<string, () => Integration> = {
+    apollo() {
+      const integration = dynamicRequire(module, './integrations/apollo') as {
+        Apollo: IntegrationClass<Integration>;
+      };
+      return new integration.Apollo();
+    },
     graphql() {
       const integration = dynamicRequire(module, './integrations/graphql') as {
         GraphQL: IntegrationClass<Integration>;

packages/tracing/src/integrations/apollo.ts

@@ -0,0 +1,106 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable no-console */
+/* eslint-disable no-debugger */
+import { Hub } from '@sentry/hub';
+import { EventProcessor, Integration } from '@sentry/types';
+import { fill, isThenable, loadModule, logger } from '@sentry/utils';
+
+type ApolloResolverGroup = {
+  [key: string]: () => any;
+};
+
+type ApolloField = {
+  [key: string]: ApolloResolverGroup;
+};
+
+/** Tracing integration for Apollo package */
+export class Apollo implements Integration {
+  /**
+   * @inheritDoc
+   */
+  public static id: string = 'Apollo';
+
+  /**
+   * @inheritDoc
+   */
+  public name: string = Apollo.id;
+
+  /**
+   * @inheritDoc
+   */
+  public setupOnce(_: (callback: EventProcessor) => void, getCurrentHub: () => Hub): void {
+    const pkg = loadModule<{
+      ApolloServerBase: {
+        prototype: {
+          constructSchema: () => unknown;
+        };
+      };
+    }>(`apollo-server-core`);
+
+    debugger;
+    if (!pkg) {
+      logger.error(`Apollo Integration was unable to require apollo package.`);
+      return;
+    }
+
+    fill(pkg.ApolloServerBase.prototype, 'constructSchema', function(orig: () => void) {
+      return function(this: { config: { resolvers: ApolloField[] } }) {
+        this.config.resolvers = this.config.resolvers.map(field => {
+          Object.keys(field).forEach(resolverGroupName => {
+            Object.keys(field[resolverGroupName]).forEach(resolverName => {
+              if (typeof field[resolverGroupName][resolverName] !== 'function') {
+                return;
+              }
+
+              patchResolver(field, resolverGroupName, resolverName, getCurrentHub);
+            });
+          });
+
+          return field;
+        });
+
+        return orig.call(this);
+      };
+    });
+  }
+}
+
+/**
+ *
+ * @param field
+ * @param resolverGroupName
+ * @param resolverName
+ */
+function patchResolver(
+  field: ApolloField,
+  resolverGroupName: string,
+  resolverName: string,
+  getCurrentHub: () => Hub,
+): void {
+  fill(field[resolverGroupName], resolverName, function(orig: () => unknown | Promise<unknown>) {
+    return function(this: unknown, ...args: unknown[]) {
+      const scope = getCurrentHub().getScope();
+      const parentSpan = scope?.getSpan();
+      const span = parentSpan?.startChild({
+        description: `${resolverGroupName}.${resolverName}`,
+        op: `apollo`,
+      });
+
+      scope?.setSpan(span);
+
+      const rv = orig.call(this, ...args);
+
+      if (isThenable(rv)) {
+        return (rv as Promise<unknown>).then((res: unknown) => {
+          span?.finish();
+          scope?.setSpan(parentSpan);
+          return res;
+        });
+      }
+
+      span?.finish();
+      scope?.setSpan(parentSpan);
+      return rv;
+    };
+  });
+}

packages/tracing/src/integrations/graphql.ts

@@ -1,3 +1,4 @@
+/* eslint-disable no-debugger */
 import { Hub } from '@sentry/hub';
 import { EventProcessor, Integration } from '@sentry/types';
 import { fill, isThenable, loadModule, logger } from '@sentry/utils';
@@ -27,30 +28,33 @@ export class GraphQL implements Integration {
       return;
     }
 
-    ['execute', 'defaultFieldResolver', 'defaultTypeResolver', 'buildExecutionContext'].forEach(method => {
-      fill(pkg, method, function(orig: () => void | Promise<unknown>) {
-        return function(this: unknown, ...args: unknown[]) {
-          const scope = getCurrentHub().getScope();
-          const parentSpan = scope?.getSpan();
+    fill(pkg, 'execute', function(orig: () => void | Promise<unknown>) {
+      return function(this: unknown, ...args: unknown[]) {
+        const hub = getCurrentHub();
+        const scope = hub.getScope();
+        const parentSpan = scope?.getSpan();
 
-          const span = parentSpan?.startChild({
-            description: method,
-            op: 'graphql',
-          });
+        const span = parentSpan?.startChild({
+          description: 'execute',
+          op: 'graphql',
+        });
+
+        scope?.setSpan(span);
 
-          const rv = orig.call(this, ...args) as Promise<unknown>;
+        const rv = orig.call(this, ...args) as Promise<unknown>;
 
-          if (isThenable(rv)) {
-            return rv.then((res: unknown) => {
-              span?.finish();
-              return res;
-            });
-          } else {
+        if (isThenable(rv)) {
+          return rv.then((res: unknown) => {
             span?.finish();
-            return rv;
-          }
-        };
-      });
+            scope?.setSpan(parentSpan);
+            return res;
+          });
+        }
+
+        span?.finish();
+        scope?.setSpan(parentSpan);
+        return rv;
+      };
     });
   }
 }

packages/tracing/src/integrations/index.ts

@@ -3,6 +3,7 @@ export { Postgres } from './node/postgres';
 export { Mysql } from './node/mysql';
 export { Mongo } from './node/mongo';
 export { GraphQL } from './graphql';
+export { Apollo } from './apollo';
 
 // TODO(v7): Remove this export
 // Please see `src/index.ts` for more details.