dd-trace 6.8.0 → 6.10.0

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

@@ -10,12 +10,13 @@ const {
 } = require('../helpers/channel')
 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,8 +29,10 @@ const {
   getTestCoverageLinesPercentage,
   collectTestOptimizationSummariesFromTraces,
   logTestOptimizationSummary,
+  TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE,
   getTestOptimizationRequestResults,
   isModifiedTest,
+  isMarkedAsUnskippable,
 } = require('../../../dd-trace/src/plugins/util/test')
 
 const {
@@ -66,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()
@@ -95,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')
@@ -227,6 +234,7 @@ function getMochaTestSessionCoverageFiles () {
 
 function resetSuiteSkippingRunState () {
   isSuitesSkipped = false
+  areAllSuitesSkipped = false
   skippedSuites = []
   skippableSuitesCoverage = {}
   skippedSuitesCoverage = {}
@@ -357,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()
   }
 }
@@ -386,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,
@@ -418,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
 
@@ -426,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
@@ -489,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
@@ -978,6 +1049,8 @@ function onMessage (message) {
         attemptToFixExecutions,
       })
       workerReportTraceCh.publish(payload)
+    } else if (messageCode === MOCHA_WORKER_TELEMETRY_PAYLOAD_CODE) {
+      workerReportTelemetryCh.publish(payload)
     }
   }
 }
@@ -1042,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)
     }
@@ -1088,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)
       }
@@ -1110,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 &&
@@ -1130,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,17 @@
 
 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,
+  getFailedTestReplayPromise,
+  recordTestManagementExecution,
   recordAttemptToFixExecution,
   logAttemptToFixTestExecution,
 } = require('../../../dd-trace/src/plugins/util/test')
@@ -26,6 +32,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 +48,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 = {}
@@ -133,19 +142,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
   }
