dd-trace 6.14.0 → 6.16.0

package/packages/datadog-instrumentations/src/jest.js

@@ -11,7 +11,7 @@ const path = require('path')
 const satisfies = require('../../../vendor/dist/semifies')
 const { DD_MAJOR } = require('../../../version')
 const shimmer = require('../../datadog-shimmer')
-const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const log = require('../../dd-trace/src/log')
 const {
   EMPTY_EFD_RETRY_POLICY,
@@ -64,6 +64,7 @@ const { addHook, channel } = require('./helpers/instrument')
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
 const codeCoverageReportCh = channel('ci:jest:coverage-report')
+const bundlerLoadCh = channel('dd-trace:bundler:load')
 
 const testSessionConfigurationCh = channel('ci:jest:session:configuration')
 
@@ -179,7 +180,9 @@ const wrappedJestEsmLoaders = new WeakSet()
 const wrappedJestObjects = new WeakSet()
 const wrappedWorkerInitializers = new WeakSet()
 const publishedRuntimeReferenceErrors = new WeakMap()
-const jestEsmBypassModulePathsByRuntime = new WeakMap()
+const jestEsmLoggingModulePathsByRuntime = new WeakMap()
+const jestLoggingPackagesByRuntime = new WeakMap()
+const instrumentedJestLoggingModules = new WeakMap()
 const wrappedCoverageReporters = new WeakSet()
 const coverageReporterRequires = new WeakMap()
 const handledJestEvents = new WeakSet()
@@ -3733,13 +3736,15 @@ if (DD_MAJOR < 6) {
   }, jestConfigSyncWrapper)
 }
 
-const LOGGING_LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
+const JEST_LOGGING_LIBRARIES = new Set([
   'bunyan',
   'pino',
   'winston',
 ])
+const disabledJestInstrumentations = new Set(
+  getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',')
+)
 const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
-  ...LOGGING_LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE,
   'selenium-webdriver',
   'selenium-webdriver/chrome',
   'selenium-webdriver/edge',
