dd-trace 5.132.0 → 5.134.0

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()
@@ -129,6 +129,7 @@ let earlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
 let earlyFlakeDetectionFaultyThreshold = 0
 let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
+let hasAutomaticRetries = false
 let isDynamicAtrEnabled = false
 let dynamicAtrBuckets
 let isKnownTestsEnabled = false
@@ -200,13 +201,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 +221,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
   }
@@ -253,6 +256,7 @@ function configureParallelWorkerWorldParameters (options) {
   }
 
   options.worldParameters._ddIsFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
+  options.worldParameters._ddHasAutomaticRetries = hasAutomaticRetries
   options.worldParameters._ddNumTestRetries = numTestRetries
   options.worldParameters._ddIsDynamicAtrEnabled = isDynamicAtrEnabled
   options.worldParameters._ddDynamicAtrBuckets = dynamicAtrBuckets
@@ -296,6 +300,7 @@ function readParallelWorkerWorldParameters (options) {
 /**
  * @param {object} worldParameters
  * @param {boolean} [worldParameters._ddIsFlakyTestRetriesEnabled]
+ * @param {boolean} [worldParameters._ddHasAutomaticRetries]
  * @param {number} [worldParameters._ddNumTestRetries]
  * @param {boolean} [worldParameters._ddIsDynamicAtrEnabled]
  * @param {number[]} [worldParameters._ddDynamicAtrBuckets]
@@ -304,6 +309,7 @@ function readParallelWorkerWorldParameters (options) {
  */
 function readParallelWorkerAtrParameters (worldParameters) {
   isFlakyTestRetriesEnabled = !!worldParameters._ddIsFlakyTestRetriesEnabled
+  hasAutomaticRetries = !!worldParameters._ddHasAutomaticRetries
   numTestRetries = worldParameters._ddNumTestRetries ?? 0
   isDynamicAtrEnabled = !!worldParameters._ddIsDynamicAtrEnabled
   dynamicAtrBuckets = worldParameters._ddDynamicAtrBuckets
@@ -385,14 +391,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 +412,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 +500,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 +516,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}`,
   })
 }
 
@@ -733,9 +745,10 @@ function publishRetriedAttempt (runner, state) {
   const nextAttempt = currentAttempt + 1
   const failedAttemptCtx = numAttemptToCtx.get(currentAttempt)
   const isFirstAttempt = currentAttempt === 0
-  const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
+  const isAtrRetry = !isFirstAttempt && state.hasAutomaticRetries
 
   if (isFirstAttempt && isDynamicAtrEnabled && isFlakyTestRetriesEnabled) {
+    state.hasAutomaticRetries = true
     state.dynamicAtrRetryCount = getDynamicAtrRetryCount(
       performance.now() - state.executionStart,
       earlyFlakeDetectionRetryPolicy,
@@ -747,7 +760,7 @@ function publishRetriedAttempt (runner, state) {
   }
 
   // ATR: record this attempt as failed so when run().finally runs (after retry) we have all statuses
-  if (isFlakyTestRetriesEnabled) {
+  if (state.hasAutomaticRetries) {
     const nameForKey = getCucumberTestName(runner.pickle.name, currentAttempt > 0)
     const atrKey = `${runner.pickle.uri}:${nameForKey}`
     if (atrStatusesByScenarioKey.has(atrKey)) {
@@ -823,7 +836,7 @@ function wrapRun (pl, isLatestVersion, version) {
     }
     const ctx = testStartPayload
     const promises = {}
-    const state = { numAttempt: 0, promises, testStartPayload }
+    const state = { numAttempt: 0, promises, testStartPayload, hasAutomaticRetries }
     numAttemptToCtx.set(state.numAttempt, ctx)
     runnerToRetryState.set(this, state)
     if (isTestManagementTestsEnabled && getTestProperties(testSuitePath, this.pickle.name).attemptToFix) {
@@ -912,12 +925,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 &&
@@ -952,7 +966,7 @@ function wrapRun (pl, isLatestVersion, version) {
 
         // ATR: accumulate statuses by stable scenario key (uri:name) so retries are grouped.
         // Cucumber appends " (attempt N)" or " (attempt N, retried)" to the scenario name; normalize for keying.
-        if (isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0) {
+        if (state.hasAutomaticRetries && !isAttemptToFix && !isEfdRetry && numTestRetries > 0) {
           const atrKey = `${this.pickle.uri}:${testName}`
           if (atrStatusesByScenarioKey.has(atrKey)) {
             atrStatusesByScenarioKey.get(atrKey).push(status)
@@ -1001,7 +1015,7 @@ function wrapRun (pl, isLatestVersion, version) {
 
         // Notice that ATR is handled using cucumber native retries features.
         // Therefore, if we reach this point, we are certain that it's the last ATR execution
-        const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry &&
+        const isLastAtrRetry = state.hasAutomaticRetries && !isAttemptToFix && !isEfdRetry &&
           numTestRetries > 0 && this.maxAttempts > 1
 
         const statuses = lastStatusByPickleId.get(this.pickle.id)
@@ -1030,8 +1044,8 @@ function wrapRun (pl, isLatestVersion, version) {
           error,
           isNew,
           isEfdRetry,
-          isFlakyRetry: state.numAttempt > 0 && isFlakyTestRetriesEnabled,
-          isExternalRetry: state.numAttempt > 0 && !isFlakyTestRetriesEnabled,
+          isFlakyRetry: state.numAttempt > 0 && state.hasAutomaticRetries,
+          isExternalRetry: state.numAttempt > 0 && !state.hasAutomaticRetries,
           isAttemptToFix,
           isAttemptToFixRetry,
           hasFailedAllRetries,
@@ -1252,7 +1266,9 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     const processArgv = process.argv.slice(2).join(' ')
     const command = getEnvironmentVariable('npm_lifecycle_script') || `cucumber-js ${processArgv}`
 
-    if (isFlakyTestRetriesEnabled && !options.retry && numTestRetries > 0) {
+    const originalRetryCount = options.retry
+    hasAutomaticRetries = isFlakyTestRetriesEnabled && !options.retry && numTestRetries > 0
+    if (hasAutomaticRetries) {
       options.retry = numTestRetries
     }
 
@@ -1265,7 +1281,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) {
@@ -1293,6 +1310,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
         log.error('Cucumber test session finalization error: %s', finalizationError)
       }
       throw error
+    } finally {
+      if (hasAutomaticRetries) options.retry = originalRetryCount
     }
     const success = satisfies(frameworkVersion, '>=13.1.0') ? result.success : result
 
@@ -1478,10 +1497,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 +1517,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 +1526,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 +1549,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 +1611,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, registeredBuiltinNames } = require('./register.js')
 const {
   filename,
   getDisabledInstrumentations,
@@ -17,25 +17,44 @@ const { isRewriteActivationEnabled } = require('./rewriter/targets')
 const disabledInstrumentations = getDisabledInstrumentations()
 
 // register.js has now set up ritm (require-in-the-middle). In bundled
-// environments (webpack, esbuild), Node.js built-in modules required by
-// dd-trace internal modules (e.g. http from request.js) may have been loaded
-// before ritm was active. The bundler's module cache then returns those
-// pre-loaded modules for any subsequent require() calls, bypassing ritm.
-// Re-requiring them via the real Module.prototype.require ensures ritm applies
-// their instrumentation hooks.
+// environments (webpack, esbuild, Turbopack), Node.js built-ins required by the
+// application or by dd-trace itself may have been loaded and cached by the
+// bundle before ritm was active, bypassing it. Re-requiring them via the real
+// Module.prototype.require lets ritm apply their hooks to the shared exports.
 //
 // In regular Node.js, `module` is an instance of Module. In bundlers, the
 // module wrapper object is a plain object (not a Module instance), so we use
 // that to detect a bundled context and avoid unintended side-effects in
 // normal Node.js (e.g. shimmer-wrapping http before ESM modules load).
 if (!(module instanceof Module)) {
-  for (const name of ['http', 'https']) {
+  patchLoadedBuiltins()
+}
+
+function patchLoadedBuiltins () {
+  // A built-in nobody has loaded cannot be cached by the bundle yet, and a later require reaches ritm, so it is
+  // skipped. moduleLoadList is undocumented: if it ever disappears, every registered built-in is loaded instead.
+  // @ts-expect-error - process.moduleLoadList is not typed
+  const { moduleLoadList } = process
+  const loadedBuiltins = Array.isArray(moduleLoadList) ? moduleLoadList : undefined
+
+  let patched = false
+  for (const name of registeredBuiltinNames) {
+    if (loadedBuiltins?.includes(`NativeModule ${name}`) === false) continue
+
     try {
       Module.prototype.require.call(module, name)
+      patched = true
     } catch {
       // Built-in not available in this environment, skip
     }
   }
+
+  if (!patched) return
+  try {
+    Module.syncBuiltinESMExports()
+  } catch (error) {
+    log.error('Error synchronizing bundled built-in ESM exports: %s', String(error?.message ?? error), error)
+  }
 }
 
 const CHANNEL = 'dd-trace:bundler:load'
@@ -96,7 +115,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/hooks.js

@@ -97,6 +97,7 @@ module.exports = {
   'jest-config': () => require('../jest'),
   'jest-environment-node': () => require('../jest'),
   'jest-environment-jsdom': () => require('../jest'),
+  'jest-runner': () => require('../jest'),
   'jest-runtime': () => require('../jest'),
   'jest-worker': () => require('../jest'),
   knex: () => require('../knex'),

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,8 @@ const {
   matchesInstrumentation,
 } = require('./instrumentation-utils')
 const rewriter = require('./rewriter')
+const { getActivationSetup } = require('./rewriter/instrumentation-registry')
+const { isNodeBuiltinModuleName } = require('./shared-utils')
 
 const DD_TRACE_DEBUG = getValueFromEnvSources('DD_TRACE_DEBUG')
 
@@ -58,6 +60,44 @@ 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()
+/**
+ * Node.js built-ins that passed the disabled and serverless checks and received a hook.
+ * @type {string[]}
+ */
+const registeredBuiltinNames = []
+
+/**
+ * @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 +112,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)
   }
 })
 
@@ -90,6 +130,8 @@ for (const name of names) {
     hook = hook.fn
   }
 
+  if (isNodeBuiltinModuleName(name)) registeredBuiltinNames.push(name)
+
   Hook([name], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
     // All loaded versions are first expected to fail instrumentation.
     if (!instrumentedIntegrationsSuccess.has(`${name}@${moduleVersion}`)) {
@@ -176,7 +218,9 @@ function logAbortedIntegrations () {
 }
 
 module.exports = {
+  activate,
   filename,
   pathSepExpr,
   loadChannel,
+  registeredBuiltinNames,
 }

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)