dd-trace 5.128.0 → 5.129.0

package/index.d.ts

@@ -4083,13 +4083,13 @@ declare namespace tracer {
       /** Create a text or chat prompt and its first version. */
       createPrompt (
         promptId: string,
-        template: string | PromptTemplateMessage[],
+        template: string | PromptTemplateItem[],
         options?: CreatePromptOptions
       ): Promise<PromptResponse>
       /** Add a text or chat version to an existing prompt. */
       createPromptVersion (
         promptId: string,
-        template: string | PromptTemplateMessage[],
+        template: string | PromptTemplateItem[],
         options?: CreatePromptVersionOptions
       ): Promise<PromptVersionResponse>
       /** Update prompt metadata. */
@@ -4113,10 +4113,45 @@ declare namespace tracer {
       content: string
     }
 
+    /** Provider fields on expanded messages; authored templates remain text-only. */
+    interface FormattedPromptMessage extends PromptTemplateMessage {
+      // The inherited content type stays string for compatibility; tool-only payloads can omit it or contain null.
+      tool_calls?: PromptToolCall[] | null,
+      tool_results?: PromptToolResult[] | null,
+      tool_call_id?: string | null
+    }
+
+    interface PromptToolCall {
+      id?: string | null,
+      type?: string | null,
+      tool_id?: string | null,
+      name?: string | null,
+      arguments?: unknown,
+      function?: {
+        name: string,
+        arguments: string
+      } | null
+    }
+
+    interface PromptToolResult {
+      id?: string | null,
+      type?: string | null,
+      tool_id?: string | null,
+      name?: string | null,
+      result?: unknown
+    }
+
+    interface PromptMessagePlaceholder {
+      type: 'placeholder',
+      name: string
+    }
+
+    type PromptTemplateItem = PromptTemplateMessage | PromptMessagePlaceholder
+
     type PromptFallbackValue =
       | string
-      | PromptTemplateMessage[]
-      | { template: string | PromptTemplateMessage[], version?: string }
+      | PromptTemplateItem[]
+      | { template: string | PromptTemplateItem[], version?: string, config?: Record<string, JSONType> }
     type PromptFallback = PromptFallbackValue | (() => PromptFallbackValue)
 
     interface GetPromptOptions {
@@ -4135,13 +4170,15 @@ declare namespace tracer {
       title?: string,
       description?: string,
       userVersion?: string,
-      envIds?: string[]
+      envIds?: string[],
+      config?: Record<string, JSONType>
     }
 
     interface CreatePromptVersionOptions {
       description?: string,
       userVersion?: string,
-      envIds?: string[]
+      envIds?: string[],
+      config?: Record<string, JSONType>
     }
 
     interface UpdatePromptOptions {
@@ -4154,14 +4191,16 @@ declare namespace tracer {
       envIds?: string[]
     }
 
+    // Preserve released output types; placeholder entries and null/omitted tool content are not fully described here.
     interface ManagedPrompt {
       readonly id: string,
       readonly version: string,
       readonly source: 'registry' | 'cache' | 'fallback' | 'ff' | 'resolve',
       readonly template: string | ReadonlyArray<Readonly<PromptTemplateMessage>>,
+      readonly config: Readonly<Record<string, ReadonlyJSONType>>,
       readonly promptUuid?: string,
       readonly promptVersionUuid?: string,
-      format (variables?: Record<string, unknown>): string | PromptTemplateMessage[]
+      format (variables?: Record<string, unknown>): string | FormattedPromptMessage[]
       toAnnotation (variables?: Record<string, unknown>): Prompt
     }
 
@@ -4179,7 +4218,8 @@ declare namespace tracer {
       ml_app?: string,
       ml_apps?: string[],
       last_version_created_at?: string,
-      extracted_from?: string
+      extracted_from?: string,
+      config?: Record<string, JSONType>
     }
 
     interface PromptVersionResponse {
@@ -4193,7 +4233,8 @@ declare namespace tracer {
       version_created_at?: string,
       author?: string,
       description?: string,
-      ml_app?: string
+      ml_app?: string,
+      config?: Record<string, JSONType>
     }
 
     interface DeletedPromptResponse {
@@ -4205,6 +4246,8 @@ declare namespace tracer {
     /** JSON-serializable value accepted by LLMObs Experiments. */
     type JSONType = string | number | boolean | null | JSONType[] | { [key: string]: JSONType }
 
+    type ReadonlyJSONType = string | number | boolean | null | ReadonlyArray<ReadonlyJSONType> | { readonly [key: string]: ReadonlyJSONType }
+
     /**
      * A task run over each dataset record during an experiment.
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.128.0",
+  "version": "5.129.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",

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

@@ -142,7 +142,6 @@ let knownTests = {}
 let skippedSuites = []
 let isSuitesSkipped = false
 let areAllSuitesSkipped = false
-let hasTestsToRun = false
 let repositoryRoot
 
 function shouldRunEarlyFlakeDetection () {
@@ -1218,7 +1217,6 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       }
     }
 
-    hasTestsToRun = isCoordinator ? this.sourcedPickles.length > 0 : this.pickleIds.length > 0
     pickleByFile = isCoordinator ? getPickleByFileNew(this) : getPickleByFile(this)
 
     if (isKnownTestsEnabled) {
@@ -1330,10 +1328,17 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }
 
-    const isExpectedEmptySession = success && !hasTestsToRun
+    const testCaseAttempts = (this.eventDataCollector || eventDataCollector).getTestCaseAttempts()
+    const getStatus = satisfies(frameworkVersion, '>=7.3.0') ? getStatusFromResultLatest : getStatusFromResult
+    const hasExecutedTests = testCaseAttempts.some(({ worstTestStepResult }) =>
+      getStatus(worstTestStepResult).status !== 'skip'
+    )
+    const testSessionEmptyReason = success && !hasExecutedTests
+      ? (testCaseAttempts.length > 0 || skippedSuites.length > 0 ? 'all_tests_skipped' : 'zero_tests')
+      : undefined
     const flushPromise = getChannelPromise(sessionFinishCh, {
-      status: isExpectedEmptySession ? 'skip' : (success ? 'pass' : 'fail'),
-      isExpectedEmptySession,
+      status: testSessionEmptyReason ? 'skip' : (success ? 'pass' : 'fail'),
+      testSessionEmptyReason,
       isSuitesSkipped,
       testCodeCoverageLinesTotal,
       testSessionCoverageFiles,

package/packages/datadog-instrumentations/src/cypress-config.js

@@ -426,15 +426,16 @@ function registerManualAfterScreenshotHandlers (on, handlers, datadogHandler) {
 }
 
 /**
- * Registers one Cypress after:spec handler that runs every collected handler
+ * Registers one Cypress lifecycle handler that runs every collected handler
  * in registration order. Cypress 10+ otherwise keeps only the last handler.
  *
  * @param {Function} on Cypress event registration function
- * @param {Function[]} handlers collected after:spec handlers
- * @param {Function} [datadogHandler] manual Datadog after:spec handler
+ * @param {'before:run'|'after:spec'} event lifecycle event
+ * @param {Function[]} handlers collected lifecycle handlers
+ * @param {Function} [datadogHandler] Datadog lifecycle handler
  * @param {Function} [cleanup] removes generated support files after an error
  */
-function registerAfterSpecHandlers (on, handlers, datadogHandler, cleanup) {
+function registerLifecycleHandlers (on, event, handlers, datadogHandler, cleanup) {
   const userHandlers = datadogHandler
     ? handlers.filter(handler => handler !== datadogHandler)
     : handlers
@@ -442,27 +443,31 @@ function registerAfterSpecHandlers (on, handlers, datadogHandler, cleanup) {
   if (userHandlers.length === 0) {
     if (datadogHandler) {
       if (cleanup) {
-        on('after:spec', (...args) => Promise.resolve().then(() => datadogHandler(...args)).catch((error) => {
+        on(event, (...args) => Promise.resolve().then(() => datadogHandler(...args)).catch((error) => {
           cleanup()
           throw error
         }))
       } else {
-        on('after:spec', datadogHandler)
+        on(event, datadogHandler)
       }
     }
     return
   }
 
-  on('after:spec', (spec, results) => {
+  on(event, (...args) => {
     const callHandler = datadogHandler
-      ? handler => runUserHandler(() => handler(spec, results))
-      : handler => handler(spec, results)
+      ? handler => runUserHandler(() => handler(...args))
+      : handler => handler(...args)
     const chain = userHandlers.reduce(
       (promise, handler) => promise.then(() => callHandler(handler)),
       Promise.resolve()
     )
     if (!datadogHandler) return chain
-    const finalization = finalizeAfterUserHandlers(chain, (...args) => datadogHandler(spec, results, ...args))
+    const finalization = finalizeAfterUserHandlers(chain, (...errors) => {
+      // A failed setup hook must abort the run before Datadog starts its session.
+      if (event === 'before:run' && errors.length > 0) return
+      return datadogHandler(...args, ...errors)
+    })
     if (!cleanup) return finalization
     return finalization.catch((error) => {
       cleanup()
@@ -514,6 +519,9 @@ function registerDdTraceHooks (
   if (generatedSupportFiles) registerGeneratedFilesForExitCleanup(generatedSupportFiles)
 
   const cleanupWrapper = () => {
+    // Open mode reuses this support file across runs, including failed setup attempts.
+    // The registered process-exit cleanup owns its lifetime instead.
+    if (config.isInteractive) return
     if (generatedSupportFiles) cleanupGeneratedFiles(generatedSupportFiles)
   }
 
@@ -537,8 +545,13 @@ function registerDdTraceHooks (
     })
   }
 
+  const registerBeforeRun = handler => {
+    registerLifecycleHandlers(on, 'before:run', userBeforeRunHandlers, handler, cleanupWrapper)
+  }
+
   const registerNoopHandlers = () => {
-    registerAfterSpecHandlers(on, userAfterSpecHandlers)
+    registerBeforeRun()
+    registerLifecycleHandlers(on, 'after:spec', userAfterSpecHandlers)
     for (const h of userAfterScreenshotHandlers) on('after:screenshot', h)
     registerAfterRunWithCleanup()
     on('task', noopTask)
@@ -555,8 +568,8 @@ function registerDdTraceHooks (
         manualPlugin.initialConfig.experimentalInteractiveRunEvents = config.experimentalInteractiveRunEvents
       }
     }
-    for (const handler of userBeforeRunHandlers) on('before:run', handler)
-    registerAfterSpecHandlers(on, userAfterSpecHandlers, manualPlugin.afterSpecHandler, cleanupWrapper)
+    registerBeforeRun(manualPlugin.beforeRunHandler)
+    registerLifecycleHandlers(on, 'after:spec', userAfterSpecHandlers, manualPlugin.afterSpecHandler, cleanupWrapper)
     registerManualAfterScreenshotHandlers(on, userAfterScreenshotHandlers, manualPlugin.afterScreenshotHandler)
     registerAfterRunWithCleanup(manualPlugin.afterRunHandler)
     on('task', manualPlugin.taskHandler)
@@ -572,8 +585,6 @@ function registerDdTraceHooks (
     )
   }
 
-  for (const handler of userBeforeRunHandlers) on('before:run', handler)
-
   if (!setupNodeEventsCh.hasSubscribers) {
     registerNoopHandlers()
     return config
@@ -588,6 +599,7 @@ function registerDdTraceHooks (
     userAfterSpecHandlers,
     userAfterRunHandlers,
     userAfterScreenshotHandlers,
+    registerBeforeRun,
     cleanupWrapper,
     registered: false,
     configPromise: undefined,

package/packages/datadog-instrumentations/src/helpers/bundler-register.js

@@ -13,6 +13,7 @@ const {
 } = require('./instrumentation-utils')
 const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
+const { isRewriteActivationEnabled } = require('./rewriter/targets')
 const disabledInstrumentations = getDisabledInstrumentations()
 
 // register.js has now set up ritm (require-in-the-middle). In bundled
@@ -94,6 +95,11 @@ dc.subscribe(CHANNEL, (message) => {
   const name = payload.package
   if (disabledInstrumentations.has(name)) return
 
+  if (payload.activate && isRewriteActivationEnabled(name)) {
+    loadChannel.publish({ name })
+    return
+  }
+
   const isPrefixedWithNode = name.startsWith('node:')
   const isNodeModule = isPrefixedWithNode || !hooks[name]
 

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -69,6 +69,7 @@ const earlyLoadFrameworks = new Map([
  */
 module.exports.checkForRequiredModules = function () {
   const packages = require('./hooks')
+  const { isRewriteTargetName } = require('./rewriter/targets')
   const naughties = new Set()
   const frameworksSeen = new Set()
   let didWarn = false
@@ -98,7 +99,7 @@ module.exports.checkForRequiredModules = function () {
       continue
     }
 
-    if (naughties.has(pkg) || !(pkg in packages)) continue
+    if (naughties.has(pkg) || (!(pkg in packages) && !isRewriteTargetName(pkg))) continue
 
     loadOrderWarnings.push(
       () => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`

package/packages/datadog-instrumentations/src/helpers/hooks.js

@@ -25,14 +25,12 @@ module.exports = {
   '@anthropic-ai/sdk': { esmFirst: true, fn: () => require('../anthropic') },
   '@apollo/server': () => require('../apollo-server'),
   '@apollo/gateway': () => require('../apollo'),
-  '@langchain/langgraph': { esmFirst: true, fn: () => require('../langgraph') },
   '@modelcontextprotocol/sdk': { esmFirst: true, fn: () => require('../modelcontextprotocol-sdk') },
   '@openai/agents': () => require('../openai-agents'),
   '@openai/agents-openai': () => require('../openai-agents'),
   'apollo-server-core': () => require('../apollo-server-core'),
   '@aws-sdk/smithy-client': () => require('../aws-sdk'),
   '@aws/durable-execution-sdk-js': () => require('../aws-durable-execution-sdk-js'),
-  '@azure/cosmos': { esmFirst: true, fn: () => require('../azure-cosmos') },
   '@azure/event-hubs': () => require('../azure-event-hubs'),
   '@azure/functions': () => require('../azure-functions'),
   'durable-functions': () => require('../azure-durable-functions'),
@@ -54,7 +52,6 @@ module.exports = {
   '@jest/test-sequencer': () => require('../jest'),
   '@jest/transform': () => require('../jest'),
   '@koa/router': () => require('../koa'),
-  '@langchain/core': { esmFirst: true, fn: () => require('../langchain') },
   '@node-redis/client': () => require('../redis'),
   '@opensearch-project/opensearch': () => require('../opensearch'),
   '@opentelemetry/sdk-trace': () => require('../otel-sdk-trace'),
@@ -78,7 +75,6 @@ module.exports = {
   bluebird: () => require('../bluebird'),
   'body-parser': () => require('../body-parser'),
   'browser-bunyan': () => require('../browser-bunyan'),
-  bullmq: () => require('../bullmq'),
   bunyan: () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
   connect: () => require('../connect'),
@@ -114,14 +110,12 @@ module.exports = {
   'koa-router': () => require('../koa'),
   '@confluentinc/kafka-javascript': () => require('../confluentinc-kafka-javascript'),
   kafkajs: () => require('../kafkajs'),
-  langchain: () => require('../langchain'),
   ldapjs: () => require('../ldapjs'),
   'light-my-request': () => require('../light-my-request'),
   'limitd-client': () => require('../limitd-client'),
   lodash: () => require('../lodash'),
   mariadb: { esmFirst: true, fn: () => require('../mariadb') },
   memcached: () => require('../memcached'),
-  mercurius: () => require('../mercurius'),
   'microgateway-core': () => require('../microgateway-core'),
   mocha: () => require('../mocha'),
   'mocha-each': () => require('../mocha'),

package/packages/datadog-instrumentations/src/helpers/register.js

@@ -25,6 +25,7 @@ const pathSepExpr = new RegExp(`\\${path.sep}`, 'g')
 const disabledInstrumentations = getDisabledInstrumentations()
 
 const loadChannel = channel('dd-trace:instrumentation:load')
+const orchestrionLoadChannel = channel('dd-trace:instrumentation:load:orchestrion')
 
 // Globals
 if (!disabledInstrumentations.has('fetch')) {
@@ -55,6 +56,25 @@ const instrumentedNodeModules = new Map()
 const instrumentedIntegrationsSuccess = new Map()
 /** @type {Set<string>} */
 const alreadyLoggedIncompatibleIntegrations = new Set()
+/** @type {Set<string>} */
+const compatibleOrchestrionTargets = new Set()
+
+orchestrionLoadChannel.subscribe(({ moduleName, version, result }) => {
+  const nameVersion = `${moduleName}@${version}`
+
+  if (result === 'unsupported') {
+    if (!compatibleOrchestrionTargets.has(nameVersion) && !instrumentedIntegrationsSuccess.has(nameVersion)) {
+      instrumentedIntegrationsSuccess.set(nameVersion, false)
+    }
+    return
+  }
+
+  if (result === 'matched' || result === 'rewritten') {
+    compatibleOrchestrionTargets.add(nameVersion)
+    instrumentedIntegrationsSuccess.set(nameVersion, true)
+    if (result === 'rewritten') loadChannel.publish({ name: moduleName })
+  }
+})
 
 for (const name of names) {
   if (disabledInstrumentations.has(name)) continue

package/packages/datadog-instrumentations/src/helpers/rewriter/index.js

@@ -19,7 +19,7 @@ const { getRewriteTarget } = require('./targets')
  *   { code: string, map?: string|object }} transform
  *
  * @typedef {(content: string|Buffer|ArrayBuffer|Uint8Array, filename: string, format?: string,
- *   target?: { moduleName: string, filePath: string }, sourceMap?: string|object) =>
+ *   target?: { moduleName: string, filePath: string, activate?: boolean }, sourceMap?: string|object) =>
  *   { code: string|Buffer|ArrayBuffer|Uint8Array, map?: string|object }} BundlerRewriter
  */
 
@@ -62,7 +62,7 @@ function normalizeFilename (filename) {
  * @param {string|Buffer|ArrayBuffer|Uint8Array} content
  * @param {string} filename
  * @param {string} [format]
- * @param {{ moduleName: string, filePath: string }} [target]
+ * @param {{ moduleName: string, filePath: string, activate?: boolean }} [target]
  * @returns {string|Buffer|ArrayBuffer|Uint8Array}
  */
 function rewrite (content, filename, format, target) {
@@ -74,7 +74,7 @@ function rewrite (content, filename, format, target) {
     if (!target) return content
 
     const moduleType = format === 'module' ? 'esm' : 'cjs'
-    const { moduleName, filePath } = target
+    const { moduleName, filePath, activate } = target
     if (disabled.has(moduleName)) return content
 
     const version = getVersion(filename, filePath)
@@ -82,10 +82,18 @@ function rewrite (content, filename, format, target) {
 
     const transformer = getMatcher(moduleType).getTransformer(moduleName, version, filePath)
 
-    if (!transformer) return content
+    if (!transformer && !activate) return content
 
     const source = getSourceText(content)
 
+    if (!transformer) {
+      return appendOrchestrionLoad(
+        source,
+        { moduleName, version, result: 'unsupported' },
+        moduleType
+      )
+    }
+
     // TODO: pass existing sourcemap as input for remapping
     let { code, map } = transformer.transform(source, moduleType)
 
@@ -98,6 +106,11 @@ function rewrite (content, filename, format, target) {
       map = shiftSourceMapLine(map)
     }
 
+    if (activate) {
+      const result = code === source ? 'matched' : 'rewritten'
+      code = appendOrchestrionLoad(code, { moduleName, version, result }, moduleType)
+    }
+
     if (!map) return code
 
     const inlineMap = Buffer.from(typeof map === 'string' ? map : JSON.stringify(map)).toString('base64')
@@ -236,6 +249,30 @@ function getSourceText (source) {
   return Buffer.from(source).toString('utf8')
 }
 
+/**
+ * Publish target-level compatibility on the application thread when a pure target is evaluated.
+ *
+ * @param {string} source
+ * @param {{ moduleName: string, version: string,
+ *   result: 'unsupported'|'matched'|'rewritten' }} payload
+ * @param {'cjs'|'esm'} moduleType
+ */
+function appendOrchestrionLoad (source, payload, moduleType) {
+  const dcModule = JSON.stringify(getDcPolyfillSpecifier(moduleType) ?? 'diagnostics_channel')
+  const message = JSON.stringify(payload)
+
+  if (moduleType === 'esm') {
+    let binding = 'ddTraceOrchestrionDc'
+    let suffix = 0
+    while (source.includes(binding)) binding = `ddTraceOrchestrionDc${++suffix}`
+
+    return `${source};import ${binding} from ${dcModule};` +
+      `${binding}.channel('dd-trace:instrumentation:load:orchestrion').publish(${message});`
+  }
+
+  return `${source};require(${dcModule}).channel('dd-trace:instrumentation:load:orchestrion').publish(${message});`
+}
+
 /**
  * Account for a shebang restored ahead of the generated program. The transformer already maps original positions
  * past the input shebang, so only the generated side needs an additional empty line.

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentation-registry.js

@@ -1,17 +1,19 @@
 'use strict'
 
-// activationName is the plugin-manager key published after a target is successfully rewritten.
+// Activated rewrites publish their module name to the plugin manager after evaluation.
+// Only pure Orchestrion integrations that need this activation set activate: true.
+// Other entries use hooks or another activation path, or do not need activation from a rewrite.
 const registry = [
   { instrumentations: require('./instrumentations/ai') },
-  { activationName: '@azure/cosmos', instrumentations: require('./instrumentations/azure-cosmos') },
+  { activate: true, instrumentations: require('./instrumentations/azure-cosmos') },
   { instrumentations: require('./instrumentations/azure-durable-functions') },
-  { activationName: 'bullmq', instrumentations: require('./instrumentations/bullmq') },
+  { activate: true, instrumentations: require('./instrumentations/bullmq') },
   { instrumentations: require('./instrumentations/claude-agent-sdk') },
   { instrumentations: require('./instrumentations/graphql') },
   { instrumentations: require('./instrumentations/graphql-jit') },
-  { activationName: '@langchain/core', instrumentations: require('./instrumentations/langchain') },
-  { activationName: '@langchain/langgraph', instrumentations: require('./instrumentations/langgraph') },
-  { activationName: 'mercurius', instrumentations: require('./instrumentations/mercurius') },
+  { activate: true, instrumentations: require('./instrumentations/langchain') },
+  { activate: true, instrumentations: require('./instrumentations/langgraph') },
+  { activate: true, instrumentations: require('./instrumentations/mercurius') },
   { instrumentations: require('./instrumentations/modelcontextprotocol-sdk') },
   { instrumentations: require('./instrumentations/openai-agents') },
   { instrumentations: require('./instrumentations/playwright') },
@@ -21,10 +23,10 @@ const registry = [
   { instrumentations: require('./instrumentations/supabase') },
 ]
 
-const activationNames = new Map()
-for (const { activationName, instrumentations } of registry) {
-  if (!activationName) continue
-  for (const { module } of instrumentations) activationNames.set(module.name, activationName)
+const activatedModules = new Set()
+for (const { activate, instrumentations } of registry) {
+  if (!activate) continue
+  for (const { module } of instrumentations) activatedModules.add(module.name)
 }
 
 const instrumentations = registry.flatMap(entry => entry.instrumentations)
@@ -32,8 +34,8 @@ const instrumentations = registry.flatMap(entry => entry.instrumentations)
 /**
  * @param {string} moduleName
  */
-function getRewriteActivationName (moduleName) {
-  return activationNames.get(moduleName)
+function isRewriteActivationEnabled (moduleName) {
+  return activatedModules.has(moduleName)
 }
 
-module.exports = { getRewriteActivationName, instrumentations, registry }
+module.exports = { isRewriteActivationEnabled, instrumentations, registry }

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

@@ -3,6 +3,49 @@
 // Playwright keeps several hook targets in private local classes/functions.
 // Keep these rewrites limited to bundled internals that addHook cannot wrap.
 module.exports = [
+  {
+    module: {
+      name: '@playwright/test',
+      versionRange: '>=1.18.0 <1.38.0',
+      filePath: 'lib/reporters/multiplexer.js',
+    },
+    functionQuery: {
+      className: 'Multiplexer',
+      methodName: 'onError',
+      kind: 'Sync',
+    },
+    channelName: 'Multiplexer_onError',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.44.0 <1.60.0',
+      filePath: 'lib/runner/runner.js',
+    },
+    astQuery: 'FunctionDeclaration[id.name="writeLastRunInfo"] ' +
+      'CallExpression[callee.property.name="map"] > ArrowFunctionExpression',
+    channelName: 'lastRunTestId',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.44.0 <1.60.0',
+      filePath: 'lib/runner/lastRun.js',
+    },
+    astQuery: 'ClassDeclaration[id.name="LastRunReporter"] ' +
+      'CallExpression[callee.property.name="map"] > ArrowFunctionExpression',
+    channelName: 'lastRunTestId',
+  },
+  {
+    module: {
+      name: 'playwright',
+      versionRange: '>=1.60.0',
+      filePath: 'lib/runner/index.js',
+    },
+    astQuery: 'VariableDeclarator[id.name="LastRunReporter"] ' +
+      'CallExpression[callee.property.name="map"] > ArrowFunctionExpression',
+    channelName: 'lastRunTestId',
+  },
   {
     module: {
       name: 'playwright',

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/webdriverio.js

@@ -1,6 +1,19 @@
 'use strict'
 
 module.exports = [
+  {
+    module: {
+      name: '@wdio/config',
+      versionRange: '>=9.0.0',
+      filePath: 'build/node/index.js',
+    },
+    functionQuery: {
+      className: 'ConfigParser',
+      methodName: 'shard',
+      kind: 'Sync',
+    },
+    channelName: 'ConfigParser_shard',
+  },
   {
     module: {
       name: '@wdio/cli',