@@ -3884,13 +3889,17 @@ function requireOutsideJestRequireEngine (runtime, moduleName) {
  * @param {string} moduleName
  * @returns {void}
  */
-function recordJestEsmBypassModulePath (runtime, from, moduleName) {
-  if (typeof from !== 'string' || !LOGGING_LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) return
+function recordJestEsmLoggingModulePath (runtime, from, moduleName) {
+  if (
+    typeof from !== 'string' ||
+    !JEST_LOGGING_LIBRARIES.has(moduleName) ||
+    disabledJestInstrumentations.has(moduleName)
+  ) return
 
-  let pathsByParent = jestEsmBypassModulePathsByRuntime.get(runtime)
+  let pathsByParent = jestEsmLoggingModulePathsByRuntime.get(runtime)
   if (!pathsByParent) {
     pathsByParent = new Map()
-    jestEsmBypassModulePathsByRuntime.set(runtime, pathsByParent)
+    jestEsmLoggingModulePathsByRuntime.set(runtime, pathsByParent)
   }
 
   let modulePaths = pathsByParent.get(from)
@@ -3911,16 +3920,15 @@ function recordJestEsmBypassModulePath (runtime, from, moduleName) {
  * @param {object} runtime
  * @param {string} from
  * @param {string} modulePath
- * @returns {boolean}
+ * @returns {string | undefined}
  */
-function hasJestEsmBypassModulePath (runtime, from, modulePath) {
-  const modulePaths = jestEsmBypassModulePathsByRuntime.get(runtime)?.get(from)
-  if (!modulePaths) return false
+function getJestEsmLoggingModuleName (runtime, from, modulePath) {
+  const modulePaths = jestEsmLoggingModulePathsByRuntime.get(runtime)?.get(from)
+  if (!modulePaths) return
 
-  for (const resolvedPath of modulePaths.values()) {
-    if (resolvedPath === modulePath) return true
+  for (const [moduleName, resolvedPath] of modulePaths) {
+    if (resolvedPath === modulePath) return moduleName
   }
-  return false
 }
 
 /**
@@ -3934,7 +3942,7 @@ function wrapJestEsmLoader (runtime) {
   wrappedJestEsmLoaders.add(esmLoader)
   if (typeof esmLoader.resolveModule === 'function') {
     shimmer.wrap(esmLoader, 'resolveModule', resolveModule => function (moduleName, from) {
-      recordJestEsmBypassModulePath(runtime, from, moduleName)
+      recordJestEsmLoggingModulePath(runtime, from, moduleName)
       return resolveModule.apply(this, arguments)
     })
   }
@@ -3943,7 +3951,7 @@ function wrapJestEsmLoader (runtime) {
       esmLoader,
       'resolveSpecifierForSyncGraph',
       resolveSpecifier => function (from, moduleName) {
-        recordJestEsmBypassModulePath(runtime, from, moduleName)
+        recordJestEsmLoggingModulePath(runtime, from, moduleName)
         return resolveSpecifier.apply(this, arguments)
       }
     )
@@ -3960,11 +3968,10 @@ function getJestBypassModulePath (runtime, from, moduleName) {
   if (typeof from !== 'string' || typeof moduleName !== 'string') return
 
   if (!LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
-    // Jest passes the resolved path when a CommonJS package is imported from an ESM test.
-    if (path.isAbsolute(moduleName) && hasJestEsmBypassModulePath(runtime, from, moduleName)) {
-      return moduleName
-    }
-    return
+    // Keep the native fallback for logging packages that cannot be instrumented in Jest's realm, such as a
+    // package-name-preserving symlink whose target is a user wrapper rather than the package itself.
+    if (path.isAbsolute(moduleName) && getJestEsmLoggingModuleName(runtime, from, moduleName)) return moduleName
+    if (!JEST_LOGGING_LIBRARIES.has(moduleName) || disabledJestInstrumentations.has(moduleName)) return
   }
 
   try {
@@ -3983,6 +3990,113 @@ function getJestBypassModulePath (runtime, from, moduleName) {
   }
 }
 
+/**
+ * @param {object} runtime
+ * @param {string} from
+ * @param {string} moduleName
+ * @returns {string}
+ */
+function resolveJestModulePath (runtime, from, moduleName) {
+  if (path.isAbsolute(moduleName)) return moduleName
+
+  if (typeof runtime._resolveCjsModule === 'function') {
+    return runtime._resolveCjsModule(from, moduleName)
+  } else if (typeof runtime.cjsLoader?.resolution?.resolveCjs === 'function') {
+    return runtime.cjsLoader.resolution.resolveCjs(from, moduleName)
+  }
+  return runtime._resolveModule(from, moduleName)
+}
+
+/**
+ * @param {object} runtime
+ * @param {string} from
+ * @param {string} moduleName
+ * @returns {{ name: string, path: string, version: string } | undefined}
+ */
+function getJestLoggingPackage (runtime, from, moduleName) {
+  if (typeof from !== 'string' || typeof moduleName !== 'string') return
+
+  const directModuleName = JEST_LOGGING_LIBRARIES.has(moduleName) && !disabledJestInstrumentations.has(moduleName)
+    ? moduleName
+    : getJestEsmLoggingModuleName(runtime, from, moduleName)
+  const packages = jestLoggingPackagesByRuntime.get(runtime)
+  let containingPackage
+  if (!directModuleName) {
+    if (!packages) return
+
+    const normalizedFrom = from.replaceAll(path.sep, '/')
+    for (const [packageRoot, loggingPackage] of packages) {
+      if (normalizedFrom.startsWith(`${packageRoot}/`)) {
+        containingPackage = { packageRoot, ...loggingPackage }
+        break
+      }
+    }
+    if (!containingPackage) return
+  }
+
+  try {
+    const modulePath = resolveJestModulePath(runtime, from, moduleName)
+    const normalizedModulePath = modulePath.replaceAll(path.sep, '/')
+
+    if (directModuleName) {
+      if (modulePath !== createRequire(from).resolve(directModuleName)) return
+
+      const nodeModulesPath = `/node_modules/${directModuleName}/`
+      const packagePathIndex = normalizedModulePath.lastIndexOf(nodeModulesPath)
+      if (packagePathIndex === -1) return
+
+      const packageRoot = normalizedModulePath.slice(0, packagePathIndex + nodeModulesPath.length - 1)
+      const { version } = JSON.parse(readFileSync(`${packageRoot}/package.json`, 'utf8'))
+      if (typeof version !== 'string') return
+
+      let runtimePackages = packages
+      if (!runtimePackages) {
+        runtimePackages = new Map()
+        jestLoggingPackagesByRuntime.set(runtime, runtimePackages)
+      }
+      runtimePackages.set(packageRoot, { name: directModuleName, version })
+      return { name: directModuleName, path: directModuleName, version }
+    }
+
+    const { packageRoot, name, version } = containingPackage
+    if (!normalizedModulePath.startsWith(`${packageRoot}/`)) return
+
+    const modulePathWithinPackage = normalizedModulePath.slice(packageRoot.length + 1)
+    return { name, path: `${name}/${modulePathWithinPackage}`, version }
+  } catch {
+    // Let Jest load unresolved, resolver-only, or virtual modules without instrumentation.
+  }
+}
+
+/**
+ * @param {unknown} moduleExports
+ * @param {{ name: string, path: string, version: string } | undefined} loggingPackage
+ * @returns {unknown}
+ */
+function instrumentJestLoggingModule (moduleExports, loggingPackage) {
+  if (!loggingPackage || (typeof moduleExports !== 'object' && typeof moduleExports !== 'function')) {
+    return moduleExports
+  }
+  if (moduleExports === null) return moduleExports
+
+  const instrumentedModule = instrumentedJestLoggingModules.get(moduleExports)
+  if (instrumentedModule) return instrumentedModule
+
+  const payload = {
+    module: moduleExports,
+    package: loggingPackage.name,
+    path: loggingPackage.path,
+    version: loggingPackage.version,
+  }
+  // Apply the regular instrumentation after Jest has evaluated the module so its built-ins stay in Jest's realm.
+  bundlerLoadCh.publish(payload)
+  instrumentedJestLoggingModules.set(moduleExports, payload.module)
+  if (payload.module && (typeof payload.module === 'object' || typeof payload.module === 'function')) {
+    instrumentedJestLoggingModules.set(payload.module, payload.module)
+  }
+  return payload.module
+}
+
 function formatDefaultStackTrace (error, structuredStackTrace) {
   const errorString = Error.prototype.toString.call(error)
   if (structuredStackTrace.length === 0) return errorString
@@ -4009,7 +4123,7 @@ addHook({
   // Jest 28 through 30.3 keeps ESM dependency resolution on Runtime itself.
   if (typeof Runtime.prototype.resolveModule === 'function') {
     shimmer.wrap(Runtime.prototype, 'resolveModule', resolveModule => function (moduleName, from) {
-      recordJestEsmBypassModulePath(this, from, moduleName)
+      recordJestEsmLoggingModulePath(this, from, moduleName)
       return resolveModule.apply(this, arguments)
     })
   }
@@ -4024,11 +4138,13 @@ addHook({
   shimmer.wrap(Runtime.prototype, 'requireModule', requireModule => function (from, moduleName) {
     wrapJestGlobalsForRuntime(this)
     try {
+      const loggingPackage = getJestLoggingPackage(this, from, moduleName)
       // Jest calls requireModule only after deciding that the module should not be mocked.
-      const bypassModulePath = getJestBypassModulePath(this, from, moduleName)
-      const returnedValue = bypassModulePath
+      const bypassModulePath = loggingPackage ? undefined : getJestBypassModulePath(this, from, moduleName)
+      let returnedValue = bypassModulePath
         ? requireOutsideJestRequireEngine(this, bypassModulePath)
         : requireModule.apply(this, arguments)
+      returnedValue = instrumentJestLoggingModule(returnedValue, loggingPackage)
       if (moduleName === '@jest/globals') {
         wrapConcurrentJestGlobalsForRuntime(this, returnedValue)
       }

package/packages/datadog-instrumentations/src/langchain.js

@@ -2,6 +2,6 @@
 
 const { addHook, getHooks } = require('./helpers/instrument')
 
-for (const hook of getHooks('@langchain/core')) {
+for (const hook of getHooks('@langchain/core').values()) {
   addHook(hook, exports => exports)
 }

package/packages/datadog-instrumentations/src/langgraph.js

@@ -2,6 +2,6 @@
 
 const { addHook, getHooks } = require('./helpers/instrument')
 
-for (const hook of getHooks('@langchain/langgraph')) {
+for (const hook of getHooks('@langchain/langgraph').values()) {
   addHook(hook, exports => exports)
 }

package/packages/datadog-instrumentations/src/mercurius.js

@@ -6,6 +6,6 @@
 
 const { addHook, getHooks } = require('./helpers/instrument')
 
-for (const hook of getHooks('mercurius')) {
+for (const hook of getHooks('mercurius').values()) {
   addHook(hook, exports => exports)
 }

package/packages/datadog-instrumentations/src/mocha/main.js

@@ -1,5 +1,7 @@
 'use strict'
 
+const { AsyncResource } = require('node:async_hooks')
+
 const { createCoverageMap } = require('../../../../vendor/dist/istanbul-lib-coverage')
 const satisfies = require('../../../../vendor/dist/semifies')
 const { DD_MAJOR } = require('../../../../version')
@@ -80,6 +82,8 @@ const runnerTestEndHandlers = new WeakMap()
 const runnerFailuresAdjusted = new WeakSet()
 const runnerFrameworkErrors = new WeakMap()
 const runnerStarted = new WeakSet()
+const readyRunners = new WeakSet()
+const pendingRunnerStarts = new WeakMap()
 const runnerRecoveryStates = new WeakMap()
 const runnersWithPendingCoverageReset = new WeakSet()
 const parallelRunners = new WeakSet()
@@ -1066,6 +1070,38 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
   runStoresWithCompletion(libraryConfigurationCh, ctx, onReceivedConfiguration)
 }
 
+/**
+ * @param {import('mocha').Runner} runner
+ * @returns {void}
+ */
+function startMochaRunner (runner) {
+  if (readyRunners.has(runner)) {
+    runner.suite.run()
+  } else {
+    // Global setup can finish after configuration. Preserve the configuration
+    // context until Runner#run has installed its delayed-start listener.
+    pendingRunnerStarts.set(runner, AsyncResource.bind(() => runner.suite.run()))
+  }
+}
+
+/**
+ * @param {import('mocha').Runner['run']} run
+ * @param {import('mocha').Runner} runner
+ * @param {Parameters<import('mocha').Runner['run']>} args
+ * @returns {import('mocha').Runner}
+ */
+function runMochaRunner (run, runner, args) {
+  const result = run.apply(runner, args)
+  // Once delay mode is enabled, startup must complete even if the plugin is disabled during global setup.
+  readyRunners.add(runner)
+  const start = pendingRunnerStarts.get(runner)
+  if (start) {
+    pendingRunnerStarts.delete(runner)
+    start()
+  }
+  return result
+}
+
 // In this hook we delay the execution with options.delay to grab library configuration,
 // skippable and known tests.
 // It is called but skipped in parallel mode.
@@ -1118,11 +1154,11 @@ function wrapMochaRun (Mocha, frameworkVersion) {
         getCodeCoverageCh.publish({
           onDone: (receivedCodeCoverage) => {
             untestedCoverage = receivedCodeCoverage
-            global.run()
+            startMochaRunner(runner)
           },
         })
       } else {
-        global.run()
+        startMochaRunner(runner)
       }
     })
 
@@ -1146,7 +1182,7 @@ addHook({
     const mocha = args[0]
 
     /**
-     * This attaches `run` to the global context, which we'll call after
+     * This enables the delayed root suite, which we'll release after
      * our configuration and skippable suites requests.
      * You need this both here and in Mocha#run hook: the programmatic API
      * does not call `runMocha`, so it needs to be in Mocha#run. When using
@@ -1178,7 +1214,7 @@ addHook({
 
   shimmer.wrap(Runner.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, args)
+      return runMochaRunner(run, this, args)
     }
 
     const { onRunDone, onFlushDone } = getRunCompletionCallbacks(args[0])
@@ -1511,7 +1547,7 @@ addHook({
       }
     })
 
-    return run.apply(this, args)
+    return runMochaRunner(run, this, args)
   })
 
   return Runner

package/packages/datadog-instrumentations/src/modelcontextprotocol-sdk.js

@@ -4,7 +4,7 @@ const { tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel, getHooks } = require('./helpers/instrument')
 
-for (const hook of getHooks('@modelcontextprotocol/sdk')) {
+for (const hook of getHooks('@modelcontextprotocol/sdk').values()) {
   addHook(hook, exports => exports)
 }
 

package/packages/datadog-instrumentations/src/openai-agents.js

@@ -24,7 +24,7 @@ function captureChatCompletionsModelBaseURL (ctx) {
 
 chatCompletionsModelConstructorCh.end.subscribe(captureChatCompletionsModelBaseURL)
 
-for (const hook of getHooks('@openai/agents-openai')) {
+for (const hook of getHooks('@openai/agents-openai').values()) {
   addHook(hook, moduleExports => moduleExports)
 }
 

package/packages/datadog-instrumentations/src/openai.js

@@ -8,46 +8,28 @@ const ch = dc.tracingChannel('apm:openai:request')
 const onStreamedChunkCh = dc.channel('apm:openai:request:chunk')
 const responsePromiseContexts = new WeakMap()
 
-// Provider lifecycle channels. Payloads stay OpenAI-native:
-// before { args, parentSpan, abortController, pending }
-// after  { args, body, parentSpan, abortController, pending }
-const chatCompletionsBeforeChannel = dc.channel('dd-trace:openai:chat.completions:before')
-const chatCompletionsAfterChannel = dc.channel('dd-trace:openai:chat.completions:after')
-const responsesBeforeChannel = dc.channel('dd-trace:openai:responses:before')
-const responsesAfterChannel = dc.channel('dd-trace:openai:responses:after')
-
-const LIFECYCLE_CHANNELS = {
-  'chat.completions': {
-    before: chatCompletionsBeforeChannel,
-    after: chatCompletionsAfterChannel,
-  },
-  responses: {
-    before: responsesBeforeChannel,
-    after: responsesAfterChannel,
-  },
-}
+// Published synchronously with the native call data. A subscriber may set either callback and
+// this instrumentation applies it, so the wrapping stays here and only the policy lives outside:
+//   beforeResult () => Promise<void>|undefined   holds the result back until it settles
+//   onResult (body) => unknown|Promise<unknown>  inspects or replaces the delivered body
+const chatCompletionsInterceptChannel = dc.channel('dd-trace:openai:chat.completions:intercept')
+const responsesInterceptChannel = dc.channel('dd-trace:openai:responses:intercept')
 
 /**
- * Publishes a provider-native lifecycle payload to a cancelable lifecycle channel.
- *
- * Subscribers push async work into `pending` synchronously during publication and
- * abort `abortController` with an error before the pushed promise resolves to block.
+ * Returns `promise`, but not before `settled` settles, so a rejection from an interceptor
+ * reaches the caller instead of the SDK's value.
  *
- * @param {object} channel
- * @param {object} payload
- * @returns {Promise<void>}
+ * @template T
+ * @param {Promise<T>} promise
+ * @param {Promise<void>|undefined} settled
+ * @returns {Promise<T>}
  */
-function publishLifecycle (channel, payload) {
-  const abortController = new AbortController()
-  const ctx = { ...payload, abortController, pending: [] }
+function heldUntil (promise, settled) {
+  if (!settled) return promise
 
-  channel.publish(ctx)
-
-  return Promise.all(ctx.pending).then(() => {
-    if (abortController.signal.aborted) {
-      throw abortController.signal.reason
-    }
-  })
+  // The interceptor's rejection wins over an earlier SDK rejection, so keep that one handled.
+  promise.catch(() => {})
+  return settled.then(() => promise)
 }
 
 const V4_PACKAGE_SHIMS = [
@@ -57,6 +39,7 @@ const V4_PACKAGE_SHIMS = [
     baseResource: 'chat.completions',
     methods: ['create'],
     streamedResponse: true,
+    interceptChannel: chatCompletionsInterceptChannel,
   },
   {
     file: 'resources/completions',
@@ -72,6 +55,7 @@ const V4_PACKAGE_SHIMS = [
     methods: ['create'], // implicitly covers `parse` as well which calls `create` under the hood
     streamedResponse: true,
     versions: ['>=4.87.0'],
+    interceptChannel: responsesInterceptChannel,
   },
   {
     file: 'resources/embeddings',
@@ -185,6 +169,7 @@ const V4_PACKAGE_SHIMS = [
     methods: ['create'],
     streamedResponse: true,
     versions: ['>=4.85.0'],
+    interceptChannel: chatCompletionsInterceptChannel,
   },
 ]
 
@@ -287,13 +272,11 @@ for (const extension of extensions) {
         return handleUnwrappedAPIPromise(parsedPromise, state)
       })
 
+      // Raw-response callers bypass `parse`, so run the interceptor here too.
       shimmer.wrap(prototype, 'asResponse', asResponse => function (...args) {
         const state = responsePromiseContexts.get(this.responsePromise)
-        const responsePromise = asResponse.apply(this, args)
-
-        if (!state?.getBeforeVerdict) return responsePromise
 
-        return Promise.all([state.getBeforeVerdict(), responsePromise]).then(([, response]) => response)
+        return heldUntil(asResponse.apply(this, args), state?.interceptCtx?.beforeResult?.())
       })
 
       return exports
@@ -303,7 +286,7 @@ for (const extension of extensions) {
 
 for (const extension of extensions) {
   for (const shim of V4_PACKAGE_SHIMS) {
-    const { file, targetClass, baseResource, methods, versions, streamedResponse } = shim
+    const { file, targetClass, baseResource, methods, versions, streamedResponse, interceptChannel } = shim
     addHook({ name: 'openai', file: file + extension, versions: versions || ['>=4'] }, exports => {
       const targetPrototype = exports[targetClass].prototype
 
@@ -314,10 +297,9 @@ for (const extension of extensions) {
           // chat.completions and completions
           const stream = streamedResponse && getOption(args, 'stream', false)
 
-          const channels = stream ? null : LIFECYCLE_CHANNELS[baseResource]
-          const hasLifecycle = !!channels && (channels.before.hasSubscribers || channels.after.hasSubscribers)
+          const intercepted = !stream && interceptChannel?.hasSubscribers
 
-          if (!ch.start.hasSubscribers && !hasLifecycle) {
+          if (!ch.start.hasSubscribers && !intercepted) {
             return methodFn.apply(this, args)
           }
 
@@ -330,24 +312,21 @@ for (const extension of extensions) {
           }
 
           return ch.start.runStores(ctx, () => {
-            // Capture the parent span explicitly: the _thenUnwrap/parse path decouples
-            // the lazy evaluation from the active scope at call time.
-            const parentSpan = hasLifecycle ? ctx.currentStore?.span : undefined
-
             const apiProm = methodFn.apply(this, args)
 
-            const beforeChannel = hasLifecycle && channels.before.hasSubscribers ? channels.before : null
-            const afterChannel = hasLifecycle && channels.after.hasSubscribers ? channels.after : null
-            let beforeVerdict
-            const getBeforeVerdict = beforeChannel
-              ? function getBeforeVerdict () {
-                beforeVerdict ??= publishLifecycle(beforeChannel, { args, parentSpan })
-                return beforeVerdict
-              }
-              : null
+            let interceptCtx
+            if (intercepted) {
+              interceptCtx = { arguments: args, tracingContext: ctx }
+              interceptChannel.publish(interceptCtx)
+            }
 
-            const state = { ctx, stream, getBeforeVerdict, afterChannel, parentSpan }
-            responsePromiseContexts.set(apiProm.responsePromise, state)
+            // Keyed by the response promise rather than the APIPromise: `_thenUnwrap` builds a new
+            // APIPromise around the same response, which is how `responses.parse` and the
+            // pagination page types reach the prototype wrappers above. A method that resolves to
+            // a plain value has none, and a WeakMap rejects a non-object key.
+            if (apiProm?.responsePromise) {
+              responsePromiseContexts.set(apiProm.responsePromise, { ctx, stream, interceptCtx })
+            }
 
             ch.end.publish(ctx)
 
@@ -361,20 +340,17 @@ for (const extension of extensions) {
 }
 
 function handleUnwrappedAPIPromise (apiProm, state) {
-  const { ctx, stream, getBeforeVerdict, afterChannel, parentSpan } = state
-  const gatedApiProm = getBeforeVerdict
-    ? Promise.all([getBeforeVerdict(), apiProm]).then(([, result]) => result)
-    : apiProm
+  const { ctx, stream, interceptCtx } = state
 
-  return gatedApiProm
+  return heldUntil(apiProm, interceptCtx?.beforeResult?.())
     .then(([{ response, options }, body]) => {
       if (stream) {
+        const wrapIterator = wrapStreamIterator(response, options, ctx)
+
         if (body.iterator) {
-          shimmer.wrap(body, 'iterator', wrapStreamIterator(response, options, ctx))
+          shimmer.wrap(body, 'iterator', wrapIterator)
         } else {
-          shimmer.wrap(
-            body.response.body, Symbol.asyncIterator, wrapStreamIterator(response, options, ctx)
-          )
+          shimmer.wrap(body.response.body, Symbol.asyncIterator, wrapIterator)
         }
         return body
       }
@@ -388,28 +364,29 @@ function handleUnwrappedAPIPromise (apiProm, state) {
         },
       }
 
-      if (!afterChannel) {
+      if (!interceptCtx?.onResult) {
         finish(ctx, responseData)
         return body
       }
 
-      // Finish after evaluation so a block propagates the error to openai.request
-      // and the span wraps its child instead of closing before it.
-      return publishLifecycle(afterChannel, { args: ctx.args, body, parentSpan }).then(() => {
+      // Finish after the callback settles so a rejection propagates to openai.request and the
+      // span wraps its child instead of closing before it.
+      return Promise.resolve(interceptCtx.onResult(body)).then(deliveredBody => {
         finish(ctx, responseData)
-        return body
+        return deliveredBody
       })
     })
     .catch(error => {
-      // ctx.result is set inside finish(); if absent, finish never ran (sync throw in the success
-      // branch, Before Model block, After Model block, or openai error) — record the error now so
-      // the openai.request span is marked errored. If finish already ran, don't double-publish.
-      if (!ctx.result) finish(ctx, undefined, error)
+      finish(ctx, undefined, error)
       throw error
     })
 }
 
 function finish (ctx, response, error) {
+  // `parse` is re-entered on every await of the same APIPromise, and a stream may be iterated
+  // more than once, so the span must only close once.
+  if (ctx.finished) return
+
   if (error) {
     ctx.error = error
     ch.error.publish(ctx)
@@ -419,6 +396,7 @@ function finish (ctx, response, error) {
   // so we don't want to override it here
   ctx.result ??= {}
   Object.assign(ctx.result, response)
+  ctx.finished = true
 
   ch.asyncEnd.publish(ctx)
 }

package/packages/datadog-instrumentations/src/playwright.js

@@ -81,6 +81,7 @@ const testsToTestStatuses = new Map()
 const activeRumPages = new Set()
 
 const RUM_FLUSH_WAIT_TIME = getValueFromEnvSources('DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS')
+const isPlaywrightWorker = getValueFromEnvSources('DD_PLAYWRIGHT_WORKER') === '1'
 const DD_PROPERTIES_TIMEOUT = 5000
 const isFailureScreenshotUploadEnabled =
   getValueFromEnvSources('DD_TEST_FAILURE_SCREENSHOTS_ENABLED') === true
@@ -1712,6 +1713,9 @@ createRootSuiteCh.subscribe({
 
 pageGotoCh.subscribe({
   asyncEnd (ctx) {
+    // Playwright library consumers such as Vitest have no Playwright test span and may navigate during page startup.
+    if (!isPlaywrightWorker) return
+
     // The Page.goto rewriter waits for this so tests closing immediately after navigation still get RUM tags.
     const rumDetectionPromise = handlePageGoto(ctx.self)
     ctx.resolveCallback = onDone => rumDetectionPromise.then(onDone, onDone)