dd-trace 5.96.0 → 5.97.0

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

@@ -1,9 +1,9 @@
 'use strict'
 
+const { builtinModules } = require('module')
 const path = require('path')
 const { channel } = require('dc-polyfill')
 const satisfies = require('../../../../vendor/dist/semifies')
-const requirePackageJson = require('../../../dd-trace/src/require-package-json')
 const log = require('../../../dd-trace/src/log')
 const telemetry = require('../../../dd-trace/src/guardrails/telemetry')
 const { IS_SERVERLESS } = require('../../../dd-trace/src/serverless')
@@ -36,27 +36,47 @@ if (!disabledInstrumentations.has('process')) {
   require('../process')
 }
 
-const HOOK_SYMBOL = Symbol('hookExportsSet')
-
 if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
   checkRequireCache.checkForRequiredModules()
   setImmediate(checkRequireCache.checkForPotentialConflicts)
 }
 
-const seenCombo = new Set()
-const allInstrumentations = {}
-
 for (const inst of disabledInstrumentations) {
   rewriter.disable(inst)
 }
 
-// TODO: make this more efficient
-for (const packageName of names) {
-  if (disabledInstrumentations.has(packageName)) continue
+/** @type {Map<string, object>} */
+const instrumentedNodeModules = new Map()
+/** @type {Map<string, boolean>} */
+const instrumentedIntegrationsSuccess = new Map()
+/** @type {Set<string>} */
+const alreadyLoggedIncompatibleIntegrations = new Set()
+
+// Always disable prefixed and unprefixed node modules if one is disabled.
+if (disabledInstrumentations.size) {
+  const builtinsSet = new Set(builtinModules)
+  for (const name of disabledInstrumentations) {
+    const hasPrefix = name.startsWith('node:')
+    if (hasPrefix || builtinsSet.has(name)) {
+      if (hasPrefix) {
+        const unprefixedName = name.slice(5)
+        if (!disabledInstrumentations.has(unprefixedName)) {
+          disabledInstrumentations.add(unprefixedName)
+        }
+      } else if (!disabledInstrumentations.has(`node:${name}`)) {
+        disabledInstrumentations.add(`node:${name}`)
+      }
+    }
+  }
+  builtinsSet.clear()
+}
+
+for (const name of names) {
+  if (disabledInstrumentations.has(name)) continue
 
   const hookOptions = {}
 
-  let hook = hooks[packageName]
+  let hook = hooks[name]
 
   if (hook !== null && typeof hook === 'object') {
     if (hook.serverless === false && IS_SERVERLESS) continue
@@ -65,173 +85,114 @@ for (const packageName of names) {
     hook = hook.fn
   }
 
-  // get the instrumentation file name to save all hooked versions
-  const instrumentationFileName = parseHookInstrumentationFileName(packageName)
-
-  Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
-    moduleName = moduleName.replace(pathSepExpr, '/')
+  Hook([name], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
+    // All loaded versions are first expected to fail instrumentation.
+    if (!instrumentedIntegrationsSuccess.has(`${name}@${moduleVersion}`)) {
+      instrumentedIntegrationsSuccess.set(`${name}@${moduleVersion}`, false)
+    }
 
     // This executes the integration file thus adding its entries to `instrumentations`
     hook()
 
-    if (!instrumentations[packageName]) {
+    if (!instrumentations[name] || moduleExports === instrumentedNodeModules.get(name)) {
       return moduleExports
     }
 
-    const namesAndSuccesses = {}
-    for (const { name, file, versions, hook, filePattern, patchDefault } of instrumentations[packageName]) {
-      if (patchDefault === false && !moduleExports.default && isIitm) {
-        return moduleExports
-      } else if (patchDefault === true && moduleExports.default && isIitm) {
-        moduleExports = moduleExports.default
+    // Used for node: prefixed modules to prevent double instrumentation.
+    if (moduleBaseDir) {
+      moduleName = moduleName.replace(pathSepExpr, '/')
+    } else {
+      instrumentedNodeModules.set(name, moduleExports)
+    }
+
+    for (const { file, versions, hook, filePattern, patchDefault } of instrumentations[name]) {
+      if (isIitm && patchDefault === !!moduleExports.default) {
+        if (patchDefault) {
+          moduleExports = moduleExports.default
+        } else {
+          return moduleExports
+        }
       }
 
-      let fullFilePattern = filePattern
       const fullFilename = filename(name, file)
-      if (fullFilePattern) {
-        fullFilePattern = filename(name, fullFilePattern)
-      }
 
-      // Create a WeakSet associated with the hook function so that patches on the same moduleExport only happens once
-      // for example by instrumenting both dns and node:dns double the spans would be created
-      // since they both patch the same moduleExport, this WeakSet is used to mitigate that
-      // TODO(BridgeAR): Instead of using a WeakSet here, why not just use aliases for the hook in register?
-      // That way it would also not be duplicated. The actual name being used has to be identified else wise.
-      // Maybe it is also not important to know what name was actually used?
-      hook[HOOK_SYMBOL] ??= new WeakSet()
       let matchesFile = moduleName === fullFilename
 
       if (!matchesFile && isRelativeRequire(name)) matchesFile = true
 
+      const fullFilePattern = filePattern && filename(name, filePattern)
       if (fullFilePattern) {
         // Some libraries include a hash in their filenames when installed,
         // so our instrumentation has to include a '.*' to match them for more than a single version.
-        matchesFile = matchesFile || new RegExp(fullFilePattern).test(moduleName)
+        matchesFile ||= new RegExp(fullFilePattern).test(moduleName)
       }
 
-      if (matchesFile) {
-        let version = moduleVersion
+      if (matchesFile && matchVersion(moduleVersion, versions)) {
+        // Do not log in case of an error to prevent duplicate telemetry for the same integration version.
+        instrumentedIntegrationsSuccess.set(`${name}@${moduleVersion}`, true)
         try {
-          version = version || getVersion(moduleBaseDir)
-          allInstrumentations[instrumentationFileName] = allInstrumentations[instrumentationFileName] || false
-        } catch (e) {
-          log.error('Error getting version for "%s": %s', name, e.message, e)
-          continue
-        }
-        if (namesAndSuccesses[`${name}@${version}`] === undefined && !file) {
-          // TODO If `file` is present, we might elsewhere instrument the result of the module
-          // for a version range that actually matches, so we can't assume that we're _not_
-          // going to instrument that. However, the way the data model around instrumentation
-          // works, we can't know either way just yet, so to avoid false positives, we'll just
-          // ignore this if there is a `file` in the hook. The thing to do here is rework
-          // everything so that we can be sure that there are _no_ instrumentations that it
-          // could match.
-          namesAndSuccesses[`${name}@${version}`] = false
-        }
-
-        if (matchVersion(version, versions)) {
-          allInstrumentations[instrumentationFileName] = true
-
-          // Check if the hook already has a set moduleExport
-          if (hook[HOOK_SYMBOL].has(moduleExports)) {
-            namesAndSuccesses[`${name}@${version}`] = true
-            return moduleExports
-          }
-
-          try {
-            loadChannel.publish({ name, version, file })
-            // Send the name and version of the module back to the callback because now addHook
-            // takes in an array of names so by passing the name the callback will know which module name is being used
-            // TODO(BridgeAR): This is only true in case the name is identical
-            // in all loads. If they deviate, the deviating name would not be
-            // picked up due to the unification. Check what modules actually use the name.
-            // TODO(BridgeAR): Only replace moduleExports if the hook returns a new value.
-            // This allows to reduce the instrumentation code (no return needed).
-
-            moduleExports = hook(moduleExports, version, name, isIitm) ?? moduleExports
-            // Set the moduleExports in the hooks WeakSet
-            hook[HOOK_SYMBOL].add(moduleExports)
-          } catch (e) {
-            log.info('Error during ddtrace instrumentation of application, aborting.', e)
-            telemetry('error', [
-              `error_type:${e.constructor.name}`,
-              `integration:${name}`,
-              `integration_version:${version}`,
-            ], {
-              result: 'error',
-              result_class: 'internal_error',
-              result_reason: `Error during instrumentation of ${name}@${version}: ${e.message}`,
-            })
-          }
-          namesAndSuccesses[`${name}@${version}`] = true
+          loadChannel.publish({ name })
+
+          moduleExports = hook(moduleExports, moduleVersion, isIitm) ?? moduleExports
+        } catch (error) {
+          log.info('Error during ddtrace instrumentation of application, aborting.', error)
+          telemetry('error', [
+            `error_type:${error.constructor.name}`,
+            `integration:${name}`,
+            `integration_version:${moduleVersion}`,
+          ], {
+            result: 'error',
+            result_class: 'internal_error',
+            result_reason: `Error during instrumentation of ${name}@${moduleVersion}: ${error.message}`,
+          })
         }
       }
     }
-    for (const nameVersion of Object.keys(namesAndSuccesses)) {
-      const [name, version] = nameVersion.split('@')
-      const success = namesAndSuccesses[nameVersion]
-      // we check allVersions to see if any version of the integration was successfully instrumented
-      if (!success && !seenCombo.has(nameVersion) && !allInstrumentations[instrumentationFileName]) {
-        telemetry('abort.integration', [
-          `integration:${name}`,
-          `integration_version:${version}`,
-        ], {
-          result: 'abort',
-          result_class: 'incompatible_library',
-          result_reason: `Incompatible integration version: ${name}@${version}`,
-        })
-        log.info('Found incompatible integration version: %s', nameVersion)
-        seenCombo.add(nameVersion)
-      }
-    }
 
     return moduleExports
   })
 }
 
-function matchVersion (version, ranges) {
-  return !version || !ranges || ranges.some(range => satisfies(version, range))
-}
+globalThis[Symbol.for('dd-trace')]?.beforeExitHandlers.add(logAbortedIntegrations)
+// TODO: check if we want to stop using channels for single subscriber tasks
+channel('dd-trace:exporter:first-flush').subscribe(logAbortedIntegrations)
 
-function getVersion (moduleBaseDir) {
-  if (moduleBaseDir) {
-    return requirePackageJson(moduleBaseDir, module).version
+function logAbortedIntegrations () {
+  for (const [nameVersion, success] of instrumentedIntegrationsSuccess) {
+    // Only ever log a single version of an integration, even if it is loaded later.
+    if (!success && !alreadyLoggedIncompatibleIntegrations.has(nameVersion)) {
+      const [name, version] = nameVersion.split('@')
+      telemetry('abort.integration', [
+        `integration:${name}`,
+        `integration_version:${version}`,
+      ], {
+        result: 'abort',
+        result_class: 'incompatible_library',
+        result_reason: `Incompatible integration version: ${name}@${version}`,
+      })
+      log.info('Found incompatible integration version: %s', nameVersion)
+      alreadyLoggedIncompatibleIntegrations.add(nameVersion)
+    }
   }
+  // Clear the map to avoid reporting the same integration version again.
+  instrumentedIntegrationsSuccess.clear()
 }
 
-function filename (name, file) {
-  return [name, file].filter(Boolean).join('/')
+/**
+ * @param {string|undefined} version
+ * @param {string[]|undefined} ranges
+ */
+function matchVersion (version, ranges) {
+  return !version || !ranges || ranges.some(range => satisfies(version, range))
 }
 
-// This function captures the instrumentation file name for a given package by parsing the hook require
-// function given the module name. It is used to ensure that instrumentations such as redis
-// that have several different modules being hooked, ie: 'redis' main package, and @redis/client submodule
-// return a consistent instrumentation name. This is used later to ensure that at least some portion of
-// the integration was successfully instrumented. Prevents incorrect `Found incompatible integration version: ` messages
-// Example:
-//                  redis -> "() => require('../redis')" -> redis
-//          @redis/client -> "() => require('../redis')" -> redis
-//
-function parseHookInstrumentationFileName (packageName) {
-  let hook = hooks[packageName]
-  if (hook.fn) {
-    hook = hook.fn
-  }
-  const hookString = hook.toString()
-  const regex = /require\('([^']*)'\)/
-  const match = hookString.match(regex)
-
-  // try to capture the hook require file location.
-  if (match && match[1]) {
-    let moduleName = match[1]
-    // Remove leading '../' if present
-    if (moduleName.startsWith('../')) {
-      moduleName = moduleName.slice(3)
-    }
-    return moduleName
-  }
-
-  return null
+/**
+ * @param {string} name
+ * @param {string} [file]
+ * @returns {string}
+ */
+function filename (name, file) {
+  return file ? `${name}/${file}` : name
 }
 
 module.exports = {

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

@@ -16,9 +16,8 @@ const asyncStartChannel = channel('apm:http:client:request:asyncStart')
 const errorChannel = channel('apm:http:client:request:error')
 const responseFinishChannel = channel('apm:http:client:response:finish')
 
-const names = ['http', 'https', 'node:http', 'node:https']
-
-addHook({ name: names }, hookFn)
+addHook({ name: 'http' }, hookFn)
+addHook({ name: 'https' }, hookFn)
 
 function hookFn (http) {
   patch(http, 'request')

package/packages/datadog-instrumentations/src/http/server.js

@@ -16,10 +16,7 @@ const startSetHeaderCh = channel('datadog:http:server:response:set-header:start'
 
 const requestFinishedSet = new WeakSet()
 
-const httpNames = ['http', 'node:http']
-const httpsNames = ['https', 'node:https']
-
-addHook({ name: httpNames }, http => {
+addHook({ name: 'http' }, http => {
   shimmer.wrap(http.ServerResponse.prototype, 'emit', wrapResponseEmit)
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
   shimmer.wrap(http.ServerResponse.prototype, 'writeHead', wrapWriteHead)
@@ -34,7 +31,7 @@ addHook({ name: httpNames }, http => {
   return http
 })
 
-addHook({ name: httpsNames }, http => {
+addHook({ name: 'https' }, http => {
   // http.ServerResponse not present on https
   shimmer.wrap(http.Server.prototype, 'emit', wrapEmit)
   return http

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

@@ -10,8 +10,6 @@ const asyncStartChannel = channel('apm:http2:client:request:asyncStart')
 const asyncEndChannel = channel('apm:http2:client:request:asyncEnd')
 const errorChannel = channel('apm:http2:client:request:error')
 
-const names = ['http2', 'node:http2']
-
 function createWrapEmit (ctx) {
   return function wrapEmit (emit) {
     return function (event, arg1) {
@@ -68,7 +66,7 @@ function wrapConnect (connect) {
   }
 }
 
-addHook({ name: names }, http2 => {
+addHook({ name: 'http2' }, http2 => {
   shimmer.wrap(http2, 'connect', wrapConnect)
   if (http2.default) http2.default.connect = http2.connect
 

package/packages/datadog-instrumentations/src/http2/server.js

@@ -13,9 +13,7 @@ const startServerCh = channel('apm:http2:server:request:start')
 const errorServerCh = channel('apm:http2:server:request:error')
 const emitCh = channel('apm:http2:server:response:emit')
 
-const names = ['http2', 'node:http2']
-
-addHook({ name: names }, http2 => {
+addHook({ name: 'http2' }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
 })

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const path = require('path')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -111,6 +114,8 @@ const efdDeterminedRetries = new Map()
 const efdSlowAbortedTests = new Set()
 // Tests added as EFD new-test candidates (not ATF, not impacted).
 const efdNewTestCandidates = new Set()
+// Tests that are genuinely new (not in known tests list).
+const newTests = new Set()
 const testSuiteAbsolutePathsWithFastCheck = new Set()
 const testSuiteJestObjects = new Map()
 
@@ -485,7 +490,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         if (this.isKnownTestsEnabled) {
-          isNewTest = retriedTestsToNumAttempts.has(testName)
+          isNewTest = newTests.has(testName)
         }
 
         const willRunEfd = this.isEarlyFlakeDetectionEnabled && (isNewTest || isModified)
@@ -605,6 +610,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
         if (!isAttemptToFix && this.isKnownTestsEnabled) {
           const isNew = !this.knownTestsForThisSuite.includes(testFullName)
+          if (isNew && !isSkipped) {
+            newTests.add(testFullName)
+          }
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testFullName)) {
             if (DYNAMIC_NAME_RE.test(testFullName)) {
               // Populated directly for runInBand; for parallel workers the main process
@@ -715,7 +723,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         let isEfdRetry = false
         // We'll store the test statuses of the retries
         if (this.isKnownTestsEnabled) {
-          const isNewTest = retriedTestsToNumAttempts.has(testName)
+          const isNewTest = newTests.has(testName)
           if (isNewTest) {
             if (newTestsTestStatuses.has(testName)) {
               newTestsTestStatuses.get(testName).push(status)
@@ -776,7 +784,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         // This means that tests retried with DI are BREAKPOINT_HIT_GRACE_PERIOD_MS slower at least.
         if (status === 'fail' && mightHitBreakpoint) {
           await new Promise(resolve => {
-            setTimeout(() => {
+            realSetTimeout(() => {
               resolve()
             }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
           })
@@ -811,6 +819,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         efdDeterminedRetries.clear()
         efdSlowAbortedTests.clear()
         efdNewTestCandidates.clear()
+        newTests.clear()
         retriedTestsToNumAttempts.clear()
         attemptToFixRetriedTestsStatuses.clear()
         testsToBeRetried.clear()
@@ -1345,7 +1354,7 @@ function getCliWrapper (isNewJestVersion) {
       })
 
       const timeoutPromise = new Promise((resolve) => {
-        timeoutId = setTimeout(() => {
+        timeoutId = realSetTimeout(() => {
           resolve('timeout')
         }, FLUSH_TIMEOUT).unref()
       })

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

@@ -14,7 +14,7 @@ function wrapRequest (original) {
 addHook({
   name: 'limitd-client',
   versions: ['>=2.8'],
-  file: ['client.js'],
+  file: 'client.js',
 }, LimitdClient => {
   shimmer.wrap(LimitdClient.prototype, '_directRequest', wrapRequest)
   shimmer.wrap(LimitdClient.prototype, '_retriedRequest', wrapRequest)

package/packages/datadog-instrumentations/src/mocha/utils.js

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const { getTestSuitePath, DYNAMIC_NAME_RE } = require('../../../dd-trace/src/plugins/util/test')
 const { channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
@@ -293,7 +296,7 @@ function getOnTestEndHandler (config) {
     // This means that tests retried with DI are BREAKPOINT_HIT_GRACE_PERIOD_MS slower at least.
     if (test._ddShouldWaitForHitProbe || test._retriedTest?._ddShouldWaitForHitProbe) {
       await new Promise((resolve) => {
-        setTimeout(() => {
+        realSetTimeout(() => {
           resolve()
         }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
       })

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

@@ -16,16 +16,10 @@ const errorTCPCh = channel('apm:net:tcp:error')
 const readyCh = channel('apm:net:tcp:ready')
 const connectionCh = channel('apm:net:tcp:connection')
 
-const names = ['net', 'node:net']
-
-addHook({ name: names }, (net, version, name) => {
+addHook({ name: 'net' }, (net) => {
   // explicitly require dns so that net gets an instrumented instance
   // so that we don't miss the dns calls
-  if (name === 'net') {
-    require('dns')
-  } else {
-    require('node:dns')
-  }
+  require('node:dns')
 
   shimmer.wrap(net.Socket.prototype, 'connect', connect => function () {
     if (!startICPCh.hasSubscribers || !startTCPCh.hasSubscribers) {

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

@@ -97,7 +97,7 @@ addHook({ name: 'pino', versions: ['>=5.14.0 <6.8.0'] }, (pino) => {
   return wrapped
 })
 
-addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino, _1, _2, isIitm) => {
+addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino) => {
   const mixinSym = pino.symbols.mixinSym
 
   const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(mixinSym, wrapMixin, pino))

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const satisfies = require('../../../vendor/dist/semifies')
 
 const shimmer = require('../../datadog-shimmer')
@@ -1216,7 +1219,7 @@ addHook({
 
                 if (isRumActive) {
                   // Give some time RUM to flush data, similar to what we do in selenium
-                  await new Promise(resolve => setTimeout(resolve, RUM_FLUSH_WAIT_TIME))
+                  await new Promise(resolve => realSetTimeout(resolve, RUM_FLUSH_WAIT_TIME))
                   const url = page.url()
                   if (url) {
                     const domain = new URL(url).hostname

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

@@ -136,11 +136,10 @@ function resolveClientDbConfig (clientConfig, datasourceName, runtimeDbConfig) {
 /**
  * @param {unknown} runtime
  * @param {string} versions
- * @param {string} [name]
  * @param {boolean} [isIitm]
  * @returns {object}
  */
-const prismaHook = (runtime, versions, name, isIitm) => {
+const prismaHook = (runtime, versions, isIitm) => {
   /**
    * @typedef {{ getPrismaClient?: (config: PrismaRuntimeConfig, ...args: unknown[]) => Function }} PrismaRuntime
    */

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

@@ -1,5 +1,8 @@
 'use strict'
 
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const shimmer = require('../../datadog-shimmer')
 const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
 const { addHook, channel } = require('./helpers/instrument')
@@ -66,7 +69,7 @@ addHook({
     if (isRumActive) {
       // We'll have time for RUM to flush the events (there's no callback to know when it's done)
       await new Promise(resolve => {
-        setTimeout(() => {
+        realSetTimeout(() => {
           resolve()
         }, DD_CIVISIBILITY_RUM_FLUSH_WAIT_MILLIS)
       })

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

@@ -6,7 +6,7 @@ const {
   addHook,
 } = require('./helpers/instrument')
 
-addHook({ name: 'sequelize', versions: ['>=4'], file: ['lib/sequelize.js'] }, Sequelize => {
+addHook({ name: 'sequelize', versions: ['>=4'], file: 'lib/sequelize.js' }, Sequelize => {
   const startCh = channel('datadog:sequelize:query:start')
   const finishCh = channel('datadog:sequelize:query:finish')
 

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

@@ -2,13 +2,11 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { addHook, channel } = require('./helpers/instrument')
-const names = ['url', 'node:url']
-
 const parseFinishedChannel = channel('datadog:url:parse:finish')
 const urlGetterChannel = channel('datadog:url:getter:finish')
 const instrumentedGetters = ['host', 'origin', 'hostname']
 
-addHook({ name: names }, function (url) {
+addHook({ name: 'url' }, function (url) {
   shimmer.wrap(url, 'parse', (parse) => {
     return function wrappedParse (input) {
       const parsedValue = parse.apply(this, arguments)

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

@@ -1,4 +1,8 @@
 'use strict'
+
+// Capture real timers at module load time, before any test can install fake timers.
+const realSetTimeout = setTimeout
+
 const path = require('node:path')
 
 const shimmer = require('../../datadog-shimmer')
@@ -83,7 +87,7 @@ function getTestCommand () {
 
 function waitForHitProbe () {
   return new Promise(resolve => {
-    setTimeout(() => {
+    realSetTimeout(() => {
       resolve()
     }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
   })

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

@@ -2,12 +2,10 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { channel, addHook } = require('./helpers/instrument')
-const names = ['vm', 'node:vm']
-
 const runScriptStartChannel = channel('datadog:vm:run-script:start')
 const sourceTextModuleStartChannel = channel('datadog:vm:source-text-module:start')
 
-addHook({ name: names }, function (vm) {
+addHook({ name: 'vm' }, function (vm) {
   vm.Script = class extends vm.Script {
     constructor (code) {
       super(...arguments)

package/packages/datadog-plugin-aws-sdk/src/base.js

@@ -23,12 +23,13 @@ class BaseAwsSdkPlugin extends ClientPlugin {
     return id
   }
 
+  /** @type {import('../../dd-trace/src/config/config-types').ConfigProperties['cloudPayloadTagging']} */
   get cloudTaggingConfig () {
     return this._tracerConfig.cloudPayloadTagging
   }
 
   get payloadTaggingRules () {
-    return this.cloudTaggingConfig.rules.aws?.[this.constructor.id]
+    return this.cloudTaggingConfig.rules?.aws?.[this.constructor.id]
   }
 
   constructor (...args) {
@@ -78,7 +79,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
         this.requestInject(span, request)
       })
 
-      if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.requestsEnabled) {
+      if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.request) {
         const maxDepth = this.cloudTaggingConfig.maxDepth
         const requestTags = tagsFromRequest(this.payloadTaggingRules, request.params, { maxDepth })
         span.addTags(requestTags)
@@ -215,7 +216,7 @@ class BaseAwsSdkPlugin extends ClientPlugin {
 
     span.addTags(tags)
 
-    if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.responsesEnabled) {
+    if (this.constructor.isPayloadReporter && this.cloudTaggingConfig.response) {
       const maxDepth = this.cloudTaggingConfig.maxDepth
       const responseBody = this.extractResponseBody(response)
       const responseTags = tagsFromResponse(this.payloadTaggingRules, responseBody, { maxDepth })