dd-trace 5.121.0 → 5.122.0

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

@@ -25,6 +25,13 @@ const KNOWN_CHANNEL_SUFFIXES = new Set([
   'bedrockruntime',
 ])
 
+// Older SDK clients report EventBridge under its CloudWatch Events name or its `events` endpoint
+// prefix; both share the EventBridge channels.
+const CHANNEL_SUFFIX_ALIASES = new Map([
+  ['cloudwatchevents', 'eventbridge'],
+  ['events', 'eventbridge'],
+])
+
 /**
  * @typedef {object} ChannelBag
  * @property {ReturnType<typeof channel>} start
@@ -314,7 +321,8 @@ function addResponse (ctx, error, result) {
 function getChannelSuffix (name) {
   // some resource identifiers have spaces between ex: bedrock runtime
   name = String(name).replaceAll(' ', '')
-  return KNOWN_CHANNEL_SUFFIXES.has(name) ? name : 'default'
+  if (KNOWN_CHANNEL_SUFFIXES.has(name)) return name
+  return CHANNEL_SUFFIX_ALIASES.get(name) ?? 'default'
 }
 
 addHook({ name: '@smithy/smithy-client', versions: ['>=1.0.3'] }, smithy => {

package/packages/datadog-instrumentations/src/browser-bunyan.js

@@ -0,0 +1,11 @@
+'use strict'
+
+const wrapLogger = require('./helpers/bunyan')
+const { addHook } = require('./helpers/instrument')
+
+addHook({ name: 'browser-bunyan', versions: ['>=1'] }, browserBunyan => {
+  // Published versions generate `_emit` through different bundle shapes,
+  // so Orchestrion has no stable function to match.
+  wrapLogger(browserBunyan.Logger, 'browser-bunyan')
+  return browserBunyan
+})

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

@@ -1,22 +1,9 @@
 'use strict'
 
-const shimmer = require('../../datadog-shimmer')
-const {
-  channel,
-  addHook,
-} = require('./helpers/instrument')
+const wrapLogger = require('./helpers/bunyan')
+const { addHook } = require('./helpers/instrument')
 
 addHook({ name: 'bunyan', versions: ['>=1'] }, Logger => {
-  const logCh = channel('apm:bunyan:log')
-  shimmer.wrap(Logger.prototype, '_emit', emit => {
-    return function wrappedEmit (rec) {
-      if (logCh.hasSubscribers) {
-        const payload = { message: rec }
-        logCh.publish(payload)
-        arguments[0] = payload.message
-      }
-      return emit.apply(this, arguments)
-    }
-  })
+  wrapLogger(Logger, 'bunyan')
   return Logger
 })

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

@@ -116,7 +116,7 @@ let pickleByFile = {}
 const pickleResultByFile = {}
 
 let skippableSuites = []
-let skippableSuitesCoverage = {}
+let skippableSuitesCoverage
 let skippedSuitesCoverage = {}
 let itrCorrelationId = ''
 let isForcedToRun = false
@@ -153,12 +153,6 @@ function isValidKnownTests (receivedKnownTests) {
   return !!receivedKnownTests.cucumber
 }
 
-function hasSkippableSuitesCoverage () {
-  return skippableSuitesCoverage &&
-    typeof skippableSuitesCoverage === 'object' &&
-    Object.keys(skippableSuitesCoverage).length > 0
-}
-
 function isTiaCoverageBackfillEnabled () {
   return isItrEnabled && isCoverageReportUploadEnabled
 }
@@ -172,7 +166,7 @@ function shouldReportCodeCoverageLinesPct (hasBackfilledCoverage) {
 }
 
 function getSkippedSuitesCoverageForRun () {
-  return isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
+  return isSuitesSkipped && isTiaCoverageBackfillEnabled() && skippableSuitesCoverage !== undefined
     ? skippableSuitesCoverage
     : {}
 }
@@ -188,7 +182,7 @@ function getCucumberTestSessionCoverageFiles () {
 
 function resetSuiteSkippingRunState () {
   skippableSuites = []
-  skippableSuitesCoverage = {}
+  skippableSuitesCoverage = undefined
   skippedSuitesCoverage = {}
   skippedSuites = []
   isSuitesSkipped = false
@@ -1143,7 +1137,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 
       errorSkippableRequest = skippableResponse.err
       skippableSuites = skippableResponse.skippableSuites ?? []
-      skippableSuitesCoverage = skippableResponse.skippableSuitesCoverage ?? {}
+      skippableSuitesCoverage = skippableResponse.skippableSuitesCoverage
 
       if (!errorSkippableRequest) {
         const filteredPickles = isCoordinator
@@ -1222,7 +1216,28 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       itrSkippedSuitesCh.publish({ skippedSuites, frameworkVersion })
     }
 
-    const result = await start.apply(this, arguments)
+    let result
+    try {
+      result = await start.apply(this, arguments)
+    } catch (error) {
+      try {
+        await getChannelPromise(sessionFinishCh, {
+          status: 'fail',
+          error,
+          isSuitesSkipped,
+          numSkippedSuites: skippedSuites.length,
+          hasUnskippableSuites: isUnskippable,
+          hasForcedToRunSuites: isForcedToRun,
+          isEarlyFlakeDetectionEnabled,
+          isEarlyFlakeDetectionFaulty,
+          isTestManagementTestsEnabled,
+          isParallel,
+        })
+      } catch (finalizationError) {
+        log.error('Cucumber test session finalization error: %s', finalizationError)
+      }
+      throw error
+    }
     const success = satisfies(frameworkVersion, '>=13.1.0') ? result.success : result
 
     let untestedCoverage

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

@@ -7,9 +7,18 @@ const { pathToFileURL } = require('url')
 
 const log = require('../../dd-trace/src/log')
 const { getSegment } = require('../../dd-trace/src/util')
+const {
+  finalizeAfterUserHandlers,
+  manualPluginOwner,
+  runUserHandler,
+} = require('../../datadog-plugin-cypress/src/finalization')
 const { channel } = require('./helpers/instrument')
 
 const DD_CONFIG_WRAPPED = Symbol.for('dd-trace.cypress.config.wrapped')
+const DD_CYPRESS_AFTER_SPEC_HANDLER = Symbol.for('dd-trace.cypress.after-spec.handler')
+const DD_CYPRESS_AFTER_RUN_HANDLER = Symbol.for('dd-trace.cypress.after-run.handler')
+const DD_CYPRESS_TASK_HANDLER = Symbol.for('dd-trace.cypress.task.handler')
+const DD_CYPRESS_NOOP_TASK_HANDLER = Symbol.for('dd-trace.cypress.noop-task.handler')
 const BROWSER_INSTRUMENTATION_NOT_INSTALLED =
   'Browser-side Cypress Test Optimization instrumentation was not installed.'
 const CONFIG_INSTRUMENTATION_NOT_INSTALLED =
@@ -184,6 +193,47 @@ function isDatadogTaskRegistration (handler) {
     typeof handler['dd:addTags'] === 'function'
 }
 
+/**
+ * @param {unknown} handler Cypress after:run handler
+ * @returns {boolean} whether this is the handler registered by the manual Datadog plugin
+ */
+function isDatadogAfterRunHandler (handler) {
+  return typeof handler === 'function' && handler[DD_CYPRESS_AFTER_RUN_HANDLER] === true
+}
+
+/**
+ * @param {unknown} handler Cypress after:spec handler
+ * @returns {boolean} whether this is the handler registered by the manual Datadog plugin
+ */
+function isDatadogAfterSpecHandler (handler) {
+  return typeof handler === 'function' && handler[DD_CYPRESS_AFTER_SPEC_HANDLER] === true
+}
+
+/**
+ * @param {object} manualPlugin manual plugin registration state
+ * @returns {boolean} whether the manual plugin supports error-aware finalization
+ */
+function supportsErrorAwareFinalization (manualPlugin) {
+  return isDatadogAfterSpecHandler(manualPlugin.afterSpecHandler) &&
+    isDatadogAfterRunHandler(manualPlugin.afterRunHandler)
+}
+
+/**
+ * @param {unknown} handler Cypress task handler map
+ * @returns {boolean} whether the current manual Datadog plugin owns the task map
+ */
+function isCurrentDatadogTaskRegistration (handler) {
+  return !!handler && handler[DD_CYPRESS_TASK_HANDLER] === manualPluginOwner
+}
+
+/**
+ * @param {unknown} handler Cypress task handler map
+ * @returns {boolean} whether the manual plugin registered only fallback tasks
+ */
+function isDatadogNoopTaskRegistration (handler) {
+  return !!handler && handler[DD_CYPRESS_NOOP_TASK_HANDLER] === true
+}
+
 /**
  * @param {unknown} value
  * @returns {boolean}
@@ -393,15 +443,61 @@ function registerManualAfterScreenshotHandlers (on, handlers, datadogHandler) {
  *
  * @param {Function} on Cypress event registration function
  * @param {Function[]} handlers collected after:spec handlers
+ * @param {Function} [datadogHandler] manual Datadog after:spec handler
+ * @param {Function} [cleanup] removes generated support files after an error
  * @returns {void}
  */