@@ -154,7 +172,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) {
@@ -205,13 +223,14 @@ 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)
 }
 
 /**
@@ -223,22 +242,32 @@ function isDatadogManagedRetryTest (test, config) {
  *   _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()
@@ -250,7 +279,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()
           }
@@ -266,14 +295,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) {
@@ -462,7 +483,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
@@ -576,7 +597,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)) {
@@ -587,7 +608,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')
 
@@ -642,6 +664,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()),
@@ -788,7 +821,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) {
@@ -921,14 +954,7 @@ function getOnTestRetryHandler (config) {
         promises,
         ...ctx.currentStore,
       })
-      if (promises.setProbePromise && promises.finishTestPromise) {
-        test._ddFailedTestReplayPromise = Promise.all([
-          promises.setProbePromise,
-          promises.finishTestPromise,
-        ]).then(() => {})
-      } else if (promises.setProbePromise || promises.finishTestPromise) {
-        test._ddFailedTestReplayPromise = promises.setProbePromise || promises.finishTestPromise
-      }
+      test._ddFailedTestReplayPromise = getFailedTestReplayPromise(promises)
     }
     const key = getTestToContextKey(test)
     testToContext.delete(key)
@@ -1004,17 +1030,12 @@ function getRunTestsWrapper (runTests, config) {
           onDone: (isModified) => {
             if (isModified) {
               test._ddIsModified = true
-              if (
-                !test.isPending() &&
-                !test._ddIsDisabled &&
-                !test._ddIsAttemptToFix &&
-                config.isEarlyFlakeDetectionEnabled
-              ) {
+              if (!test.isPending() && isEarlyFlakeDetectionTest(test, config)) {
                 retryTest(
                   test,
-                  getConfiguredEfdRetryCount(config),
+                  config.earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
                   ['_ddIsModified', '_ddIsEfdRetry'],
-                  config.earlyFlakeDetectionSlowTestRetries
+                  config.earlyFlakeDetectionRetryPolicy
                 )
               }
             }
@@ -1028,17 +1049,12 @@ function getRunTestsWrapper (runTests, config) {
       suite.tests.forEach((test) => {
         if (!test.isPending() && isNewTest(test, config.knownTests)) {
           test._ddIsNew = true
-          if (
-            config.isEarlyFlakeDetectionEnabled &&
-            !test._ddIsDisabled &&
-            !test._ddIsAttemptToFix &&
-            !test._ddIsModified
-          ) {
+          if (!test._ddIsModified && isEarlyFlakeDetectionTest(test, config)) {
             retryTest(
               test,
-              getConfiguredEfdRetryCount(config),
+              config.earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
               ['_ddIsNew', '_ddIsEfdRetry'],
-              config.earlyFlakeDetectionSlowTestRetries
+              config.earlyFlakeDetectionRetryPolicy
             )
           }
         }

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

@@ -7,12 +7,37 @@ const {
   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,

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

@@ -2,6 +2,7 @@
 
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { EMPTY_EFD_RETRY_POLICY } = require('../../../dd-trace/src/ci-visibility/efd-retry-policy')
 const { getEnvironmentVariable } = require('../../../dd-trace/src/config/helper')
 const log = require('../../../dd-trace/src/log')
 const { DD_MAJOR } = require('../../../../version')
@@ -23,7 +24,7 @@ const {
 const {
   CONFIGURATION_REQUEST,
   CONFIGURATION_RESPONSE,
-  createWebdriverioWorkerMessage,
+  sendWebdriverioWorkerMessage,
   SUITE_FINISH,
   WEBDRIVERIO_WORKER_ENV,
   WORKER_READY,
@@ -35,7 +36,9 @@ const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
 const workerFinishCh = channel('ci:mocha:worker:finish')
 const workerConfigurationCh = channel('ci:mocha:worker:configuration')
 
-const config = {}
+const config = {
+  earlyFlakeDetectionRetryPolicy: EMPTY_EFD_RETRY_POLICY,
+}
 const runnerToFiles = new WeakMap()
 const runnerToFailedHooks = new WeakMap()
 const isWebdriverioWorker = !!getEnvironmentVariable(WEBDRIVERIO_WORKER_ENV)
@@ -50,19 +53,12 @@ let configurationRequestId = 0
  * @returns {void}
  */
 function sendWebdriverioMessage (message, onError, onDone) {
-  if (!process.send || !process.connected) {
-    onError?.()
-    onDone?.()
-    return
-  }
-
-  process.send(createWebdriverioWorkerMessage(message), (error) => {
+  sendWebdriverioWorkerMessage(message, error => {
     if (error) {
       log.error('WebdriverIO Test Optimization IPC error', error)
-      onError?.()
     }
-    onDone?.()
-  })
+    onError?.()
+  }, onDone)
 }
 
 /**
@@ -76,12 +72,10 @@ function applyMochaOptions (options) {
     config.isKnownTestsEnabled = true
     config.isEarlyFlakeDetectionEnabled = options._ddIsEfdEnabled
     config.knownTests = options._ddKnownTests
-    config.earlyFlakeDetectionNumRetries = options._ddEfdNumRetries
-    config.earlyFlakeDetectionSlowTestRetries = options._ddEfdSlowTestRetries ?? {}
+    config.earlyFlakeDetectionRetryPolicy = options._ddEfdRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
     delete options._ddIsEfdEnabled
     delete options._ddKnownTests
-    delete options._ddEfdNumRetries
-    delete options._ddEfdSlowTestRetries
+    delete options._ddEfdRetryPolicy
     delete options._ddIsKnownTestsEnabled
   }
   if (options._ddIsImpactedTestsEnabled) {
@@ -245,7 +239,7 @@ function getWebdriverioHookTest (hook) {
  */
 function adjustWebdriverioHookFailures (runner) {
   let suppressedFailures = 0
-  for (const { test } of runnerToFailedHooks.get(runner) || []) {
+  for (const { test } of runnerToFailedHooks.get(runner)) {
     if (isWebdriverioFailureSuppressed(test)) {
       suppressedFailures++
     }
@@ -287,7 +281,7 @@ function getWebdriverioSuiteResults (runner) {
     }
   })
 
-  for (const { file, test } of runnerToFailedHooks.get(runner) || []) {
+  for (const { file, test } of runnerToFailedHooks.get(runner)) {
     const result = resultsByFile.get(file)
     if (result && !isWebdriverioFailureSuppressed(test)) {
       result.status = 'fail'