dd-trace 6.21.0 → 6.22.0

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

@@ -42,9 +42,9 @@ function wrapExecuteWithCallback (executeWithCallback) {
 function wrapProcess (process) {
   return function (...args) {
     const cb = args[0]
-    if (!ch.start.hasSubscribers || typeof cb !== 'function') return process.apply(this, args)
-
-    if (this[kTracingCallbackCommand]) return process.apply(this, args)
+    if (!ch.start.hasSubscribers || typeof cb !== 'function' || this[kTracingCallbackCommand]) {
+      return process.apply(this, args)
+    }
 
     const ctx = getContext(this)
 

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

@@ -228,11 +228,11 @@ for (const hook of getHooks('ai').values()) {
 
         // The SDK builds a model from a string id, in which case only the resolved instance is
         // worth wrapping; when the caller passed an instance, that is the one the SDK calls.
-        if (typeof model !== 'string' && model !== ctx.result) {
+        if (typeof model === 'string' || model === ctx.result) {
+          wrapModel(ctx.result)
+        } else {
           wrapModel(model)
           wrappedModels.add(ctx.result)
-        } else {
-          wrapModel(ctx.result)
         }
       },
     })

package/packages/datadog-instrumentations/src/aws-durable-execution-sdk-js.js

@@ -2,7 +2,6 @@
 
 const { channel, tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
-const { addHook, getHooks } = require('./helpers/instrument')
 const LAZY_DURABLE_PROMISE_METHODS = require('./aws-durable-execution-sdk-js-context-methods')
 
 for (const method of LAZY_DURABLE_PROMISE_METHODS) {
@@ -102,8 +101,3 @@ function observeDurablePromise (dp, onSettle) {
   instrumentDurablePromiseProto(Object.getPrototypeOf(dp))
   dp[ON_SETTLE] = onSettle
 }
-
-for (const hook of getHooks('@aws/durable-execution-sdk-js').values()) {
-  hook.file = null
-  addHook(hook, exports => exports)
-}

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

@@ -2,12 +2,14 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { channel, addHook } = require('./helpers/instrument')
+const sendSonic = require('./nova-sonic')
 
 const patchedClientConfigProtocols = new WeakSet()
 const patchedCommandPrototypes = new WeakSet()
+const patchedSmithyClients = new WeakSet()
 
 // Resource identifiers that already match the channel-suffix slug. Anything
-// else falls back to `'default'`. Hoisted out of the per-call hot path so we
+// else falls back to `'aws'`. Hoisted out of the per-call hot path so we
 // don't allocate a fresh Array literal + run `.includes` on every AWS send.
 const KNOWN_CHANNEL_SUFFIXES = new Set([
   'cloudwatchlogs',
@@ -161,6 +163,9 @@ function wrapSmithySend (send) {
     const channels = getChannelBag(channelSuffix)
     const clientName = getClientName(this.constructor)
     const operation = getOperationName(command.constructor)
+    if (channelSuffix === 'bedrockruntime' && operation === 'invokeModelWithBidirectionalStream') {
+      return sendSonic(send, this, command, args)
+    }
     const request = {
       operation,
       params: command.input,
@@ -320,18 +325,24 @@ function getChannelSuffix (name) {
   // some resource identifiers have spaces between ex: bedrock runtime
   name = String(name).replaceAll(' ', '')
   if (KNOWN_CHANNEL_SUFFIXES.has(name)) return name
-  return CHANNEL_SUFFIX_ALIASES.get(name) ?? 'default'
+  return CHANNEL_SUFFIX_ALIASES.get(name) ?? 'aws'
 }
 
-addHook({ name: '@smithy/smithy-client', versions: ['>=1.0.3'] }, smithy => {
-  shimmer.wrap(smithy.Client.prototype, 'send', wrapSmithySend)
+/** @param {{ Client: Function }} smithy */
+function patchSmithyClient (smithy) {
+  const prototype = smithy.Client.prototype
+  // Recent smithy-client releases re-export core/client. Loading both entry points must not
+  // install two observers on the same send (and consume/charge every duplex event twice).
+  if (!patchedSmithyClients.has(prototype)) {
+    shimmer.wrap(prototype, 'send', wrapSmithySend)
+    patchedSmithyClients.add(prototype)
+  }
   return smithy
-})
+}
 
-addHook({ name: '@aws-sdk/smithy-client', versions: ['>=3'] }, smithy => {
-  shimmer.wrap(smithy.Client.prototype, 'send', wrapSmithySend)
-  return smithy
-})
+addHook({ name: '@smithy/smithy-client', versions: ['>=1.0.3'] }, patchSmithyClient)
+
+addHook({ name: '@aws-sdk/smithy-client', versions: ['>=3'] }, patchSmithyClient)
 
 // `@aws-sdk/client-*` >= 3.1046.0 dropped `@smithy/smithy-client` and now
 // extends from `@smithy/core/client` directly. The `Client.send` contract is
@@ -341,10 +352,7 @@ addHook({
   name: '@smithy/core',
   file: 'dist-cjs/submodules/client/index.js',
   versions: ['>=3.24.0'],
-}, smithyCoreClient => {
-  shimmer.wrap(smithyCoreClient.Client.prototype, 'send', wrapSmithySend)
-  return smithyCoreClient
-})
+}, patchSmithyClient)
 
 addHook({ name: 'aws-sdk', versions: ['>=2.3.0'] }, AWS => {
   shimmer.wrap(AWS.config, 'setPromisesDependency', setPromisesDependency => {

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -11,6 +11,7 @@ const finishCh = channel('apm:cassandra-driver:query:finish')
 const errorCh = channel('apm:cassandra-driver:query:error')
 const connectCh = channel('apm:cassandra-driver:query:connect')
 
+/** @type {Record<string, unknown> & { error?: Error }} */
 let startCtx = {}
 
 addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
@@ -24,23 +25,23 @@ addHook({ name: 'cassandra-driver', versions: ['>=3.0.0'] }, cassandra => {
     startCtx = { keyspace: this.keyspace, query: queries, contactPoints: this.options && this.options.contactPoints }
     return startCh.runStores(startCtx, () => {
       if (typeof cb === 'function') {
-        arguments[lastIndex] = wrapCallback(finishCh, errorCh, startCtx, cb)
+        arguments[lastIndex] = wrapCallback(startCtx, cb)
       }
 
       try {
         const res = batch.apply(this, arguments)
         if (typeof res === 'function') {
-          return wrapCallback(finishCh, errorCh, startCtx, res)
+          return wrapCallback(startCtx, res)
         }
         if (!res) {
           return res
         }
         return res.then(
-          () => finish(finishCh, errorCh, startCtx),
-          err => finish(finishCh, errorCh, startCtx, err)
+          () => finish(startCtx),
+          err => finish(startCtx, err)
         )
       } catch (e) {
-        finish(finishCh, errorCh, startCtx, e)
+        finish(startCtx, e)
         throw e
       }
     })
@@ -58,8 +59,8 @@ addHook({ name: 'cassandra-driver', versions: ['>=4.4'], patchDefault: false },
       const promise = _execute.apply(this, arguments)
 
       promise.then(
-        () => finish(finishCh, errorCh, startCtx),
-        err => finish(finishCh, errorCh, startCtx, err)
+        () => finish(startCtx),
+        err => finish(startCtx, err)
       )
       return promise
     })
@@ -74,10 +75,7 @@ const isValid = (args) => {
 addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'], patchDefault: false }, (cassandra) => {
   shimmer.wrap(cassandra.Client.prototype, '_innerExecute', _innerExecute =>
     function (query, params, execOptions, callback) {
-      if (!startCh.hasSubscribers) {
-        return _innerExecute.apply(this, arguments)
-      }
-      if (!isValid(arguments)) {
+      if (!startCh.hasSubscribers || !isValid(arguments)) {
         return _innerExecute.apply(this, arguments)
       }
 
@@ -87,13 +85,13 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'], patchDefault: false }
         const cb = arguments[lastIndex]
 
         if (typeof cb === 'function') {
-          arguments[lastIndex] = wrapCallback(finishCh, errorCh, startCtx, cb)
+          arguments[lastIndex] = wrapCallback(startCtx, cb)
         }
 
         try {
           return _innerExecute.apply(this, arguments)
         } catch (e) {
-          finish(finishCh, errorCh, startCtx, e)
+          finish(startCtx, e)
           throw e
         }
       })
@@ -156,7 +154,11 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-ha
   return RequestHandler
 })
 
-function finish (finishCh, errorCh, ctx, error) {
+/**
+ * @param {Record<string, unknown> & { error?: Error }} ctx
+ * @param {Error} [error]
+ */
+function finish (ctx, error) {
   if (error) {
     ctx.error = error
     errorCh.publish(ctx)
@@ -164,19 +166,22 @@ function finish (finishCh, errorCh, ctx, error) {
   finishCh.runStores(ctx, () => {})
 }
 
-function wrapCallback (finishCh, errorCh, ctx, callback) {
+/**
+ * @param {Record<string, unknown> & { error?: Error }} ctx
+ * @param {Parameters<typeof finishCh.runStores>[1]} callback
+ */
+function wrapCallback (ctx, callback) {
   return shimmer.wrapCallback(callback, callback => function (err) {
     if (err) {
       ctx.error = err
       errorCh.publish(ctx)
     }
-    return finishCh.runStores(ctx, callback, this, ...arguments)
+    return finishCh.runStores(
+      ctx, /** @type {Parameters<typeof finishCh.runStores>[1]} */ (callback), this, ...arguments
+    )
   })
 }
 
 function isRequestValid (exec, args, length) {
-  if (!exec) return false
-  if (args.length !== length || typeof args[length - 1] !== 'function') return false
-
-  return true
+  return !!exec && args.length === length && typeof args[length - 1] === 'function'
 }

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -2,7 +2,6 @@
 
 const { tracingChannel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
-const { addHook, getHooks } = require('./helpers/instrument')
 const queryChannel = tracingChannel('orchestrion:@anthropic-ai/claude-agent-sdk:query')
 
 const stepCh = tracingChannel('apm:claude-agent-sdk:step')
@@ -638,28 +637,15 @@ function wrapQueryAsyncIterator (asyncIterator, ctx) {
   }
 }
 
-let querySubscribed = false
+queryChannel.subscribe({
+  start: onQueryStart,
+  end (ctx) {
+    if (!ctx.claudeAgentSdkTracing) return
 
-for (const hook of getHooks('@anthropic-ai/claude-agent-sdk').values()) {
-  hook.file = null
+    const { result } = ctx
 
-  addHook(hook, exports => {
-    if (!querySubscribed) {
-      querySubscribed = true
-      queryChannel.subscribe({
-        start: onQueryStart,
-        end (ctx) {
-          if (!ctx.claudeAgentSdkTracing) return
+    ctx.streamResolved = false
 
-          const { result } = ctx
-
-          ctx.streamResolved = false
-
-          shimmer.wrap(result, Symbol.asyncIterator, asyncIterator => wrapQueryAsyncIterator(asyncIterator, ctx))
-        },
-      })
-    }
-
-    return exports
-  })
-}
+    shimmer.wrap(result, Symbol.asyncIterator, asyncIterator => wrapQueryAsyncIterator(asyncIterator, ctx))
+  },
+})

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

@@ -102,7 +102,7 @@ const efdRetryCountByPickleId = new Map()
 const efdSlowAbortedPickleIds = new Set()
 const finishedParallelSuites = new Set()
 const numAttemptToCtx = new Map()
-const newTestsByTestFullname = new Map()
+const efdStatusesByPickleId = new Map()
 const attemptToFixTestsByTestFullname = new Map()
 const modifiedTestsByPickleId = new Map()
 const runnerToRetryState = new WeakMap()
@@ -200,13 +200,13 @@ function getSuiteStatusFromTestStatuses (testStatuses) {
   return 'pass'
 }
 
-function publishWorkerEfdRetryCount (pickle, retryCount) {
+function publishWorkerEfdRetryCount (pickle, retryCount, isModified) {
   const message = {
     [DD_EFD_RETRY_COUNT_MESSAGE]: {
       pickleId: pickle.id,
       retryCount,
+      isModified,
       testFileAbsolutePath: pickle.uri,
-      testName: pickle.name,
     },
   }
 
@@ -220,10 +220,12 @@ function publishWorkerEfdRetryCount (pickle, retryCount) {
   }
 
   try {
-    const { isMainThread, parentPort } = require('node:worker_threads')
+    const { isMainThread, parentPort, workerData } = require('node:worker_threads')
     if (isMainThread || !parentPort) return
 
-    parentPort.postMessage(message)
+    // Share Cucumber's envelope port so EFD metadata arrives before test results.
+    const port = workerData?.port ?? parentPort
+    port.postMessage(message)
   } catch {
     // ignore IPC errors
   }
@@ -385,14 +387,16 @@ function handleParallelTestCaseFinished (pickle, worstTestStepResult, usesNumeri
   const testFileAbsolutePath = pickle.uri
   const finished = (pickleResultByFile[testFileAbsolutePath] ||= [])
 
-  if (shouldRunEarlyFlakeDetection() && isNew) {
-    const testFullname = `${pickle.uri}:${pickle.name}`
-    let testStatuses = newTestsByTestFullname.get(testFullname)
+  const isAttemptToFix = isTestManagementTestsEnabled &&
+    getTestProperties(getTestSuitePath(testFileAbsolutePath, process.cwd()), pickle.name).attemptToFix
+
+  if (!isAttemptToFix && shouldRunEarlyFlakeDetection() && (isNew || modifiedTestsByPickleId.get(pickle.id))) {
+    let testStatuses = efdStatusesByPickleId.get(pickle.id)
     if (testStatuses) {
       testStatuses.push(status)
     } else {
       testStatuses = [status]
-      newTestsByTestFullname.set(testFullname, testStatuses)
+      efdStatusesByPickleId.set(pickle.id, testStatuses)
     }
     let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
     if (efdRetryCount === undefined) {
@@ -404,11 +408,8 @@ function handleParallelTestCaseFinished (pickle, worstTestStepResult, usesNumeri
         efdSlowAbortedPickleIds.add(pickle.id)
       }
     }
-    maybeRecordFinalParallelEfdStatus({ pickleId: pickle.id, testFileAbsolutePath, testFullname })
-  } else if (
-    isTestManagementTestsEnabled &&
-    getTestProperties(getTestSuitePath(testFileAbsolutePath, process.cwd()), pickle.name).attemptToFix
-  ) {
+    maybeRecordFinalParallelEfdStatus({ pickleId: pickle.id, testFileAbsolutePath })
+  } else if (isAttemptToFix) {
     const testFullname = `${pickle.uri}:${pickle.name}`
     let testStatuses = attemptToFixTestsByTestFullname.get(testFullname)
     if (testStatuses) {
@@ -495,8 +496,14 @@ function finishParallelSuiteIfDone (testFileAbsolutePath) {
   const finished = pickleResultByFile[testFileAbsolutePath]
   const expectedPickles = pickleByFile[testFileAbsolutePath]
 
-  if (!finished || !expectedPickles || finished.length !== expectedPickles.length) return
-  if (finishedParallelSuites.has(testFileAbsolutePath)) return
+  if (
+    !finished ||
+    !expectedPickles ||
+    finished.length !== expectedPickles.length ||
+    finishedParallelSuites.has(testFileAbsolutePath)
+  ) {
+    return
+  }
 
   finishedParallelSuites.add(testFileAbsolutePath)
   testSuiteFinishCh.publish({
@@ -505,29 +512,30 @@ function finishParallelSuiteIfDone (testFileAbsolutePath) {
   })
 }
 
-function maybeRecordFinalParallelEfdStatus ({ pickleId, testFileAbsolutePath, testFullname }) {
+function maybeRecordFinalParallelEfdStatus ({ pickleId, testFileAbsolutePath }) {
   const efdRetryCount = efdRetryCountByPickleId.get(pickleId)
-  const testStatuses = newTestsByTestFullname.get(testFullname)
+  const testStatuses = efdStatusesByPickleId.get(pickleId)
   const finished = pickleResultByFile[testFileAbsolutePath]
 
-  if (efdRetryCount === undefined || !testStatuses || !finished) return
-  if (testStatuses.length !== efdRetryCount + 1) return
+  if (efdRetryCount === undefined || !testStatuses || !finished || testStatuses.length !== efdRetryCount + 1) return
 
-  finished.push(getTestStatusFromRetries(testStatuses))
-  newTestsByTestFullname.delete(testFullname)
+  finished.push(efdRetryCount === 0 ? testStatuses[0] : getTestStatusFromRetries(testStatuses))
+  efdStatusesByPickleId.delete(pickleId)
   finishParallelSuiteIfDone(testFileAbsolutePath)
 }
 
 function handleEfdRetryCountMessage (message) {
-  const { pickleId, retryCount, testFileAbsolutePath, testName } = message
+  const { pickleId, retryCount, isModified, testFileAbsolutePath } = message
 
-  if (!pickleId || typeof retryCount !== 'number' || !testFileAbsolutePath || !testName) return
+  if (!pickleId || !testFileAbsolutePath) return
+
+  if (isModified) modifiedTestsByPickleId.set(pickleId, true)
+  if (typeof retryCount !== 'number') return
 
   efdRetryCountByPickleId.set(pickleId, retryCount)
   maybeRecordFinalParallelEfdStatus({
     pickleId,
     testFileAbsolutePath,
-    testFullname: `${testFileAbsolutePath}:${testName}`,
   })
 }
 
@@ -912,12 +920,13 @@ function wrapRun (pl, isLatestVersion, version) {
           isNew = newTestPickleIds.has(this.pickle.id)
         }
 
-        if (isNew || isModified) {
+        if (!isAttemptToFix && (isNew || isModified)) {
           isEfdRetry = numRetries > 0
         }
 
         if (
           shouldRunEarlyFlakeDetection() &&
+          !isAttemptToFix &&
           status !== 'skip' &&
           (isNew || isModified) &&
           !isEfdRetry &&
@@ -1265,7 +1274,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     efdRetryCountByPickleId.clear()
     efdSlowAbortedPickleIds.clear()
     finishedParallelSuites.clear()
-    newTestsByTestFullname.clear()
+    efdStatusesByPickleId.clear()
+    modifiedTestsByPickleId.clear()
     sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
@@ -1478,10 +1488,15 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
     const originalRetry = this.options.retry
-    const isManagedRetry = isAttemptToFix || (shouldRunEarlyFlakeDetection() && (isNew || isModified))
+    const isEfdTest = !isAttemptToFix && shouldRunEarlyFlakeDetection() && (isNew || isModified)
+    const isManagedRetry = isAttemptToFix || isEfdTest
     if (isManagedRetry) {
       this.options.retry = 0
     }
+    if (isWorker && isModified && isEfdTest) {
+      // The coordinator must recognize modified EFD tests before their first result arrives.
+      publishWorkerEfdRetryCount(pickle, undefined, true)
+    }
     // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
     const firstExecutionStart = performance.now()
     let runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
@@ -1493,7 +1508,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     const testStatuses = lastStatusByPickleId.get(pickle.id)
     const lastTestStatus = testStatuses.at(-1)
 
-    // New tests should not be marked as attempt to fix, so EFD + Attempt to fix should not be enabled at the same time
+    // Attempt to Fix owns retries for managed tests, including modified tests.
     if (isAttemptToFix && lastTestStatus !== 'skip') {
       for (let retryIndex = 0; retryIndex < testManagementAttemptToFixRetries; retryIndex++) {
         numRetriesByPickleId.set(pickle.id, retryIndex + 1)
@@ -1502,8 +1517,8 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
 
-    // If it's a new test and it hasn't been skipped, we run it again
-    if (shouldRunEarlyFlakeDetection() && lastTestStatus !== 'skip' && (isNew || isModified)) {
+    // Retry eligible new or modified tests unless their first attempt was skipped.
+    if (isEfdTest && lastTestStatus !== 'skip') {
       let efdRetryCount = efdRetryCountByPickleId.get(pickle.id)
       if (efdRetryCount === undefined) {
         efdRetryCount = getEfdRetryCountForDuration(firstExecutionDurationMs, earlyFlakeDetectionRetryPolicy)
@@ -1525,7 +1540,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let shouldBePassedByEFD = false
     let shouldBePassedByTestManagement = false
     let shouldBeFailedByAttemptToFix = false
-    if ((isNew || isModified) && shouldRunEarlyFlakeDetection()) {
+    if (isEfdTest) {
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
        * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
@@ -1587,7 +1602,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       return shouldBePassedByTestManagement
     }
 
-    if (isNewerCucumberVersion && shouldRunEarlyFlakeDetection() && (isNew || isModified)) {
+    if (isNewerCucumberVersion && isEfdTest) {
       return shouldBePassedByEFD
     }
 

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
   }