dd-trace 6.20.1 → 6.22.0

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

@@ -72,11 +72,7 @@ function createWrapRequest (name) {
 
   return function wrapRequest (request) {
     return function (params, options, cb) {
-      if (!startCh.hasSubscribers) {
-        return request.apply(this, arguments)
-      }
-
-      if (!params) return request.apply(this, arguments)
+      if (!startCh.hasSubscribers || !params) return request.apply(this, arguments)
 
       const ctx = { params }
       return startCh.runStores(ctx, () => {

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

@@ -83,10 +83,10 @@ function createWrapAddListener (ch, mappings) {
   }
 }
 
-function createWrapRemoveListener (mappings) {
+function createWrapRemoveListener () {
   return function wrapRemoveListener (removeListener) {
     return function (channel, listener) {
-      const mapping = mappings[channel]
+      const mapping = listeners[channel]
 
       if (mapping) {
         const wrapper = mapping.get(listener)
@@ -212,10 +212,10 @@ addHook({ name: 'electron', versions: ['>=37.0.0'] }, electron => {
     wrap(ipcRenderer, 'sendToHost', createWrapSend(rendererSendCh))
 
     wrap(ipcRenderer, 'addListener', createWrapAddListener(rendererReceiveCh, listeners))
-    wrap(ipcRenderer, 'off', createWrapRemoveListener(listeners))
+    wrap(ipcRenderer, 'off', createWrapRemoveListener())
     wrap(ipcRenderer, 'on', createWrapAddListener(rendererReceiveCh, listeners))
     wrap(ipcRenderer, 'once', createWrapAddListener(rendererReceiveCh, listeners))
-    wrap(ipcRenderer, 'removeListener', createWrapRemoveListener(listeners))
+    wrap(ipcRenderer, 'removeListener', createWrapRemoveListener())
     wrap(ipcRenderer, 'removeAllListeners', createWrapRemoveAllListeners(listeners))
 
     ipcRenderer.send('datadog:apm:renderer:patched')
@@ -223,12 +223,12 @@ addHook({ name: 'electron', versions: ['>=37.0.0'] }, electron => {
     wrap(ipcMain, 'addListener', createWrapAddListener(mainReceiveCh, listeners))
     wrap(ipcMain, 'handle', createWrapAddListener(mainHandleCh, handlers))
     wrap(ipcMain, 'handleOnce', createWrapAddListener(mainHandleCh, handlers))
-    wrap(ipcMain, 'off', createWrapRemoveListener(listeners))
+    wrap(ipcMain, 'off', createWrapRemoveListener())
     wrap(ipcMain, 'on', createWrapAddListener(mainReceiveCh, listeners))
     wrap(ipcMain, 'once', createWrapAddListener(mainReceiveCh, listeners))
     wrap(ipcMain, 'removeAllListeners', createWrapRemoveAllListeners(listeners))
     wrap(ipcMain, 'removeHandler', createWrapRemoveAllListeners(handlers))
-    wrap(ipcMain, 'removeListener', createWrapRemoveListener(listeners))
+    wrap(ipcMain, 'removeListener', createWrapRemoveListener())
 
     ipcMain.once('datadog:apm:renderer:patched', event => rendererPatchedCh.publish(event))
 

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
+const { isEmpty } = require('../../dd-trace/src/util')
 const { addHook, channel, createErrorPublisher } = require('./helpers/instrument')
 
 const errorChannel = channel('apm:fastify:middleware:error')
@@ -186,6 +187,17 @@ function onRequest (request, reply, done) {
   return done()
 }
 
+/**
+ * Publishing an empty body would set a WAF address for nothing, so only non-empty bodies are published.
+ * Strings, arrays and binary bodies are checked by length to avoid enumerating one key per character or element.
+ *
+ * @param {unknown} body
+ */
+function hasBody (body) {
+  if (typeof body === 'string') return body.length > 0
+  return typeof body === 'object' && body !== null && !isEmpty(body)
+}
+
 function preHandler (request, reply, done) {
   if (typeof done !== 'function') return
   if (!reply || typeof reply.send !== 'function') return done()
@@ -194,11 +206,8 @@ function preHandler (request, reply, done) {
   const res = getRes(reply)
   const ctx = { req, res }
 
-  // eslint-disable-next-line no-restricted-syntax -- arbitrary body keys; publishing {} sets a WAF address
-  const hasBody = request.body && Object.keys(request.body).length > 0
-
   // For multipart/form-data, the body is not available until after preValidation hook
-  if (bodyParserReadCh.hasSubscribers && hasBody && !bodyPublished.has(req)) {
+  if (bodyParserReadCh.hasSubscribers && !bodyPublished.has(req) && hasBody(request.body)) {
     ctx.abortController = new AbortController()
     ctx.body = request.body
     bodyParserReadCh.publish(ctx)

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

@@ -232,9 +232,9 @@ function getMethodParamsRelationByPrefix (prefix) {
   return paramsByMethod
 }
 
-function createWatchWrapFunction (override = '') {
+function createWatchWrapFunction () {
   return function wrapFunction (original) {
-    const name = override || original.name
+    const name = original.name
     const method = name
     const operation = name
     return function (...args) {

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -126,10 +126,14 @@ function wrapMethod (method) {
   }
 }
 
-function massWrap (obj, methods, wrapper) {
+/**
+ * @param {Record<string, Function>} obj
+ * @param {string[]} methods
+ */
+function massWrap (obj, methods) {
   for (const method of methods) {
     if (typeof obj[method] === 'function') {
-      shimmer.wrap(obj, method, wrapper)
+      shimmer.wrap(obj, method, wrapMethod)
     }
   }
 }
@@ -274,11 +278,11 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
 addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'] }, (obj) => {
   const { PublisherClient, SchemaServiceClient, SubscriberClient } = obj.v1
 
-  massWrap(PublisherClient.prototype, publisherMethods, wrapMethod)
-  massWrap(SubscriberClient.prototype, subscriberMethods, wrapMethod)
+  massWrap(PublisherClient.prototype, publisherMethods)
+  massWrap(SubscriberClient.prototype, subscriberMethods)
 
   if (SchemaServiceClient) {
-    massWrap(SchemaServiceClient.prototype, schemaServiceMethods, wrapMethod)
+    massWrap(SchemaServiceClient.prototype, schemaServiceMethods)
   }
 
   return obj

package/packages/datadog-instrumentations/src/grpc/client.js

@@ -246,6 +246,8 @@ function patch (hasPeer = false) {
   return function patch (grpc) {
     const proto = grpc.Client.prototype
 
+    if (instances.has(proto)) return grpc
+
     instances.set(proto, grpc)
 
     shimmer.wrap(proto, 'makeBidiStreamRequest', createWrapMakeRequest(types.bidi, hasPeer))

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

@@ -4,7 +4,7 @@ const Module = require('module')
 const dc = require('dc-polyfill')
 
 const log = require('../../../dd-trace/src/log')
-const { loadChannel } = require('./register.js')
+const { activate, loadChannel } = require('./register.js')
 const {
   filename,
   getDisabledInstrumentations,
@@ -96,7 +96,7 @@ dc.subscribe(CHANNEL, (message) => {
   if (disabledInstrumentations.has(name)) return
 
   if (payload.activate && isRewriteActivationEnabled(name)) {
-    loadChannel.publish({ name })
+    activate(name, payload.version)
     return
   }
 

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

@@ -132,8 +132,7 @@ module.exports.checkForPotentialConflicts = function () {
 
   for (const pathToModule of Object.keys(require.cache)) {
     const { pkg } = extractPackageAndModulePath(pathToModule)
-    if (naughties.has(pkg)) continue
-    if (!potentialConflicts.has(pkg)) continue
+    if (naughties.has(pkg) || !potentialConflicts.has(pkg)) continue
 
     warnings.push(() => `Warning: Package '${pkg}' may cause conflicts with dd-trace.`)
 

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

@@ -88,7 +88,7 @@ exports.getHooks = function getHooks (names) {
   for (const { module } of rewriterInstrumentations) {
     if (!requested.has(module.name)) continue
     // Fresh objects, including the versions array: callers may adjust a hook
-    // for their own registration (the ai, claude-agent-sdk and
+    // for their own registration (the ai and
     // aws-durable-execution-sdk-js plugins set `hook.file = null`), which must
     // not leak into any other call.
     const hook = { name: module.name, versions: [module.versionRange], file: module.filePath }

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

@@ -14,6 +14,7 @@ const {
   matchesInstrumentation,
 } = require('./instrumentation-utils')
 const rewriter = require('./rewriter')
+const { getActivationSetup } = require('./rewriter/instrumentation-registry')
 
 const DD_TRACE_DEBUG = getValueFromEnvSources('DD_TRACE_DEBUG')
 
@@ -58,6 +59,39 @@ const instrumentedIntegrationsSuccess = new Map()
 const alreadyLoggedIncompatibleIntegrations = new Set()
 /** @type {Set<string>} */
 const compatibleOrchestrionTargets = new Set()
+/** @type {Set<(activation: import('./rewriter/instrumentation-registry').Activation) => void>} */
+const blockedActivationSetups = new Set()
+
+/**
+ * @param {string} moduleName
+ * @param {string} [version]
+ */
+function activate (moduleName, version) {
+  const setup = getActivationSetup(moduleName)
+  if (setup) {
+    if (blockedActivationSetups.has(setup)) return
+    // Block re-entrant activation until setup completes, and never retry a failed setup.
+    blockedActivationSetups.add(setup)
+    try {
+      setup({ moduleName, version })
+      blockedActivationSetups.delete(setup)
+    } catch (error) {
+      const message = String(error?.message ?? error)
+      log.error('Error during activation setup of %s: %s', moduleName, message, error)
+      telemetry('error', [
+        `error_type:${error?.constructor?.name ?? typeof error}`,
+        `integration:${moduleName}`,
+        `integration_version:${version ?? 'unknown'}`,
+      ], {
+        result: 'error',
+        result_class: 'internal_error',
+        result_reason: `Error during activation of ${moduleName}: ${message}`,
+      })
+      return
+    }
+  }
+  loadChannel.publish({ name: moduleName })
+}
 
 orchestrionLoadChannel.subscribe(({ moduleName, version, result }) => {
   const nameVersion = `${moduleName}@${version}`
@@ -72,7 +106,7 @@ orchestrionLoadChannel.subscribe(({ moduleName, version, result }) => {
   if (result === 'matched' || result === 'rewritten') {
     compatibleOrchestrionTargets.add(nameVersion)
     instrumentedIntegrationsSuccess.set(nameVersion, true)
-    if (result === 'rewritten') loadChannel.publish({ name: moduleName })
+    if (result === 'rewritten') activate(moduleName, version)
   }
 })
 
@@ -176,6 +210,7 @@ function logAbortedIntegrations () {
 }
 
 module.exports = {
+  activate,
   filename,
   pathSepExpr,
   loadChannel,

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

@@ -188,6 +188,7 @@ function createMatcher (dcModule) {
     waitForAsyncEnd,
   } = require('./transforms')
   const {
+    postgresQueryAcquire,
     postgresQueryHandlers,
     postgresQueryLifecycle,
     postgresQueryPreparation,
@@ -204,6 +205,7 @@ function createMatcher (dcModule) {
   matcher.addTransform('configureGraphqlJitRuntime', configureGraphqlJitRuntime)
   matcher.addTransform('configureMercuriusRequest', configureMercuriusRequest)
   matcher.addTransform('publishDurableOrchestrationFailure', publishDurableOrchestrationFailure)
+  matcher.addTransform('postgresQueryAcquire', postgresQueryAcquire)
   matcher.addTransform('postgresQueryHandlers', postgresQueryHandlers)
   matcher.addTransform('postgresQueryLifecycle', postgresQueryLifecycle)
   matcher.addTransform('postgresQueryPreparation', postgresQueryPreparation)

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

@@ -1,14 +1,35 @@
 'use strict'
 
 // Activated rewrites publish their module name to the plugin manager after evaluation.
-// Only pure Orchestrion integrations that need this activation set activate: true.
+// Integrations can also provide synchronous runtime setup before plugin activation.
+// Setup must not load rewrite targets: re-entrant activations of the same group are dropped.
+// activate: true covers every rewrite target in the entry; activate.modules narrows it to the packages
+// that should trigger activation, leaving the rest of the entry rewrite-only.
 // Other entries use hooks or another activation path, or do not need activation from a rewrite.
+/**
+ * @typedef {object} Activation
+ * @property {string} moduleName
+ * @property {string} [version]
+ *
+ * @typedef {object} ActivationConfig
+ * @property {string[]} [modules]
+ * @property {((activation: Activation) => void)} [setup]
+ *
+ * @typedef {object} InstrumentationRegistryEntry
+ * @property {true|ActivationConfig} [activate]
+ * @property {Array<{ module: { name: string } }>} instrumentations
+ */
+
+/** @satisfies {InstrumentationRegistryEntry[]} */
 const registry = [
   { instrumentations: require('./instrumentations/ai') },
   { activate: true, instrumentations: require('./instrumentations/azure-cosmos') },
   { instrumentations: require('./instrumentations/azure-durable-functions') },
   { activate: true, instrumentations: require('./instrumentations/bullmq') },
-  { instrumentations: require('./instrumentations/claude-agent-sdk') },
+  {
+    activate: { setup: () => require('../../claude-agent-sdk') },
+    instrumentations: require('./instrumentations/claude-agent-sdk'),
+  },
   { instrumentations: require('./instrumentations/graphql') },
   { instrumentations: require('./instrumentations/graphql-jit') },
   { activate: true, instrumentations: require('./instrumentations/langchain') },
@@ -19,14 +40,66 @@ const registry = [
   { instrumentations: require('./instrumentations/playwright') },
   { activate: true, instrumentations: require('./instrumentations/postgres') },
   { instrumentations: require('./instrumentations/webdriverio') },
-  { instrumentations: require('./instrumentations/aws-durable-execution-sdk-js') },
+  {
+    activate: { setup: () => require('../../aws-durable-execution-sdk-js') },
+    instrumentations: require('./instrumentations/aws-durable-execution-sdk-js'),
+  },
   { activate: true, instrumentations: require('./instrumentations/supabase') },
 ]
 
 const activatedModules = new Set()
+/** @type {Map<string, (activation: Activation) => void>} */
+const activationSetups = new Map()
 for (const { activate, instrumentations } of registry) {
-  if (!activate) continue
-  for (const { module } of instrumentations) activatedModules.add(module.name)
+  if (activate === undefined) continue
+  if (activate !== true && (typeof activate !== 'object' || activate === null || Array.isArray(activate))) {
+    throw new TypeError('Instrumentation registry activate must be true or an activation config object')
+  }
+  const config = activate === true ? undefined : activate
+  const setup = config?.setup
+  if (setup !== undefined && typeof setup !== 'function') {
+    throw new TypeError('Instrumentation registry activate.setup must be a function')
+  }
+
+  const rewriteModules = new Set(instrumentations.map(({ module }) => module.name))
+  for (const moduleName of resolveActivationModules(config?.modules, rewriteModules)) {
+    if (activatedModules.has(moduleName) && activationSetups.get(moduleName) !== setup) {
+      throw new TypeError(`Instrumentation registry activation module "${moduleName}" has conflicting setup functions`)
+    }
+    activatedModules.add(moduleName)
+    if (setup) activationSetups.set(moduleName, setup)
+  }
+}
+
+/**
+ * Activation covers every rewrite target in the entry unless it names the packages to activate. An explicit
+ * list keeps helper packages that share the entry rewrite-only.
+ * @param {string[]|undefined} modules
+ * @param {Set<string>} rewriteModules
+ * @returns {Set<string>}
+ */
+function resolveActivationModules (modules, rewriteModules) {
+  if (modules === undefined) return rewriteModules
+  if (!Array.isArray(modules) || modules.length === 0) {
+    throw new TypeError('Instrumentation registry activate.modules must be a non-empty array')
+  }
+
+  const entryModules = new Set()
+  for (const moduleName of modules) {
+    if (typeof moduleName !== 'string' || moduleName.length === 0) {
+      throw new TypeError('Instrumentation registry activate.modules must contain non-empty strings')
+    }
+    if (!rewriteModules.has(moduleName)) {
+      throw new TypeError(
+        `Instrumentation registry activation module "${moduleName}" is not a rewrite target in its entry`
+      )
+    }
+    if (entryModules.has(moduleName)) {
+      throw new TypeError(`Instrumentation registry activation module "${moduleName}" is duplicated in its entry`)
+    }
+    entryModules.add(moduleName)
+  }
+  return entryModules
 }
 
 const instrumentations = registry.flatMap(entry => entry.instrumentations)
@@ -38,4 +111,12 @@ function isRewriteActivationEnabled (moduleName) {
   return activatedModules.has(moduleName)
 }
 
-module.exports = { isRewriteActivationEnabled, instrumentations, registry }
+/**
+ * @param {string} moduleName
+ * @returns {((activation: Activation) => void)|undefined}
+ */
+function getActivationSetup (moduleName) {
+  return activationSetups.get(moduleName)
+}
+
+module.exports = { getActivationSetup, isRewriteActivationEnabled, instrumentations, registry }

package/packages/datadog-instrumentations/src/helpers/rewriter/instrumentations/graphql-jit.js

@@ -26,11 +26,10 @@ const COMPILE_DEFERRED_FIELD = 'FunctionDeclaration[id.name="compileDeferredFiel
  */
 
 /**
- * @param {GraphqlJitInstrumentation[]} instrumentations
  * @param {string} versionRange
  * @param {string} filePath
  */
-function addInstrumentations (instrumentations, versionRange, filePath) {
+function addInstrumentations (versionRange, filePath) {
   const moduleDefinition = { name: 'graphql-jit', versionRange, filePath }
   instrumentations.push(
     {
@@ -75,9 +74,9 @@ function addInstrumentations (instrumentations, versionRange, filePath) {
 const instrumentations = []
 // graphql-jit 0.7 and 0.8.0 use this layout and remain compatible with GraphQL 15 and 16.
 // GraphQL 17 compatibility starts at 0.8.1.
-addInstrumentations(instrumentations, '>=0.7.0 <0.8.5 || >=0.8.7 <0.9.0', 'dist/execution.js')
-addInstrumentations(instrumentations, '>=0.8.5 <0.8.7', 'dist/cjs/execution.js')
-addInstrumentations(instrumentations, '>=0.8.5 <0.8.7', 'dist/esm/execution.js')
-addInstrumentations(instrumentations, '>=0.8.7 <0.9.0', 'dist/execution.mjs')
+addInstrumentations('>=0.7.0 <0.8.5 || >=0.8.7 <0.9.0', 'dist/execution.js')
+addInstrumentations('>=0.8.5 <0.8.7', 'dist/cjs/execution.js')
+addInstrumentations('>=0.8.5 <0.8.7', 'dist/esm/execution.js')
+addInstrumentations('>=0.8.7 <0.9.0', 'dist/execution.mjs')
 
 module.exports = instrumentations

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

@@ -1,36 +1,53 @@
 'use strict'
 
-const handlers = ['src/index.js', 'cjs/src/index.js'].map(filePath => ({
-  module: {
-    name: 'postgres',
-    versionRange: '>=3.0.0',
-    filePath,
-  },
-  astQuery: 'Program',
-  transform: 'postgresQueryHandlers',
-  channelName: 'query',
-}))
+const instrumentations = []
 
-const preparations = ['src/connection.js', 'cjs/src/connection.js'].map(filePath => ({
-  module: {
-    name: 'postgres',
-    versionRange: '>=3.0.0',
-    filePath,
-  },
-  astQuery: 'Program',
-  transform: 'postgresQueryPreparation',
-  channelName: 'query:prepare',
-}))
+for (const filePath of ['src/index.js', 'cjs/src/index.js']) {
+  instrumentations.push({
+    module: {
+      name: 'postgres',
+      versionRange: '>=3.0.0',
+      filePath,
+    },
+    astQuery: 'Program',
+    transform: 'postgresQueryHandlers',
+    channelName: 'query',
+  })
+}
 
-const lifecycles = ['src/query.js', 'cjs/src/query.js'].map(filePath => ({
-  module: {
-    name: 'postgres',
-    versionRange: '>=3.0.0',
-    filePath,
-  },
-  astQuery: 'Program',
-  transform: 'postgresQueryLifecycle',
-  channelName: 'query',
-}))
+for (const filePath of ['src/connection.js', 'cjs/src/connection.js']) {
+  instrumentations.push({
+    module: {
+      name: 'postgres',
+      versionRange: '>=3.0.0',
+      filePath,
+    },
+    astQuery: 'Program',
+    transform: 'postgresQueryAcquire',
+    channelName: 'query:acquire',
+  }, {
+    module: {
+      name: 'postgres',
+      versionRange: '>=3.0.0',
+      filePath,
+    },
+    astQuery: 'Program',
+    transform: 'postgresQueryPreparation',
+    channelName: 'query:prepare',
+  })
+}
 
-module.exports = [...handlers, ...preparations, ...lifecycles]
+for (const filePath of ['src/query.js', 'cjs/src/query.js']) {
+  instrumentations.push({
+    module: {
+      name: 'postgres',
+      versionRange: '>=3.0.0',
+      filePath,
+    },
+    astQuery: 'Program',
+    transform: 'postgresQueryLifecycle',
+    channelName: 'query',
+  })
+}
+
+module.exports = instrumentations

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

@@ -80,6 +80,19 @@ module.exports = [
     },
     channelName: 'Runner_run',
   },
+  {
+    module: {
+      name: '@wdio/runner',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      className: 'Runner',
+      methodName: '_startSession',
+      kind: 'Async',
+    },
+    channelName: 'Runner_startSession',
+  },
   {
     module: {
       name: '@wdio/runner',
@@ -130,6 +143,33 @@ module.exports = [
     channelName: 'BaseReporter_waitForSync',
     transform: 'waitForAsyncEnd',
   },
+  {
+    module: {
+      name: '@wdio/mocha-framework',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    functionQuery: {
+      className: 'MochaAdapter',
+      methodName: 'init',
+      kind: 'Async',
+    },
+    channelName: 'MochaAdapter_init',
+  },
+  {
+    module: {
+      name: '@wdio/mocha-framework',
+      versionRange: '>=9.0.0',
+      filePath: 'build/index.js',
+    },
+    astQuery: 'VariableDeclarator[id.name="MochaAdapter"] > ClassExpression > ClassBody > ' +
+      'MethodDefinition[key.name="init"] ReturnStatement > ' +
+      'CallExpression[callee.object.name="promise"][callee.property.name="then"], ' +
+      'ClassDeclaration[id.name="MochaAdapter"] > ClassBody > MethodDefinition[key.name="init"] ReturnStatement > ' +
+      'CallExpression[callee.object.name="promise"][callee.property.name="then"]',
+    channelName: 'MochaAdapter_init',
+    transform: 'waitForAsyncEnd',
+  },
   {
     module: {
       name: '@wdio/jasmine-framework',
@@ -466,9 +506,8 @@ module.exports = [
       versionRange: '>=9.0.0',
       filePath: 'build/index.js',
     },
-    astQuery: 'TryStatement:has(CatchClause IfStatement[test.operator=">"]' +
-      '[test.left.object.name="retries"][test.left.property.name="limit"]' +
-      '[test.right.object.name="retries"][test.right.property.name="attempts"]) > BlockStatement',
+    astQuery: 'FunctionDeclaration[id.name="executeAsync"] TryStatement:has(CatchClause ' +
+      'CallExpression[callee.object.name="executeAsync"][callee.property.name="call"]) > BlockStatement',
     channelName: 'executeAsync',
     transform: 'awaitContextCallback',
     transformOptions: {
@@ -481,10 +520,8 @@ module.exports = [
       versionRange: '>=9.0.0',
       filePath: 'build/index.js',
     },
-    astQuery: 'FunctionDeclaration[id.name="executeAsync"] CatchClause ' +
-      'IfStatement[test.operator=">"][test.left.object.name="retries"]' +
-      '[test.left.property.name="limit"][test.right.object.name="retries"]' +
-      '[test.right.property.name="attempts"]',
+    astQuery: 'FunctionDeclaration[id.name="executeAsync"] CatchClause > BlockStatement > ' +
+      'IfStatement:has(CallExpression[callee.object.name="executeAsync"][callee.property.name="call"])',
     channelName: 'executeAsync',
     transform: 'awaitContextCallback',
     transformOptions: {
@@ -495,12 +532,15 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     astQuery: 'AssignmentExpression[left.object.object.name="Spec"]' +
       '[left.object.property.name="prototype"][left.property.name="execute"] > FunctionExpression',
+    // A method name keeps the original function expression, so the start context
+    // carries `self` (the legacy Spec) that the WebdriverIO Jasmine lifecycle reads.
     functionQuery: {
+      methodName: 'execute',
       kind: 'Sync',
     },
     channelName: 'Spec_execute',
@@ -508,7 +548,7 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     astQuery: 'AssignmentExpression[left.object.object.name="Spec"]' +
@@ -521,7 +561,20 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
+      filePath: 'lib/jasmine-core/jasmine.js',
+    },
+    functionQuery: {
+      className: 'Spec',
+      methodName: 'status',
+      kind: 'Sync',
+    },
+    channelName: 'Spec_attemptDone',
+  },
+  {
+    module: {
+      name: 'jasmine-core',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     functionQuery: {
@@ -534,7 +587,7 @@ module.exports = [
   {
     module: {
       name: 'jasmine-core',
-      versionRange: '>=5.0.0 <6.0.0',
+      versionRange: '>=5.0.0 <7.0.0',
       filePath: 'lib/jasmine-core/jasmine.js',
     },
     functionQuery: {

package/packages/datadog-instrumentations/src/helpers/rewriter/targets.json

@@ -45,6 +45,7 @@
   "@wdio/config/build/node/index.js": "@wdio/config",
   "@wdio/jasmine-framework/build/index.js": "@wdio/jasmine-framework",
   "@wdio/local-runner/build/index.js": "@wdio/local-runner",
+  "@wdio/mocha-framework/build/index.js": "@wdio/mocha-framework",
   "@wdio/runner/build/index.js": "@wdio/runner",
   "@wdio/utils/build/index.js": "@wdio/utils",
   "ai/dist/index.js": "ai",