dd-trace 5.43.0 → 5.45.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.43.0",
+  "version": "5.45.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -85,7 +85,7 @@
   },
   "dependencies": {
     "@datadog/libdatadog": "^0.5.0",
-    "@datadog/native-appsec": "8.5.0",
+    "@datadog/native-appsec": "8.5.1",
     "@datadog/native-iast-rewriter": "2.8.0",
     "@datadog/native-iast-taint-tracking": "3.3.0",
     "@datadog/native-metrics": "^3.1.0",
@@ -95,7 +95,7 @@
     "@opentelemetry/api": ">=1.0.0 <1.9.0",
     "@opentelemetry/core": "^1.14.0",
     "crypto-randomuuid": "^1.0.0",
-    "dc-polyfill": "^0.1.4",
+    "dc-polyfill": "0.1.6",
     "ignore": "^5.2.4",
     "import-in-the-middle": "1.13.1",
     "istanbul-lib-coverage": "3.2.0",
@@ -125,7 +125,7 @@
     "@msgpack/msgpack": "^3.0.0-beta3",
     "@stylistic/eslint-plugin-js": "^3.0.1",
     "@types/node": "^16.0.0",
-    "application-config-path": "^1.0.0",
+    "application-config-path": "^0.1.1",
     "autocannon": "^4.5.2",
     "aws-sdk": "^2.1446.0",
     "axios": "^1.8.2",

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

@@ -73,6 +73,7 @@ let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
+let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
 let numTestRetries = 0
 let knownTests = []
@@ -121,10 +122,10 @@ function isNewTest (testSuite, testName) {
 }
 
 function getTestProperties (testSuite, testName) {
-  const { disabled, quarantined } =
+  const { attempt_to_fix: attemptToFix, disabled, quarantined } =
     testManagementTests?.cucumber?.suites?.[testSuite]?.tests?.[testName]?.properties || {}
 
-  return { disabled, quarantined }
+  return { attemptToFix, disabled, quarantined }
 }
 
 function getTestStatusFromRetries (testStatuses) {
@@ -303,22 +304,42 @@ function wrapRun (pl, isLatestVersion) {
         }
         let isNew = false
         let isEfdRetry = false
+        let isAttemptToFix = false
+        let isAttemptToFixRetry = false
+        let hasFailedAllRetries = false
+        let hasPassedAllRetries = false
         let isDisabled = false
         let isQuarantined = false
-        if (isKnownTestsEnabled && status !== 'skip') {
-          const numRetries = numRetriesByPickleId.get(this.pickle.id)
 
-          isNew = numRetries !== undefined
-          isEfdRetry = numRetries > 0
-        }
         if (isTestManagementTestsEnabled) {
           const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
           const testProperties = getTestProperties(testSuitePath, this.pickle.name)
+          const numRetries = numRetriesByPickleId.get(this.pickle.id)
+          isAttemptToFix = testProperties.attemptToFix
+          isAttemptToFixRetry = isAttemptToFix && numRetries > 0
           isDisabled = testProperties.disabled
-          if (!isDisabled) {
-            isQuarantined = testProperties.quarantined
+          isQuarantined = testProperties.quarantined
+
+          if (isAttemptToFixRetry) {
+            const statuses = lastStatusByPickleId.get(this.pickle.id)
+            if (statuses.length === testManagementAttemptToFixRetries + 1) {
+              const { pass, fail } = statuses.reduce((acc, status) => {
+                acc[status]++
+                return acc
+              }, { pass: 0, fail: 0 })
+              hasFailedAllRetries = fail === testManagementAttemptToFixRetries + 1
+              hasPassedAllRetries = pass === testManagementAttemptToFixRetries + 1
+            }
           }
         }
+
+        if (isKnownTestsEnabled && status !== 'skip' && !isAttemptToFix) {
+          const numRetries = numRetriesByPickleId.get(this.pickle.id)
+
+          isNew = numRetries !== undefined
+          isEfdRetry = numRetries > 0
+        }
+
         const attemptAsyncResource = numAttemptToAsyncResource.get(numAttempt)
 
         const error = getErrorFromCucumberResult(result)
@@ -334,6 +355,10 @@ function wrapRun (pl, isLatestVersion) {
             isNew,
             isEfdRetry,
             isFlakyRetry: numAttempt > 0,
+            isAttemptToFix,
+            isAttemptToFixRetry,
+            hasFailedAllRetries,
+            hasPassedAllRetries,
             isDisabled,
             isQuarantined
           })
@@ -426,6 +451,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     numTestRetries = configurationResponse.libraryConfig?.flakyTestRetriesCount
     isKnownTestsEnabled = configurationResponse.libraryConfig?.isKnownTestsEnabled
     isTestManagementTestsEnabled = configurationResponse.libraryConfig?.isTestManagementEnabled
+    testManagementAttemptToFixRetries = configurationResponse.libraryConfig?.testManagementAttemptToFixRetries
 
     if (isKnownTestsEnabled) {
       const knownTestsResponse = await getChannelPromise(knownTestsCh)
@@ -576,22 +602,25 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     }
 
     let isNew = false
+    let isAttemptToFix = false
     let isDisabled = false
     let isQuarantined = false
 
-    if (isKnownTestsEnabled) {
-      isNew = isNewTest(testSuitePath, pickle.name)
-      if (isNew) {
-        numRetriesByPickleId.set(pickle.id, 0)
-      }
-    }
     if (isTestManagementTestsEnabled) {
       const testProperties = getTestProperties(testSuitePath, pickle.name)
+      isAttemptToFix = testProperties.attemptToFix
       isDisabled = testProperties.disabled
-      if (isDisabled) {
+      isQuarantined = testProperties.quarantined
+      // If attempt to fix is enabled, we run even if the test is disabled
+      if (!isAttemptToFix && isDisabled) {
         this.options.dryRun = true
-      } else {
-        isQuarantined = testProperties.quarantined
+      }
+    }
+
+    if (isKnownTestsEnabled && !isAttemptToFix) {
+      isNew = isNewTest(testSuitePath, pickle.name)
+      if (isNew) {
+        numRetriesByPickleId.set(pickle.id, 0)
       }
     }
     // TODO: for >=11 we could use `runTestCaseResult` instead of accumulating results in `lastStatusByPickleId`
@@ -599,6 +628,15 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
 
     const testStatuses = lastStatusByPickleId.get(pickle.id)
     const lastTestStatus = testStatuses[testStatuses.length - 1]
+
+    // New tests should not be marked as attempt to fix, so EFD + Attempt to fix should not be enabled at the same time
+    if (isAttemptToFix && lastTestStatus !== 'skip') {
+      for (let retryIndex = 0; retryIndex < testManagementAttemptToFixRetries; retryIndex++) {
+        numRetriesByPickleId.set(pickle.id, retryIndex + 1)
+        runTestCaseResult = await runTestCaseFunction.apply(this, arguments)
+      }
+    }
+
     // If it's a new test and it hasn't been skipped, we run it again
     if (isEarlyFlakeDetectionEnabled && lastTestStatus !== 'skip' && isNew) {
       for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
@@ -608,7 +646,7 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
     }
     let testStatus = lastTestStatus
     let shouldBePassedByEFD = false
-    let shouldBePassedByQuarantine = false
+    let shouldBePassedByTestManagement = false
     if (isNew && isEarlyFlakeDetectionEnabled) {
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
@@ -625,9 +663,9 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       }
     }
 
-    if (isTestManagementTestsEnabled && isQuarantined) {
+    if (isTestManagementTestsEnabled && (isDisabled || isQuarantined)) {
       this.success = true
-      shouldBePassedByQuarantine = true
+      shouldBePassedByTestManagement = true
     }
 
     if (!pickleResultByFile[testFileAbsolutePath]) {
@@ -661,8 +699,8 @@ function getWrappedRunTestCase (runTestCaseFunction, isNewerCucumberVersion = fa
       return shouldBePassedByEFD
     }
 
-    if (isNewerCucumberVersion && isTestManagementTestsEnabled && isQuarantined) {
-      return shouldBePassedByQuarantine
+    if (isNewerCucumberVersion && isTestManagementTestsEnabled && (isQuarantined || isDisabled)) {
+      return shouldBePassedByTestManagement
     }
 
     return runTestCaseResult

package/packages/datadog-instrumentations/src/dd-trace-api.js

@@ -0,0 +1,7 @@
+'use strict'
+
+const { addHook } = require('./helpers/instrument')
+
+// Empty hook just to make the plugin load.
+// TODO: Add version range when the module is released on npm.
+addHook({ name: 'dd-trace-api' }, api => api)

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

@@ -43,6 +43,7 @@ module.exports = {
   couchbase: () => require('../couchbase'),
   crypto: () => require('../crypto'),
   cypress: () => require('../cypress'),
+  'dd-trace-api': () => require('../dd-trace-api'),
   dns: () => require('../dns'),
   elasticsearch: () => require('../elasticsearch'),
   express: () => require('../express'),

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

@@ -158,7 +158,7 @@ for (const packageName of names) {
 }
 
 function matchVersion (version, ranges) {
-  return !version || (ranges && ranges.some(range => satisfies(version, range)))
+  return !version || !ranges || ranges.some(range => satisfies(version, range))
 }
 
 function getVersion (moduleBaseDir) {

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

@@ -13,7 +13,9 @@ const {
   addEfdStringToTestName,
   removeEfdStringFromTestName,
   getIsFaultyEarlyFlakeDetection,
-  JEST_WORKER_LOGS_PAYLOAD_CODE
+  JEST_WORKER_LOGS_PAYLOAD_CODE,
+  addAttemptToFixStringToTestName,
+  removeAttemptToFixStringFromTestName
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   getFormattedJestTestParameters,
@@ -73,6 +75,7 @@ let hasFilteredSkippableSuites = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
 let testManagementTests = {}
+let testManagementAttemptToFixRetries = 0
 
 const sessionAsyncResource = new AsyncResource('bound-anonymous-fn')
 
@@ -80,6 +83,7 @@ const asyncResources = new WeakMap()
 const originalTestFns = new WeakMap()
 const retriedTestsToNumAttempts = new Map()
 const newTestsTestStatuses = new Map()
+const attemptToFixRetriedTestsStatuses = new Map()
 
 const BREAKPOINT_HIT_GRACE_PERIOD_MS = 200
 
@@ -110,7 +114,7 @@ function getTestEnvironmentOptions (config) {
   return {}
 }
 
-function getEfdStats (testStatuses) {
+function getTestStats (testStatuses) {
   return testStatuses.reduce((acc, testStatus) => {
     acc[testStatus]++
     return acc
@@ -169,6 +173,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (this.isTestManagementTestsEnabled) {
         try {
           const hasTestManagementTests = !!testManagementTests.jest
+          testManagementAttemptToFixRetries = this.testEnvironmentOptions._ddTestManagementAttemptToFixRetries
           this.testManagementTestsForThisSuite = hasTestManagementTests
             ? this.getTestManagementTestsForSuite(testManagementTests.jest.suites?.[this.testSuite]?.tests)
             : this.getTestManagementTestsForSuite(this.testEnvironmentOptions._ddTestManagementTests)
@@ -213,9 +218,9 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (this.testManagementTestsForThisSuite) {
         return this.testManagementTestsForThisSuite
       }
-      // TODO - ADD ATTEMPT_TO_FIX tests
       if (!testManagementTests) {
         return {
+          attemptToFix: [],
           disabled: [],
           quarantined: []
         }
@@ -228,14 +233,19 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
 
       const result = {
+        attemptToFix: [],
         disabled: [],
         quarantined: []
       }
 
       Object.entries(testManagementTestsForSuite).forEach(([testName, { properties }]) => {
+        if (properties?.attempt_to_fix) {
+          result.attemptToFix.push(testName)
+        }
         if (properties?.disabled) {
           result.disabled.push(testName)
-        } else if (properties?.quarantined) {
+        }
+        if (properties?.quarantined) {
           result.quarantined.push(testName)
         }
       })
@@ -243,11 +253,30 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return result
     }
 
-    // Add the `add_test` event we don't have the test object yet, so
+    // Generic function to handle test retries
+    retryTest (testName, retryCount, addRetryStringToTestName, retryType, event) {
+      // Retrying snapshots has proven to be problematic, so we'll skip them for now
+      // We'll still detect new tests, but we won't retry them.
+      // TODO: do not bail out of retrying tests for the whole test suite
+      if (this.getHasSnapshotTests()) {
+        log.warn(`${retryType} is disabled for suites with snapshots`)
+        return
+      }
+
+      for (let retryIndex = 0; retryIndex < retryCount; retryIndex++) {
+        if (this.global.test) {
+          this.global.test(addRetryStringToTestName(testName, retryIndex), event.fn, event.timeout)
+        } else {
+          log.error(`${retryType} could not retry test because global.test is undefined`)
+        }
+      }
+    }
+
+    // At the `add_test` event we don't have the test object yet, so we can't use it
     getTestNameFromAddTestEvent (event, state) {
       const describeSuffix = getJestTestName(state.currentDescribeBlock)
       const fullTestName = describeSuffix ? `${describeSuffix} ${event.testName}` : event.testName
-      return removeEfdStringFromTestName(fullTestName)
+      return removeAttemptToFixStringFromTestName(removeEfdStringFromTestName(fullTestName))
     }
 
     async handleTestEvent (event, state) {
@@ -273,15 +302,31 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (event.name === 'test_start') {
         let isNewTest = false
         let numEfdRetry = null
+        let numOfAttemptsToFixRetries = null
         const testParameters = getTestParametersString(this.nameToParams, event.test.name)
         // Async resource for this test is created here
         // It is used later on by the test_done handler
         const asyncResource = new AsyncResource('bound-anonymous-fn')
         asyncResources.set(event.test, asyncResource)
         const testName = getJestTestName(event.test)
+        const originalTestName = removeEfdStringFromTestName(removeAttemptToFixStringFromTestName(testName))
+
+        let isAttemptToFix = false
+        let isDisabled = false
+        let isQuarantined = false
+        if (this.isTestManagementTestsEnabled) {
+          isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
+          isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(originalTestName)
+          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(originalTestName)
+          if (isAttemptToFix) {
+            numOfAttemptsToFixRetries = retriedTestsToNumAttempts.get(originalTestName)
+            retriedTestsToNumAttempts.set(originalTestName, numOfAttemptsToFixRetries + 1)
+          } else if (isDisabled) {
+            event.test.mode = 'skip'
+          }
+        }
 
         if (this.isKnownTestsEnabled) {
-          const originalTestName = removeEfdStringFromTestName(testName)
           isNewTest = retriedTestsToNumAttempts.has(originalTestName)
           if (isNewTest) {
             numEfdRetry = retriedTestsToNumAttempts.get(originalTestName)
@@ -289,16 +334,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
 
-        if (this.isTestManagementTestsEnabled) {
-          const isDisabled = this.testManagementTestsForThisSuite?.disabled?.includes(testName)
-          if (isDisabled) {
-            event.test.mode = 'skip'
-          }
-        }
         const isJestRetry = event.test?.invocations > 1
         asyncResource.runInAsyncScope(() => {
           testStartCh.publish({
-            name: removeEfdStringFromTestName(testName),
+            name: originalTestName,
             suite: this.testSuite,
             testSourceFile: this.testSourceFile,
             displayName: this.displayName,
@@ -306,34 +345,46 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             frameworkVersion: jestVersion,
             isNew: isNewTest,
             isEfdRetry: numEfdRetry > 0,
-            isJestRetry
+            isAttemptToFix,
+            isAttemptToFixRetry: numOfAttemptsToFixRetries > 0,
+            isJestRetry,
+            isDisabled,
+            isQuarantined
           })
           originalTestFns.set(event.test, event.test.fn)
           event.test.fn = asyncResource.bind(event.test.fn)
         })
       }
+
       if (event.name === 'add_test') {
+        const originalTestName = this.getTestNameFromAddTestEvent(event, state)
+
+        const isSkipped = event.mode === 'todo' || event.mode === 'skip'
+        if (this.isTestManagementTestsEnabled) {
+          const isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
+          if (isAttemptToFix && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
+            retriedTestsToNumAttempts.set(originalTestName, 0)
+            this.retryTest(
+              event.testName,
+              testManagementAttemptToFixRetries,
+              addAttemptToFixStringToTestName,
+              'Test Management (Attempt to Fix)',
+              event
+            )
+          }
+        }
         if (this.isKnownTestsEnabled) {
-          const testName = this.getTestNameFromAddTestEvent(event, state)
-          const isNew = !this.knownTestsForThisSuite?.includes(testName)
-          const isSkipped = event.mode === 'todo' || event.mode === 'skip'
-          if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(testName)) {
-            retriedTestsToNumAttempts.set(testName, 0)
+          const isNew = !this.knownTestsForThisSuite?.includes(originalTestName)
+          if (isNew && !isSkipped && !retriedTestsToNumAttempts.has(originalTestName)) {
+            retriedTestsToNumAttempts.set(originalTestName, 0)
             if (this.isEarlyFlakeDetectionEnabled) {
-              // Retrying snapshots has proven to be problematic, so we'll skip them for now
-              // We'll still detect new tests, but we won't retry them.
-              // TODO: do not bail out of EFD with the whole test suite
-              if (this.getHasSnapshotTests()) {
-                log.warn('Early flake detection is disabled for suites with snapshots')
-                return
-              }
-              for (let retryIndex = 0; retryIndex < earlyFlakeDetectionNumRetries; retryIndex++) {
-                if (this.global.test) {
-                  this.global.test(addEfdStringToTestName(event.testName, retryIndex), event.fn, event.timeout)
-                } else {
-                  log.error('Early flake detection could not retry test because global.test is undefined')
-                }
-              }
+              this.retryTest(
+                event.testName,
+                earlyFlakeDetectionNumRetries,
+                addEfdStringToTestName,
+                'Early flake detection',
+                event
+              )
             }
           }
         }
@@ -346,6 +397,32 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         // restore in case it is retried
         event.test.fn = originalTestFns.get(event.test)
 
+        let attemptToFixPassed = false
+        let failedAllTests = false
+        if (this.isTestManagementTestsEnabled) {
+          const testName = getJestTestName(event.test)
+          const originalTestName = removeAttemptToFixStringFromTestName(testName)
+          const isAttemptToFix = this.testManagementTestsForThisSuite?.attemptToFix?.includes(originalTestName)
+          if (isAttemptToFix) {
+            if (attemptToFixRetriedTestsStatuses.has(originalTestName)) {
+              attemptToFixRetriedTestsStatuses.get(originalTestName).push(status)
+            } else {
+              attemptToFixRetriedTestsStatuses.set(originalTestName, [status])
+            }
+            const testStatuses = attemptToFixRetriedTestsStatuses.get(originalTestName)
+            // Check if this is the last attempt to fix.
+            // If it is, we'll set the failedAllTests flag to true if all the tests failed
+            // If all tests passed, we'll set the attemptToFixPassed flag to true
+            if (testStatuses.length === testManagementAttemptToFixRetries + 1) {
+              if (testStatuses.every(status => status === 'fail')) {
+                failedAllTests = true
+              } else if (testStatuses.every(status => status === 'pass')) {
+                attemptToFixPassed = true
+              }
+            }
+          }
+        }
+
         // We'll store the test statuses of the retries
         if (this.isKnownTestsEnabled) {
           const testName = getJestTestName(event.test)
@@ -359,12 +436,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             }
           }
         }
-        let isQuarantined = false
-
-        if (this.isTestManagementTestsEnabled) {
-          const testName = getJestTestName(event.test)
-          isQuarantined = this.testManagementTestsForThisSuite?.quarantined?.includes(testName)
-        }
 
         const promises = {}
         const numRetries = this.global[RETRY_TIMES]
@@ -399,7 +470,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           testFinishCh.publish({
             status,
             testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
-            isQuarantined
+            attemptToFixPassed,
+            failedAllTests
           })
         })
 
@@ -552,6 +624,7 @@ function cliWrapper (cli, jestVersion) {
         earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
         isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
         isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
+        testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
       }
     } catch (err) {
       log.error('Jest library configuration error', err)
@@ -710,7 +783,7 @@ function cliWrapper (cli, jestVersion) {
     if (isEarlyFlakeDetectionEnabled) {
       let numFailedTestsToIgnore = 0
       for (const testStatuses of newTestsTestStatuses.values()) {
-        const { pass, fail } = getEfdStats(testStatuses)
+        const { pass, fail } = getTestStats(testStatuses)
         if (pass > 0) { // as long as one passes, we'll consider the test passed
           numFailedTestsToIgnore += fail
         }
@@ -725,29 +798,41 @@ function cliWrapper (cli, jestVersion) {
       const failedTests = result
         .results
         .testResults.flatMap(({ testResults, testFilePath: testSuiteAbsolutePath }) => (
-          testResults.map(({ fullName: testName, status }) => ({ testName, testSuiteAbsolutePath, status }))
+          testResults.map(({ fullName: testName, status }) => (
+            { testName, testSuiteAbsolutePath, status }
+          ))
         ))
         .filter(({ status }) => status === 'failed')
 
       let numFailedQuarantinedTests = 0
+      let numFailedQuarantinedOrDisabledAttemptedToFixTests = 0
 
       for (const { testName, testSuiteAbsolutePath } of failedTests) {
         const testSuite = getTestSuitePath(testSuiteAbsolutePath, result.globalConfig.rootDir)
-        const isQuarantined = testManagementTests
+        const originalName = removeAttemptToFixStringFromTestName(testName)
+        const testManagementTest = testManagementTests
           ?.jest
           ?.suites
           ?.[testSuite]
           ?.tests
-          ?.[testName]
+          ?.[originalName]
           ?.properties
-          ?.quarantined
-        if (isQuarantined) {
+        // 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++
+        } else if (testManagementTest?.quarantined) {
           numFailedQuarantinedTests++
         }
       }
 
       // If every test that failed was quarantined, we'll consider the suite passed
-      if (numFailedQuarantinedTests !== 0 && result.results.numFailedTests === numFailedQuarantinedTests) {
+      // 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)
+      if (
+        (numFailedQuarantinedOrDisabledAttemptedToFixTests !== 0 || numFailedQuarantinedTests !== 0) &&
+        result.results.numFailedTests ===
+          numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
+      ) {
         result.results.success = true
       }
     }
@@ -947,6 +1032,7 @@ addHook({
       _ddIsKnownTestsEnabled,
       _ddIsTestManagementTestsEnabled,
       _ddTestManagementTests,
+      _ddTestManagementAttemptToFixRetries,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 

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

@@ -30,7 +30,9 @@ const {
   newTests,
   testsQuarantined,
   getTestFullName,
-  getRunTestsWrapper
+  getRunTestsWrapper,
+  testsAttemptToFix,
+  testsStatuses
 } = require('./utils')
 
 require('./common')
@@ -138,16 +140,26 @@ 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
     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
-      this.failures -= numFailedQuarantinedTests
+      this.stats.failures -= numFailedQuarantinedTests + numFailedRetriedQuarantinedOrDisabledTests
+      this.failures -= numFailedQuarantinedTests + numFailedRetriedQuarantinedOrDisabledTests
     }
 
     if (status === 'fail') {
@@ -193,6 +205,7 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     if (err) {
       config.testManagementTests = {}
       config.isTestManagementTestsEnabled = false
+      config.testManagementAttemptToFixRetries = 0
     } else {
       config.testManagementTests = receivedTestManagementTests
     }
@@ -260,6 +273,7 @@ function getExecutionConfiguration (runner, isParallel, onFinishRequest) {
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
+    config.testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
     // ITR and auto test retries are not supported in parallel mode yet
     config.isSuitesSkippingEnabled = !isParallel && libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = !isParallel && libraryConfig.isFlakyTestRetriesEnabled
@@ -401,7 +415,7 @@ addHook({
 
     this.on('test', getOnTestHandler(true))
 
-    this.on('test end', getOnTestEndHandler())
+    this.on('test end', getOnTestEndHandler(config))
 
     this.on('retry', getOnTestRetryHandler())
 
@@ -637,6 +651,8 @@ addHook({
     if (config.isTestManagementTestsEnabled) {
       const testSuiteTestManagementTests = config.testManagementTests?.mocha?.suites?.[testPath] || {}
       newWorkerArgs._ddIsTestManagementTestsEnabled = true
+      // TODO: attempt to fix does not work in parallel mode yet
+      // newWorkerArgs._ddTestManagementAttemptToFixRetries = config.testManagementAttemptToFixRetries
       newWorkerArgs._ddTestManagementTests = {
         mocha: {
           suites: {