dd-trace 6.7.0 → 6.9.0

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

@@ -41,11 +41,9 @@ addHook({
 }, (Suite) => {
   shimmer.wrap(Suite.prototype, 'addTest', addTest => function (test) {
     const callSites = getCallSites()
-    let startLine
     const testCallSite = callSites.find(site => site.getFileName() === test.file)
     if (testCallSite) {
-      startLine = testCallSite.getLineNumber()
-      testToStartLine.set(test, startLine)
+      testToStartLine.set(test, testCallSite.getLineNumber())
     }
     return addTest.apply(this, arguments)
   })

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

@@ -11,11 +11,13 @@ const {
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 const { isMarkedAsUnskippable } = require('../../../datadog-plugin-jest/src/util')
+const { EMPTY_EFD_RETRY_POLICY } = require('../../../dd-trace/src/ci-visibility/efd-retry-policy')
 const { writeCoverageBackfillToCache } = require('../../../dd-trace/src/ci-visibility/test-optimization-cache')
 const log = require('../../../dd-trace/src/log')
 const { getEnvironmentVariable } = require('../../../dd-trace/src/config/helper')
 const {
   getTestSuitePath,
+  MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   fromCoverageMapToCoverage,
   getCoveredFilesFromCoverage,
@@ -28,6 +30,7 @@ const {
   getTestCoverageLinesPercentage,
   collectTestOptimizationSummariesFromTraces,
   logTestOptimizationSummary,
+  TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE,
   getTestOptimizationRequestResults,
   isModifiedTest,
 } = require('../../../dd-trace/src/plugins/util/test')
@@ -53,6 +56,7 @@ const {
   newTestsWithDynamicNames,
   attemptToFixExecutions,
   loggedAttemptToFixTests,
+  adjustRunnerFailuresForTestOptimization,
 } = require('./utils')
 
 require('./common')
@@ -65,12 +69,15 @@ let hasWarnedDeprecatedMochaVersion = false
 const unskippableSuites = []
 let suitesToSkip = []
 let isSuitesSkipped = false
+let areAllSuitesSkipped = false
 let skippedSuites = []
 let skippableSuitesCoverage = {}
 let skippedSuitesCoverage = {}
 let itrCorrelationId = ''
 let isForcedToRun = false
-const config = {}
+const config = {
+  earlyFlakeDetectionRetryPolicy: EMPTY_EFD_RETRY_POLICY,
+}
 
 // We'll preserve the original coverage here
 const originalCoverageMap = createCoverageMap()
@@ -94,6 +101,7 @@ const mochaGlobalRunCh = channel('ci:mocha:global:run')
 const testManagementTestsCh = channel('ci:mocha:test-management-tests')
 const modifiedFilesCh = channel('ci:mocha:modified-files')
 const workerReportTraceCh = channel('ci:mocha:worker-report:trace')
+const workerReportTelemetryCh = channel('ci:mocha:worker-report:telemetry')
 const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
 const itrSkippedSuitesCh = channel('ci:mocha:itr:skipped-suites')
@@ -114,17 +122,6 @@ function warnDeprecatedMochaVersion (frameworkVersion) {
   )
 }
 
-// Tests from workers do not come with `isFailed` method
-function isTestFailed (test) {
-  if (test.isFailed) {
-    return test.isFailed()
-  }
-  if (test.isPending) {
-    return !test.isPending() && test.state === 'failed'
-  }
-  return false
-}
-
 function getRootSuiteStatus (rootTests) {
   let status = 'pass'
   if (rootTests.every(t => t.isPending())) {
@@ -237,6 +234,7 @@ function getMochaTestSessionCoverageFiles () {
 
 function resetSuiteSkippingRunState () {
   isSuitesSkipped = false
+  areAllSuitesSkipped = false
   skippedSuites = []
   skippableSuitesCoverage = {}
   skippedSuitesCoverage = {}
@@ -309,37 +307,7 @@ function getOnEndHandler (isParallel, onDone) {
       status = 'fail'
     }
 
-    if (config.isEarlyFlakeDetectionEnabled) {
-      /**
-       * If Early Flake Detection (EFD) is enabled the logic is as follows:
-       * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
-       * - If just a single attempt passes, we will prevent the test process from failing.
-       * The rationale behind is the following: you may still be able to block your CI pipeline by gating
-       * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
-       */
-      for (const tests of Object.values(efdTests)) {
-        const failingEfdTests = tests.filter(test => isTestFailed(test))
-        const areAllEfdTestsFailing = failingEfdTests.length === tests.length
-        const nonQuarantinedFailingEfdTests = failingEfdTests.filter(test => !testsQuarantined.has(test))
-        if (nonQuarantinedFailingEfdTests.length && !areAllEfdTestsFailing) {
-          this.stats.failures -= nonQuarantinedFailingEfdTests.length
-          this.failures -= nonQuarantinedFailingEfdTests.length
-        }
-      }
-    }
-
-    // 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
-      for (const test of testsQuarantined) {
-        if (isTestFailed(test)) {
-          numFailedQuarantinedTests++
-        }
-      }
-      this.stats.failures -= numFailedQuarantinedTests
-      this.failures -= numFailedQuarantinedTests
-    }
+    adjustRunnerFailuresForTestOptimization(this, config)
 
     // Recompute status after EFD and quarantine adjustments have reduced failure counts
     if (status === 'fail') {
@@ -397,7 +365,11 @@ function getOnEndHandler (isParallel, onDone) {
       isParallel,
     }, onDone)
 
-    logTestOptimizationSummary({ attemptToFixExecutions, newTestsWithDynamicNames })
+    logTestOptimizationSummary({
+      attemptToFixExecutions,
+      newTestsWithDynamicNames,
+      extraSections: areAllSuitesSkipped ? [TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE] : [],
+    })
     loggedAttemptToFixTests.clear()
   }
 }
@@ -426,6 +398,57 @@ function isFailedTestReplayEnabled () {
   return config.isTestDynamicInstrumentationEnabled && config.isDiEnabled
 }
 
+/**
+ * @typedef {object} MochaSuite
+ * @property {MochaSuite[]} suites
+ * @property {import('mocha').Test[]} tests
+ * @property {MochaSuite[]} _onlySuites
+ * @property {import('mocha').Test[]} _onlyTests
+ */
+
+/**
+ * Mirrors Mocha 5's private exclusivity check.
+ *
+ * @param {MochaSuite} suite
+ * @returns {boolean}
+ */
+function hasOnly (suite) {
+  if (suite._onlyTests.length || suite._onlySuites.length) return true
+
+  for (const childSuite of suite.suites) {
+    if (hasOnly(childSuite)) return true
+  }
+  return false
+}
+
+/**
+ * Mirrors Mocha 5's private exclusivity filter.
+ *
+ * @param {MochaSuite} suite
+ * @returns {boolean}
+ */
+function filterOnly (suite) {
+  if (suite._onlyTests.length) {
+    suite.tests = suite._onlyTests
+    suite.suites = []
+  } else {
+    suite.tests = []
+
+    for (const onlySuite of suite._onlySuites) {
+      if (hasOnly(onlySuite)) filterOnly(onlySuite)
+    }
+
+    const filteredSuites = []
+    for (const childSuite of suite.suites) {
+      if (suite._onlySuites.includes(childSuite) || filterOnly(childSuite)) {
+        filteredSuites.push(childSuite)
+      }
+    }
+    suite.suites = filteredSuites
+  }
+  return suite.tests.length > 0 || suite.suites.length > 0
+}
+
 function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFinishRequest, localSuites) {
   const ctx = {
     isParallel,
@@ -458,6 +481,13 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     }
 
     // We remove the suites that we skip through ITR
+    // Mocha normally applies exclusivity after this asynchronous configuration step.
+    if (typeof runner.suite.hasOnly === 'function') {
+      if (runner.suite.hasOnly()) runner.suite.filterOnly()
+    } else if (hasOnly(runner.suite)) {
+      filterOnly(runner.suite)
+    }
+    const numTestsToRun = runner.grepTotal(runner.suite)
     const filteredSuites = getFilteredSuites(runner.suite.suites)
     const { suitesToRun, suitesToSkipForRun } = filteredSuites
 
@@ -466,6 +496,7 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     log.debug('%d out of %d suites are going to run.', suitesToRun.length, runner.suite.suites.length)
 
     runner.suite.suites = suitesToRun
+    areAllSuitesSkipped = isSuitesSkipped && numTestsToRun > 0 && runner.grepTotal(runner.suite) === 0
 
     skippedSuites = [...filteredSuites.skippedSuites]
     suitesToSkip = suitesToSkipForRun
@@ -529,8 +560,8 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     }
     config.repositoryRoot = repositoryRoot
     config.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
-    config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
-    config.earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
+    config.earlyFlakeDetectionRetryPolicy =
+      libraryConfig.earlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
     config.earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold
     config.isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
@@ -1018,6 +1049,8 @@ function onMessage (message) {
         attemptToFixExecutions,
       })
       workerReportTraceCh.publish(payload)
+    } else if (messageCode === MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE) {
+      workerReportTelemetryCh.publish(payload)
     }
   }
 }
