feat(execution): publish on graphql:resolve tracing channel

Wraps the single resolver invocation site in Executor.executeField with
maybeTraceMixed so each field resolver call emits start/end (and the
async tail when the resolver returns a promise, or error when it
throws). The emission is inside the engine — no field.resolve mutation,
no schema walking, nothing stacks across multiple APM subscribers.

The published context captures the field-level metadata APM tools use
to name and attribute per-field spans:

  - fieldName        from info.fieldName
  - parentType       from info.parentType.name
  - fieldType        stringified info.returnType
  - args             resolver arguments, by reference
  - isTrivialResolver (field.resolve === undefined), a hint for
    subscribers that want to skip default property-access resolvers
  - fieldPath        lazy getter, serializes info.path only on first
    read since it is O(depth) work and many subscribers depth-filter
    without reading it

graphql:resolve is the noisiest channel (one event per field per
operation); all emission sites are gated on hasSubscribers before any
context is constructed, so it remains zero-cost when no APM is loaded.

Author: logaretm

integrationTests/diagnostics/test.js

@@ -198,6 +198,50 @@ async function runSubscribeCase() {
   }
 }
 
+function runResolveCase() {
+  const schema = buildSchema(
+    `type Query { hello: String nested: Nested } type Nested { leaf: String }`,
+  );
+  const document = parse('{ hello nested { leaf } }');
+
+  const events = [];
+  const handler = {
+    start: (msg) =>
+      events.push({
+        kind: 'start',
+        fieldName: msg.fieldName,
+        parentType: msg.parentType,
+        fieldType: msg.fieldType,
+        fieldPath: msg.fieldPath,
+        isTrivialResolver: msg.isTrivialResolver,
+      }),
+    end: () => events.push({ kind: 'end' }),
+    asyncStart: () => events.push({ kind: 'asyncStart' }),
+    asyncEnd: () => events.push({ kind: 'asyncEnd' }),
+    error: (msg) => events.push({ kind: 'error', error: msg.error }),
+  };
+
+  const channel = dc.tracingChannel('graphql:resolve');
+  channel.subscribe(handler);
+
+  try {
+    const rootValue = { hello: () => 'world', nested: { leaf: 'leaf-value' } };
+    execute({ schema, document, rootValue });
+
+    const starts = events.filter((e) => e.kind === 'start');
+    const paths = starts.map((e) => e.fieldPath);
+    assert.deepEqual(paths, ['hello', 'nested', 'nested.leaf']);
+
+    const hello = starts.find((e) => e.fieldName === 'hello');
+    assert.equal(hello.parentType, 'Query');
+    assert.equal(hello.fieldType, 'String');
+    // buildSchema never attaches field.resolve; all fields report as trivial.
+    assert.equal(hello.isTrivialResolver, true);
+  } finally {
+    channel.unsubscribe(handler);
+  }
+}
+
 function runNoSubscriberCase() {
   const doc = parse('{ field }');
   assert.equal(doc.kind, 'Document');
@@ -208,6 +252,7 @@ async function main() {
   runValidateCase();
   runExecuteCase();
   await runSubscribeCase();
+  runResolveCase();
   runNoSubscriberCase();
   console.log('diagnostics integration test passed');
 }

src/execution/Executor.ts

@@ -44,6 +44,8 @@ import {
 } from '../type/definition.js';
 import type { GraphQLSchema } from '../type/schema.js';
 
+import { maybeTraceMixed } from '../diagnostics.js';
+
 import { withCancellation } from './cancellablePromise.js';
 import type {
   DeferUsage,
@@ -608,7 +610,11 @@ export class Executor<
       // The resolve function's optional third argument is a context value that
       // is provided to every resolve function within an execution. It is commonly
       // used to represent an authenticated user, or request-specific caches.
-      const result = resolveFn(source, args, contextValue, info);
+      const result = maybeTraceMixed(
+        'resolve',
+        () => buildResolveCtx(info, args, fieldDef.resolve === undefined),
+        () => resolveFn(source, args, contextValue, info),
+      );
 
       if (isPromise(result)) {
         return this.completePromisedValue(
@@ -1395,3 +1401,29 @@ export class Executor<
 function toNodes(fieldDetailsList: FieldDetailsList): ReadonlyArray<FieldNode> {
   return fieldDetailsList.map((fieldDetails) => fieldDetails.node);
 }
+
+/**
+ * Build a graphql:resolve channel context for a single field invocation.
+ *
+ * `fieldPath` is exposed as a lazy getter because serializing the response
+ * path is O(depth) and APMs that depth-filter or skip trivial resolvers
+ * often never read it. `args` is passed through by reference.
+ */
+function buildResolveCtx(
+  info: GraphQLResolveInfo,
+  args: { readonly [argument: string]: unknown },
+  isTrivialResolver: boolean,
+): object {
+  let cachedFieldPath: string | undefined;
+  return {
+    fieldName: info.fieldName,
+    parentType: info.parentType.name,
+    fieldType: String(info.returnType),
+    args,
+    isTrivialResolver,
+    get fieldPath() {
+      cachedFieldPath ??= pathToArray(info.path).join('.');
+      return cachedFieldPath;
+    },
+  };
+}

src/execution/__tests__/resolve-diagnostics-test.ts

@@ -0,0 +1,173 @@
+import { expect } from 'chai';
+import { afterEach, beforeEach, describe, it } from 'mocha';
+
+import {
+  collectEvents,
+  FakeDc,
+} from '../../__testUtils__/fakeDiagnosticsChannel.js';
+
+import { isPromise } from '../../jsutils/isPromise.js';
+
+import { parse } from '../../language/parser.js';
+
+import { GraphQLObjectType } from '../../type/definition.js';
+import { GraphQLString } from '../../type/scalars.js';
+import { GraphQLSchema } from '../../type/schema.js';
+
+import { buildSchema } from '../../utilities/buildASTSchema.js';
+
+import { enableDiagnosticsChannel } from '../../diagnostics.js';
+
+import { execute } from '../execute.js';
+
+const schema = buildSchema(`
+  type Query {
+    sync: String
+    async: String
+    fail: String
+    plain: String
+    nested: Nested
+  }
+  type Nested {
+    leaf: String
+  }
+`);
+
+const rootValue = {
+  sync: () => 'hello',
+  async: () => Promise.resolve('hello-async'),
+  fail: () => {
+    throw new Error('boom');
+  },
+  // no `plain` resolver, default property-access is used.
+  plain: 'plain-value',
+  nested: { leaf: 'leaf-value' },
+};
+
+const fakeDc = new FakeDc();
+const resolveChannel = fakeDc.tracingChannel('graphql:resolve');
+
+describe('resolve diagnostics channel', () => {
+  let active: ReturnType<typeof collectEvents> | undefined;
+
+  beforeEach(() => {
+    enableDiagnosticsChannel(fakeDc);
+  });
+
+  afterEach(() => {
+    active?.unsubscribe();
+    active = undefined;
+  });
+
+  it('emits start and end around a synchronous resolver', () => {
+    active = collectEvents(resolveChannel);
+
+    const result = execute({ schema, document: parse('{ sync }'), rootValue });
+    if (isPromise(result)) {
+      throw new Error('expected sync');
+    }
+
+    const starts = active.events.filter((e) => e.kind === 'start');
+    expect(starts.length).to.equal(1);
+    expect(starts[0].ctx.fieldName).to.equal('sync');
+    expect(starts[0].ctx.parentType).to.equal('Query');
+    expect(starts[0].ctx.fieldType).to.equal('String');
+    expect(starts[0].ctx.fieldPath).to.equal('sync');
+
+    const kinds = active.events.map((e) => e.kind);
+    expect(kinds).to.deep.equal(['start', 'end']);
+  });
+
+  it('emits the full async lifecycle when a resolver returns a promise', async () => {
+    active = collectEvents(resolveChannel);
+
+    const result = execute({ schema, document: parse('{ async }'), rootValue });
+    await result;
+
+    const kinds = active.events.map((e) => e.kind);
+    expect(kinds).to.deep.equal(['start', 'end', 'asyncStart', 'asyncEnd']);
+  });
+
+  it('emits start, error, end when a sync resolver throws', () => {
+    active = collectEvents(resolveChannel);
+
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    execute({ schema, document: parse('{ fail }'), rootValue });
+
+    const kinds = active.events.map((e) => e.kind);
+    expect(kinds).to.deep.equal(['start', 'error', 'end']);
+  });
+
+  it('reports isTrivialResolver based on field.resolve presence', () => {
+    const trivialSchema = new GraphQLSchema({
+      query: new GraphQLObjectType({
+        name: 'Query',
+        fields: {
+          trivial: { type: GraphQLString },
+          custom: {
+            type: GraphQLString,
+            resolve: () => 'explicit',
+          },
+        },
+      }),
+    });
+
+    active = collectEvents(resolveChannel);
+
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    execute({
+      schema: trivialSchema,
+      document: parse('{ trivial custom }'),
+      rootValue: { trivial: 'value' },
+    });
+
+    const starts = active.events.filter((e) => e.kind === 'start');
+    const byField = new Map(
+      starts.map((e) => [e.ctx.fieldName, e.ctx.isTrivialResolver]),
+    );
+    expect(byField.get('trivial')).to.equal(true);
+    expect(byField.get('custom')).to.equal(false);
+  });
+
+  it('serializes fieldPath lazily, joining path keys with dots', () => {
+    active = collectEvents(resolveChannel);
+
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    execute({
+      schema,
+      document: parse('{ nested { leaf } }'),
+      rootValue,
+    });
+
+    const starts = active.events.filter((e) => e.kind === 'start');
+    const paths = starts.map((e) => e.ctx.fieldPath);
+    expect(paths).to.deep.equal(['nested', 'nested.leaf']);
+  });
+
+  it('fires once per field, not per schema walk', () => {
+    active = collectEvents(resolveChannel);
+
+    // eslint-disable-next-line @typescript-eslint/no-floating-promises
+    execute({
+      schema,
+      document: parse('{ sync plain nested { leaf } }'),
+      rootValue,
+    });
+
+    const starts = active.events.filter((e) => e.kind === 'start');
+    const endsSync = active.events.filter((e) => e.kind === 'end');
+    expect(starts.length).to.equal(4); // sync, plain, nested, nested.leaf
+    expect(endsSync.length).to.equal(4);
+  });
+
+  it('does nothing when no subscribers are attached', () => {
+    const result = execute({
+      schema,
+      document: parse('{ sync }'),
+      rootValue,
+    });
+    if (isPromise(result)) {
+      throw new Error('expected sync');
+    }
+  });
+});