dd-trace 5.132.0 → 5.134.0

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

@@ -64,7 +64,7 @@ const {
   getChannelPromise,
   publishWithCompletion,
 } = require('./helpers/channel')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, getHooks, tracingChannel } = require('./helpers/instrument')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
@@ -125,6 +125,7 @@ const jestSessionState = (globalThis[JEST_SESSION_STATE] ||= {})
 
 // https://github.com/jestjs/jest/blob/41f842a46bb2691f828c3a5f27fc1d6290495b82/packages/jest-circus/src/types.ts#L9C8-L9C54
 const RETRY_TIMES = Symbol.for('RETRY_TIMES')
+const RETRY_TIMES_SETTER = Symbol.for('RETRY_TIMES_SETTER')
 
 let skippableSuites = []
 let skippableSuitesCoverage
@@ -195,6 +196,7 @@ const dynamicAtrResultHandlerRegistrations = new WeakMap()
 // Tests that are genuinely new (not in known tests list).
 const newTests = new Set()
 const testSuiteJestObjects = new Map()
+const deferredTestSuiteFinishes = new Map()
 const testSuiteDatadogEnvironments = new Map()
 const wrappedJestGlobals = new WeakSet()
 const wrappedJestEsmLoaders = new WeakSet()
@@ -741,9 +743,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
       }
 