@@ -1082,7 +1115,7 @@ addHook({
   versions: ['>=8.0.0'],
   file: 'lib/nodejs/parallel-buffered-runner.js',
 }, (ParallelBufferedRunner, frameworkVersion) => {
-  shimmer.wrap(ParallelBufferedRunner.prototype, 'run', run => function (cb, { files }) {
+  shimmer.wrap(ParallelBufferedRunner.prototype, 'run', run => function (cb, { files, options = {} }) {
     if (!testFinishCh.hasSubscribers) {
       return run.apply(this, arguments)
     }
@@ -1128,10 +1161,11 @@ addHook({
           }
         }
         isSuitesSkipped = skippedFiles.length > 0
+        areAllSuitesSkipped = options.grep === undefined && files.length > 0 && filteredFiles.length === 0
         skippedSuites = skippedFiles
         skippedSuitesCoverage = getSkippedSuitesCoverageForRun()
         writeCoverageBackfillToCache(skippedSuitesCoverage, getCoverageRootDir())
-        run.apply(this, [onRunDone, { files: filteredFiles }])
+        run.apply(this, [onRunDone, { files: filteredFiles, options }])
       } else {
         run.apply(this, arguments)
       }
@@ -1150,9 +1184,34 @@ addHook({
   name: 'mocha',
   versions: ['>=8.0.0'],
   file: 'lib/nodejs/buffered-worker-pool.js',
-}, (BufferedWorkerPoolPackage) => {
+}, (BufferedWorkerPoolPackage, frameworkVersion) => {
   const { BufferedWorkerPool } = BufferedWorkerPoolPackage
 
+  if (satisfies(frameworkVersion, '<9.2.0')) {
+    // Shimmer is required because the worker environment must be changed before workerpool forks,
+    // before any test lifecycle hook can run. Mocha added this worker ID itself in 9.2.0.
+    shimmer.wrap(BufferedWorkerPool, 'create', create => function () {
+      const pool = create.apply(this, arguments)
+
+      if (!testFinishCh.hasSubscribers) return pool
+
+      let workerId = 0
+      shimmer.wrap(pool._pool, '_createWorkerHandler', createWorkerHandler => function () {
+        this.forkOpts = {
+          ...this.forkOpts,
+          env: {
+            // eslint-disable-next-line eslint-rules/eslint-process-env
+            ...(this.forkOpts.env || process.env),
+            MOCHA_WORKER_ID: String(workerId++),
+          },
+        }
+        return createWorkerHandler.apply(this, arguments)
+      })
+
+      return pool
+    })
+  }
+
   shimmer.wrap(BufferedWorkerPool.prototype, 'run', run => async function (testSuiteAbsolutePath, workerArgs) {
     if (!testFinishCh.hasSubscribers ||
         (!config.isKnownTestsEnabled &&
@@ -1170,8 +1229,7 @@ addHook({
     if (config.isKnownTestsEnabled) {
       if (config.knownTests?.mocha) {
         const testSuiteKnownTests = config.knownTests.mocha[testPath] || []
-        newWorkerArgs._ddEfdNumRetries = config.earlyFlakeDetectionNumRetries
-        newWorkerArgs._ddEfdSlowTestRetries = config.earlyFlakeDetectionSlowTestRetries
+        newWorkerArgs._ddEfdRetryPolicy = config.earlyFlakeDetectionRetryPolicy
         newWorkerArgs._ddIsEfdEnabled = config.isEarlyFlakeDetectionEnabled
         newWorkerArgs._ddIsKnownTestsEnabled = true
         newWorkerArgs._ddKnownTests = {

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

@@ -2,11 +2,16 @@
 
 const { performance } = require('node:perf_hooks')
 
+const { getEnvironmentVariable } = require('../../../dd-trace/src/config/helper')
+const {
+  getEfdRetryCountForDuration,
+  hasEfdRetries,
+  shouldSkipEfdRetry,
+} = require('../../../dd-trace/src/ci-visibility/efd-retry-policy')
 const {
   getTestSuitePath,
   DYNAMIC_NAME_RE,
-  getEfdRetryCount,
-  getMaxEfdRetryCount,
+  recordTestManagementExecution,
   recordAttemptToFixExecution,
   logAttemptToFixTestExecution,
 } = require('../../../dd-trace/src/plugins/util/test')
@@ -26,6 +31,8 @@ const isModifiedCh = channel('ci:mocha:test:is-modified')
 // suite channels
 const testSuiteErrorCh = channel('ci:mocha:test-suite:error')
 
+/** @typedef {{ length: number, [index: number]: unknown } & Iterable<unknown>} ArgumentsLike */
+
 const testToContext = new WeakMap()
 const originalFns = new WeakMap()
 const testToStartLine = new WeakMap()
@@ -40,6 +47,7 @@ const testsStatuses = new Map()
 const efdRetryCountByTestFullName = new Map()
 const efdSlowAbortedTests = new Set()
 const attemptToFixExecutions = new Map()
+const isMochaWorker = !!getEnvironmentVariable('MOCHA_WORKER_ID')
 
 function waitForHitProbe () {
   const promises = {}
@@ -48,6 +56,59 @@ function waitForHitProbe () {
 }
 const loggedAttemptToFixTests = new Set()
 
+/**
+ * Checks whether a Mocha test failed, including serialized tests from parallel workers.
+ *
+ * @param {object} test
+ * @returns {boolean}
+ */
+function isTestFailed (test) {
+  if (test.isFailed) {
+    return test.isFailed()
+  }
+  if (test.isPending) {
+    return !test.isPending() && test.state === 'failed'
+  }
+  return false
+}
+
+/**
+ * Applies EFD and quarantine failure suppression to a completed Mocha runner.
+ *
+ * @param {object} runner
+ * @param {object} config
+ * @returns {void}
+ */
+function adjustRunnerFailuresForTestOptimization (runner, config) {
+  if (config.isEarlyFlakeDetectionEnabled) {
+    for (const tests of Object.values(efdTests)) {
+      const executedEfdTests = tests.filter(test => !test.isPending())
+      const failingEfdTests = tests.filter(test => isTestFailed(test))
+      const areAllEfdTestsFailing = failingEfdTests.length === executedEfdTests.length
+      const nonQuarantinedFailingEfdTests = failingEfdTests.filter(test => !testsQuarantined.has(test))
+      if (nonQuarantinedFailingEfdTests.length && !areAllEfdTestsFailing) {
+        if (runner.stats) {
+          runner.stats.failures -= nonQuarantinedFailingEfdTests.length
+        }
+        runner.failures -= nonQuarantinedFailingEfdTests.length
+      }
+    }
+  }
+
+  if (config.isTestManagementTestsEnabled) {
+    let numFailedQuarantinedTests = 0
+    for (const test of testsQuarantined) {
+      if (isTestFailed(test)) {
+        numFailedQuarantinedTests++
+      }
+    }
+    if (runner.stats) {
+      runner.stats.failures -= numFailedQuarantinedTests
+    }
+    runner.failures -= numFailedQuarantinedTests
+  }
+}
+
 function getAfterEachHooks (testOrHook) {
   const hooks = []
 
@@ -80,19 +141,28 @@ function isNewTest (test, knownTests) {
   return !testsForSuite.includes(testName)
 }
 
-function setEfdRetryCountForTest (test, duration, slowTestRetries) {
+/**
+ * @param {import('mocha').Test} test
+ * @param {number} duration
+ * @param {import('../../../dd-trace/src/ci-visibility/efd-retry-policy').EfdRetryPolicy} retryPolicy
+ */
+function setEfdRetryCountForTest (test, duration, retryPolicy) {
   const testName = getTestFullName(test)
   if (efdRetryCountByTestFullName.has(testName)) {
     return
   }
-  const retryCount = getEfdRetryCount(duration, slowTestRetries || {})
+  const retryCount = getEfdRetryCountForDuration(duration, retryPolicy)
   efdRetryCountByTestFullName.set(testName, retryCount)
   if (retryCount === 0) {
     efdSlowAbortedTests.add(testName)
   }
 }
 
-function wrapOriginalEfdTest (test, slowTestRetries) {
+/**
+ * @param {import('mocha').Test} test
+ * @param {import('../../../dd-trace/src/ci-visibility/efd-retry-policy').EfdRetryPolicy} retryPolicy
+ */
+function wrapOriginalEfdTest (test, retryPolicy) {
   if (test._ddEfdDurationWrapped || typeof test.fn !== 'function') {
     return
   }
@@ -101,7 +171,7 @@ function wrapOriginalEfdTest (test, slowTestRetries) {
   test.fn = shimmer.wrapFunction(originalFn, originalFn => function () {
     const start = performance.now()
     const recordDuration = () => {
-      setEfdRetryCountForTest(test, performance.now() - start, slowTestRetries)
+      setEfdRetryCountForTest(test, performance.now() - start, retryPolicy)
     }
 
     if (originalFn.length > 0) {
@@ -152,38 +222,51 @@ function disableMochaRetries (test) {
  *   _ddIsModified?: boolean,
  *   _ddIsNew?: boolean
  * }} test
- * @param {{ isEarlyFlakeDetectionEnabled?: boolean }} config
+ * @param {{
+ *   isEarlyFlakeDetectionEnabled?: boolean,
+ *   earlyFlakeDetectionRetryPolicy?: import('../../../dd-trace/src/ci-visibility/efd-retry-policy').EfdRetryPolicy
+ * }} config
  * @returns {boolean}
  */
 function isDatadogManagedRetryTest (test, config) {
-  return test._ddIsAttemptToFix ||
-    test._ddIsEfdRetry ||
-    (config.isEarlyFlakeDetectionEnabled && (test._ddIsNew || test._ddIsModified))
+  return test._ddIsAttemptToFix || isEarlyFlakeDetectionTest(test, config)
 }
 
 /**
  * Checks whether a runnable belongs to an Early Flake Detection execution.
  * @param {{
  *   _ddIsAttemptToFix?: boolean,
+ *   _ddIsDisabled?: boolean,
  *   _ddIsEfdRetry?: boolean,
  *   _ddIsModified?: boolean,
  *   _ddIsNew?: boolean
  * }} test
- * @param {{ isEarlyFlakeDetectionEnabled?: boolean }} config
+ * @param {{
+ *   isEarlyFlakeDetectionEnabled?: boolean,
+ *   earlyFlakeDetectionRetryPolicy?: import('../../../dd-trace/src/ci-visibility/efd-retry-policy').EfdRetryPolicy
+ * }} config
  * @returns {boolean}
  */
 function isEarlyFlakeDetectionTest (test, config) {
   return !test._ddIsAttemptToFix &&
+    !test._ddIsDisabled &&
     config.isEarlyFlakeDetectionEnabled &&
+    hasEfdRetries(config.earlyFlakeDetectionRetryPolicy) &&
     (test._ddIsEfdRetry || test._ddIsNew || test._ddIsModified)
 }
 
-function retryTest (test, numRetries, tags, slowTestRetries) {
+/**
+ * @param {import('mocha').Test} test
+ * @param {number} numRetries
+ * @param {string[]} tags
+ * @param {import('../../../dd-trace/src/ci-visibility/efd-retry-policy').EfdRetryPolicy} retryPolicy
+ */
+function retryTest (test, numRetries, tags, retryPolicy) {
   const suite = test.parent
   const isEfdRetry = tags.includes('_ddIsEfdRetry')
   disableMochaRetries(test)
   if (isEfdRetry) {
-    wrapOriginalEfdTest(test, slowTestRetries)
+    wrapOriginalEfdTest(test, retryPolicy)
   }
   for (let retryIndex = 0; retryIndex < numRetries; retryIndex++) {
     const clonedTest = test.clone()
@@ -195,7 +278,7 @@ function retryTest (test, numRetries, tags, slowTestRetries) {
       if (typeof originalFn === 'function') {
         clonedTest.fn = shimmer.wrapFunction(originalFn, originalFn => function (...args) {
           const efdRetryCount = efdRetryCountByTestFullName.get(getTestFullName(clonedTest))
-          if (efdRetryCount !== undefined && clonedTest._ddEfdRetryIndex > efdRetryCount) {
+          if (shouldSkipEfdRetry(clonedTest._ddEfdRetryIndex, efdRetryCount)) {
             clonedTest._ddShouldSkipEfdRetry = true
             this.skip()
           }
@@ -211,14 +294,6 @@ function retryTest (test, numRetries, tags, slowTestRetries) {
   }
 }
 
-function getConfiguredEfdRetryCount (config) {
-  const { earlyFlakeDetectionSlowTestRetries } = config
-  if (!earlyFlakeDetectionSlowTestRetries || !Object.keys(earlyFlakeDetectionSlowTestRetries).length) {
-    return config.earlyFlakeDetectionNumRetries
-  }
-  return getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
-}
-
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
   function getSuites (suite) {
@@ -407,7 +482,7 @@ function getOnTestHandler (isMain) {
 
     if (isEfdRetry) {
       const efdRetryCount = efdRetryCountByTestFullName.get(getTestFullName(test))
-      if (efdRetryCount !== undefined && test._ddEfdRetryIndex > efdRetryCount) {
+      if (shouldSkipEfdRetry(test._ddEfdRetryIndex, efdRetryCount)) {
         test.pending = true
         test._ddShouldSkipEfdRetry = true
         return
@@ -521,7 +596,7 @@ function getTestFinishInfo (test, status, config, error) {
     !efdRetryCountByTestFullName.has(testName)
   ) {
     const duration = test.duration > 0 ? test.duration : performance.now() - test._ddStartTime
-    setEfdRetryCountForTest(test, duration, config.earlyFlakeDetectionSlowTestRetries)
+    setEfdRetryCountForTest(test, duration, config.earlyFlakeDetectionRetryPolicy)
   }
 
   if (testsStatuses.get(testName)) {
@@ -532,7 +607,8 @@ function getTestFinishInfo (test, status, config, error) {
   const testStatuses = testsStatuses.get(testName)
 
   const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
-  const efdRetryCount = efdRetryCountByTestFullName.get(testName) ?? getConfiguredEfdRetryCount(config)
+  const efdRetryCount = efdRetryCountByTestFullName.get(testName) ??
+    config.earlyFlakeDetectionRetryPolicy.schedulingRetryCount
   const isLastEfdRetry = testStatuses.length === efdRetryCount + 1
   const isLastAtrAttempt = getIsLastRetry(test) || (config.isFlakyTestRetriesEnabled && status === 'pass')
 
@@ -587,6 +663,17 @@ function getTestFinishInfo (test, status, config, error) {
     isFinalAttempt,
   })
 
+  if (!isMochaWorker) {
+    recordTestManagementExecution({
+      testSuite: getTestSuitePath(test.file, process.cwd()),
+      testName: test.fullTitle(),
+      status,
+      isAttemptToFix: _ddIsAttemptToFix,
+      isDisabled: _ddIsDisabled,
+      isQuarantined: _ddIsQuarantined,
+    })
+  }
+
   if (_ddIsAttemptToFix) {
     recordAttemptToFixExecution(attemptToFixExecutions, {
       testSuite: getTestSuitePath(test.file, process.cwd()),
@@ -733,7 +820,7 @@ function finishDeferredHookEnd (test) {
  * @param {object} test - Mocha test currently owning the hook.
  * @param {Promise<void>|undefined} failedTestReplayPromise - Pending Failed Test Replay wait, if any.
  * @param {unknown} hookThis - Callback receiver.
- * @param {IArguments} args - Arguments passed by Mocha.
+ * @param {ArgumentsLike} args - Arguments passed by Mocha.
  * @returns {unknown}
  */
 function runFailedTestReplayHookUpCallback (fn, test, failedTestReplayPromise, hookThis, args) {
@@ -949,12 +1036,12 @@ function getRunTestsWrapper (runTests, config) {
           onDone: (isModified) => {
             if (isModified) {
               test._ddIsModified = true
-              if (!test.isPending() && !test._ddIsAttemptToFix && config.isEarlyFlakeDetectionEnabled) {
+              if (!test.isPending() && isEarlyFlakeDetectionTest(test, config)) {
                 retryTest(
                   test,
-                  getConfiguredEfdRetryCount(config),
+                  config.earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
                   ['_ddIsModified', '_ddIsEfdRetry'],
-                  config.earlyFlakeDetectionSlowTestRetries
+                  config.earlyFlakeDetectionRetryPolicy
                 )
               }
             }
@@ -968,12 +1055,12 @@ function getRunTestsWrapper (runTests, config) {
       suite.tests.forEach((test) => {
         if (!test.isPending() && isNewTest(test, config.knownTests)) {
           test._ddIsNew = true
-          if (config.isEarlyFlakeDetectionEnabled && !test._ddIsAttemptToFix && !test._ddIsModified) {
+          if (!test._ddIsModified && isEarlyFlakeDetectionTest(test, config)) {
             retryTest(
               test,
-              getConfiguredEfdRetryCount(config),
+              config.earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
               ['_ddIsNew', '_ddIsEfdRetry'],
-              config.earlyFlakeDetectionSlowTestRetries
+              config.earlyFlakeDetectionRetryPolicy
             )
           }
         }
@@ -1015,4 +1102,5 @@ module.exports = {
   testsStatuses,
   attemptToFixExecutions,
   loggedAttemptToFixTests,
+  adjustRunnerFailuresForTestOptimization,
 }

package/packages/datadog-instrumentations/src/mocha/webdriverio-protocol.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const {
+  createWebdriverioWorkerMessage,
+  WEBDRIVERIO_WORKER_ENV,
+  WEBDRIVERIO_WORKER_EVENT,
+  WEBDRIVERIO_WORKER_ORIGIN,
+} = require('../../../dd-trace/src/ci-visibility/exporters/test-worker/webdriverio')
+
+/**
+ * Sends a message over WebdriverIO's worker IPC envelope.
+ *
+ * @param {object} message
+ * @param {(error?: Error) => void} [onError]
+ * @param {() => void} [onDone]
+ * @returns {void}
+ */
+function sendWebdriverioWorkerMessage (message, onError, onDone) {
+  if (!process.send || !process.connected) {
+    onError?.()
+    onDone?.()
+    return
+  }
+
+  process.send(createWebdriverioWorkerMessage(message), (error) => {
+    if (error) {
+      onError?.(error)
+    }
+    onDone?.()
+  })
+}
+
+module.exports = {
+  CONFIGURATION_REQUEST: 'dd:test-optimization:webdriverio:configuration:request',
+  CONFIGURATION_RESPONSE: 'dd:test-optimization:webdriverio:configuration:response',
+  createWebdriverioWorkerMessage,
+  sendWebdriverioWorkerMessage,
+  SUITE_FINISH: 'dd:test-optimization:webdriverio:test-suite:finish',
+  WORKER_READY: 'dd:test-optimization:webdriverio:worker:ready',
+  WORKER_READY_RESPONSE: 'dd:test-optimization:webdriverio:worker:ready:response',
+  WEBDRIVERIO_WORKER_ENV,
+  WEBDRIVERIO_WORKER_EVENT,
+  WEBDRIVERIO_WORKER_ORIGIN,
+}