dd-trace 5.101.0 → 5.103.0

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

@@ -18,8 +18,8 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
 
     const client = this
 
-    const wrappedQueryCompiler = function () {
-      const query = queryCompiler.apply(this, arguments)
+    const wrappedQueryCompiler = function (...args) {
+      const query = queryCompiler.apply(this, args)
 
       const ctx = { client, server, query }
       startCh.runStores(ctx, () => {

package/packages/datadog-instrumentations/src/microgateway-core.js

@@ -14,8 +14,8 @@ const versions = ['>=2.1 <=3.0.0']
 const requestContexts = new WeakMap()
 
 function wrapConfigProxyFactory (configProxyFactory) {
-  return function () {
-    const configProxy = configProxyFactory.apply(this, arguments)
+  return function (...args) {
+    const configProxy = configProxyFactory.apply(this, args)
 
     return function (req, res, next) {
       const ctx = { req, res }

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

@@ -20,9 +20,9 @@ addHook({
 
   patched.add(mochaEach)
 
-  return shimmer.wrapFunction(mochaEach, mochaEach => function () {
-    const [params] = arguments
-    const { it, ...rest } = mochaEach.apply(this, arguments)
+  return shimmer.wrapFunction(mochaEach, mochaEach => function (...args) {
+    const [params] = args
+    const { it, ...rest } = mochaEach.apply(this, args)
     return {
       it: function (title) {
         parameterizedTestCh.publish({ title, params })

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

@@ -326,6 +326,7 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     }
     config.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
     config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+    config.earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -369,17 +370,17 @@ addHook({
 }, (Mocha, frameworkVersion) => {
   warnDeprecatedMochaVersion(frameworkVersion)
 
-  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+  shimmer.wrap(Mocha.prototype, 'run', run => function (...args) {
     // Workers do not need to request any data, just run the tests
     if (!testFinishCh.hasSubscribers || getEnvironmentVariable('MOCHA_WORKER_ID') || this.options.parallel) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
 
     // `options.delay` does not work in parallel mode, so we can't delay the execution this way
     // This needs to be both here and in `runMocha` hook. Read the comment in `runMocha` hook for more info.
     this.options.delay = true
 
-    const runner = run.apply(this, arguments)
+    const runner = run.apply(this, args)
 
     // eslint-disable-next-line unicorn/no-array-for-each
     this.files.forEach((path) => {
@@ -426,11 +427,11 @@ addHook({
   file: 'lib/cli/run-helpers.js',
 }, (run) => {
   // `runMocha` is an async function
-  shimmer.wrap(run, 'runMocha', runMocha => function () {
+  shimmer.wrap(run, 'runMocha', runMocha => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return runMocha.apply(this, arguments)
+      return runMocha.apply(this, args)
     }
-    const mocha = arguments[0]
+    const mocha = args[0]
 
     /**
      * This attaches `run` to the global context, which we'll call after
@@ -444,7 +445,7 @@ addHook({
       mocha.options.delay = true
     }
 
-    return runMocha.apply(this, arguments)
+    return runMocha.apply(this, args)
   })
   return run
 })
@@ -462,12 +463,16 @@ addHook({
 
   shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
 
-  shimmer.wrap(Runner.prototype, 'run', run => function () {
+  shimmer.wrap(Runner.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
 
     const { suitesByTestFile, numSuitesByTestFile } = getSuitesByTestFile(this.suite)
+    // Root-level tests (direct children of root, no describe wrapper) keyed by file.
+    // Populated during the root 'suite' event so the normal finish path can include them
+    // in mixed-file status calculation.
+    const rootTestsByFile = new Map()
 
     this.once('start', getOnStartHandler(frameworkVersion))
 
@@ -488,6 +493,30 @@ addHook({
 
     this.on('suite', function (suite) {
       if (suite.root || !suite.tests.length) {
+        // This branch can be triggered when we have top level it(...) inside test files.
+        // In that case, they all (even if they are from different files) are going to be
+        // children of the root suite.
+        // Note: We could have suites that contain top level it(...) and also it(...) nested
+        // inside describe(...) ("mixed case"). Duplication is avoided by the context guard
+        // below. Since 'suite' fires for root first, in the mixed case the ctx is created
+        // here and the describe-based handler finds it already set.
+        if (suite.root && suite.tests.length > 0) {
+          const files = new Set(suite.tests.map(test => test.file).filter(Boolean))
+          for (const file of files) {
+            rootTestsByFile.set(file, suite.tests.filter(t => t.file === file))
+            if (testFileToSuiteCtx.get(file)) continue
+            const isUnskippable = unskippableSuites.includes(file)
+            isForcedToRun = isUnskippable && suitesToSkip.includes(getTestSuitePath(file, process.cwd()))
+            const ctx = {
+              testSuiteAbsolutePath: file,
+              isUnskippable,
+              isForcedToRun,
+              itrCorrelationId,
+            }
+            testFileToSuiteCtx.set(file, ctx)
+            testSuiteStartCh.runStores(ctx, () => {})
+          }
+        }
         return
       }
       let ctx = testFileToSuiteCtx.get(suite.file)
@@ -507,6 +536,44 @@ addHook({
 
     this.on('suite end', function (suite) {
       if (suite.root) {
+        // Symmetric to the suite start fix
+        const fileToTests = new Map()
+        for (const test of suite.tests) {
+          if (!test.file) continue
+          if (!fileToTests.has(test.file)) fileToTests.set(test.file, [])
+          fileToTests.get(test.file).push(test)
+        }
+        for (const [file, tests] of fileToTests) {
+          // Mixed case: if a file appears in suitesByTestFile (pre-populated before the run),
+          // its numSuitesByTestFile counter hits zero when its last describe-based suite ends
+          // and the normal path below fires testSuiteFinishCh. Since root is last when
+          // 'suite end' fires, any such file has already been handled — skipping it here
+          // avoids duplication.
+          if (suitesByTestFile[file]) continue
+          let status = 'pass'
+          if (tests.every(test => test.isPending())) {
+            status = 'skip'
+          } else {
+            for (const test of tests) {
+              if (test.state === 'failed' || test.timedOut) {
+                status = 'fail'
+                break
+              }
+            }
+          }
+          if (global.__coverage__) {
+            const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+            testSuiteCodeCoverageCh.publish({ coverageFiles, suiteFile: file })
+            mergeCoverage(global.__coverage__, originalCoverageMap)
+            resetCoverage(global.__coverage__)
+          }
+          const ctx = testFileToSuiteCtx.get(file)
+          if (ctx) {
+            testSuiteFinishCh.publish({ status, ...ctx.currentStore }, () => {})
+          } else {
+            log.warn('No ctx found for suite', file)
+          }
+        }
         return
       }
       const suitesInTestFile = suitesByTestFile[suite.file]
@@ -516,8 +583,9 @@ addHook({
         return
       }
 
+      const rootTests = rootTestsByFile.get(suite.file) || []
       let status = 'pass'
-      if (suitesInTestFile.every(suite => suite.pending)) {
+      if (suitesInTestFile.every(suite => suite.pending) && rootTests.every(test => test.isPending())) {
         status = 'skip'
       } else {
         // has to check every test in the test file
@@ -529,6 +597,11 @@ addHook({
             }
           })
         })
+        for (const test of rootTests) {
+          if (test.state === 'failed' || test.timedOut) {
+            status = 'fail'
+          }
+        }
       }
 
       if (global.__coverage__) {
@@ -552,7 +625,7 @@ addHook({
       }
     })
 
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
 
   return Runner
@@ -722,6 +795,7 @@ addHook({
       if (config.knownTests?.mocha) {
         const testSuiteKnownTests = config.knownTests.mocha[testPath] || []
         newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
+        newWorkerArgs._ddEfdSlowTestRetries = config.earlyFlakeDetectionSlowTestRetries
         newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
         newWorkerArgs._ddIsKnownTestsEnabled = true
         newWorkerArgs._ddKnownTests = {

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

@@ -1,11 +1,15 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 // Capture real timers at module load time, before any test can install fake timers.
 const realSetTimeout = setTimeout
 
 const {
   getTestSuitePath,
   DYNAMIC_NAME_RE,
+  getEfdRetryCount,
+  getMaxEfdRetryCount,
   recordAttemptToFixExecution,
   logAttemptToFixTestExecution,
 } = require('../../../dd-trace/src/plugins/util/test')
@@ -35,6 +39,8 @@ const newTestsWithDynamicNames = new Set()
 const testsAttemptToFix = new Set()
 const testsQuarantined = new Set()
 const testsStatuses = new Map()
+const efdRetryCountByTestFullName = new Map()
+const efdSlowAbortedTests = new Set()
 const attemptToFixExecutions = new Map()
 const loggedAttemptToFixTests = new Set()
 
@@ -70,11 +76,82 @@ function isNewTest (test, knownTests) {
   return !testsForSuite.includes(testName)
 }
 
-function retryTest (test, numRetries, tags) {
+function setEfdRetryCountForTest (test, duration, slowTestRetries) {
+  const testName = getTestFullName(test)
+  if (efdRetryCountByTestFullName.has(testName)) {
+    return
+  }
+  const retryCount = getEfdRetryCount(duration, slowTestRetries || {})
+  efdRetryCountByTestFullName.set(testName, retryCount)
+  if (retryCount === 0) {
+    efdSlowAbortedTests.add(testName)
+  }
+}
+
+function wrapOriginalEfdTest (test, slowTestRetries) {
+  if (test._ddEfdDurationWrapped || typeof test.fn !== 'function') {
+    return
+  }
+  test._ddEfdDurationWrapped = true
+  const originalFn = test.fn
+  test.fn = shimmer.wrapFunction(originalFn, originalFn => function () {
+    const start = performance.now()
+    const recordDuration = () => {
+      setEfdRetryCountForTest(test, performance.now() - start, slowTestRetries)
+    }
+
+    if (originalFn.length > 0) {
+      const args = Array.prototype.slice.call(arguments)
+      args[0] = shimmer.wrapFunction(args[0], done => function (...args) {
+        recordDuration()
+        return done.apply(this, args)
+      })
+      return originalFn.apply(this, args)
+    }
+
+    try {
+      const result = originalFn.apply(this, arguments)
+      if (result?.then) {
+        return result.then(value => {
+          recordDuration()
+          return value
+        }, error => {
+          recordDuration()
+          throw error
+        })
+      }
+      recordDuration()
+      return result
+    } catch (error) {
+      recordDuration()
+      throw error
+    }
+  })
+}
+
+function retryTest (test, numRetries, tags, slowTestRetries) {
   const suite = test.parent
+  const isEfdRetry = tags.includes('_ddIsEfdRetry')
+  if (isEfdRetry) {
+    wrapOriginalEfdTest(test, slowTestRetries)
+  }
   for (let retryIndex = 0; retryIndex < numRetries; retryIndex++) {
     const clonedTest = test.clone()
     suite.addTest(clonedTest)
+    if (isEfdRetry) {
+      clonedTest._ddEfdRetryIndex = retryIndex + 1
+      const originalFn = clonedTest.fn
+      if (typeof originalFn === 'function') {
+        clonedTest.fn = shimmer.wrapFunction(originalFn, originalFn => function (...args) {
+          const efdRetryCount = efdRetryCountByTestFullName.get(getTestFullName(clonedTest))
+          if (efdRetryCount !== undefined && clonedTest._ddEfdRetryIndex > efdRetryCount) {
+            clonedTest._ddShouldSkipEfdRetry = true
+            this.skip()
+          }
+          return originalFn.apply(this, args)
+        })
+      }
+    }
     for (const tag of tags) {
       if (tag) {
         clonedTest[tag] = true
@@ -83,6 +160,14 @@ function retryTest (test, numRetries, tags) {
   }
 }
 
+function getConfiguredEfdRetryCount (config) {
+  const { earlyFlakeDetectionSlowTestRetries } = config
+  if (!earlyFlakeDetectionSlowTestRetries || !Object.keys(earlyFlakeDetectionSlowTestRetries).length) {
+    return config.earlyFlakeDetectionNumRetries
+  }
+  return getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
+}
+
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
   function getSuites (suite) {
@@ -137,8 +222,7 @@ function getTestToContextKey (test) {
   if (!wrappedFunctions.has(test.fn)) {
     return test.fn
   }
-  const originalFn = originalFns.get(test.fn)
-  return originalFn
+  return originalFns.get(test.fn)
 }
 
 function getTestContext (test) {
@@ -147,9 +231,9 @@ function getTestContext (test) {
 }
 
 function runnableWrapper (RunnablePackage, libraryConfig) {
-  shimmer.wrap(RunnablePackage.prototype, 'run', run => function () {
+  shimmer.wrap(RunnablePackage.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
     if (libraryConfig?.isFlakyTestRetriesEnabled) {
       this.retries(libraryConfig?.flakyTestRetriesCount)
@@ -175,8 +259,8 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
 
       if (ctx) {
         // we bind the test fn to the correct context
-        const newFn = shimmer.wrapFunction(this.fn, originalFn => function () {
-          return testFnCh.runStores(ctx, () => originalFn.apply(this, arguments))
+        const newFn = shimmer.wrapFunction(this.fn, originalFn => function (...args) {
+          return testFnCh.runStores(ctx, () => originalFn.apply(this, args))
         })
 
         // we store the original function, not to lose it
@@ -187,7 +271,7 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
       }
     }
 
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
   return RunnablePackage
 }
@@ -215,6 +299,17 @@ function getOnTestHandler (isMain) {
       _ddIsModified: isModified,
     } = test
 
+    test._ddStartTime = performance.now()
+
+    if (isEfdRetry) {
+      const efdRetryCount = efdRetryCountByTestFullName.get(getTestFullName(test))
+      if (efdRetryCount !== undefined && test._ddEfdRetryIndex > efdRetryCount) {
+        test.pending = true
+        test._ddShouldSkipEfdRetry = true
+        return
+      }
+    }
+
     const testInfo = {
       testName: test.fullTitle(),
       testSuiteAbsolutePath,
@@ -273,6 +368,7 @@ function getFinalStatus ({
   isAttemptToFix,
   isLastAttemptToFix,
   attemptToFixPassed,
+  hasPassedAnyEfdAttempt,
   isQuarantined,
   isDisabled,
 }) {
@@ -301,7 +397,7 @@ function getFinalStatus ({
     return hasFailedAllRetries ? 'fail' : 'pass'
   }
   if (isEfdRetry && isLastEfdRetry) {
-    return hasFailedAllRetries ? 'fail' : 'pass'
+    return hasPassedAnyEfdAttempt ? 'pass' : 'fail'
   }
   if (isAttemptToFix && isLastAttemptToFix) {
     return attemptToFixPassed ? 'pass' : 'fail'
@@ -314,6 +410,15 @@ function getTestFinishInfo (test, status, config, error) {
   let attemptToFixFailed = false
 
   const testName = getTestFullName(test)
+  if (
+    config.isEarlyFlakeDetectionEnabled &&
+    (test._ddIsNew || test._ddIsModified) &&
+    !test._ddIsEfdRetry &&
+    !efdRetryCountByTestFullName.has(testName)
+  ) {
+    const duration = test.duration > 0 ? test.duration : performance.now() - test._ddStartTime
+    setEfdRetryCountForTest(test, duration, config.earlyFlakeDetectionSlowTestRetries)
+  }
 
   if (testsStatuses.get(testName)) {
     testsStatuses.get(testName).push(status)
@@ -323,12 +428,14 @@ function getTestFinishInfo (test, status, config, error) {
   const testStatuses = testsStatuses.get(testName)
 
   const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
-  const isLastEfdRetry = testStatuses.length === config.earlyFlakeDetectionNumRetries + 1
+  const efdRetryCount = efdRetryCountByTestFullName.get(testName) ?? getConfiguredEfdRetryCount(config)
+  const isLastEfdRetry = testStatuses.length === efdRetryCount + 1
   const isLastAtrAttempt = getIsLastRetry(test) || (config.isFlakyTestRetriesEnabled && status === 'pass')
 
   // Needed for the getFinalStatus call. This is because EFD does NOT tag as
   // EFD retry the first run of the test. It only tags as retries the clones
-  const isEfdRetry = test._ddIsEfdRetry || (test._ddIsNew && config.isEarlyFlakeDetectionEnabled)
+  const isEfdRetry =
+    test._ddIsEfdRetry || ((test._ddIsNew || test._ddIsModified) && config.isEarlyFlakeDetectionEnabled)
 
   if (test._ddIsAttemptToFix && isLastAttempt) {
     if (testStatuses.includes('fail')) {
@@ -341,7 +448,7 @@ function getTestFinishInfo (test, status, config, error) {
     }
   }
 
-  if (test._ddIsEfdRetry && isLastEfdRetry &&
+  if (test._ddIsEfdRetry && efdRetryCount > 0 && isLastEfdRetry &&
     testStatuses.every(status => status === 'fail')) {
     hasFailedAllRetries = true
   }
@@ -370,6 +477,7 @@ function getTestFinishInfo (test, status, config, error) {
     isAttemptToFix: _ddIsAttemptToFix,
     isLastAttemptToFix: isLastAttempt,
     attemptToFixPassed,
+    hasPassedAnyEfdAttempt: testStatuses.includes('pass'),
     isQuarantined: _ddIsQuarantined,
     isDisabled: _ddIsDisabled,
   })
@@ -391,11 +499,15 @@ function getTestFinishInfo (test, status, config, error) {
     isAttemptToFixRetry,
     isAtrRetry,
     finalStatus,
+    earlyFlakeAbortReason: efdSlowAbortedTests.has(testName) ? 'slow' : undefined,
   }
 }
 
 function getOnTestEndHandler (config) {
   return async function (test) {
+    if (test._ddShouldSkipEfdRetry) {
+      return
+    }
     const ctx = getTestContext(test)
     const status = getTestStatus(test)
 
@@ -518,6 +630,9 @@ function getOnTestRetryHandler (config) {
 
 function getOnPendingHandler () {
   return function (test) {
+    if (test._ddShouldSkipEfdRetry) {
+      return
+    }
     const testStartLine = testToStartLine.get(test)
     const {
       file: testSuiteAbsolutePath,
@@ -587,8 +702,9 @@ function getRunTestsWrapper (runTests, config) {
               if (!test.isPending() && !test._ddIsAttemptToFix && config.isEarlyFlakeDetectionEnabled) {
                 retryTest(
                   test,
-                  config.earlyFlakeDetectionNumRetries,
-                  ['_ddIsModified', '_ddIsEfdRetry']
+                  getConfiguredEfdRetryCount(config),
+                  ['_ddIsModified', '_ddIsEfdRetry'],
+                  config.earlyFlakeDetectionSlowTestRetries
                 )
               }
             }
@@ -606,8 +722,9 @@ function getRunTestsWrapper (runTests, config) {
           if (config.isEarlyFlakeDetectionEnabled && !test._ddIsAttemptToFix && !test._ddIsModified) {
             retryTest(
               test,
-              config.earlyFlakeDetectionNumRetries,
-              ['_ddIsNew', '_ddIsEfdRetry']
+              getConfiguredEfdRetryCount(config),
+              ['_ddIsNew', '_ddIsEfdRetry'],
+              config.earlyFlakeDetectionSlowTestRetries
             )
           }
         }

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

@@ -27,15 +27,17 @@ addHook({
   versions: ['>=8.0.0'],
   file: 'lib/mocha.js',
 }, (Mocha) => {
-  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+  shimmer.wrap(Mocha.prototype, 'run', run => function (...args) {
     if (this.options._ddIsKnownTestsEnabled) {
       config.isKnownTestsEnabled = true
       config.isEarlyFlakeDetectionEnabled = this.options._ddIsEfdEnabled
       config.knownTests = this.options._ddKnownTests
       config.earlyFlakeDetectionNumRetries = this.options._ddEfdNumRetries
+      config.earlyFlakeDetectionSlowTestRetries = this.options._ddEfdSlowTestRetries ?? {}
       delete this.options._ddIsEfdEnabled
       delete this.options._ddKnownTests
       delete this.options._ddEfdNumRetries
+      delete this.options._ddEfdSlowTestRetries
       delete this.options._ddIsKnownTestsEnabled
     }
     if (this.options._ddIsImpactedTestsEnabled) {
@@ -58,7 +60,7 @@ addHook({
       delete this.options._ddIsFlakyTestRetriesEnabled
       delete this.options._ddFlakyTestRetriesCount
     }
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
 
   return Mocha
@@ -72,9 +74,9 @@ addHook({
 }, function (Runner) {
   shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
 
-  shimmer.wrap(Runner.prototype, 'run', run => function () {
+  shimmer.wrap(Runner.prototype, 'run', run => function (...args) {
     if (!workerFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
     // We flush when the worker ends with its test file (a mocha instance in a worker runs a single test file)
     this.once('end', () => {
@@ -93,7 +95,7 @@ addHook({
 
     this.on('pending', getOnPendingHandler())
 
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
   return Runner
 })