-function registerAfterSpecHandlers (on, handlers) {
-  if (handlers.length === 0) return
+function registerAfterSpecHandlers (on, handlers, datadogHandler, cleanup) {
+  const userHandlers = datadogHandler
+    ? handlers.filter(handler => handler !== datadogHandler)
+    : handlers
 
-  on('after:spec', (spec, results) => handlers.reduce(
-    (chain, handler) => chain.then(() => handler(spec, results)),
-    Promise.resolve()
-  ))
+  if (userHandlers.length === 0) {
+    if (datadogHandler) {
+      if (cleanup) {
+        on('after:spec', (...args) => Promise.resolve().then(() => datadogHandler(...args)).catch((error) => {
+          cleanup()
+          throw error
+        }))
+      } else {
+        on('after:spec', datadogHandler)
+      }
+    }
+    return
+  }
+
+  on('after:spec', (spec, results) => {
+    const callHandler = datadogHandler
+      ? handler => runUserHandler(() => handler(spec, results))
+      : handler => handler(spec, results)
+    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))
+    if (!cleanup) return finalization
+    return finalization.catch((error) => {
+      cleanup()
+      throw error
+    })
+  })
+}
+
+/**
+ * Enables the Cypress lifecycle events needed to finish Test Optimization
+ * sessions in interactive mode.
+ *
+ * @param {object} config Cypress resolved config object
+ * @returns {void}
+ */
+function enableInteractiveRunEvents (config) {
+  if (config.isInteractive && config.experimentalInteractiveRunEvents !== true) {
+    config.experimentalInteractiveRunEvents = true
+    log.warn(
+      'Datadog enabled Cypress experimentalInteractiveRunEvents so Test Optimization can finish the test session.'
+    )
+  }
 }
 
 /**
@@ -412,6 +508,7 @@ function registerAfterSpecHandlers (on, handlers) {
  *
  * @param {Function} on Cypress event registration function
  * @param {object} config Cypress resolved config object
+ * @param {Function[]} userBeforeRunHandlers user's before:run handlers collected from wrappedOn
  * @param {Function[]} userAfterSpecHandlers user's after:spec handlers collected from wrappedOn
  * @param {Function[]} userAfterRunHandlers user's after:run handlers collected from wrappedOn
  * @param {Function[]} userAfterScreenshotHandlers user's after:screenshot handlers collected from wrappedOn
@@ -421,6 +518,7 @@ function registerAfterSpecHandlers (on, handlers) {
 function registerDdTraceHooks (
   on,
   config,
+  userBeforeRunHandlers,
   userAfterSpecHandlers,
   userAfterRunHandlers,
   userAfterScreenshotHandlers,
@@ -433,13 +531,23 @@ function registerDdTraceHooks (
     if (generatedSupportFiles) cleanupGeneratedFiles(generatedSupportFiles)
   }
 
-  const registerAfterRunWithCleanup = () => {
+  const registerAfterRunWithCleanup = (datadogHandler) => {
+    const handlers = datadogHandler
+      ? userAfterRunHandlers.filter(handler => handler !== datadogHandler)
+      : userAfterRunHandlers
+
     on('after:run', (results) => {
-      const chain = userAfterRunHandlers.reduce(
-        (p, h) => p.then(() => h(results)),
+      const callHandler = datadogHandler
+        ? handler => runUserHandler(() => handler(results))
+        : handler => handler(results)
+      const chain = handlers.reduce(
+        (promise, handler) => promise.then(() => callHandler(handler)),
         Promise.resolve()
       )
-      return chain.finally(cleanupWrapper)
+      if (!datadogHandler) return chain.finally(cleanupWrapper)
+
+      return finalizeAfterUserHandlers(chain, (...args) => datadogHandler(results, ...args))
+        .finally(cleanupWrapper)
     })
   }
 
@@ -450,13 +558,36 @@ function registerDdTraceHooks (
     on('task', noopTask)
   }
 
-  if (manualPlugin.detected) {
-    registerAfterSpecHandlers(on, userAfterSpecHandlers)
+  if (manualPlugin.detected &&
+    (manualPlugin.isNoop ||
+      manualPlugin.ownsCurrentPlugin ||
+      supportsErrorAwareFinalization(manualPlugin) ||
+      !setupNodeEventsCh.hasSubscribers)) {
+    if (manualPlugin.afterRunHandler) {
+      enableInteractiveRunEvents(config)
+      if (manualPlugin.initialConfig !== config) {
+        manualPlugin.initialConfig.experimentalInteractiveRunEvents = config.experimentalInteractiveRunEvents
+      }
+    }
+    for (const handler of userBeforeRunHandlers) on('before:run', handler)
+    registerAfterSpecHandlers(on, userAfterSpecHandlers, manualPlugin.afterSpecHandler, cleanupWrapper)
     registerManualAfterScreenshotHandlers(on, userAfterScreenshotHandlers, manualPlugin.afterScreenshotHandler)
-    registerAfterRunWithCleanup()
+    registerAfterRunWithCleanup(manualPlugin.afterRunHandler)
+    on('task', manualPlugin.taskHandler)
     return config
   }
 
+  if (manualPlugin.detected) {
+    userBeforeRunHandlers = userBeforeRunHandlers.filter(handler => handler !== manualPlugin.beforeRunHandler)
+    userAfterSpecHandlers = userAfterSpecHandlers.filter(handler => handler !== manualPlugin.afterSpecHandler)
+    userAfterRunHandlers = userAfterRunHandlers.filter(handler => handler !== manualPlugin.afterRunHandler)
+    userAfterScreenshotHandlers = userAfterScreenshotHandlers.filter(
+      handler => handler !== manualPlugin.afterScreenshotHandler
+    )
+  }
+
+  for (const handler of userBeforeRunHandlers) on('before:run', handler)
+
   if (!setupNodeEventsCh.hasSubscribers) {
     registerNoopHandlers()
     return config
@@ -483,6 +614,7 @@ function registerDdTraceHooks (
     return config
   }
 
+  enableInteractiveRunEvents(config)
   return payload.configPromise || config
 }
 
@@ -492,28 +624,60 @@ function registerDdTraceHooks (
  */
 function wrapSetupNodeEvents (originalSetupNodeEvents) {
   return function ddSetupNodeEvents (on, config) {
+    const userBeforeRunHandlers = []
     const userAfterSpecHandlers = []
     const userAfterRunHandlers = []
     const userAfterScreenshotHandlers = []
     const manualPlugin = {
       detected: false,
+      initialConfig: config,
+      beforeRunHandler: undefined,
+      afterSpecHandler: undefined,
+      afterRunHandler: undefined,
       afterScreenshotHandler: undefined,
+      taskHandler: undefined,
+      ownsCurrentPlugin: false,
+      isNoop: false,
     }
+    const recentRegistrations = []
 
     const wrappedOn = (event, handler) => {
-      if (event === 'after:spec') {
+      if (event === 'before:run') {
+        userBeforeRunHandlers.push(handler)
+      } else if (event === 'after:spec') {
         userAfterSpecHandlers.push(handler)
+        if (isDatadogAfterSpecHandler(handler)) manualPlugin.afterSpecHandler = handler
       } else if (event === 'after:run') {
         userAfterRunHandlers.push(handler)
+        if (isDatadogAfterRunHandler(handler)) manualPlugin.afterRunHandler = handler
       } else if (event === 'after:screenshot') {
         userAfterScreenshotHandlers.push(handler)
       } else {
         if (event === 'task' && isDatadogTaskRegistration(handler)) {
           manualPlugin.detected = true
-          manualPlugin.afterScreenshotHandler = userAfterScreenshotHandlers.at(-1)
+          manualPlugin.ownsCurrentPlugin = isCurrentDatadogTaskRegistration(handler)
+          manualPlugin.isNoop = isDatadogNoopTaskRegistration(handler)
+          const afterRun = recentRegistrations.at(-1)
+          const afterSpec = recentRegistrations.at(-2)
+          const possibleAfterScreenshot = recentRegistrations.at(-3)
+          const hasAfterScreenshot = possibleAfterScreenshot?.event === 'after:screenshot'
+          const beforeRun = hasAfterScreenshot ? recentRegistrations.at(-4) : possibleAfterScreenshot
+          if (!manualPlugin.isNoop &&
+            beforeRun?.event === 'before:run' &&
+            afterSpec?.event === 'after:spec' &&
+            afterRun?.event === 'after:run') {
+            manualPlugin.beforeRunHandler ||= beforeRun.handler
+            manualPlugin.afterSpecHandler ||= afterSpec.handler
+            manualPlugin.afterRunHandler ||= afterRun.handler
+            if (hasAfterScreenshot) manualPlugin.afterScreenshotHandler ||= possibleAfterScreenshot.handler
+          }
+          manualPlugin.taskHandler = handler
+        } else {
+          on(event, handler)
         }
-        on(event, handler)
       }
+      recentRegistrations.push({ event, handler })
+      if (recentRegistrations.length > 4) recentRegistrations.shift()
     }
 
     const maybePromise = originalSetupNodeEvents
@@ -525,6 +689,7 @@ function wrapSetupNodeEvents (originalSetupNodeEvents) {
         return registerDdTraceHooks(
           on,
           mergeReturnedConfig(config, result),
+          userBeforeRunHandlers,
           userAfterSpecHandlers,
           userAfterRunHandlers,
           userAfterScreenshotHandlers,
@@ -536,6 +701,7 @@ function wrapSetupNodeEvents (originalSetupNodeEvents) {
     return registerDdTraceHooks(
       on,
       mergeReturnedConfig(config, maybePromise),
+      userBeforeRunHandlers,
       userAfterSpecHandlers,
       userAfterRunHandlers,
       userAfterScreenshotHandlers,

package/packages/datadog-instrumentations/src/cypress-legacy-finalizers.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { shouldDeferLegacyFinalization } = require('../../datadog-plugin-cypress/src/finalization')
+const Hook = require('./helpers/hook')
+
+const DD_CYPRESS_LEGACY_FINALIZER_WRAPPED = Symbol.for('dd-trace.cypress.legacy-finalizer.wrapped')
+const LEGACY_FINALIZER_MODULES = new Set([
+  'dd-trace/packages/datadog-plugin-cypress/src/after-run.js',
+  'dd-trace/packages/datadog-plugin-cypress/src/after-spec.js',
+])
+
+/**
+ * @param {Function} finalizer standalone Datadog Cypress finalizer
+ * @returns {Function} context-aware finalizer
+ */
+function wrapLegacyFinalizer (finalizer) {
+  if (finalizer[DD_CYPRESS_LEGACY_FINALIZER_WRAPPED]) return finalizer
+
+  function wrappedLegacyFinalizer () {
+    if (shouldDeferLegacyFinalization()) return
+    return finalizer.apply(this, arguments)
+  }
+  wrappedLegacyFinalizer[DD_CYPRESS_LEGACY_FINALIZER_WRAPPED] = true
+  return wrappedLegacyFinalizer
+}
+
+Hook(['dd-trace'], { internals: true }, (moduleExports, moduleName) => {
+  if (!LEGACY_FINALIZER_MODULES.has(moduleName.replaceAll('\\', '/'))) return moduleExports
+  return wrapLegacyFinalizer(moduleExports)
+})

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

@@ -8,6 +8,8 @@ const {
   wrapConfig,
 } = require('./cypress-config')
 
+require('./cypress-legacy-finalizers')
+
 const MINIMUM_CYPRESS_VERSION = DD_MAJOR >= 6 ? '>=12.0.0' : '>=10.2.0'
 
 // Wrap defineConfig() so configs are instrumented when loaded in Cypress's

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

@@ -146,6 +146,7 @@ function wrapHookDone (ctx, request, reply, req, name, doneCallback) {
     ctx.error = error
     publishError(ctx)
 
+    // eslint-disable-next-line no-restricted-syntax -- arbitrary cookie names; publishing {} sets a WAF address
     const hasCookies = request.cookies && Object.keys(request.cookies).length > 0
 
     if (cookieParserReadCh.hasSubscribers && hasCookies && !cookiesPublished.has(req)) {
@@ -193,6 +194,7 @@ 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

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

@@ -0,0 +1,22 @@
+'use strict'
+
+const shimmer = require('../../../datadog-shimmer')
+const { channel } = require('./instrument')
+
+/**
+ * @param {{ prototype: object }} Logger
+ * @param {string} id
+ */
+module.exports = function wrapLogger (Logger, id) {
+  const logCh = channel(`apm:${id}:log`)
+  shimmer.wrap(Logger.prototype, '_emit', emit => {
+    return function wrappedEmit (rec) {
+      if (logCh.hasSubscribers) {
+        const payload = { message: rec }
+        logCh.publish(payload)
+        arguments[0] = payload.message
+      }
+      return emit.apply(this, arguments)
+    }
+  })
+}

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

@@ -70,6 +70,7 @@ module.exports = {
   'aws-sdk': () => require('../aws-sdk'),
   bluebird: () => require('../bluebird'),
   'body-parser': () => require('../body-parser'),
+  'browser-bunyan': () => require('../browser-bunyan'),
   bullmq: () => require('../bullmq'),
   bunyan: () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
@@ -110,7 +111,7 @@ module.exports = {
   'light-my-request': () => require('../light-my-request'),
   'limitd-client': () => require('../limitd-client'),
   lodash: () => require('../lodash'),
-  mariadb: () => require('../mariadb'),
+  mariadb: { esmFirst: true, fn: () => require('../mariadb') },
   memcached: () => require('../memcached'),
   mercurius: () => require('../mercurius'),
   'microgateway-core': () => require('../microgateway-core'),

package/packages/datadog-instrumentations/src/helpers/pool-acquire.js

@@ -518,10 +518,11 @@ function runPoolQueryConnectionCallback (
  * @param {unknown} error
  * @param {Record<string, unknown>} acquireCtx
  * @param {AcquireErrorChannels} channels
+ * @param {number} [poolWaitTime]
  */
-function reportPoolAcquireError (start, error, acquireCtx, channels) {
+function reportPoolAcquireError (start, error, acquireCtx, channels, poolWaitTime) {
   acquireCtx.error = error
-  acquireCtx.poolWaitTime = acquireWait(start)
+  acquireCtx.poolWaitTime = poolWaitTime ?? acquireWait(start)
   if (start !== undefined) acquireCtx.startTime = performance.timeOrigin + start
   channels.acquireStartCh.publish(acquireCtx)
   channels.acquireFinishCh.publish(acquireCtx)
@@ -536,11 +537,14 @@ function reportPoolAcquireError (start, error, acquireCtx, channels) {
  * @param {Function} callback
  * @param {unknown} thisArg
  * @param {ArgumentsLike} args
+ * @param {number} [poolWaitTime]
  * @returns {unknown}
  */
-function runPoolAcquireError (start, error, acquireCtx, channels, connectionCtx, callback, thisArg, args) {
+function runPoolAcquireError (
+  start, error, acquireCtx, channels, connectionCtx, callback, thisArg, args, poolWaitTime
+) {
   return channels.connectionFinishCh.runStores(connectionCtx, () => {
-    reportPoolAcquireError(start, error, acquireCtx, channels)
+    reportPoolAcquireError(start, error, acquireCtx, channels, poolWaitTime)
     return callback.apply(thisArg, args)
   })
 }
@@ -613,6 +617,7 @@ function takeClusterAcquire (key) {
 }
 
 module.exports = {
+  acquireWait,
   clearPoolWaitTime,
   dispatchesAcquireSynchronously,
   isPoolQueryAcquire,

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

@@ -112,14 +112,6 @@ for (const name of names) {
     }
 
     for (const { file, versions, hook, filePattern, patchDefault } of instrumentations[name]) {
-      if (isIitm && patchDefault === !!moduleExports.default) {
-        if (patchDefault) {
-          moduleExports = moduleExports.default
-        } else {
-          return moduleExports
-        }
-      }
-
       const fullFilename = filename(name, file)
 
       let matchesFile = moduleName === fullFilename
@@ -134,6 +126,16 @@ for (const name of names) {
       }
 
       if (matchesFile && matchVersion(moduleVersion, versions)) {
+        // IITM invokes this callback for every module in the package. Only unwrap the namespace after its file and
+        // version match, otherwise a default export from an unrelated internal module can replace that module.
+        if (isIitm && patchDefault === !!moduleExports.default) {
+          if (patchDefault) {
+            moduleExports = moduleExports.default
+          } else {
+            return moduleExports
+          }
+        }
+
         // Do not log in case of an error to prevent duplicate telemetry for the same integration version.
         instrumentedIntegrationsSuccess.set(`${name}@${moduleVersion}`, true)
         try {