feat(validation): publish on graphql:validate tracing channel

Wraps the public validate() entry point with maybeTraceSync. The context
carries both the schema being validated against and the parsed document,
so APM tools can associate the span with a concrete GraphQL operation.

validate() is synchronous so traceSync is appropriate; errors thrown by
assertValidSchema or the visitor rethrow propagate through the channel's
error sub-channel.

Also extracts the in-memory TracingChannel fake used by parser-diagnostics
into src/__testUtils__/fakeDiagnosticsChannel.ts so subsequent emission
sites (validate, execute, subscribe, resolve) can reuse it without
duplicating the lifecycle simulation.

Author: logaretm

integrationTests/diagnostics/test.js

@@ -5,7 +5,12 @@
 import assert from 'node:assert/strict';
 import dc from 'node:diagnostics_channel';
 
-import { enableDiagnosticsChannel, parse } from 'graphql';
+import {
+  buildSchema,
+  enableDiagnosticsChannel,
+  parse,
+  validate,
+} from 'graphql';
 
 enableDiagnosticsChannel(dc);
 
@@ -64,6 +69,40 @@ enableDiagnosticsChannel(dc);
   }
 }
 
+// graphql:validate - synchronous, with schema/document context
+{
+  const schema = buildSchema(`type Query { field: String }`);
+  const doc = parse('{ field }');
+
+  const events = [];
+  const handler = {
+    start: (msg) =>
+      events.push({
+        kind: 'start',
+        schema: msg.schema,
+        document: msg.document,
+      }),
+    end: () => events.push({ kind: 'end' }),
+    error: (msg) => events.push({ kind: 'error', error: msg.error }),
+  };
+
+  const channel = dc.tracingChannel('graphql:validate');
+  channel.subscribe(handler);
+
+  try {
+    const errors = validate(schema, doc);
+    assert.deepEqual(errors, []);
+    assert.deepEqual(
+      events.map((e) => e.kind),
+      ['start', 'end'],
+    );
+    assert.equal(events[0].schema, schema);
+    assert.equal(events[0].document, doc);
+  } finally {
+    channel.unsubscribe(handler);
+  }
+}
+
 // No-op when nothing is subscribed - parse still succeeds.
 {
   const doc = parse('{ field }');

src/__testUtils__/fakeDiagnosticsChannel.ts

@@ -0,0 +1,186 @@
+import type {
+  MinimalChannel,
+  MinimalDiagnosticsChannel,
+  MinimalTracingChannel,
+} from '../diagnostics.js';
+
+export type Listener = (message: unknown) => void;
+
+/**
+ * In-memory `MinimalChannel` implementation used by the unit tests. Tracks
+ * subscribers and replays Node's `runStores` semantics by simply invoking
+ * `fn`.
+ */
+export class FakeChannel implements MinimalChannel {
+  listeners: Array<Listener> = [];
+
+  get [Symbol.toStringTag]() {
+    return 'FakeChannel';
+  }
+
+  get hasSubscribers(): boolean {
+    return this.listeners.length > 0;
+  }
+
+  publish(message: unknown): void {
+    for (const l of this.listeners) {
+      l(message);
+    }
+  }
+
+  runStores<T, ContextType extends object>(
+    _ctx: ContextType,
+    fn: (this: ContextType, ...args: Array<unknown>) => T,
+    thisArg?: unknown,
+    ...args: Array<unknown>
+  ): T {
+    return fn.apply(thisArg as ContextType, args);
+  }
+
+  subscribe(listener: Listener): void {
+    this.listeners.push(listener);
+  }
+
+  unsubscribe(listener: Listener): void {
+    const idx = this.listeners.indexOf(listener);
+    if (idx >= 0) {
+      this.listeners.splice(idx, 1);
+    }
+  }
+}
+
+/**
+ * Structurally-faithful `MinimalTracingChannel` implementation mirroring
+ * Node's `TracingChannel.traceSync` / `tracePromise` lifecycle (start,
+ * runStores, error, asyncStart, asyncEnd, end).
+ */
+export class FakeTracingChannel implements MinimalTracingChannel {
+  start: FakeChannel = new FakeChannel();
+  end: FakeChannel = new FakeChannel();
+  asyncStart: FakeChannel = new FakeChannel();
+  asyncEnd: FakeChannel = new FakeChannel();
+  error: FakeChannel = new FakeChannel();
+
+  get [Symbol.toStringTag]() {
+    return 'FakeTracingChannel';
+  }
+
+  get hasSubscribers(): boolean {
+    return (
+      this.start.hasSubscribers ||
+      this.end.hasSubscribers ||
+      this.asyncStart.hasSubscribers ||
+      this.asyncEnd.hasSubscribers ||
+      this.error.hasSubscribers
+    );
+  }
+
+  traceSync<T>(
+    fn: (...args: Array<unknown>) => T,
+    ctx: object,
+    thisArg?: unknown,
+    ...args: Array<unknown>
+  ): T {
+    this.start.publish(ctx);
+    try {
+      return this.end.runStores(ctx, fn, thisArg, ...args);
+    } catch (err) {
+      (ctx as { error: unknown }).error = err;
+      this.error.publish(ctx);
+      throw err;
+    } finally {
+      this.end.publish(ctx);
+    }
+  }
+
+  tracePromise<T>(
+    fn: (...args: Array<unknown>) => Promise<T>,
+    ctx: object,
+    thisArg?: unknown,
+    ...args: Array<unknown>
+  ): Promise<T> {
+    this.start.publish(ctx);
+    let promise: Promise<T>;
+    try {
+      promise = this.end.runStores(ctx, fn, thisArg, ...args);
+    } catch (err) {
+      (ctx as { error: unknown }).error = err;
+      this.error.publish(ctx);
+      this.end.publish(ctx);
+      throw err;
+    }
+    this.end.publish(ctx);
+    return promise.then(
+      (result) => {
+        (ctx as { result: unknown }).result = result;
+        this.asyncStart.publish(ctx);
+        this.asyncEnd.publish(ctx);
+        return result;
+      },
+      (err: unknown) => {
+        (ctx as { error: unknown }).error = err;
+        this.error.publish(ctx);
+        this.asyncStart.publish(ctx);
+        this.asyncEnd.publish(ctx);
+        throw err;
+      },
+    );
+  }
+}
+
+export class FakeDc implements MinimalDiagnosticsChannel {
+  private cache = new Map<string, FakeTracingChannel>();
+
+  get [Symbol.toStringTag]() {
+    return 'FakeDc';
+  }
+
+  tracingChannel(name: string): FakeTracingChannel {
+    let existing = this.cache.get(name);
+    if (existing === undefined) {
+      existing = new FakeTracingChannel();
+      this.cache.set(name, existing);
+    }
+    return existing;
+  }
+}
+
+export interface CollectedEvent {
+  kind: 'start' | 'end' | 'asyncStart' | 'asyncEnd' | 'error';
+  ctx: { [key: string]: unknown };
+}
+
+/**
+ * Attach listeners to every sub-channel on a FakeTracingChannel and return
+ * the captured event buffer plus an unsubscribe hook.
+ */
+export function collectEvents(channel: FakeTracingChannel): {
+  events: Array<CollectedEvent>;
+  unsubscribe: () => void;
+} {
+  const events: Array<CollectedEvent> = [];
+  const make =
+    (kind: CollectedEvent['kind']): Listener =>
+    (m) =>
+      events.push({ kind, ctx: m as { [key: string]: unknown } });
+  const startL = make('start');
+  const endL = make('end');
+  const asyncStartL = make('asyncStart');
+  const asyncEndL = make('asyncEnd');
+  const errorL = make('error');
+  channel.start.subscribe(startL);
+  channel.end.subscribe(endL);
+  channel.asyncStart.subscribe(asyncStartL);
+  channel.asyncEnd.subscribe(asyncEndL);
+  channel.error.subscribe(errorL);
+  return {
+    events,
+    unsubscribe() {
+      channel.start.unsubscribe(startL);
+      channel.end.unsubscribe(endL);
+      channel.asyncStart.unsubscribe(asyncStartL);
+      channel.asyncEnd.unsubscribe(asyncEndL);
+      channel.error.unsubscribe(errorL);
+    },
+  };
+}