refactor(diagnostics): align async lifecycle with Node's tracePromise shape

maybeTraceMixed now publishes asyncStart immediately once it knows the
operation is in-flight asynchronously and asyncEnd in a .finally once the
promise settles, matching the shape subscribers expect from a
tracePromise-style channel (asyncStart brackets the async tail rather
than being paired with asyncEnd in a single microtask).

Also brings the in-memory FakeTracingChannel in line with Node's actual
traceSync behavior: Node sets ctx.result before publishing end, letting
subscribers check isPromise(ctx.result) inside their end handler to
decide whether asyncEnd will follow or the span is complete. The fake
now does the same so unit tests aren't looser than real-Node behavior.

Author: logaretm

src/__testUtils__/fakeDiagnosticsChannel.ts

@@ -82,15 +82,22 @@ export class FakeTracingChannel implements MinimalTracingChannel {
     ...args: Array<unknown>
   ): T {
     this.start.publish(ctx);
+    let result: T;
     try {
-      return this.end.runStores(ctx, fn, thisArg, ...args);
+      result = 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);
+      throw err;
     }
+    // Node's real traceSync sets `ctx.result` before publishing `end`, so
+    // subscribers can inspect `isPromise(ctx.result)` inside their `end`
+    // handler to decide whether the operation is complete or async events
+    // will follow. Match that semantic here.
+    (ctx as { result: unknown }).result = result;
+    this.end.publish(ctx);
+    return result;
   }
 
   tracePromise<T>(
@@ -110,21 +117,22 @@ export class FakeTracingChannel implements MinimalTracingChannel {
       throw err;
     }
     this.end.publish(ctx);
-    return promise.then(
-      (result) => {
-        (ctx as { result: unknown }).result = result;
-        this.asyncStart.publish(ctx);
+    this.asyncStart.publish(ctx);
+    return promise
+      .then(
+        (result) => {
+          (ctx as { result: unknown }).result = result;
+          return result;
+        },
+        (err: unknown) => {
+          (ctx as { error: unknown }).error = err;
+          this.error.publish(ctx);
+          throw err;
+        },
+      )
+      .finally(() => {
         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;
-      },
-    );
+      });
   }
 }
 

src/diagnostics.ts

@@ -185,16 +185,7 @@ export function maybeTracePromise<T>(
 }
 
 /**
- * Publish a mixed sync-or-promise operation through the named graphql tracing
- * channel. Delegates the start/end/error lifecycle to Node's `traceSync`
- * (which also runs `fn` inside `end.runStores` for AsyncLocalStorage context
- * propagation) and, when `fn` returns a promise, appends `asyncStart` and
- * `asyncEnd` on settlement plus `error` on rejection.
- *
- * Use this when the function may return either a value or a promise, which
- * is common on graphql-js's execution path where async-ness is determined
- * by resolvers only after the call begins. Short-circuits to `fn()` when
- * the channel isn't registered or nothing is listening.
+ * Publish a mixed sync-or-promise operation through the named graphql tracing channel.
  *
  * @internal
  */
@@ -211,24 +202,30 @@ export function maybeTraceMixed<T>(
     error?: unknown;
     result?: unknown;
   };
+
+  // traceSync fires start/end (and error, if fn throws synchronously)
   const result = channel.traceSync(fn, ctx);
   if (!isPromise(result)) {
-    ctx.result = result;
     return result;
   }
-  return result.then(
-    (value) => {
-      ctx.result = value;
-      channel.asyncStart.publish(ctx);
-      channel.asyncEnd.publish(ctx);
-      return value;
-    },
-    (err: unknown) => {
-      ctx.error = err;
-      channel.error.publish(ctx);
-      channel.asyncStart.publish(ctx);
+
+  // Fires off `asyncStart` and `asyncEnd` lifecycle events.
+  channel.asyncStart.publish(ctx);
+  return result
+    .then(
+      (value) => {
+        ctx.result = value;
+
+        return value;
+      },
+      (err: unknown) => {
+        ctx.error = err;
+        channel.error.publish(ctx);
+
+        throw err;
+      },
+    )
+    .finally(() => {
       channel.asyncEnd.publish(ctx);
-      throw err;
-    },
-  );
+    });
 }