dd-trace 5.66.0 → 5.68.0

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

@@ -82,10 +82,14 @@ let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
 let modifiedTests = {}
 let numTestRetries = 0
-let knownTests = []
+let knownTests = {}
 let skippedSuites = []
 let isSuitesSkipped = false
 
+function isValidKnownTests (receivedKnownTests) {
+  return !!receivedKnownTests.cucumber
+}
+
 function getSuiteStatusFromTestStatuses (testStatuses) {
   if (testStatuses.includes('fail')) {
     return 'fail'
@@ -123,7 +127,10 @@ function getStatusFromResultLatest (result) {
 }
 
 function isNewTest (testSuite, testName) {
-  const testsForSuite = knownTests.cucumber?.[testSuite] || []
+  if (!isValidKnownTests(knownTests)) {
+    return false
+  }
+  const testsForSuite = knownTests.cucumber[testSuite] || []
   return !testsForSuite.includes(testName)
 }
 
@@ -508,9 +515,9 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     pickleByFile = isCoordinator ? getPickleByFileNew(this) : getPickleByFile(this)
 
     if (isKnownTestsEnabled) {
-      const isFaulty = getIsFaultyEarlyFlakeDetection(
+      const isFaulty = !isValidKnownTests(knownTests) || getIsFaultyEarlyFlakeDetection(
         Object.keys(pickleByFile),
-        knownTests.cucumber || {},
+        knownTests.cucumber,
         earlyFlakeDetectionFaultyThreshold
       )
       if (isFaulty) {
@@ -592,6 +599,9 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
 // Handles EFD in both the main process and the worker process.
 function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = false, isWorker = false) {
   return async function () {
+    if (!testSuiteFinishCh.hasSubscribers) {
+      return runTestCaseFunction.apply(this, arguments)
+    }
     const pickle = isNewerCucumberVersion
       ? arguments[0].pickle
       : this.eventDataCollector.getPickle(arguments[0])
@@ -747,6 +757,9 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
 function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion) {
   return function (worker, message) {
+    if (!testSuiteFinishCh.hasSubscribers) {
+      return parseWorkerMessageFunction.apply(this, arguments)
+    }
     // If the message is an array, it's a dd-trace message, so we need to stop cucumber processing,
     // or cucumber will throw an error
     // TODO: identify the message better
@@ -972,10 +985,17 @@ addHook({
   )
   // EFD in parallel mode only supported in >=11.0.0
   shimmer.wrap(adapterPackage.ChildProcessAdapter.prototype, 'startWorker', startWorker => function () {
-    if (isKnownTestsEnabled) {
+    if (isKnownTestsEnabled && isValidKnownTests(knownTests)) {
+      this.options.worldParameters._ddIsKnownTestsEnabled = true
       this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
       this.options.worldParameters._ddKnownTests = knownTests
       this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+    } else {
+      isEarlyFlakeDetectionEnabled = false
+      isKnownTestsEnabled = false
+      this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled = false
+      this.options.worldParameters._ddIsKnownTestsEnabled = false
+      this.options.worldParameters._ddEarlyFlakeDetectionNumRetries = 0
     }
 
     if (isImpactedTestsEnabled) {
@@ -1001,9 +1021,14 @@ addHook({
     'initialize',
     initialize => async function () {
       await initialize.apply(this, arguments)
-      isKnownTestsEnabled = !!this.options.worldParameters._ddKnownTests
+      isKnownTestsEnabled = !!this.options.worldParameters._ddIsKnownTestsEnabled
       if (isKnownTestsEnabled) {
         knownTests = this.options.worldParameters._ddKnownTests
+        // if for whatever reason the worker does not receive valid known tests, we disable EFD and known tests
+        if (!isValidKnownTests(knownTests)) {
+          isKnownTestsEnabled = false
+          knownTests = {}
+        }
       }
       isEarlyFlakeDetectionEnabled = !!this.options.worldParameters._ddIsEarlyFlakeDetectionEnabled
       if (isEarlyFlakeDetectionEnabled) {

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

@@ -2,8 +2,7 @@
 
 const { createWrapRouterMethod } = require('./router')
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel } = require('./helpers/instrument')
-const tracingChannel = require('dc-polyfill').tracingChannel
+const { addHook, channel, tracingChannel } = require('./helpers/instrument')
 
 const handleChannel = channel('apm:express:request:handle')
 
@@ -57,7 +56,7 @@ function wrapResponseRender (render) {
   }
 }
 
-addHook({ name: 'express', versions: ['>=4'] }, express => {
+addHook({ name: 'express', versions: ['>=4'], file: ['lib/express.js'] }, express => {
   shimmer.wrap(express.application, 'handle', wrapHandle)
 
   shimmer.wrap(express.response, 'json', wrapResponseJson)
@@ -70,7 +69,7 @@ addHook({ name: 'express', versions: ['>=4'] }, express => {
 // Express 5 does not rely on router in the same way as v4 and should not be instrumented anymore.
 // It would otherwise produce spans for router and express, and so duplicating them.
 // We now fall back to router instrumentation
-addHook({ name: 'express', versions: ['4'] }, express => {
+addHook({ name: 'express', versions: ['4'], file: 'lib/express.js' }, express => {
   shimmer.wrap(express.Router, 'use', wrapRouterMethod)
   shimmer.wrap(express.Router, 'route', wrapRouterMethod)
 
@@ -132,12 +131,12 @@ function wrapProcessParamsMethod (requestPositionInArguments) {
   }
 }
 
-addHook({ name: 'express', versions: ['>=4.0.0 <4.3.0'] }, express => {
+addHook({ name: 'express', versions: ['>=4.0.0 <4.3.0'], file: ['lib/express.js'] }, express => {
   shimmer.wrap(express.Router, 'process_params', wrapProcessParamsMethod(1))
   return express
 })
 
-addHook({ name: 'express', versions: ['>=4.3.0 <5.0.0'] }, express => {
+addHook({ name: 'express', versions: ['>=4.3.0 <5.0.0'], file: ['lib/express.js'] }, express => {
   shimmer.wrap(express.Router, 'process_params', wrapProcessParamsMethod(2))
   return express
 })

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

@@ -265,7 +265,7 @@ function canPublishResponsePayload (payload) {
     !ArrayBuffer.isView(payload) // TypedArray
 }
 
-addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
+addHook({ name: 'fastify', versions: ['>=3'] }, (fastify) => {
   const wrapped = shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, true))
 
   wrapped.fastify = wrapped
@@ -274,11 +274,11 @@ addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
   return wrapped
 })
 
-addHook({ name: 'fastify', versions: ['2'] }, fastify => {
+addHook({ name: 'fastify', versions: ['2'] }, (fastify) => {
   return shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, true))
 })
 
-addHook({ name: 'fastify', versions: ['1'] }, fastify => {
+addHook({ name: 'fastify', versions: ['1'] }, (fastify) => {
   return shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, false))
 })
 

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

@@ -1,7 +1,6 @@
 'use strict'
-
-const path = require('path')
 const iitm = require('../../../dd-trace/src/iitm')
+const path = require('path')
 const ritm = require('../../../dd-trace/src/ritm')
 
 /**
@@ -20,29 +19,43 @@ function Hook (modules, hookOptions, onrequire) {
   }
 
   this._patched = Object.create(null)
+  const patched = new WeakMap()
 
-  const safeHook = (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
+  const safeHook = (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
     const parts = [moduleBaseDir, moduleName].filter(Boolean)
     const filename = path.join(...parts)
 
-    if (this._patched[filename]) return moduleExports
+    if (this._patched[filename] && patched.has(moduleExports)) {
+      return patched.get(moduleExports)
+    }
 
-    this._patched[filename] = true
+    let defaultWrapResult
+
+    if (
+      isIitm &&
+      moduleExports.default &&
+      (typeof moduleExports.default === 'object' ||
+      typeof moduleExports.default === 'function')
+    ) {
+      defaultWrapResult = onrequire(moduleExports.default, moduleName, moduleBaseDir, moduleVersion, isIitm)
+    }
+
+    const newExports = onrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm)
+
+    if (defaultWrapResult) newExports.default = defaultWrapResult
 
-    return onrequire(moduleExports, moduleName, moduleBaseDir, moduleVersion)
+    this._patched[filename] = true
+    if (newExports &&
+      (typeof newExports === 'object' ||
+      typeof newExports === 'function')) {
+      patched.set(moduleExports, newExports)
+    }
+    return newExports
   }
 
   this._ritmHook = ritm(modules, {}, safeHook)
   this._iitmHook = iitm(modules, hookOptions, (moduleExports, moduleName, moduleBaseDir) => {
-    // TODO: Move this logic to import-in-the-middle and only do it for CommonJS
-    // modules and not ESM. In the meantime, all the modules we instrument are
-    // CommonJS modules for which the default export is always moved to
-    // `default` anyway.
-    if (moduleExports && moduleExports.default) {
-      moduleExports.default = safeHook(moduleExports.default, moduleName, moduleBaseDir)
-      return moduleExports
-    }
-    return safeHook(moduleExports, moduleName, moduleBaseDir)
+    return safeHook(moduleExports, moduleName, moduleBaseDir, null, true)
   })
 }
 

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

@@ -16,6 +16,7 @@ module.exports = {
   '@graphql-tools/executor': () => require('../graphql'),
   '@grpc/grpc-js': () => require('../grpc'),
   '@hapi/hapi': () => require('../hapi'),
+  '@happy-dom/jest-environment': () => require('../jest'),
   '@jest/core': () => require('../jest'),
   '@jest/reporters': () => require('../jest'),
   '@jest/test-sequencer': () => require('../jest'),
@@ -130,6 +131,7 @@ module.exports = {
   sequelize: () => require('../sequelize'),
   sharedb: () => require('../sharedb'),
   tedious: () => require('../tedious'),
+  tinypool: { esmFirst: true, fn: () => require('../vitest') },
   undici: () => require('../undici'),
   url: () => require('../url'),
   vitest: { esmFirst: true, fn: () => require('../vitest') },

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

@@ -13,6 +13,15 @@ exports.channel = function (name) {
   return ch
 }
 
+const tracingChannelMap = {}
+exports.tracingChannel = function (name) {
+  const maybe = tracingChannelMap[name]
+  if (maybe) return maybe
+  const tc = dc.tracingChannel(name)
+  tracingChannelMap[name] = tc
+  return tc
+}
+
 /**
  * @param {string} args.name module name
  * @param {string[]} args.versions array of semver range strings
@@ -20,7 +29,7 @@ exports.channel = function (name) {
  * @param {string} args.filePattern pattern to match files within package to instrument
  * @param Function hook
  */
-exports.addHook = function addHook ({ name, versions, file, filePattern }, hook) {
+exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {
   if (typeof name === 'string') {
     name = [name]
   }
@@ -29,7 +38,7 @@ exports.addHook = function addHook ({ name, versions, file, filePattern }, hook)
     if (!instrumentations[val]) {
       instrumentations[val] = []
     }
-    instrumentations[val].push({ name: val, versions, file, filePattern, hook })
+    instrumentations[val].push({ name: val, versions, file, filePattern, hook, patchDefault })
   }
 }
 

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

@@ -66,7 +66,7 @@ for (const packageName of names) {
   // get the instrumentation file name to save all hooked versions
   const instrumentationFileName = parseHookInstrumentationFileName(packageName)
 
-  Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion) => {
+  Hook([packageName], hookOptions, (moduleExports, moduleName, moduleBaseDir, moduleVersion, isIitm) => {
     moduleName = moduleName.replace(pathSepExpr, '/')
 
     // This executes the integration file thus adding its entries to `instrumentations`
@@ -77,7 +77,13 @@ for (const packageName of names) {
     }
 
     const namesAndSuccesses = {}
-    for (const { name, file, versions, hook, filePattern } of instrumentations[packageName]) {
+    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
+      }
+
       let fullFilePattern = filePattern
       const fullFilename = filename(name, file)
       if (fullFilePattern) {
@@ -137,7 +143,8 @@ for (const packageName of names) {
             // 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) ?? moduleExports
+
+            moduleExports = hook(moduleExports, version, name, isIitm) ?? moduleExports
             // Set the moduleExports in the hooks WeakSet
             hook[HOOK_SYMBOL].add(moduleExports)
           } catch (e) {

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

@@ -70,6 +70,7 @@ function wrapConnect (connect) {
 
 addHook({ name: names }, http2 => {
   shimmer.wrap(http2, 'connect', wrapConnect)
+  if (http2.default) http2.default.connect = http2.connect
 
   return http2
 })

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

@@ -18,7 +18,6 @@ const names = ['http2', 'node:http2']
 addHook({ name: names }, http2 => {
   shimmer.wrap(http2, 'createSecureServer', wrapCreateServer)
   shimmer.wrap(http2, 'createServer', wrapCreateServer)
-  return http2
 })
 
 function wrapCreateServer (createServer) {

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

@@ -10,7 +10,7 @@ const startCh = channel('apm:ioredis:command:start')
 const finishCh = channel('apm:ioredis:command:finish')
 const errorCh = channel('apm:ioredis:command:error')
 
-addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
+function wrapRedis (Redis) {
   shimmer.wrap(Redis.prototype, 'sendCommand', sendCommand => function (command, stream) {
     if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
 
@@ -35,8 +35,19 @@ addHook({ name: 'ioredis', versions: ['>=2'] }, Redis => {
     })
   })
   return Redis
+}
+
+addHook({ name: 'ioredis', versions: ['>=2 <4'], file: 'lib/redis.js' }, wrapRedis)
+
+addHook({ name: 'ioredis', versions: ['>=4 <4.11.0'], file: 'built/redis.js' }, wrapRedis)
+
+addHook({ name: 'ioredis', versions: ['>=4.11.0 <5'], file: 'built/redis/index.js' }, (exports) => {
+  wrapRedis(exports.default)
+  return exports
 })
 
+addHook({ name: 'ioredis', versions: ['>=5'] }, wrapRedis)
+
 function finish (finishCh, errorCh, ctx, error) {
   if (error) {
     ctx.error = error

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

@@ -160,15 +160,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.isImpactedTestsEnabled = this.testEnvironmentOptions._ddIsImpactedTestsEnabled
 
       if (this.isKnownTestsEnabled) {
+        earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
         try {
-          const hasKnownTests = !!knownTests?.jest
-          earlyFlakeDetectionNumRetries = this.testEnvironmentOptions._ddEarlyFlakeDetectionNumRetries
-          this.knownTestsForThisSuite = hasKnownTests
-            ? (knownTests?.jest?.[this.testSuite] || [])
-            : this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
-          log.debug(`this.knownTestsForThisSuite is an array: ${Array.isArray(this.knownTestsForThisSuite)}`)
-          log.debug(`this.knownTestsForThisSuite is null: ${this.knownTestsForThisSuite === null}`)
-          log.debug(`this.knownTestsForThisSuite is undefined: ${this.knownTestsForThisSuite === undefined}`)
+          this.knownTestsForThisSuite = this.getKnownTestsForSuite(this.testEnvironmentOptions._ddKnownTests)
+
+          if (!Array.isArray(this.knownTestsForThisSuite)) {
+            log.warn('this.knownTestsForThisSuite is not an array so new test and Early Flake detection is disabled.')
+            this.isEarlyFlakeDetectionEnabled = false
+            this.isKnownTestsEnabled = false
+          }
         } catch {
           // If there has been an error parsing the tests, we'll disable Early Flake Deteciton
           this.isEarlyFlakeDetectionEnabled = false
@@ -224,19 +224,20 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return hasSnapshotTests
     }
 
-    // Function that receives a list of known tests for a test service and
-    // returns the ones that belong to the current suite
-    getKnownTestsForSuite (knownTests) {
-      if (this.knownTestsForThisSuite) {
-        return this.knownTestsForThisSuite
+    // This function returns an array if the known tests are valid and null otherwise.
+    getKnownTestsForSuite (suiteKnownTests) {
+      // `suiteKnownTests` is `this.testEnvironmentOptions._ddKnownTests`,
+      // which is only set if jest is configured to run in parallel.
+      if (suiteKnownTests) {
+        return suiteKnownTests
       }
-      let knownTestsForSuite = knownTests
-      // If jest is using workers, known tests are serialized to json.
-      // If jest runs in band, they are not.
-      if (typeof knownTestsForSuite === 'string') {
-        knownTestsForSuite = JSON.parse(knownTestsForSuite)
+      // Global variable `knownTests` is set only in the main process.
+      // If jest is configured to run serially, the tests run in the same process, so `knownTests` is set.
+      // The assumption is that if the key `jest` is defined in the dictionary, the response is valid.
+      if (knownTests?.jest) {
+        return knownTests.jest[this.testSuite] || []
       }
-      return knownTestsForSuite
+      return null
     }
 
     getTestManagementTestsForSuite (testManagementTests) {
@@ -472,10 +473,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
         if (this.isKnownTestsEnabled) {
-          // Check if knownTestsForThisSuite is an array, since the worker may not have provided this information.
-          // If it's null or undefined, we can't determine if the test is new.
-          const isNew = Array.isArray(this.knownTestsForThisSuite) &&
-            !this.knownTestsForThisSuite.includes(originalTestName)
+          const isNew = !this.knownTestsForThisSuite.includes(originalTestName)
           if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
             retriedTestsToNumAttempts.set(originalTestName, 0)
             if (this.isEarlyFlakeDetectionEnabled) {
@@ -623,9 +621,17 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 function getTestEnvironment (pkg, jestVersion) {
   if (pkg.default) {
     const wrappedTestEnvironment = getWrappedEnvironment(pkg.default, jestVersion)
-    pkg.default = wrappedTestEnvironment
-    pkg.TestEnvironment = wrappedTestEnvironment
-    return pkg
+    return new Proxy(pkg, {
+      get (target, prop) {
+        if (prop === 'default') {
+          return wrappedTestEnvironment
+        }
+        if (prop === 'TestEnvironment') {
+          return wrappedTestEnvironment
+        }
+        return target[prop]
+      }
+    })
   }
   return getWrappedEnvironment(pkg, jestVersion)
 }
@@ -657,6 +663,11 @@ addHook({
   versions: ['>=24.8.0']
 }, getTestEnvironment)
 
+addHook({
+  name: '@happy-dom/jest-environment',
+  versions: ['>=10.0.0']
+}, getTestEnvironment)
+
 function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
   // `scheduleTests` is an async function
   return function (tests) {
@@ -681,8 +692,11 @@ function searchSourceWrapper (searchSourcePackage, frameworkVersion) {
 
     if (isKnownTestsEnabled) {
       const projectSuites = testPaths.tests.map(test => getTestSuitePath(test.path, test.context.config.rootDir))
-      const isFaulty =
-        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests?.jest || {}, earlyFlakeDetectionFaultyThreshold)
+
+      // If the `jest` key does not exist in the known tests response, we consider the Early Flake detection faulty.
+      const isFaulty = !knownTests?.jest ||
+        getIsFaultyEarlyFlakeDetection(projectSuites, knownTests.jest, earlyFlakeDetectionFaultyThreshold)
+
       if (isFaulty) {
         log.error('Early flake detection is disabled because the number of new suites is too high.')
         isEarlyFlakeDetectionEnabled = false
@@ -1266,12 +1280,6 @@ const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'winston'
 ])
 
-function shouldBypassJestRequireEngine (moduleName) {
-  return (
-    LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)
-  )
-}
-
 addHook({
   name: 'jest-runtime',
   versions: ['>=24.8.0']
@@ -1283,6 +1291,10 @@ addHook({
     const suiteFilePath = this._testPath
 
     shimmer.wrap(result, 'mock', mock => function (moduleName) {
+      // If the library is mocked with `jest.mock`, we don't want to bypass jest's own require engine
+      if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
+        LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.delete(moduleName)
+      }
       if (suiteFilePath) {
         const existingMockedFiles = testSuiteMockedFiles.get(suiteFilePath) || []
         const suiteDir = path.dirname(suiteFilePath)
@@ -1297,7 +1309,7 @@ addHook({
 
   shimmer.wrap(Runtime.prototype, 'requireModuleOrMock', requireModuleOrMock => function (from, moduleName) {
     // TODO: do this for every library that we instrument
-    if (shouldBypassJestRequireEngine(moduleName)) {
+    if (LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE.has(moduleName)) {
       // To bypass jest's own require engine
       return this._requireCoreModule(moduleName)
     }
@@ -1336,7 +1348,7 @@ function sendWrapper (send) {
     // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/workers/ChildProcessWorker.ts#L424
     if (type === CHILD_MESSAGE_CALL) {
       // This is the message that the main process sends to the worker to run a test suite (=test file).
-      // In here we modify the config.testEnvironmentOptions to include the known tests for the suite.
+      // In here we modify the `config.testEnvironmentOptions` to include the known tests for the suite.
       // This way the suite only knows about the tests that are part of it.
       const args = request.at(-1)
       if (args.length > 1) {

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

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

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

@@ -663,14 +663,22 @@ addHook({
     const newWorkerArgs = { ...workerArgs }
 
     if (config.isKnownTestsEnabled) {
-      const testSuiteKnownTests = config.knownTests.mocha?.[testPath] || []
-      newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
-      newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
-      newWorkerArgs._ddIsKnownTestsEnabled = true
-      newWorkerArgs._ddKnownTests = {
-        mocha: {
-          [testPath]: testSuiteKnownTests
+      if (config.knownTests?.mocha) {
+        const testSuiteKnownTests = config.knownTests.mocha[testPath] || []
+        newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
+        newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
+        newWorkerArgs._ddIsKnownTestsEnabled = true
+        newWorkerArgs._ddKnownTests = {
+          mocha: {
+            [testPath]: testSuiteKnownTests
+          }
         }
+      } else {
+        config.isEarlyFlakeDetectionEnabled = false
+        config.isKnownTestsEnabled = false
+        newWorkerArgs._ddIsKnownTestsEnabled = false
+        newWorkerArgs._ddIsEfdEnabled = false
+        newWorkerArgs._ddKnownTests = {}
       }
     }
     if (config.isTestManagementTestsEnabled) {

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

@@ -56,6 +56,9 @@ function getTestProperties (test, testManagementTests) {
 }
 
 function isNewTest (test, knownTests) {
+  if (!knownTests?.mocha) { // invalid response, so we won't consider it as new
+    return false
+  }
   const testSuite = getTestSuitePath(test.file, process.cwd())
   const testName = removeEfdStringFromTestName(test.fullTitle())
   const testsForSuite = knownTests.mocha?.[testSuite] || []

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

@@ -24,7 +24,8 @@ function wrapAddQueue (addQueue) {
 
 addHook({
   name: 'mongoose',
-  versions: ['>=4.6.4 <5', '5', '6', '>=7']
+  versions: ['>=4.6.4 <5', '5', '6', '>=7'],
+  file: 'lib/index.js'
 }, mongoose => {
   // As of Mongoose 7, custom promise libraries are no longer supported and mongoose.Promise may be undefined
   if (mongoose.Promise && mongoose.Promise !== global.Promise) {

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

@@ -20,7 +20,7 @@ function finish (ctx) {
   finishChannel.publish(ctx)
 }
 
-addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
+addHook({ name: 'oracledb', versions: ['>=5'], file: 'lib/oracledb.js' }, oracledb => {
   shimmer.wrap(oracledb.Connection.prototype, 'execute', execute => {
     return function wrappedExecute (dbQuery, ...args) {
       if (!startChannel.hasSubscribers) {
@@ -40,22 +40,28 @@ addHook({ name: 'oracledb', versions: ['>=5'] }, oracledb => {
         })
       }
 
-      // The connAttrs are used to pass through the argument to the potential
-      // serviceName method a user might have passed through as well as parsing
-      // the connection string in v5.
-      const connAttrs = connectionAttributes.get(this)
-
-      const details = typeof this.hostName === 'string' ? this : this._impl
-
       let hostname
       let port
       let dbInstance
 
-      if (details) {
-        dbInstance = details.serviceName
-        hostname = details.hostName ?? details.nscon?.ntAdapter?.hostName
-        port = String(details.port ?? details.nscon?.ntAdapter?.port ?? '')
-      }
+      try {
+        if (this.thin) {
+          const details = this._impl ?? this
+          // Prefer public getters when available (v6), fallback to nscon in v5.
+          dbInstance = this.serviceName ?? details.serviceName
+          hostname = this.hostName ?? details.nscon?.ntAdapter?.hostName
+          const p = this.port ?? details.nscon?.ntAdapter?.port
+          if (p != null) port = String(p)
+        } else {
+          // Avoid host/port getters in thick mode, as they may throw.
+          dbInstance = this.serviceName
+        }
+      } catch {}
+
+      // The connAttrs are used to pass through the argument to the potential
+      // serviceName method a user might have passed through as well as parsing
+      // the connection string in v5 as well as in thick mode.
+      const connAttrs = connectionAttributes.get(this)
 
       const ctx = {
         dbInstance,

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

@@ -15,17 +15,21 @@ const finishPoolQueryCh = channel('datadog:pg:pool:query:finish')
 
 const { errorMonitor } = require('node:events')
 
-addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
-  shimmer.wrap(pg.Client.prototype, 'query', query => wrapQuery(query))
-  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
-  return pg
+addHook({ name: 'pg', versions: ['>=8.0.3'], file: 'lib/native/client.js' }, Client => {
+  shimmer.wrap(Client.prototype, 'query', query => wrapQuery(query))
+  return Client
 })
 
-addHook({ name: 'pg', file: 'lib/native/index.js', versions: ['>=8.0.3'] }, Client => {
+addHook({ name: 'pg', versions: ['>=8.0.3 <8.15.0', '>=8.15.0 <9'], file: 'lib/client.js' }, Client => {
   shimmer.wrap(Client.prototype, 'query', query => wrapQuery(query))
   return Client
 })
 
+addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
+  shimmer.wrap(pg.Pool.prototype, 'query', query => wrapPoolQuery(query))
+  return pg
+})
+
 function wrapQuery (query) {
   return function () {
     if (!startCh.hasSubscribers) {