dd-trace 5.99.1 → 5.101.0

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

@@ -2,6 +2,7 @@
 
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { DD_MAJOR } = require('../../../../version')
 
 const {
   runnableWrapper,
@@ -15,6 +16,8 @@ const {
 } = require('./utils')
 require('./common')
 
+const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
+
 const workerFinishCh = channel('ci:mocha:worker:finish')
 
 const config = {}
@@ -64,7 +67,7 @@ addHook({
 // Runner is also hooked in mocha/main.js, but in here we only generate test events.
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/runner.js',
 }, function (Runner) {
   shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
@@ -84,9 +87,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())
 
@@ -99,6 +102,6 @@ addHook({
 // Used to set the correct async resource to the test.
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/runnable.js',
 }, (runnablePackage) => runnableWrapper(runnablePackage, config))

package/packages/datadog-instrumentations/src/otel-sdk-trace.js

@@ -3,14 +3,10 @@
 const shimmer = require('../../datadog-shimmer')
 const tracer = require('../../dd-trace')
 const { getValueFromEnvSources } = require('../../dd-trace/src/config/helper')
+const { isFalse, isTrue } = require('../../dd-trace/src/util')
 const { addHook } = require('./helpers/instrument')
 
-const otelSdkEnabled = getValueFromEnvSources('DD_TRACE_OTEL_ENABLED') ||
-getValueFromEnvSources('OTEL_SDK_DISABLED')
-  ? !getValueFromEnvSources('OTEL_SDK_DISABLED')
-  : undefined
-
-if (otelSdkEnabled) {
+if (isOtelSdkEnabled()) {
   addHook({
     name: '@opentelemetry/sdk-trace-node',
     file: 'build/src/NodeTracerProvider.js',
@@ -22,3 +18,12 @@ if (otelSdkEnabled) {
     return mod
   })
 }
+
+function isOtelSdkEnabled () {
+  // Datadog explicit opt-out wins over every OTel signal; check it first.
+  const ddTraceOtelEnabled = getValueFromEnvSources('DD_TRACE_OTEL_ENABLED')
+  if (isFalse(ddTraceOtelEnabled)) return false
+  const otelSdkDisabled = getValueFromEnvSources('OTEL_SDK_DISABLED')
+  if (isTrue(otelSdkDisabled)) return false
+  return isTrue(ddTraceOtelEnabled) || isFalse(otelSdkDisabled)
+}

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 }

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

@@ -12,7 +12,9 @@ const {
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
   getIsFaultyEarlyFlakeDetection,
   DYNAMIC_NAME_RE,
-  logDynamicNamesWarning,
+  recordAttemptToFixExecution,
+  logAttemptToFixTestExecution,
+  logTestOptimizationSummary,
 } = require('../../dd-trace/src/plugins/util/test')
 const log = require('../../dd-trace/src/log')
 const {
@@ -76,9 +78,10 @@ let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
 let isImpactedTestsEnabled = false
 let modifiedFiles = {}
-const quarantinedOrDisabledTestsAttemptToFix = []
 let quarantinedButNotAttemptToFixFqns = new Set()
 const newTestsWithDynamicNames = new Set()
+const attemptToFixExecutions = new Map()
+const loggedAttemptToFixTests = new Set()
 let rootDir = ''
 let sessionProjects = []
 
@@ -290,6 +293,32 @@ function testWillRetry (test, testStatus) {
   return testStatus === 'fail' && test.results.length <= test.retries
 }
 
+function getFinalStatus ({
+  isFinalExecution,
+  isDisabled,
+  isQuarantined,
+  isAtrRetry,
+  isEfdManagedTest,
+  isAttemptToFix,
+  hasFailedAllRetries,
+  hasFailedAttemptToFixRetries,
+  testStatus,
+}) {
+  if (!isFinalExecution) {
+    return
+  }
+  if (isDisabled || isQuarantined || testStatus === 'skip') {
+    return 'skip'
+  }
+  if (isAtrRetry || isEfdManagedTest) {
+    return hasFailedAllRetries ? 'fail' : 'pass'
+  }
+  if (isAttemptToFix) {
+    return hasFailedAttemptToFixRetries ? 'fail' : 'pass'
+  }
+  return testStatus
+}
+
 function getTestFullname (test) {
   let parent = test.parent
   const names = [test.title]
@@ -337,6 +366,11 @@ function testBeginHandler (test, browserName, shouldCreateTestSpan) {
   // We disable retries by default if attemptToFix is true
   if (getTestProperties(test).attemptToFix) {
     test.retries = 0
+    logAttemptToFixTestExecution(
+      getTestSuitePath(testSuiteAbsolutePath, rootDir),
+      getTestFullname(test),
+      loggedAttemptToFixTests
+    )
   }
 
   // this handles tests that do not go through the worker process (because they're skipped)
@@ -399,6 +433,20 @@ function testEndHandler ({
 
   const testProperties = getTestProperties(test)
 
+  if (testProperties.attemptToFix) {
+    test._ddHasFailedAttemptToFixRetries = false
+    test._ddHasFailedAllRetries = false
+    test._ddHasPassedAttemptToFixRetries = false
+
+    recordAttemptToFixExecution(attemptToFixExecutions, {
+      testSuite: getTestSuitePath(test._requireFile, rootDir),
+      testName: getTestFullname(test),
+      status: testStatus,
+      isDisabled: testProperties.disabled,
+      isQuarantined: testProperties.quarantined,
+    })
+  }
+
   if (testStatuses.length === testManagementAttemptToFixRetries + 1 && testProperties.attemptToFix) {
     if (testStatuses.includes('fail')) {
       test._ddHasFailedAttemptToFixRetries = true
@@ -431,10 +479,26 @@ function testEndHandler ({
   if (shouldCreateTestSpan) {
     const testResult = results.at(-1)
     const testCtx = testToCtx.get(test)
+    const isEfdManagedTest = (test._ddIsNew || test._ddIsModified) &&
+      !test._ddIsAttemptToFix &&
+      isEarlyFlakeDetectionEnabled
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
+
+    const finalStatus = getFinalStatus({
+      isFinalExecution: !testWillRetry(test, testStatus),
+      isDisabled: test._ddIsDisabled,
+      isQuarantined: test._ddIsQuarantined,
+      isAtrRetry,
+      isEfdManagedTest,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      testStatus,
+    })
+
     // if there is no testCtx, the skipped test will be created later
     if (testCtx) {
       testFinishCh.publish({
@@ -454,6 +518,7 @@ function testEndHandler ({
         hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
         isAtrRetry,
         isModified: test._ddIsModified,
+        finalStatus,
         ...testCtx.currentStore,
       })
     }
@@ -597,11 +662,12 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
 
       const isTimeout = status === 'timedOut'
       const shouldCreateTestSpan = test.expectedStatus === 'skipped'
+      const testStatus = STATUS_TO_TEST_STATUS[status]
       testEndHandler(
         {
           test,
           annotations,
-          testStatus: STATUS_TO_TEST_STATUS[status],
+          testStatus,
           error: errors && errors[0],
           isTimeout,
           shouldCreateTestSpan,
@@ -613,6 +679,27 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
         isFlakyTestRetriesEnabled &&
         !test._ddIsAttemptToFix &&
         !test._ddIsEfdRetry
+
+      // EFD retries (new or modified tests) are implemented as clones with retries=0,
+      // so testWillRetry always returns false for them. Instead, we track how many
+      // executions have been reported via testsToTestStatuses (updated by testEndHandler
+      // above) and mark the execution final once the count reaches the expected total.
+      // This mirrors how ATF finality is detected and centralizes the decision in the
+      // main process, so workers only need to act on the _ddIsFinalExecution flag.
+      const isEfdManagedTest = (test._ddIsNew || test._ddIsModified) &&
+        !test._ddIsAttemptToFix &&
+        isEarlyFlakeDetectionEnabled
+      let isFinalExecution
+      if (isEfdManagedTest) {
+        const testFqn = getTestFullyQualifiedName(test)
+        const efdTestStatuses = testsToTestStatuses.get(testFqn) || []
+        isFinalExecution = efdTestStatuses.length === earlyFlakeDetectionNumRetries + 1
+      } else if (test._ddIsAttemptToFix) {
+        isFinalExecution = !!(test._ddHasPassedAttemptToFixRetries || test._ddHasFailedAttemptToFixRetries)
+      } else {
+        isFinalExecution = !testWillRetry(test, testStatus)
+      }
+
       // We want to send the ddProperties to the worker
       worker.process.send({
         type: 'ddProperties',
@@ -629,6 +716,8 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
           _ddHasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
           _ddIsAtrRetry: isAtrRetry,
           _ddIsModified: test._ddIsModified,
+          _ddIsFinalExecution: isFinalExecution,
+          _ddIsEfdManagedTest: isEfdManagedTest,
         },
       })
     })
@@ -766,7 +855,6 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 
     if (isTestManagementTestsEnabled && sessionStatus === 'failed') {
       let totalFailedTestCount = 0
-      let totalAttemptToFixFailedTestCount = 0
       let totalPureQuarantinedFailedTestCount = 0
 
       for (const [fqn, testStatuses] of testsToTestStatuses.entries()) {
@@ -780,16 +868,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
         }
       }
 
-      for (const test of quarantinedOrDisabledTestsAttemptToFix) {
-        const testFqn = getTestFullyQualifiedName(test)
-        const testStatuses = testsToTestStatuses.get(testFqn)
-        // Only count as failed if the final status (after retries) is 'fail'
-        if (testStatuses && testStatuses[testStatuses.length - 1] === 'fail') {
-          totalAttemptToFixFailedTestCount += 1
-        }
-      }
-
-      const totalIgnorableFailures = totalAttemptToFixFailedTestCount + totalPureQuarantinedFailedTestCount
+      const totalIgnorableFailures = totalPureQuarantinedFailedTestCount
 
       if (totalFailedTestCount > 0 && totalFailedTestCount === totalIgnorableFailures) {
         runAllTestsReturn = 'passed'
@@ -797,7 +876,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       }
     }
 
-    logDynamicNamesWarning(newTestsWithDynamicNames)
+    logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
+    loggedAttemptToFixTests.clear()
 
     const flushWait = new Promise(resolve => {
       onDone = resolve
@@ -975,9 +1055,6 @@ addHook({
           if (!fileSuitesWithManagedTestsToProjects.has(fileSuite)) {
             fileSuitesWithManagedTestsToProjects.set(fileSuite, getSuiteType(test, 'project'))
           }
-          if (testProperties.disabled || testProperties.quarantined) {
-            quarantinedOrDisabledTestsAttemptToFix.push(test)
-          }
         }
       }
       applyRetriesToTests(
@@ -1275,6 +1352,18 @@ addHook({
     // Wait for the properties to be received
     await ddPropertiesPromise
 
+    const finalStatus = getFinalStatus({
+      isFinalExecution: test._ddIsFinalExecution,
+      isDisabled: test._ddIsDisabled,
+      isQuarantined: test._ddIsQuarantined,
+      isAtrRetry: test._ddIsAtrRetry,
+      isEfdManagedTest: test._ddIsEfdManagedTest,
+      isAttemptToFix: test._ddIsAttemptToFix,
+      hasFailedAllRetries: test._ddHasFailedAllRetries,
+      hasFailedAttemptToFixRetries: test._ddHasFailedAttemptToFixRetries,
+      testStatus: STATUS_TO_TEST_STATUS[status],
+    })
+
     testFinishCh.publish({
       testStatus: STATUS_TO_TEST_STATUS[status],
       steps: steps.filter(step => step.testId === testId),
@@ -1294,6 +1383,7 @@ addHook({
       isAtrRetry: test._ddIsAtrRetry,
       isModified: test._ddIsModified,
       onDone,
+      finalStatus,
       ...testCtx.currentStore,
     })