dd-trace 5.99.0 → 5.100.0

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

@@ -14,8 +14,8 @@ const {
   mergeCoverage,
   resetCoverage,
   getIsFaultyEarlyFlakeDetection,
-  collectDynamicNamesFromTraces,
-  logDynamicNamesWarning,
+  collectTestOptimizationSummariesFromTraces,
+  logTestOptimizationSummary,
 } = require('../../../dd-trace/src/plugins/util/test')
 
 const {
@@ -34,9 +34,9 @@ const {
   testsQuarantined,
   getTestFullName,
   getRunTestsWrapper,
-  testsAttemptToFix,
-  testsStatuses,
   newTestsWithDynamicNames,
+  attemptToFixExecutions,
+  loggedAttemptToFixTests,
 } = require('./utils')
 
 require('./common')
@@ -146,26 +146,17 @@ function getOnEndHandler (isParallel) {
       }
     }
 
-    // We substract the errors of attempt to fix tests (quarantined or disabled) from the total number of failures
-    // We subtract the errors from quarantined tests from the total number of failures
+    // We subtract the errors from quarantined tests from the total number of failures.
+    // Attempt-to-fix tests ignore quarantine/disabled suppression and keep their framework result.
     if (config.isTestManagementTestsEnabled) {
       let numFailedQuarantinedTests = 0
-      let numFailedRetriedQuarantinedOrDisabledTests = 0
-      for (const test of testsAttemptToFix) {
-        const testName = getTestFullName(test)
-        const testProperties = getTestProperties(test, config.testManagementTests)
-        if (isTestFailed(test) && (testProperties.isQuarantined || testProperties.isDisabled)) {
-          const numFailedTests = testsStatuses.get(testName).filter(status => status === 'fail').length
-          numFailedRetriedQuarantinedOrDisabledTests += numFailedTests
-        }
-      }
       for (const test of testsQuarantined) {
         if (isTestFailed(test)) {
           numFailedQuarantinedTests++
         }
       }
-      this.stats.failures -= numFailedQuarantinedTests + numFailedRetriedQuarantinedOrDisabledTests
-      this.failures -= numFailedQuarantinedTests + numFailedRetriedQuarantinedOrDisabledTests
+      this.stats.failures -= numFailedQuarantinedTests
+      this.failures -= numFailedQuarantinedTests
     }
 
     // Recompute status after EFD and quarantine adjustments have reduced failure counts
@@ -211,7 +202,8 @@ function getOnEndHandler (isParallel) {
       isParallel,
     })
 
-    logDynamicNamesWarning(newTestsWithDynamicNames)
+    logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
+    loggedAttemptToFixTests.clear()
   }
 }
 
