feat: add option to ignore default resolvers in opentelemetry (#2747)

* feat[useOnResolve]: add skipDefaultResolvers option

* feat[opentelemetry]: add defaultResolvers option

* fix[useOnResolve]: ensure resolver is not the default resolver

* add changeset

* update changeset

* use the resolver name instead of the default resovler value for better compatibility

* also ignore stitching default resolver

---------

Co-authored-by: Valentin Cocaud <[email protected]>

Author: cecchi

.changeset/frank-pigs-teach.md

@@ -0,0 +1,29 @@
+---
+'@envelop/on-resolve': minor
+'@envelop/opentelemetry': minor
+---
+
+Add option to ignore default resolvers in opentelemetry instrumentation
+
+To reduce telemetry data volume and noise in traces, it is recommended to ignore resolvers with the
+default implementation since they probably doesn't do anything worth tracking.
+
+## Usage
+
+```ts
+import { execute, parse, specifiedRules, subscribe, validate } from 'graphql'
+import { envelop, useEngine } from '@envelop/core'
+import { useOpenTelemetry } from '@envelop/opentelemetry'
+
+const getEnveloped = envelop({
+  plugins: [
+    useEngine({ parse, validate, specifiedRules, execute, subscribe }),
+    // ... other plugins ...
+
+    useOpenTelemetry({
+      resolvers: true,
+      defaultResolvers: false // explicitly disable default resolvers tracing. Defaults to `true`
+    })
+  ]
+})
+```

packages/plugins/on-resolve/src/index.ts

@@ -40,6 +40,13 @@ export type UseOnResolveOptions = {
    * @default true
    */
   skipIntrospection?: boolean;
+
+  /**
+   * Skip executing the `onResolve` hook on fields with default resolvers.
+   *
+   * @default false
+   */
+  skipDefaultResolvers?: boolean;
 };
 
 /**
@@ -49,7 +56,7 @@ export type UseOnResolveOptions = {
  */
 export function useOnResolve<PluginContext extends Record<string, any> = {}>(
   onResolve: OnResolve<PluginContext>,
-  opts: UseOnResolveOptions = { skipIntrospection: true },
+  opts: UseOnResolveOptions = { skipIntrospection: true, skipDefaultResolvers: false },
 ): Plugin<PluginContext> {
   const hasWrappedResolveSymbol = Symbol('hasWrappedResolve');
   return {
@@ -61,6 +68,14 @@ export function useOnResolve<PluginContext extends Record<string, any> = {}>(
         if ((!opts.skipIntrospection || !isIntrospectionType(type)) && isObjectType(type)) {
           for (const field of Object.values(type.getFields())) {
             if ((field as { [hasWrappedResolveSymbol]?: true })[hasWrappedResolveSymbol]) continue;
+            if (
+              opts.skipDefaultResolvers &&
+              (!field.resolve ||
+                field.resolve?.name === 'defaultFieldResolver' ||
+                field.resolve?.name === 'defaultMergedResolver')
+            ) {
+              continue;
+            }
 
             let resolver = (field.resolve || defaultFieldResolver) as Resolver<PluginContext>;
 

packages/plugins/on-resolve/test/use-on-resolve.spec.ts

@@ -8,12 +8,20 @@ describe('useOnResolve', () => {
       type Query {
         value1: String!
         value2: String!
+        obj: Obj!
+      }
+
+      type Obj {
+        field1: String!
       }
     `,
     resolvers: {
       Query: {
         value1: () => 'value1',
         value2: () => 'value2',
+        obj: () => ({
+          field1: 'field1',
+        }),
       },
     },
   });
@@ -85,6 +93,47 @@ describe('useOnResolve', () => {
     expect(onResolveDoneFn).toHaveBeenCalledTimes(0);
   });
 
+  it('should invoke the callback for default resolvers when not skipping', async () => {
+    const onResolveDoneFn = jest.fn();
+    const onResolveFn = jest.fn((_opts: OnResolveOptions) => onResolveDoneFn);
+    const testkit = createTestkit(
+      [useOnResolve(onResolveFn, { skipDefaultResolvers: false })],
+      schema,
+    );
+
+    await testkit.execute('{ obj { field1 } }');
+
+    expect(onResolveFn).toHaveBeenCalledTimes(2);
+    expect(onResolveDoneFn).toHaveBeenCalledTimes(2);
+
+    let i = 0;
+    for (const field of ['obj', 'field1']) {
+      expect(onResolveFn.mock.calls[i][0].context).toBeDefined();
+      expect(onResolveFn.mock.calls[i][0].root).toBeDefined();
+      expect(onResolveFn.mock.calls[i][0].args).toBeDefined();
+      expect(onResolveFn.mock.calls[i][0].info).toBeDefined();
+      expect(onResolveFn.mock.calls[i][0].info.fieldName).toBe(field);
+      expect(onResolveFn.mock.calls[i][0].resolver).toBeInstanceOf(Function);
+      expect(onResolveFn.mock.calls[i][0].replaceResolver).toBeInstanceOf(Function);
+
+      i++;
+    }
+  });
+
+  it('should not invoke the callback for default resolvers when skipping', async () => {
+    const onResolveDoneFn = jest.fn();
+    const onResolveFn = jest.fn((_opts: OnResolveOptions) => onResolveDoneFn);
+    const testkit = createTestkit(
+      [useOnResolve(onResolveFn, { skipDefaultResolvers: true })],
+      schema,
+    );
+
+    await testkit.execute('{ obj { field1 } }');
+
+    expect(onResolveFn).toHaveBeenCalledTimes(1);
+    expect(onResolveDoneFn).toHaveBeenCalledTimes(1);
+  });
+
   it('should replace the result using the after hook', async () => {
     const testkit = createTestkit(
       [

packages/plugins/opentelemetry/src/index.ts

@@ -38,6 +38,7 @@ export type ExcludeOperationNamesFn = (operationName: string | undefined) => boo
 export type TracingOptions = {
   document?: boolean;
   resolvers?: boolean;
+  defaultResolvers?: boolean;
   variables?: boolean | ResolveVariablesAttributesFn;
   result?: boolean;
   traceIdInResult?: string;
@@ -89,39 +90,42 @@ export const useOpenTelemetry = (
     onPluginInit({ addPlugin }) {
       if (options.resolvers) {
         addPlugin(
-          useOnResolve(({ info, context, args }) => {
-            const parentSpan = spanByContext.get(context);
-            if (parentSpan) {
-              const ctx = opentelemetry.trace.setSpan(getCurrentOtelContext(context), parentSpan);
-              const { fieldName, returnType, parentType } = info;
-
-              const resolverSpan = tracer.startSpan(
-                `${spanPrefix}${parentType.name}.${fieldName}`,
-                {
-                  attributes: {
-                    [AttributeName.RESOLVER_FIELD_NAME]: fieldName,
-                    [AttributeName.RESOLVER_TYPE_NAME]: parentType.toString(),
-                    [AttributeName.RESOLVER_RESULT_TYPE]: returnType.toString(),
-                    [AttributeName.RESOLVER_ARGS]: JSON.stringify(args || {}),
+          useOnResolve(
+            ({ info, context, args }) => {
+              const parentSpan = spanByContext.get(context);
+              if (parentSpan) {
+                const ctx = opentelemetry.trace.setSpan(getCurrentOtelContext(context), parentSpan);
+                const { fieldName, returnType, parentType } = info;
+
+                const resolverSpan = tracer.startSpan(
+                  `${spanPrefix}${parentType.name}.${fieldName}`,
+                  {
+                    attributes: {
+                      [AttributeName.RESOLVER_FIELD_NAME]: fieldName,
+                      [AttributeName.RESOLVER_TYPE_NAME]: parentType.toString(),
+                      [AttributeName.RESOLVER_RESULT_TYPE]: returnType.toString(),
+                      [AttributeName.RESOLVER_ARGS]: JSON.stringify(args || {}),
+                    },
                   },
-                },
-                ctx,
-              );
-
-              return ({ result }) => {
-                if (result instanceof Error) {
-                  resolverSpan.recordException({
-                    name: AttributeName.RESOLVER_EXCEPTION,
-                    message: JSON.stringify(result),
-                  });
-                } else {
-                  resolverSpan.end();
-                }
-              };
-            }
+                  ctx,
+                );
+
+                return ({ result }) => {
+                  if (result instanceof Error) {
+                    resolverSpan.recordException({
+                      name: AttributeName.RESOLVER_EXCEPTION,
+                      message: JSON.stringify(result),
+                    });
+                  } else {
+                    resolverSpan.end();
+                  }
+                };
+              }
 
-            return () => {};
-          }),
+              return () => {};
+            },
+            { skipDefaultResolvers: options.defaultResolvers === false },
+          ),
         );
       }
     },

packages/plugins/opentelemetry/test/use-open-telemetry.spec.ts

@@ -31,6 +31,11 @@ describe('useOpenTelemetry', () => {
         echo(message: String): String
         error: String
         context: String
+        obj: Obj
+      }
+
+      type Obj {
+        field1: String!
       }
 
       type Subscription {
@@ -48,6 +53,9 @@ describe('useOpenTelemetry', () => {
         error: () => {
           throw new GraphQLError('boom');
         },
+        obj: () => ({
+          field1: 'field1',
+        }),
       },
       Subscription: {
         counter: {
@@ -130,6 +138,49 @@ describe('useOpenTelemetry', () => {
     expect(actual[1].name).toBe('query.anonymous');
   });
 
+  it('Should add default resolver spans if enabled / unspecified', async () => {
+    const exporter = new InMemorySpanExporter();
+    const testInstance = createTestkit(
+      [useTestOpenTelemetry(exporter, { resolvers: true })],
+      schema,
+    );
+
+    await testInstance.execute(/* GraphQL */ `
+      query {
+        obj {
+          field1
+        }
+      }
+    `);
+
+    const actual = exporter.getFinishedSpans();
+    expect(actual.length).toBe(3);
+    expect(actual[0].name).toBe('Query.obj');
+    expect(actual[1].name).toBe('Obj.field1');
+    expect(actual[2].name).toBe('query.anonymous');
+  });
+
+  it('Should not add default resolver spans if disabled', async () => {
+    const exporter = new InMemorySpanExporter();
+    const testInstance = createTestkit(
+      [useTestOpenTelemetry(exporter, { resolvers: true, defaultResolvers: false })],
+      schema,
+    );
+
+    await testInstance.execute(/* GraphQL */ `
+      query {
+        obj {
+          field1
+        }
+      }
+    `);
+
+    const actual = exporter.getFinishedSpans();
+    expect(actual.length).toBe(2);
+    expect(actual[0].name).toBe('Query.obj');
+    expect(actual[1].name).toBe('query.anonymous');
+  });
+
   it('query should add trace_id to extensions', async () => {
     const exporter = new InMemorySpanExporter();
     const testInstance = createTestkit(
@@ -299,8 +350,6 @@ describe('useOpenTelemetry', () => {
       selector: '1',
     });
 
-    console.log(resp);
-
     assertSingleValue(resp);
 
     const actual = exporter.getFinishedSpans();