dd-trace 5.99.1 → 5.100.0

package/LICENSE-3rdparty.csv

@@ -85,7 +85,6 @@
 "node-gyp-build","https://github.com/prebuild/node-gyp-build","['MIT']","['Mathias Buus']"
 "opentracing","https://github.com/opentracing/opentracing-javascript","['Apache-2.0']","['opentracing']"
 "oxc-parser","https://github.com/oxc-project/oxc","['MIT']","['Boshen and oxc contributors']"
-"path-to-regexp","https://github.com/pillarjs/path-to-regexp","['MIT']","['pillarjs']"
 "pprof-format","https://github.com/DataDog/pprof-format","['MIT']","['Datadog Inc.']"
 "protobufjs","https://github.com/protobufjs/protobuf.js","['BSD-3-Clause']","['Daniel Wirtz']"
 "queue-tick","https://github.com/mafintosh/queue-tick","['MIT']","['Mathias Buus']"

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.99.1",
+  "version": "5.100.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -22,7 +22,7 @@
     "lint:fix": "node scripts/check_licenses.js && node scripts/check-no-coverage-artifacts.js && eslint . --concurrency=auto --max-warnings 0 --fix",
     "lint:inspect": "npx @eslint/config-inspector@latest",
     "lint:codeowners": "codeowners-audit",
-    "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js'",
+    "lint:codeowners:ci": "codeowners-audit --glob='**/*.spec.js' --glob='benchmark/sirun/**'",
     "release:proposal": "node scripts/release/proposal",
     "services": "node ./scripts/install_plugin_modules && node packages/dd-trace/test/setup/services",
     "test": "echo '\nError: The root \"npm test\" command is intentionally disabled.\n\nInstead, run specific test suites:\n  - npm run test:trace:core\n  - npm run test:appsec\n  - etc.\n\nOr run individual test files:\n  npx mocha path/to/test.spec.js\n\nSee CONTRIBUTING.md (Testing section) for more details.\n' && exit 1",
@@ -192,12 +192,12 @@
     "bun": "1.3.13",
     "codeowners-audit": "^2.9.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-cypress": "^6.3.1",
+    "eslint-plugin-cypress": "^6.4.0",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jsdoc": "^62.9.0",
     "eslint-plugin-mocha": "^11.2.0",
     "eslint-plugin-n": "^17.23.2",
-    "eslint-plugin-promise": "^7.2.1",
+    "eslint-plugin-promise": "^7.3.0",
     "eslint-plugin-unicorn": "^64.0.0",
     "express": "^5.1.0",
     "glob": "^10.4.5",

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

@@ -12,6 +12,10 @@ const {
   getTestSuitePath,
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
+  recordAttemptToFixExecution,
+  collectAttemptToFixExecutionsFromTraces,
+  logAttemptToFixTestExecution,
+  logTestOptimizationSummary,
 } = require('../../dd-trace/src/plugins/util/test')
 const satisfies = require('../../../vendor/dist/semifies')
 const { addHook, channel } = require('./helpers/instrument')
@@ -60,9 +64,12 @@ const atrStatusesByScenarioKey = new Map()
 const numRetriesByPickleId = new Map()
 const numAttemptToCtx = new Map()
 const newTestsByTestFullname = new Map()
+const attemptToFixTestsByTestFullname = new Map()
 const modifiedTestsByPickleId = new Map()
 // Pickle IDs for tests that are genuinely new (not in known tests list).
 const newTestPickleIds = new Set()
+const attemptToFixExecutions = new Map()
+const loggedAttemptToFixTests = new Set()
 
 let eventDataCollector = null
 let pickleByFile = {}
@@ -154,6 +161,16 @@ function getTestStatusFromRetries (testStatuses) {
   return 'pass'
 }
 