@@ -467,9 +459,9 @@ addHook({
     this.on('retry', getOnTestRetryHandler(config))
 
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
-    this.on('hook end', getOnHookEndHandler())
+    this.on('hook end', getOnHookEndHandler(config))
 
-    this.on('fail', getOnFailHandler(true))
+    this.on('fail', getOnFailHandler(true, config))
 
     this.on('pending', getOnPendingHandler())
 
@@ -557,7 +549,10 @@ function onMessage (message) {
   if (Array.isArray(message)) {
     const [messageCode, payload] = message
     if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
-      collectDynamicNamesFromTraces(payload, newTestsWithDynamicNames)
+      collectTestOptimizationSummariesFromTraces(payload, {
+        newTestsWithDynamicNames,
+        attemptToFixExecutions,
+      })
       workerReportTraceCh.publish(payload)
     }
   }
@@ -771,7 +766,8 @@ addHook({
         }
       }
       // `testsQuarantined` is filled in the worker process, so we need to use the test results to fill it here too.
-      if (config.isTestManagementTestsEnabled && getTestProperties(test, config.testManagementTests).isQuarantined) {
+      const testProperties = getTestProperties(test, config.testManagementTests)
+      if (config.isTestManagementTestsEnabled && testProperties.isQuarantined && !testProperties.isAttemptToFix) {
         testsQuarantined.add(test)
       }
     }

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

@@ -3,7 +3,12 @@
 // 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 {
+  getTestSuitePath,
+  DYNAMIC_NAME_RE,
+  recordAttemptToFixExecution,
+  logAttemptToFixTestExecution,
+} = require('../../../dd-trace/src/plugins/util/test')
 const { channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 
@@ -30,6 +35,8 @@ const newTestsWithDynamicNames = new Set()
 const testsAttemptToFix = new Set()
 const testsQuarantined = new Set()
 const testsStatuses = new Map()
+const attemptToFixExecutions = new Map()
+const loggedAttemptToFixTests = new Set()
 
 function getAfterEachHooks (testOrHook) {
   const hooks = []
@@ -229,6 +236,13 @@ function getOnTestHandler (isMain) {
     if (testInfo.hasDynamicName) {
       newTestsWithDynamicNames.add(`${getTestSuitePath(test.file, process.cwd())} › ${test.fullTitle()}`)
     }
+    if (isAttemptToFix) {
+      logAttemptToFixTestExecution(
+        getTestSuitePath(test.file, process.cwd()),
+        test.fullTitle(),
+        loggedAttemptToFixTests
+      )
+    }
     // We want to store the result of the new tests
     if (isNew) {
       const testFullName = getTestFullName(test)
@@ -272,9 +286,8 @@ function getFinalStatus ({
     return
   }
 
-  // If the test is quarantined or disabled, regardless of its actual execution result or active retry features,
-  // the final status of its last execution should be reported as 'skip'.
-  if (isQuarantined || isDisabled) {
+  // If the test is quarantined or disabled, its final status is skip unless attempt-to-fix takes precedence.
+  if (!isAttemptToFix && (isQuarantined || isDisabled)) {
     return 'skip'
   }
 
@@ -295,116 +308,126 @@ function getFinalStatus ({
   }
 }
 
-function getOnTestEndHandler (config) {
-  return async function (test) {
-    const ctx = getTestContext(test)
-    const status = getTestStatus(test)
+function getTestFinishInfo (test, status, config, error) {
+  let hasFailedAllRetries = false
+  let attemptToFixPassed = false
+  let attemptToFixFailed = false
 
-    // After finishing it might take a bit for the snapshot to be handled.
-    // 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) => {
-        realSetTimeout(() => {
-          resolve()
-        }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
-      })
-    }
-
-    let hasFailedAllRetries = false
-    let attemptToFixPassed = false
-    let attemptToFixFailed = false
-
-    const testName = getTestFullName(test)
+  const testName = getTestFullName(test)
 
-    if (testsStatuses.get(testName)) {
-      testsStatuses.get(testName).push(status)
-    } else {
-      testsStatuses.set(testName, [status])
-    }
-    const testStatuses = testsStatuses.get(testName)
+  if (testsStatuses.get(testName)) {
+    testsStatuses.get(testName).push(status)
+  } else {
+    testsStatuses.set(testName, [status])
+  }
+  const testStatuses = testsStatuses.get(testName)
 
-    const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
-    const isLastEfdRetry = testStatuses.length === config.earlyFlakeDetectionNumRetries + 1
-    const isLastAtrAttempt = getIsLastRetry(test) || (config.isFlakyTestRetriesEnabled && status === 'pass')
+  const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
+  const isLastEfdRetry = testStatuses.length === config.earlyFlakeDetectionNumRetries + 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)
+  // 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)
 
-    if (test._ddIsAttemptToFix && isLastAttempt) {
-      if (testStatuses.includes('fail')) {
-        attemptToFixFailed = true
-      }
-      if (testStatuses.every(status => status === 'fail')) {
-        hasFailedAllRetries = true
-      } else if (testStatuses.every(status => status === 'pass')) {
-        attemptToFixPassed = true
-      }
+  if (test._ddIsAttemptToFix && isLastAttempt) {
+    if (testStatuses.includes('fail')) {
+      attemptToFixFailed = true
     }
-
-    if (test._ddIsEfdRetry && isLastEfdRetry &&
-      testStatuses.every(status => status === 'fail')) {
+    if (testStatuses.every(status => status === 'fail')) {
       hasFailedAllRetries = true
+    } else if (testStatuses.every(status => status === 'pass')) {
+      attemptToFixPassed = true
     }
+  }
 
-    // ATR: set hasFailedAllRetries when all auto test retries were exhausted and every attempt failed
-    if (config.isFlakyTestRetriesEnabled && !test._ddIsAttemptToFix && !test._ddIsEfdRetry &&
-      getIsLastRetry(test) && testStatuses.every(status => status === 'fail')) {
-      hasFailedAllRetries = true
-    }
+  if (test._ddIsEfdRetry && isLastEfdRetry &&
+    testStatuses.every(status => status === 'fail')) {
+    hasFailedAllRetries = true
+  }
 
-    const isAttemptToFixRetry = test._ddIsAttemptToFix && testStatuses.length > 1
-    const isAtrRetry = config.isFlakyTestRetriesEnabled &&
-      !test._ddIsAttemptToFix &&
-      !test._ddIsEfdRetry
+  // ATR: set hasFailedAllRetries when all auto test retries were exhausted and every attempt failed
+  if (config.isFlakyTestRetriesEnabled && !test._ddIsAttemptToFix && !test._ddIsEfdRetry &&
+    getIsLastRetry(test) && testStatuses.every(status => status === 'fail')) {
+    hasFailedAllRetries = true
+  }
 
-    const { isFlakyTestRetriesEnabled } = config
-    const { _ddIsAttemptToFix, _ddIsQuarantined, _ddIsDisabled } = test
+  const isAttemptToFixRetry = test._ddIsAttemptToFix && testStatuses.length > 1
+  const isAtrRetry = config.isFlakyTestRetriesEnabled &&
+    !test._ddIsAttemptToFix &&
+    !test._ddIsEfdRetry
+
+  const { isFlakyTestRetriesEnabled } = config
+  const { _ddIsAttemptToFix, _ddIsQuarantined, _ddIsDisabled } = test
+
+  const finalStatus = getFinalStatus({
+    status,
+    hasFailedAllRetries,
+    isFlakyTestRetriesEnabled,
+    isLastAtrAttempt,
+    isEfdRetry,
+    isLastEfdRetry,
+    isAttemptToFix: _ddIsAttemptToFix,
+    isLastAttemptToFix: isLastAttempt,
+    attemptToFixPassed,
+    isQuarantined: _ddIsQuarantined,
+    isDisabled: _ddIsDisabled,
+  })
 
-    const finalStatus = getFinalStatus({
+  if (_ddIsAttemptToFix) {
+    recordAttemptToFixExecution(attemptToFixExecutions, {
+      testSuite: getTestSuitePath(test.file, process.cwd()),
+      testName: test.fullTitle(),
       status,
-      hasFailedAllRetries,
-      isFlakyTestRetriesEnabled,
-      isLastAtrAttempt,
-      isEfdRetry,
-      isLastEfdRetry,
-      isAttemptToFix: _ddIsAttemptToFix,
-      isLastAttemptToFix: isLastAttempt,
-      attemptToFixPassed,
-      isQuarantined: _ddIsQuarantined,
       isDisabled: _ddIsDisabled,
+      isQuarantined: _ddIsQuarantined,
     })
+  }
+
+  return {
+    hasFailedAllRetries,
+    attemptToFixPassed,
+    attemptToFixFailed,
+    isAttemptToFixRetry,
+    isAtrRetry,
+    finalStatus,
+  }
+}
+
+function getOnTestEndHandler (config) {
+  return async function (test) {
+    const ctx = getTestContext(test)
+    const status = getTestStatus(test)
+
+    // After finishing it might take a bit for the snapshot to be handled.
+    // 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) => {
+        realSetTimeout(() => {
+          resolve()
+        }, BREAKPOINT_HIT_GRACE_PERIOD_MS)
+      })
+    }
 
     // If there are afterEach to be run, we don't finish the test yet.
     // Disabled tests (marked pending by us) are finished immediately without waiting for afterEach hooks.
     // In older mocha versions, pending tests don't run afterEach hooks, so we can't rely on
     // getOnHookEndHandler to finish the test. This mirrors Jest's approach where the skip handler
     // directly sets finalStatus without waiting for hooks
-    if (ctx && (!getAfterEachHooks(test).length || test._ddIsDisabled)) {
+    if (ctx && (!getAfterEachHooks(test).length || (test._ddIsDisabled && !test._ddIsAttemptToFix))) {
+      const testFinishInfo = getTestFinishInfo(test, status, config, ctx.err || test.err)
       testFinishCh.publish({
         status,
         hasBeenRetried: isMochaRetry(test),
         isLastRetry: getIsLastRetry(test),
-        hasFailedAllRetries,
-        attemptToFixPassed,
-        attemptToFixFailed,
-        isAttemptToFixRetry,
-        isAtrRetry,
+        ...testFinishInfo,
         ...ctx.currentStore,
-        finalStatus,
       })
-    } else if (ctx) { // if there is an afterEach to run, let's store the finalStatus for getOnHookEndHandler
-      ctx.finalStatus = finalStatus
-      ctx.hasFailedAllRetries = hasFailedAllRetries
-      ctx.attemptToFixPassed = attemptToFixPassed
-      ctx.attemptToFixFailed = attemptToFixFailed
-      ctx.isAttemptToFixRetry = isAttemptToFixRetry
-      ctx.isAtrRetry = isAtrRetry
     }
   }
 }
 
-function getOnHookEndHandler () {
+function getOnHookEndHandler (config) {
   return function (hook) {
     const test = hook.ctx.currentTest
     const afterEachHooks = getAfterEachHooks(hook)
@@ -415,18 +438,14 @@ function getOnHookEndHandler () {
         const ctx = getTestContext(test)
         // Disabled tests are already finished in getOnTestEndHandler,
         // skip to avoid double-publishing
-        if (ctx && !test._ddIsDisabled) {
+        if (ctx && (!test._ddIsDisabled || test._ddIsAttemptToFix)) {
+          const testFinishInfo = getTestFinishInfo(test, status, config, ctx.err || test.err)
           testFinishCh.publish({
             status,
             hasBeenRetried: isMochaRetry(test),
             isLastRetry: getIsLastRetry(test),
-            hasFailedAllRetries: ctx.hasFailedAllRetries,
-            attemptToFixPassed: ctx.attemptToFixPassed,
-            attemptToFixFailed: ctx.attemptToFixFailed,
-            isAttemptToFixRetry: ctx.isAttemptToFixRetry,
-            isAtrRetry: ctx.isAtrRetry,
+            ...testFinishInfo,
             ...ctx.currentStore,
-            finalStatus: ctx.finalStatus,
           })
         }
       }
@@ -434,7 +453,7 @@ function getOnHookEndHandler () {
   }
 }
 
-function getOnFailHandler (isMain) {
+function getOnFailHandler (isMain, config) {
   return function (testOrHook, err) {
     const testFile = testOrHook.file
     let test = testOrHook
@@ -451,15 +470,12 @@ function getOnFailHandler (isMain) {
         err.message = `${testOrHook.fullTitle()}: ${err.message}`
         testContext.err = err
         errorCh.runStores(testContext, () => {})
-        // if it's a hook and it has failed, 'test end' will not be called
-        // quarantined and disabled tests always report 'skip'
-        // as final status, even when hooks fail
-        const isSkippedByManagement = test._ddIsQuarantined || test._ddIsDisabled
+        const testFinishInfo = getTestFinishInfo(test, 'fail', config, err)
         testFinishCh.publish({
           status: 'fail',
           hasBeenRetried: isMochaRetry(test),
+          ...testFinishInfo,
           ...testContext.currentStore,
-          finalStatus: isSkippedByManagement ? 'skip' : 'fail',
         })
       } else {
         testContext.err = err
@@ -627,4 +643,6 @@ module.exports = {
   testsQuarantined,
   testsAttemptToFix,
   testsStatuses,
+  attemptToFixExecutions,
+  loggedAttemptToFixTests,
 }

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

@@ -84,9 +84,9 @@ addHook({
     this.on('retry', getOnTestRetryHandler(config))
 
     // If the hook passes, 'hook end' will be emitted. Otherwise, 'fail' will be emitted
-    this.on('hook end', getOnHookEndHandler())
+    this.on('hook end', getOnHookEndHandler(config))
 
-    this.on('fail', getOnFailHandler(false))
+    this.on('fail', getOnFailHandler(false, config))
 
     this.on('pending', getOnPendingHandler())
 

package/packages/datadog-instrumentations/src/path-to-regexp.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+
+/** @type {((pattern: string | RegExp) => RegExp | undefined) | undefined} */
+let compileToRegexp
+
+addHook({ name: 'path-to-regexp', versions: ['*'] }, moduleExports => {
+  // 0.1.x and 6.x: `module.exports = (path, ...) => RegExp`.
+  // 7.x: `module.exports = { pathToRegexp(path, ...) => RegExp }`.
+  // 8.x: `module.exports = { pathToRegexp(path, ...) => { regexp, keys } }`.
+  const compile = typeof moduleExports === 'function'
+    ? moduleExports
+    : (typeof moduleExports?.pathToRegexp === 'function' ? moduleExports.pathToRegexp : undefined)
+
+  if (compile !== undefined) {
+    compileToRegexp = pattern => {
+      let result
+      try {
+        result = compile(pattern)
+      } catch {
+        return
+      }
+      const regex = result?.regexp ?? result
+      if (regex instanceof RegExp) return regex
+    }
+  }
+
+  return moduleExports
+})
+
+/**
+ * Returns whatever path-to-regexp compile adapter the host most recently
+ * loaded. Capture this once at addHook fire time so each express/router
+ * instance keeps the dialect that was current when its routes were wrapped;
+ * a later host load that swaps the global compile won't retroactively change
+ * already-wrapped routers. `undefined` when the host has not loaded
+ * path-to-regexp yet, or never if it does not depend on it.
+ */
+function getCompileToRegexp () {
+  return compileToRegexp
+}
+
+module.exports = { getCompileToRegexp }