ref(perf): inline no-subscriber fast path at tracing emission sites

On parse/validate/execute/subscribe entry points, the previous
`maybeTrace*` wrapper allocated a ctx-factory closure and a body closure
on every call before short-circuiting on `hasSubscribers`. Inline the
gate as `if (!channel?.hasSubscribers) return impl(args)` so closures
and ctx objects are only allocated when a subscriber is attached.

Recovers roughly half of the tracing-channel overhead seen in
benchmarks. List-sync is back within noise of the pre-tracing baseline.
Introspection remains ~3% slower due to the per-field resolve gate;
the shape-change fix (dropping `_resolveChannel` from Executor) in the
previous commit already captured the other half of that regression.

Author: logaretm

src/diagnostics.ts

@@ -187,3 +187,13 @@ export function traceMixed<T>(
       });
   });
 }
+
+/**
+ * Check if a channel is defined and has subscribers.
+ */
+export function shouldTrace(
+  channel: MinimalTracingChannel | undefined,
+): channel is MinimalTracingChannel {
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare
+  return channel !== undefined && channel.hasSubscribers !== false;
+}

src/execution/Executor.ts

@@ -44,8 +44,7 @@ import {
 } from '../type/definition.js';
 import type { GraphQLSchema } from '../type/schema.js';
 
-import type { MinimalTracingChannel } from '../diagnostics.js';
-import { getChannels, maybeTraceMixed, shouldTrace } from '../diagnostics.js';
+import { resolveChannel, shouldTrace, traceMixed } from '../diagnostics.js';
 
 import { withCancellation } from './cancellablePromise.js';
 import type {
@@ -245,12 +244,6 @@ export class Executor<
     values: ReadonlyArray<PromiseOrValue<T>>,
   ) => Promise<Array<T>>;
 