+function getTestStatusFromAttemptToFixExecutions (testStatuses) {
+  if (testStatuses.every(status => status === 'pass')) {
+    return 'pass'
+  }
+  if (testStatuses.every(status => status === 'skip')) {
+    return 'skip'
+  }
+  return 'fail'
+}
+
 function getErrorFromCucumberResult (cucumberResult) {
   if (!cucumberResult.message) {
     return
@@ -247,9 +264,8 @@ function getFinalStatus ({
 }) {
   // Note that intermediate executions DO NOT report a final status tag
 
-  // 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 || status === 'skip') {
+  // If the test is quarantined or disabled, its final status is skip unless attempt-to-fix takes precedence.
+  if (status === 'skip' || (!isLastAttemptToFix && (isQuarantined || isDisabled))) {
     return 'skip'
   }
 
@@ -282,6 +298,7 @@ function wrapRun (pl, isLatestVersion, version) {
     let numAttempt = 0
 
     const testFileAbsolutePath = this.pickle.uri
+    const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
 
     const testSourceLine = this.gherkinDocument?.feature?.location?.line
 
@@ -293,6 +310,9 @@ function wrapRun (pl, isLatestVersion, version) {
     }
     const ctx = testStartPayload
     numAttemptToCtx.set(numAttempt, ctx)
+    if (isTestManagementTestsEnabled && getTestProperties(testSuitePath, this.pickle.name).attemptToFix) {
+      logAttemptToFixTestExecution(testSuitePath, this.pickle.name, loggedAttemptToFixTests)
+    }
     testStartCh.runStores(ctx, () => {})
     const promises = {}
     try {
@@ -441,6 +461,16 @@ function wrapRun (pl, isLatestVersion, version) {
 
         const error = getErrorFromCucumberResult(result)
 
+        if (isAttemptToFix) {
+          recordAttemptToFixExecution(attemptToFixExecutions, {
+            testSuite: testSuitePath,
+            testName: this.pickle.name,
+            status,
+            isDisabled,
+            isQuarantined,
+          })
+        }
+
         if (promises.hitBreakpointPromise) {
           await promises.hitBreakpointPromise
         }
@@ -661,6 +691,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     }
 
     atrStatusesByScenarioKey.clear()
+    attemptToFixTestsByTestFullname.clear()
     sessionStartCh.publish({ command, frameworkVersion })
 
     if (!errorSkippableRequest && skippedSuites.length) {
@@ -701,6 +732,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       isTestManagementTestsEnabled,
       isParallel,
     })
+    logTestOptimizationSummary({ attemptToFixExecutions })
+    loggedAttemptToFixTests.clear()
     eventDataCollector = null
     return success
   }
@@ -811,6 +844,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     let testStatus = lastTestStatus
     let shouldBePassedByEFD = false
     let shouldBePassedByTestManagement = false
+    let shouldBeFailedByAttemptToFix = false
     if ((isNew || isModified) && isEarlyFlakeDetectionEnabled) {
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
@@ -827,7 +861,15 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
 
-    if (isTestManagementTestsEnabled && (isDisabled || isQuarantined)) {
+    if (isAttemptToFix && testStatuses.length === testManagementAttemptToFixRetries + 1) {
+      testStatus = getTestStatusFromAttemptToFixExecutions(testStatuses)
+      if (testStatus === 'fail') {
+        this.success = false
+        shouldBeFailedByAttemptToFix = true
+      }
+    }
+
+    if (isTestManagementTestsEnabled && !isAttemptToFix && (isDisabled || isQuarantined)) {
       this.success = true
       shouldBePassedByTestManagement = true
     }
@@ -863,10 +905,14 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       return shouldBePassedByEFD
     }
 
-    if (isNewerCucumberVersion && isTestManagementTestsEnabled && (isQuarantined || isDisabled)) {
+    if (isNewerCucumberVersion && isTestManagementTestsEnabled && !isAttemptToFix && (isQuarantined || isDisabled)) {
       return shouldBePassedByTestManagement
     }
 
+    if (isNewerCucumberVersion && isAttemptToFix && shouldBeFailedByAttemptToFix) {
+      return false
+    }
+
     return runTestCaseResult
   }
 }
@@ -882,6 +928,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
     if (Array.isArray(message)) {
       const [messageCode, payload] = message
       if (messageCode === CUCUMBER_WORKER_TRACE_PAYLOAD_CODE) {
+        collectAttemptToFixExecutionsFromTraces(payload, attemptToFixExecutions)
         workerReportTraceCh.publish(payload)
         return
       }
@@ -962,6 +1009,23 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion)
           // we only push to `finished` if the retries have finished
           finished.push(newTestFinalStatus)
         }
+      } else if (
+        isTestManagementTestsEnabled &&
+        getTestProperties(getTestSuitePath(testFileAbsolutePath, process.cwd()), pickle.name).attemptToFix
+      ) {
+        const testFullname = `${pickle.uri}:${pickle.name}`
+        let testStatuses = attemptToFixTestsByTestFullname.get(testFullname)
+        if (testStatuses) {
+          testStatuses.push(status)
+        } else {
+          testStatuses = [status]
+          attemptToFixTestsByTestFullname.set(testFullname, testStatuses)
+        }
+
+        if (status === 'skip' || testStatuses.length === testManagementAttemptToFixRetries + 1) {
+          finished.push(getTestStatusFromAttemptToFixExecutions(testStatuses))
+          attemptToFixTestsByTestFullname.delete(testFullname)
+        }
       } else {
         // TODO: can we get error message?
         const finished = pickleResultByFile[testFileAbsolutePath]

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

@@ -3,6 +3,7 @@
 const shimmer = require('../../datadog-shimmer')
 const { createWrapRouterMethod } = require('./router')
 const { addHook, channel, tracingChannel } = require('./helpers/instrument')
+const { getCompileToRegexp } = require('./path-to-regexp')
 const {
   setRouterMountPath,
   markAppMounted,
@@ -26,8 +27,6 @@ function wrapHandle (handle) {
   }
 }
 
-const wrapRouterMethod = createWrapRouterMethod('express')
-
 const responseJsonChannel = channel('datadog:express:response:json:start')
 
 function wrapResponseJson (json) {
@@ -163,6 +162,8 @@ addHook({ name: 'express', versions: ['>=4'], file: 'lib/express.js' }, express
 // 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'], file: 'lib/express.js' }, express => {
+  const wrapRouterMethod = createWrapRouterMethod('express', getCompileToRegexp())
+
   shimmer.wrap(express.Router, 'use', wrapRouterMethod)
   shimmer.wrap(express.Router, 'route', wrapRouterMethod)
 

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

@@ -118,6 +118,7 @@ module.exports = {
   passport: () => require('../passport'),
   'passport-http': () => require('../passport-http'),
   'passport-local': () => require('../passport-local'),
+  'path-to-regexp': () => require('../path-to-regexp'),
   pg: () => require('../pg'),
   pino: () => require('../pino'),
   'pino-pretty': () => require('../pino'),

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

@@ -14,9 +14,15 @@ const enterChannel = channel('apm:hono:middleware:enter')
 const exitChannel = channel('apm:hono:middleware:exit')
 const finishChannel = channel('apm:hono:middleware:finish')
 
+// `app.request()` and non-node adapters call `app.fetch` without an `incoming`
+// IncomingMessage; the APM `web` helpers depend on one, so the wrappers below
+// skip publishing whenever it is missing.
 function wrapFetch (fetch) {
   return function (request, env, executionCtx) {
-    handleChannel.publish({ req: env.incoming })
+    const req = env?.incoming
+    if (req) {
+      handleChannel.publish({ req })
+    }
     return fetch.apply(this, arguments)
   }
 }
@@ -31,8 +37,10 @@ function wrapCompose (compose) {
 
     const instrumentedOnError = (...args) => {
       const [error, context] = args
-      const req = context.env.incoming
-      errorChannel.publish({ req, error })
+      const req = context.env?.incoming
+      if (req) {
+        errorChannel.publish({ req, error })
+      }
       return onError(...args)
     }
 
@@ -62,7 +70,10 @@ function wrapMiddleware (middleware, route) {
     middleware,
     (middleware) =>
       function (context, next) {
-        const req = context.env.incoming
+        const req = context.env?.incoming
+        if (!req) {
+          return middleware.apply(this, arguments)
+        }
         routeChannel.publish({ req, route })
         enterChannel.publish({ req, name, route })
         if (typeof next === 'function') {

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

@@ -21,6 +21,9 @@ const {
   isModifiedTest,
   DYNAMIC_NAME_RE,
   collectDynamicNamesFromTraces,
+  recordAttemptToFixExecution,
+  logAttemptToFixTestExecution,
+  logTestOptimizationSummary,
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   SEED_SUFFIX_RE,
@@ -107,6 +110,7 @@ const wrappedWorkerChannels = new WeakMap()
 // New tests whose names contain likely dynamic data (timestamps, UUIDs, etc.)
 // Populated in-process for runInBand, and via worker-report:trace for parallel mode.
 const newTestsWithDynamicNames = new Set()
+const loggedAttemptToFixTests = new Set()
 const testSuiteMockedFiles = new Map()
 const testsToBeRetried = new Set()
 // Per-test: how many EFD retries were determined after the first execution.
@@ -193,64 +197,88 @@ function getTestStats (testStatuses) {
 }
 
 /**
- * @param {string[]} efdNames
- * @param {string[]} quarantineNames
- * @param {number} totalCount
- */
-/**
- * Renders a truncated bullet list from an array of items.
+ * Formats the ignored-failure section for the Test Optimization summary.
  *
- * @param {Array<{ text: string, suffix?: string }>} items
+ * @param {{ efdNames: string[], quarantineNames: string[], totalCount: number } | undefined} ignoredFailures
  * @returns {string}
  */
-function formatList (items) {
+function formatIgnoredFailuresSummary (ignoredFailures) {
+  if (!ignoredFailures) return ''
+
+  const items = []
+
+  for (const n of ignoredFailures.efdNames) {
+    items.push({ text: n, suffix: 'Early Flake Detection' })
+  }
+  for (const n of ignoredFailures.quarantineNames) {
+    items.push({ text: n, suffix: 'Quarantine' })
+  }
+
+  if (items.length === 0 || ignoredFailures.totalCount <= 0) return ''
+
   const shown = items.slice(0, MAX_IGNORED_TEST_NAMES)
   const more = items.length - shown.length
   const moreSuffix = more > 0 ? `\n  ... and ${more} more` : ''
-  return shown.map(({ text, suffix }) => `  • ${text}${suffix ? ` (${suffix})` : ''}`).join('\n') + moreSuffix
+  const formattedItems = shown
+    .map(({ text, suffix }) => `  • ${text}${suffix ? ` (${suffix})` : ''}`)
+    .join('\n') + moreSuffix
+
+  return `${ignoredFailures.totalCount} test failure(s) were ignored. Exit code set to 0.\n\n${formattedItems}`
 }
 
 /**
- * Logs a single "Datadog Test Optimization" summary at session end,
- * combining all relevant sections (ignored failures, dynamic names).
+ * Logs a single "Datadog Test Optimization" summary at session end.
  *
  * @param {{ efdNames: string[], quarantineNames: string[], totalCount: number } | undefined} ignoredFailures
  */
-function logSessionSummary (ignoredFailures) {
-  const sections = []
+function logSessionSummary (ignoredFailures, attemptToFixExecutions) {
+  logTestOptimizationSummary({
+    attemptToFixExecutions,
+    extraSections: [formatIgnoredFailuresSummary(ignoredFailures)],
+    newTestsWithDynamicNames,
+  })
+  loggedAttemptToFixTests.clear()
+}
 
-  if (ignoredFailures) {
-    const items = []
-    for (const n of ignoredFailures.efdNames) {
-      items.push({ text: n, suffix: 'Early Flake Detection' })
-    }
-    for (const n of ignoredFailures.quarantineNames) {
-      items.push({ text: n, suffix: 'Quarantine' })
-    }
-    sections.push(
-      `${ignoredFailures.totalCount} test failure(s) were ignored. Exit code set to 0.\n\n` +
-      formatList(items)
-    )
-  }
+function getTestStatusFromJestResult (status) {
+  if (status === 'failed') return 'fail'
+  if (status === 'passed') return 'pass'
+}
 
-  if (newTestsWithDynamicNames.size > 0) {
-    const items = [...newTestsWithDynamicNames].map(name => ({ text: name }))
-    sections.push(
-      `${newTestsWithDynamicNames.size} test(s) detected as new but their names contain ` +
-      'dynamic data (timestamps, UUIDs, etc.).\n' +
-      'Tests with changing names are always treated as new on every run, ' +
-      'causing unnecessary Early Flake Detection retries and preventing correct new test detection.\n' +
-      'Consider using stable, deterministic test names.\n\n' +
-      formatList(items)
-    )
-    newTestsWithDynamicNames.clear()
+function getAttemptToFixExecutionsFromJestResults (result) {
+  const executions = new Map()
+  const rootDir = result.globalConfig?.rootDir || process.cwd()
+
+  for (const { testResults, testFilePath } of result.results.testResults) {
+    const testSuite = getTestSuitePath(testFilePath, rootDir)
+    const testManagementTestsForSuite = testManagementTests
+      ?.jest
+      ?.suites
+      ?.[testSuite]
+      ?.tests
+    if (!testManagementTestsForSuite) continue
+
+    for (const { fullName, status } of testResults) {
+      const testName = testSuiteAbsolutePathsWithFastCheck.has(testFilePath)
+        ? fullName.replace(SEED_SUFFIX_RE, '')
+        : fullName
+      const testStatus = getTestStatusFromJestResult(status)
+      if (!testStatus) continue
+
+      const testManagementTest = testManagementTestsForSuite[testName]?.properties
+      if (!testManagementTest?.attempt_to_fix) continue
+
+      recordAttemptToFixExecution(executions, {
+        testSuite,
+        testName,
+        status: testStatus,
+        isDisabled: testManagementTest.disabled,
+        isQuarantined: testManagementTest.quarantined,
+      })
+    }
   }
 
-  if (sections.length === 0) return
-
-  const line = '-'.repeat(50)
-  // eslint-disable-next-line no-console -- Intentional user-facing session summary
-  console.warn(`\n${line}\nDatadog Test Optimization\n${line}\n${sections.join('\n\n')}\n`)
+  return executions
 }
 
 function getWrappedEnvironment (BaseEnvironment, jestVersion) {
@@ -556,6 +584,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
         testContexts.set(event.test, ctx)
 
+        if (isAttemptToFix) {
+          logAttemptToFixTestExecution(this.testSuite, testName, loggedAttemptToFixTests)
+        }
+
         testStartCh.runStores(ctx, () => {
           let p = event.test.parent
           const hooks = []
@@ -795,7 +827,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         // Only suppress on the final execution — not when ATR/EFD/ATF will retry the test.
         if (!event.test?.[ATR_RETRY_SUPPRESSION_FLAG] && !willBeRetriedByFailedTestReplay) {
           const quarantineCtx = testContexts.get(event.test)
-          if (quarantineCtx?.isQuarantined && event.test.errors?.length) {
+          if (quarantineCtx?.isQuarantined && !quarantineCtx.isAttemptToFix && event.test.errors?.length) {
             quarantinedFailingTests.add(`${quarantineCtx.suite} › ${quarantineCtx.name}`)
             event.test.errors = []
           }
@@ -858,10 +890,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
       if (event.name === 'run_finish') {
         for (const [test, errors] of atrSuppressedErrors) {
-          // Do not restore errors for quarantined tests — they should stay suppressed
+          // Do not restore errors for non-ATF quarantined tests — they should stay suppressed
           // so Jest doesn't see the failure (prevents --bail from stopping the run).
           const ctx = testContexts.get(test)
-          if (ctx?.isQuarantined) {
+          if (ctx?.isQuarantined && !ctx.isAttemptToFix) {
             const testName = getJestTestName(test, this.getShouldStripSeedFromTestName())
             quarantinedFailingTests.add(`${ctx.suite} › ${testName}`)
           } else {
@@ -984,7 +1016,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       // If the test is quarantined, regardless of its actual execution result,
       // the final status of its last execution should be reported as 'skip'.
-      if (this.isTestManagementTestsEnabled &&
+      if (!attemptToFixResult.isAttemptToFixEnabled &&
+        this.isTestManagementTestsEnabled &&
         this.testManagementTestsForThisSuite?.quarantined?.includes(testName)) {
         return 'skip'
       }
@@ -1315,7 +1348,6 @@ function getCliWrapper (isNewJestVersion) {
       }
 
       let numFailedQuarantinedTests = 0
-      let numFailedQuarantinedOrDisabledAttemptedToFixTests = 0
       let numSuppressedQuarantinedTests = 0
       if (isTestManagementTestsEnabled) {
         const failedTests = result
@@ -1343,11 +1375,7 @@ function getCliWrapper (isNewJestVersion) {
             ?.tests
             ?.[testName]
             ?.properties
-          // This uses `attempt_to_fix` because this is always the main process and it's not formatted in camelCase
-          if (testManagementTest?.attempt_to_fix && (testManagementTest?.quarantined || testManagementTest?.disabled)) {
-            numFailedQuarantinedOrDisabledAttemptedToFixTests++
-            quarantineIgnoredNames.push(`${testSuite} › ${testName}`)
-          } else if (testManagementTest?.quarantined) {
+          if (testManagementTest?.quarantined && !testManagementTest?.attempt_to_fix) {
             numFailedQuarantinedTests++
             quarantineIgnoredNames.push(`${testSuite} › ${testName}`)
           }
@@ -1365,13 +1393,11 @@ function getCliWrapper (isNewJestVersion) {
         quarantinedFailingTests.clear()
 
         // If every test that failed was quarantined, we'll consider the suite passed
-        // Note that if a test is attempted to fix,
-        // it's considered quarantined both if it's disabled and if it's quarantined
-        // (it'll run but its status is ignored)
+        // Attempt-to-fix tests ignore quarantine/disabled suppression and keep their framework result.
         // Skip if EFD block already flipped (to avoid logging twice)
         // Only use visible failures (from Jest results) for the flip check.
         // Suppressed quarantine failures are not in numFailedTests.
-        const visibleQuarantineFailures = numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
+        const visibleQuarantineFailures = numFailedQuarantinedTests
         if (
           !result.results.success &&
           !mustNotFlipSuccess &&
@@ -1406,7 +1432,7 @@ function getCliWrapper (isNewJestVersion) {
         (isEarlyFlakeDetectionEnabled || isTestManagementTestsEnabled)
       ) {
         const visibleIgnoredFailures =
-          numEfdFailedTestsToIgnore + numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
+          numEfdFailedTestsToIgnore + numFailedQuarantinedTests
         if (
           visibleIgnoredFailures !== 0 &&
           result.results.numFailedTests === visibleIgnoredFailures
@@ -1474,7 +1500,7 @@ function getCliWrapper (isNewJestVersion) {
         })
       }
 
-      logSessionSummary(ignoredFailuresSummary)
+      logSessionSummary(ignoredFailuresSummary, getAttemptToFixExecutionsFromJestResults(result))
 
       numSkippedSuites = 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)
       }
     }