+      this.hasAutomaticRetries = false
       if (this.isFlakyTestRetriesEnabled) {
         const currentNumRetries = this.global[RETRY_TIMES]
         if (!currentNumRetries) {
+          this.hasAutomaticRetries = true
           // When dynamic ATR is enabled, use the max bucket value as the initial count.
           // The actual duration-based count is computed per test after the first attempt.
           if (this.isDynamicAtrEnabled) {
@@ -891,8 +895,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      */
     wrapConcurrentTestFunction (target, methodName, state) {
       let concurrentTest = target?.[methodName]
-      if (typeof concurrentTest !== 'function') return
-      if (this.wrappedConcurrentTestFunctions.has(concurrentTest)) return
+      if (typeof concurrentTest !== 'function' || this.wrappedConcurrentTestFunctions.has(concurrentTest)) return
 
       const originalConcurrentTest = getOriginalConcurrentTest(concurrentTest)
       if (originalConcurrentTest !== concurrentTest) {
@@ -2446,7 +2449,16 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         let isAtrRetry = false
-        if (this.isFlakyTestRetriesEnabled && event.test?.invocations > 1 && !isAttemptToFix && !isEfdRetry) {
+        let hasAutomaticRetries = this.hasAutomaticRetries || dynamicAtrRetryCountByTest.has(event.test)
+        // Describe retries suppress per-test retries throughout the block, including nested describes.
+        for (let block = event.test.parent; block; block = block.parent) {
+          if (state.describeRetryOptions?.has(block)) {
+            hasAutomaticRetries = false
+            break
+          }
+        }
+        if (this.isFlakyTestRetriesEnabled && hasAutomaticRetries &&
+          event.test?.invocations > 1 && !isAttemptToFix && !isEfdRetry) {
           isAtrRetry = true
         }
 
@@ -2653,19 +2665,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
       }
-      const clearActiveTestSuite = () => {
-        realSetTimeout(() => {
-          if (activeTestSuiteAbsolutePath === this.testSuiteAbsolutePath) {
-            activeTestSuiteAbsolutePath = undefined
-          }
-        }, 0)
-      }
-      const result = super.teardown()
-      if (result?.then) {
-        return result.finally(clearActiveTestSuite)
-      }
-      clearActiveTestSuite()
-      return result
+      return super.teardown()
     }
   }
 }
@@ -2675,10 +2675,7 @@ function getTestEnvironment (pkg, jestVersion) {
     const wrappedTestEnvironment = getWrappedEnvironment(pkg.default, jestVersion)
     return new Proxy(pkg, {
       get (target, prop) {
-        if (prop === 'default') {
-          return wrappedTestEnvironment
-        }
-        if (prop === 'TestEnvironment') {
+        if (prop === 'default' || prop === 'TestEnvironment') {
           return wrappedTestEnvironment
         }
         return target[prop]
@@ -3496,22 +3493,48 @@ function shouldWaitForTestSuiteFinish (environment) {
   return isJestWorker && environment.globalConfig?.workerIdleMemoryLimit !== undefined
 }
 
+/**
+ * @param {string} testSuiteAbsolutePath
+ */
+function finishTestSuiteAfterRun (testSuiteAbsolutePath) {
+  const clearActiveTestSuite = () => {
+    realSetTimeout(() => {
+      if (activeTestSuiteAbsolutePath === testSuiteAbsolutePath) {
+        activeTestSuiteAbsolutePath = undefined
+      }
+    }, 0)
+  }
+  const payload = deferredTestSuiteFinishes.get(testSuiteAbsolutePath)
+  deferredTestSuiteFinishes.delete(testSuiteAbsolutePath)
+  if (payload) {
+    return getChannelPromise(testSuiteFinishCh, { ...payload, waitForFinish: true })
+      .finally(clearActiveTestSuite)
+  }
+  return clearActiveTestSuite()
+}
+
+tracingChannel('orchestrion:jest-runner:runTestInternal').end.subscribe((message) => {
+  const ctx = /** @type {{ arguments: [string, ...unknown[]], result: Promise<unknown> }} */ (message)
+  const [testSuiteAbsolutePath] = ctx.arguments
+  // Jest's runner awaits the complete custom teardown before this promise settles.
+  ctx.result = ctx.result.finally(() => finishTestSuiteAfterRun(testSuiteAbsolutePath))
+})
+
+for (const hook of getHooks('jest-runner').values()) addHook(hook, moduleExports => moduleExports)
+
 /**
  * @param {Record<string, unknown>} payload
- * @param {boolean} waitForFinish
+ * @param {InstanceType<ReturnType<typeof getWrappedEnvironment>>} environment
  */
-function publishTestSuiteFinish (payload, waitForFinish) {
+function publishTestSuiteFinish (payload, environment) {
   if (!testSuiteFinishCh.hasSubscribers) return
 
-  if (!waitForFinish) {
-    testSuiteFinishCh.publish(payload)
+  if (shouldWaitForTestSuiteFinish(environment)) {
+    deferredTestSuiteFinishes.set(environment.testSuiteAbsolutePath, payload)
     return
   }
 
-  return getChannelPromise(testSuiteFinishCh, {
-    ...payload,
-    waitForFinish,
-  })
+  testSuiteFinishCh.publish(payload)
 }
 
 function cleanupTestSuiteState (testSuiteAbsolutePath) {
@@ -3688,48 +3711,24 @@ function jestAdapterWrapper (jestAdapter, jestVersion, isIitm, hookMeta) {
           testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
         })
       }
-      const waitForFinish = shouldWaitForTestSuiteFinish(environment)
       const finishPayload = {
         status,
         errorMessage,
         testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
       }
-      if (waitForFinish) {
-        const finishPromise = publishTestSuiteFinish(finishPayload, waitForFinish)
-        if (finishPromise) {
-          return finishPromise.then(() => {
-            // Cleanup per-suite state to avoid memory leaks
-            cleanupTestSuiteState(environment.testSuiteAbsolutePath)
-
-            return suiteResults
-          })
-        }
-      }
-      publishTestSuiteFinish(finishPayload, waitForFinish)
+      publishTestSuiteFinish(finishPayload, environment)
 
       // Cleanup per-suite state to avoid memory leaks
       cleanupTestSuiteState(environment.testSuiteAbsolutePath)
 
       return suiteResults
     }).catch(error => {
-      const waitForFinish = shouldWaitForTestSuiteFinish(environment)
       const finishPayload = {
         status: 'fail',
         error,
         testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
       }
-      if (waitForFinish) {
-        const finishPromise = publishTestSuiteFinish(finishPayload, waitForFinish)
-        if (finishPromise) {
-          return finishPromise.then(() => {
-            // Cleanup per-suite state to avoid memory leaks
-            cleanupTestSuiteState(environment.testSuiteAbsolutePath)
-
-            throw error
-          })
-        }
-      }
-      publishTestSuiteFinish(finishPayload, waitForFinish)
+      publishTestSuiteFinish(finishPayload, environment)
 
       // Cleanup per-suite state to avoid memory leaks
       cleanupTestSuiteState(environment.testSuiteAbsolutePath)
@@ -3982,12 +3981,11 @@ const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'selenium-webdriver/chromium',
 ])
 
-function recordMockedFile (suiteFilePath, moduleName) {
+function recordMockedFile (suiteFilePath, moduleName, from = suiteFilePath) {
   if (!suiteFilePath || typeof moduleName !== 'string') return
 
   const existingMockedFiles = testSuiteMockedFiles.get(suiteFilePath) || []
-  const suiteDir = path.dirname(suiteFilePath)
-  const mockPath = path.resolve(suiteDir, moduleName)
+  const mockPath = path.resolve(path.dirname(from), moduleName)
   existingMockedFiles.push(mockPath)
   testSuiteMockedFiles.set(suiteFilePath, existingMockedFiles)
 }
@@ -4022,14 +4020,24 @@ function getMockedFiles (suiteFilePath) {
   return staticMockedFiles
 }
 
-function wrapJestObject (jestObject, suiteFilePath) {
+function wrapJestObject (jestObject, suiteFilePath, from = suiteFilePath) {
   if (!jestObject || !suiteFilePath || wrappedJestObjects.has(jestObject)) return
 
   testSuiteJestObjects.set(suiteFilePath, jestObject)
   wrappedJestObjects.add(jestObject)
 
+  // retryTimes is created per runtime, so wrap the returned public API object.
+  shimmer.wrap(jestObject, 'retryTimes', retryTimes => function () {
+    const environment = testSuiteDatadogEnvironments.get(suiteFilePath)
+    // Older Jest versions ignore entireDescribe and still replace the global budget.
+    if (environment && !(arguments[1]?.entireDescribe && environment.global[RETRY_TIMES_SETTER])) {
+      environment.hasAutomaticRetries = false
+    }
+    return retryTimes.apply(this, arguments)
+  })
+
   shimmer.wrap(jestObject, 'mock', mock => function (moduleName) {
-    recordMockedFile(suiteFilePath, moduleName)
+    recordMockedFile(suiteFilePath, moduleName, from)
     return mock.apply(this, arguments)
   })
 }
@@ -4043,7 +4051,7 @@ function wrapJestGlobalsForRuntime (runtime) {
   wrappedJestGlobals.add(jestGlobals)
   shimmer.wrap(jestGlobals, 'jestObjectFor', jestObjectFor => function (from) {
     const jestObject = jestObjectFor.apply(this, arguments)
-    wrapJestObject(jestObject, from)
+    wrapJestObject(jestObject, runtime._testPath || from, from)
     return jestObject
   })
 }
@@ -4338,9 +4346,9 @@ addHook({
   if (typeof Runtime.prototype._createJestObjectFor === 'function') {
     shimmer.wrap(Runtime.prototype, '_createJestObjectFor', _createJestObjectFor => function (from) {
       const result = _createJestObjectFor.apply(this, arguments)
-      const suiteFilePath = this._testPath || from
+      const suiteFilePath = this._testPath || this._environment?.testSuiteAbsolutePath || from
 
-      wrapJestObject(result, suiteFilePath)
+      wrapJestObject(result, suiteFilePath, from)
       return result
     })
   }
@@ -4495,10 +4503,7 @@ function sendWrapper (send) {
       // 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) {
-        return send.apply(this, arguments)
-      }
-      if (!args[0]?.config) {
+      if (args.length > 1 || !args[0]?.config) {
         return send.apply(this, arguments)
       }
       const [{ globalConfig, config, path: testSuiteAbsolutePath }] = args

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

@@ -62,13 +62,13 @@ addHook({
       const rawResult = raw.apply(this, args)
       shimmer.wrap(rawResult, 'then', originalThen => function (...args) {
         return rawQuerySubscribes.runStores(context, () => {
-          args[0] = wrapCallbackWithFinish(args[0], finish, context)
-          if (args[1]) args[1] = wrapCallbackWithFinish(args[1], finish, context)
+          args[0] = wrapCallbackWithFinish(args[0], context)
+          if (args[1]) args[1] = wrapCallbackWithFinish(args[1], context)
 
           const originalThenResult = originalThen.apply(this, args)
 
           shimmer.wrap(originalThenResult, 'catch', originalCatch => function (...args) {
-            args[0] = wrapCallbackWithFinish(args[0], finish, context)
+            args[0] = wrapCallbackWithFinish(args[0], context)
             return originalCatch.apply(this, args)
           })
 
@@ -78,7 +78,7 @@ addHook({
 
       shimmer.wrap(rawResult, 'asCallback', originalAsCallback => function (...args) {
         return rawQuerySubscribes.runStores(context, () => {
-          args[0] = wrapCallbackWithFinish(args[0], finish, context)
+          args[0] = wrapCallbackWithFinish(args[0], context)
           return originalAsCallback.apply(this, args)
         })
       })
@@ -118,7 +118,11 @@ addHook({
   return Transaction
 })
 
-function wrapCallbackWithFinish (callback, finish, context) {
+/**
+ * @param {unknown} callback
+ * @param {object} context
+ */
+function wrapCallbackWithFinish (callback, context) {
   if (typeof callback !== 'function') return callback
 
   return shimmer.wrapFunction(callback, callback => function (...args) {

package/packages/datadog-instrumentations/src/mariadb-bundle.js

@@ -1055,9 +1055,9 @@ function createWrapCallbackGetConnection (options) {
   return function wrapGetConnection (getConnection) {
     return function () {
       const callback = arguments[arguments.length - 1]
-      if (typeof callback !== 'function') return getConnection.apply(this, arguments)
-
-      if (!connectionStartCh.hasSubscribers) return getConnection.apply(this, arguments)
+      if (typeof callback !== 'function' || !connectionStartCh.hasSubscribers) {
+        return getConnection.apply(this, arguments)
+      }
 
       if (!acquireStartCh.hasSubscribers) {
         const ctx = {}

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

@@ -11,33 +11,45 @@ const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
 const parameterizedTestCh = channel('ci:mocha:test:parameterize')
 const patched = new WeakSet()
 
+/** @typedef {{ moduleBaseDir?: string }} MochaHookMeta */
+
 /**
  * Registers every Mocha package view that can expose the constructor.
  *
  * @param {string[]} versions
- * @param {(Mocha: Function, frameworkVersion: string) => Function} wrapMochaRun
+ * @param {(Mocha: Function, frameworkVersion: string, hookMeta: MochaHookMeta) => Function} wrapMochaRun
  */
 function addMochaRunHooks (versions, wrapMochaRun) {
-  const patchedMochaConstructors = new WeakSet()
+  const patchedMochaConstructors = new WeakMap()
 
   /**
    * @param {Function} Mocha
    * @param {string} frameworkVersion
+   * @param {boolean | undefined} isIitm
+   * @param {{ moduleBaseDir: string } | undefined} hookMeta
    * @returns {Function}
    */
-  function wrapMochaOnce (Mocha, frameworkVersion) {
-    if (patchedMochaConstructors.has(Mocha)) return Mocha
-    patchedMochaConstructors.add(Mocha)
-    return wrapMochaRun(Mocha, frameworkVersion)
+  function wrapMochaOnce (Mocha, frameworkVersion, isIitm, hookMeta) {
+    let metadata = patchedMochaConstructors.get(Mocha)
+    if (metadata) {
+      // A bundler can expose the constructor before an ordinary loader supplies its package directory.
+      metadata.moduleBaseDir ??= hookMeta?.moduleBaseDir
+      return Mocha
+    }
+    metadata = { moduleBaseDir: hookMeta?.moduleBaseDir }
+    patchedMochaConstructors.set(Mocha, metadata)
+    return wrapMochaRun(Mocha, frameworkVersion, metadata)
   }
 
   /**
    * @param {object|Function} MochaPackage
    * @param {string} frameworkVersion
+   * @param {boolean | undefined} isIitm
+   * @param {{ moduleBaseDir: string } | undefined} hookMeta
    * @returns {object|Function}
    */
-  function wrapMochaPackage (MochaPackage, frameworkVersion) {
-    wrapMochaOnce(MochaPackage.default ?? MochaPackage, frameworkVersion)
+  function wrapMochaPackage (MochaPackage, frameworkVersion, isIitm, hookMeta) {
+    wrapMochaOnce(MochaPackage.default ?? MochaPackage, frameworkVersion, isIitm, hookMeta)
     return MochaPackage
   }