-  // Resolved once per Executor so the per-field gate in `executeField` is a
-  // single member read + null check, not a `getChannels()?.resolve` walk +
-  // `hasSubscribers` read on every resolution. Undefined when diagnostics
-  // are off or nobody is listening at construction time.
-  _resolveChannel: MinimalTracingChannel | undefined;
-
   constructor(
     validatedExecutionArgs: ValidatedExecutionArgs,
     sharedExecutionContext?: SharedExecutionContext,
@@ -260,11 +253,6 @@ export class Executor<
     this.abortReason = defaultAbortReason;
     this.collectedErrors = new CollectedErrors();
 
-    const resolveChannel = getChannels()?.resolve;
-    this._resolveChannel = shouldTrace(resolveChannel)
-      ? resolveChannel
-      : undefined;
-
     if (sharedExecutionContext === undefined) {
       this.resolverAbortController = new AbortController();
       this.sharedExecutionContext = createSharedExecutionContext(
@@ -622,10 +610,10 @@ 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 = this._resolveChannel
-        ? maybeTraceMixed(
-            'resolve',
-            () => buildResolveCtx(info, args, fieldDef.resolve === undefined),
+      const result = shouldTrace(resolveChannel)
+        ? traceMixed(
+            resolveChannel,
+            buildResolveCtx(info, args, fieldDef.resolve === undefined),
             () => resolveFn(source, args, contextValue, info),
           )
         : resolveFn(source, args, contextValue, info);

src/execution/execute.ts

@@ -34,7 +34,11 @@ import type { GraphQLSchema } from '../type/schema.js';
 
 import { getOperationAST } from '../utilities/getOperationAST.js';
 
-import { maybeTraceMixed } from '../diagnostics.js';
+import {
+  executeChannel,
+  subscribeChannel,
+  traceMixed,
+} from '../diagnostics.js';
 
 import { cancellablePromise } from './cancellablePromise.js';
 import type { FieldDetailsList, FragmentDetails } from './collectFields.js';
@@ -58,26 +62,24 @@ const UNEXPECTED_EXPERIMENTAL_DIRECTIVES =
  * resolution of the operation AST to a lazy getter so the cost of walking
  * the document is only paid if a subscriber reads it.
  */
-function buildExecuteCtxFromArgs(args: ExecutionArgs): () => object {
-  return () => {
-    let operation: OperationDefinitionNode | null | undefined;
-    const resolveOperation = (): OperationDefinitionNode | null | undefined => {
-      if (operation === undefined) {
-        operation = getOperationAST(args.document, args.operationName);
-      }
-      return operation;
-    };
-    return {
-      document: args.document,
-      schema: args.schema,
-      variableValues: args.variableValues,
-      get operationName() {
-        return args.operationName ?? resolveOperation()?.name?.value;
-      },
-      get operationType() {
-        return resolveOperation()?.operation;
-      },
-    };
+function buildExecuteCtxFromArgs(args: ExecutionArgs): object {
+  let operation: OperationDefinitionNode | null | undefined;
+  const resolveOperation = (): OperationDefinitionNode | null | undefined => {
+    if (operation === undefined) {
+      operation = getOperationAST(args.document, args.operationName);
+    }
+    return operation;
+  };
+  return {
+    document: args.document,
+    schema: args.schema,
+    variableValues: args.variableValues,
+    get operationName() {
+      return args.operationName ?? resolveOperation()?.name?.value;
+    },
+    get operationType() {
+      return resolveOperation()?.operation;
+    },
   };
 }
 
@@ -90,14 +92,14 @@ function buildExecuteCtxFromArgs(args: ExecutionArgs): () => object {
  */
 function buildExecuteCtxFromValidatedArgs(
   args: ValidatedExecutionArgs,
-): () => object {
-  return () => ({
+): object {
+  return {
     operation: args.operation,
     schema: args.schema,
     variableValues: args.variableValues,
     operationName: args.operation.name?.value,
     operationType: args.operation.operation,
-  });
+  };
 }
 
 /**
@@ -117,23 +119,27 @@ function buildExecuteCtxFromValidatedArgs(
  * delivery.
  */
 export function execute(args: ExecutionArgs): PromiseOrValue<ExecutionResult> {
-  return maybeTraceMixed('execute', buildExecuteCtxFromArgs(args), () => {
-    if (
-      args.schema.getDirective('defer') ||
-      args.schema.getDirective('stream')
-    ) {
-      throw new Error(UNEXPECTED_EXPERIMENTAL_DIRECTIVES);
-    }
+  if (!executeChannel?.hasSubscribers) {
+    return executeImpl(args);
+  }
+  return traceMixed(executeChannel, buildExecuteCtxFromArgs(args), () =>
+    executeImpl(args),
+  );
+}
 
-    const validatedExecutionArgs = validateExecutionArgs(args);
+function executeImpl(args: ExecutionArgs): PromiseOrValue<ExecutionResult> {
+  if (args.schema.getDirective('defer') || args.schema.getDirective('stream')) {
+    throw new Error(UNEXPECTED_EXPERIMENTAL_DIRECTIVES);
+  }
 
-    // Return early errors if execution context failed.
-    if (!('schema' in validatedExecutionArgs)) {
-      return { errors: validatedExecutionArgs };
-    }
+  const validatedExecutionArgs = validateExecutionArgs(args);
 
-    return executeQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs);
-  });
+  // Return early errors if execution context failed.
+  if (!('schema' in validatedExecutionArgs)) {
+    return { errors: validatedExecutionArgs };
+  }
+
+  return executeQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs);
 }
 
 /**
@@ -151,39 +157,57 @@ export function execute(args: ExecutionArgs): PromiseOrValue<ExecutionResult> {
 export function experimentalExecuteIncrementally(
   args: ExecutionArgs,
 ): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults> {
-  return maybeTraceMixed('execute', buildExecuteCtxFromArgs(args), () => {
-    // If a valid execution context cannot be created due to incorrect
-    // arguments, a "Response" with only errors is returned.
-    const validatedExecutionArgs = validateExecutionArgs(args);
-
-    // Return early errors if execution context failed.
-    if (!('schema' in validatedExecutionArgs)) {
-      return { errors: validatedExecutionArgs };
-    }
+  if (!executeChannel?.hasSubscribers) {
+    return experimentalExecuteIncrementallyImpl(args);
+  }
+  return traceMixed(executeChannel, buildExecuteCtxFromArgs(args), () =>
+    experimentalExecuteIncrementallyImpl(args),
+  );
+}
 
-    return experimentalExecuteQueryOrMutationOrSubscriptionEvent(
-      validatedExecutionArgs,
-    );
-  });
+function experimentalExecuteIncrementallyImpl(
+  args: ExecutionArgs,
+): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults> {
+  // If a valid execution context cannot be created due to incorrect
+  // arguments, a "Response" with only errors is returned.
+  const validatedExecutionArgs = validateExecutionArgs(args);
+
+  // Return early errors if execution context failed.
+  if (!('schema' in validatedExecutionArgs)) {
+    return { errors: validatedExecutionArgs };
+  }
+
+  return experimentalExecuteQueryOrMutationOrSubscriptionEvent(
+    validatedExecutionArgs,
+  );
 }
 
 export function executeIgnoringIncremental(
   args: ExecutionArgs,
 ): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults> {
-  return maybeTraceMixed('execute', buildExecuteCtxFromArgs(args), () => {
-    // If a valid execution context cannot be created due to incorrect
-    // arguments, a "Response" with only errors is returned.
-    const validatedExecutionArgs = validateExecutionArgs(args);
-
-    // Return early errors if execution context failed.
-    if (!('schema' in validatedExecutionArgs)) {
-      return { errors: validatedExecutionArgs };
-    }
+  if (!executeChannel?.hasSubscribers) {
+    return executeIgnoringIncrementalImpl(args);
+  }
+  return traceMixed(executeChannel, buildExecuteCtxFromArgs(args), () =>
+    executeIgnoringIncrementalImpl(args),
+  );
+}
 
-    return executeQueryOrMutationOrSubscriptionEventIgnoringIncremental(
-      validatedExecutionArgs,
-    );
-  });
+function executeIgnoringIncrementalImpl(
+  args: ExecutionArgs,
+): PromiseOrValue<ExecutionResult | ExperimentalIncrementalExecutionResults> {
+  // If a valid execution context cannot be created due to incorrect
+  // arguments, a "Response" with only errors is returned.
+  const validatedExecutionArgs = validateExecutionArgs(args);
+
+  // Return early errors if execution context failed.
+  if (!('schema' in validatedExecutionArgs)) {
+    return { errors: validatedExecutionArgs };
+  }
+
+  return executeQueryOrMutationOrSubscriptionEventIgnoringIncremental(
+    validatedExecutionArgs,
+  );
 }
 
 /**
@@ -244,8 +268,11 @@ export function executeSync(args: ExecutionArgs): ExecutionResult {
 export function executeSubscriptionEvent(
   validatedExecutionArgs: ValidatedExecutionArgs,
 ): PromiseOrValue<ExecutionResult> {
-  return maybeTraceMixed(
-    'execute',
+  if (!executeChannel?.hasSubscribers) {
+    return executeQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs);
+  }
+  return traceMixed(
+    executeChannel,
     buildExecuteCtxFromValidatedArgs(validatedExecutionArgs),
     () => executeQueryOrMutationOrSubscriptionEvent(validatedExecutionArgs),
   );
@@ -282,26 +309,37 @@ export function subscribe(
 ): PromiseOrValue<
   AsyncGenerator<ExecutionResult, void, void> | ExecutionResult
 > {
-  return maybeTraceMixed('subscribe', buildExecuteCtxFromArgs(args), () => {
-    // If a valid execution context cannot be created due to incorrect
-    // arguments, a "Response" with only errors is returned.
-    const validatedExecutionArgs = validateExecutionArgs(args);
-
-    // Return early errors if execution context failed.
-    if (!('schema' in validatedExecutionArgs)) {
-      return { errors: validatedExecutionArgs };
-    }
+  if (!subscribeChannel?.hasSubscribers) {
+    return subscribeImpl(args);
+  }
+  return traceMixed(subscribeChannel, buildExecuteCtxFromArgs(args), () =>
+    subscribeImpl(args),
+  );
+}
 
-    const resultOrStream = createSourceEventStreamImpl(validatedExecutionArgs);
+function subscribeImpl(
+  args: ExecutionArgs,
+): PromiseOrValue<
+  AsyncGenerator<ExecutionResult, void, void> | ExecutionResult
+> {
+  // If a valid execution context cannot be created due to incorrect
+  // arguments, a "Response" with only errors is returned.
+  const validatedExecutionArgs = validateExecutionArgs(args);
 
-    if (isPromise(resultOrStream)) {
-      return resultOrStream.then((resolvedResultOrStream) =>
-        mapSourceToResponse(validatedExecutionArgs, resolvedResultOrStream),
-      );
-    }
+  // Return early errors if execution context failed.
+  if (!('schema' in validatedExecutionArgs)) {
+    return { errors: validatedExecutionArgs };
+  }
+
+  const resultOrStream = createSourceEventStreamImpl(validatedExecutionArgs);
+
+  if (isPromise(resultOrStream)) {
+    return resultOrStream.then((resolvedResultOrStream) =>
+      mapSourceToResponse(validatedExecutionArgs, resolvedResultOrStream),
+    );
+  }
 
-    return mapSourceToResponse(validatedExecutionArgs, resultOrStream);
-  });
+  return mapSourceToResponse(validatedExecutionArgs, resultOrStream);
 }
 
 /**

src/language/parser.ts

@@ -3,7 +3,7 @@ import type { Maybe } from '../jsutils/Maybe.js';
 import type { GraphQLError } from '../error/GraphQLError.js';
 import { syntaxError } from '../error/syntaxError.js';
 
-import { parseChannel } from '../diagnostics.js';
+import { parseChannel, shouldTrace } from '../diagnostics.js';
 
 import type {
   ArgumentCoordinateNode,
@@ -134,10 +134,9 @@ export function parse(
   source: string | Source,
   options?: ParseOptions,
 ): DocumentNode {
-  if (!parseChannel?.hasSubscribers) {
-    return parseImpl(source, options);
-  }
-  return parseChannel.traceSync(() => parseImpl(source, options), { source });
+  return shouldTrace(parseChannel)
+    ? parseChannel.traceSync(() => parseImpl(source, options), { source })
+    : parseImpl(source, options);
 }
 
 function parseImpl(

src/validation/validate.ts

@@ -12,7 +12,7 @@ import { assertValidSchema } from '../type/validate.js';
 
 import { TypeInfo, visitWithTypeInfo } from '../utilities/TypeInfo.js';
 
-import { validateChannel } from '../diagnostics.js';
+import { shouldTrace, validateChannel } from '../diagnostics.js';
 
 import { specifiedRules, specifiedSDLRules } from './specifiedRules.js';
 import type { SDLValidationRule, ValidationRule } from './ValidationContext.js';
@@ -63,13 +63,12 @@ export function validate(
   rules: ReadonlyArray<ValidationRule> = specifiedRules,
   options?: ValidationOptions,
 ): ReadonlyArray<GraphQLError> {
-  if (!validateChannel?.hasSubscribers) {
-    return validateImpl(schema, documentAST, rules, options);
-  }
-  return validateChannel.traceSync(
-    () => validateImpl(schema, documentAST, rules, options),
-    { schema, document: documentAST },
-  );
+  return shouldTrace(validateChannel)
+    ? validateChannel.traceSync(
+        () => validateImpl(schema, documentAST, rules, options),
+        { schema, document: documentAST },
+      )
+    : validateImpl(schema, documentAST, rules, options);
 }
 
 function validateImpl(