dd-trace 5.84.0 → 5.86.0

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

@@ -7,23 +7,26 @@ const {
   getCoveredFilenamesFromCoverage,
   JEST_WORKER_TRACE_PAYLOAD_CODE,
   JEST_WORKER_COVERAGE_PAYLOAD_CODE,
+  JEST_WORKER_TELEMETRY_PAYLOAD_CODE,
   getTestLineStart,
   getTestSuitePath,
   getTestParametersString,
   getIsFaultyEarlyFlakeDetection,
   JEST_WORKER_LOGS_PAYLOAD_CODE,
   getTestEndLine,
-  isModifiedTest
+  isModifiedTest,
 } = require('../../dd-trace/src/plugins/util/test')
 const {
+  SEED_SUFFIX_RE,
   getFormattedJestTestParameters,
   getJestTestName,
-  getJestSuitesToRun
+  getJestSuitesToRun,
 } = require('../../datadog-plugin-jest/src/util')
 const { addHook, channel } = require('./helpers/instrument')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
+const codeCoverageReportCh = channel('ci:jest:coverage-report')
 
 const testSessionConfigurationCh = channel('ci:jest:session:configuration')
 
@@ -34,6 +37,7 @@ const testSuiteErrorCh = channel('ci:jest:test-suite:error')
 const workerReportTraceCh = channel('ci:jest:worker-report:trace')
 const workerReportCoverageCh = channel('ci:jest:worker-report:coverage')
 const workerReportLogsCh = channel('ci:jest:worker-report:logs')
+const workerReportTelemetryCh = channel('ci:jest:worker-report:telemetry')
 
 const testSuiteCodeCoverageCh = channel('ci:jest:test-suite:code-coverage')
 
@@ -54,6 +58,7 @@ const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 // Message sent by jest's main process to workers to run a test suite (=test file)
 // https://github.com/jestjs/jest/blob/1d682f21c7a35da4d3ab3a1436a357b980ebd0fa/packages/jest-worker/src/types.ts#L37
 const CHILD_MESSAGE_CALL = 1
+
 // Maximum time we'll wait for the tracer to flush
 const FLUSH_TIMEOUT = 10_000
 
@@ -284,7 +289,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         return {
           attemptToFix: [],
           disabled: [],
-          quarantined: []
+          quarantined: [],
         }
       }
       let testManagementTestsForSuite = testManagementTests
@@ -297,10 +302,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       const result = {
         attemptToFix: [],
         disabled: [],
-        quarantined: []
+        quarantined: [],
       }
 
-      Object.entries(testManagementTestsForSuite).forEach(([testName, { properties }]) => {
+      for (const [testName, { properties }] of Object.entries(testManagementTestsForSuite)) {
         if (properties?.attempt_to_fix) {
           result.attemptToFix.push(testName)
         }
@@ -310,7 +315,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         if (properties?.quarantined) {
           result.quarantined.push(testName)
         }
-      })
+      }
 
       return result
     }
@@ -319,7 +324,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     retryTest ({
       jestEvent,
       retryCount,
-      retryType
+      retryType,
     }) {
       const { testName, fn, timeout } = jestEvent
       for (let retryIndex = 0; retryIndex < retryCount; retryIndex++) {
@@ -428,7 +433,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           isDisabled,
           isQuarantined,
           isModified,
-          testSuiteAbsolutePath: this.testSuiteAbsolutePath
+          testSuiteAbsolutePath: this.testSuiteAbsolutePath,
         }
         testContexts.set(event.test, ctx)
 
@@ -475,7 +480,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           this.retryTest({
             jestEvent: event,
             retryCount: testManagementAttemptToFixRetries,
-            retryType: 'Test Management (Attempt to Fix)'
+            retryType: 'Test Management (Attempt to Fix)',
           })
         }
         if (!isAttemptToFix && this.isImpactedTestsEnabled) {
@@ -494,7 +499,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             this.retryTest({
               jestEvent: event,
               retryCount: earlyFlakeDetectionNumRetries,
-              retryType: 'Impacted tests'
+              retryType: 'Impacted tests',
             })
           }
         }
@@ -507,13 +512,14 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
               this.retryTest({
                 jestEvent: event,
                 retryCount: earlyFlakeDetectionNumRetries,
-                retryType: 'Early flake detection'
+                retryType: 'Early flake detection',
               })
             }
           }
         }
       }
       if (event.name === 'test_done') {
+        const originalError = event.test?.errors?.[0]
         let status = 'pass'
         if (event.test.errors && event.test.errors.length) {
           status = 'fail'
@@ -560,8 +566,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
         let isEfdRetry = false
         // We'll store the test statuses of the retries
+        const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
         if (this.isKnownTestsEnabled) {
-          const testName = getJestTestName(event.test, this.getShouldStripSeedFromTestName())
           const isNewTest = retriedTestsToNumAttempts.has(testName)
           if (isNewTest) {
             if (newTestsTestStatuses.has(testName)) {
@@ -576,18 +582,27 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const promises = {}
         const numRetries = this.global[RETRY_TIMES]
         const numTestExecutions = event.test?.invocations
-        const willBeRetried = numRetries > 0 && numTestExecutions - 1 < numRetries
+        const willBeRetriedByFailedTestReplay = numRetries > 0 && numTestExecutions - 1 < numRetries
         const mightHitBreakpoint = this.isDiEnabled && numTestExecutions >= 2
 
         const ctx = testContexts.get(event.test)
 
+        const finalStatus = this.getFinalStatus(testName,
+          status,
+          !!ctx?.isNew,
+          !!ctx?.isModified,
+          isEfdRetry,
+          isAttemptToFix,
+          numTestExecutions)
+
         if (status === 'fail') {
-          const shouldSetProbe = this.isDiEnabled && willBeRetried && numTestExecutions === 1
+          const shouldSetProbe = this.isDiEnabled && willBeRetriedByFailedTestReplay && numTestExecutions === 1
           testErrCh.publish({
             ...ctx.currentStore,
-            error: formatJestError(event.test.errors[0]),
+            error: formatJestError(originalError),
             shouldSetProbe,
-            promises
+            promises,
+            finalStatus,
           })
         }
 
@@ -613,7 +628,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           attemptToFixPassed,
           failedAllTests,
           attemptToFixFailed,
-          isAtrRetry
+          isAtrRetry,
+          finalStatus,
         })
 
         if (promises.isProbeReady) {
@@ -635,13 +651,102 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
             testSourceFile: this.testSourceFile,
             displayName: this.displayName,
             frameworkVersion: jestVersion,
-            testStartLine: getTestLineStart(event.test.asyncError, this.testSuite)
+            testStartLine: getTestLineStart(event.test.asyncError, this.testSuite),
           },
-          isDisabled: this.testManagementTestsForThisSuite?.disabled?.includes(testName)
+          isDisabled: this.testManagementTestsForThisSuite?.disabled?.includes(testName),
         })
       }
     }
 
+    getEfdResult ({ testName, isNewTest, isModifiedTest, isEfdRetry, numberOfExecutedRetries }) {
+      const isEfdEnabled = this.isEarlyFlakeDetectionEnabled
+      const isEfdActive = isEfdEnabled && (isNewTest || isModifiedTest)
+      const isLastEfdRetry = isEfdRetry && numberOfExecutedRetries >= (earlyFlakeDetectionNumRetries + 1)
+      const isFinalEfdTestExecution = isEfdActive && isLastEfdRetry
+
+      let finalStatus
+      if (isEfdActive && isFinalEfdTestExecution) {
+        // For EFD: The framework reports 'pass' if ANY attempt passed (flaky but not failing)
+        const testStatuses = newTestsTestStatuses.get(testName)
+        finalStatus = testStatuses && testStatuses.includes('pass') ? 'pass' : 'fail'
+      }
+
+      return { isEfdEnabled, isEfdActive, isFinalEfdTestExecution, finalStatus }
+    }
+
+    getAtrResult ({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations }) {
+      const isAtrEnabled =
+        this.isFlakyTestRetriesEnabled &&
+        !isEfdRetry &&
+        !isAttemptToFix &&
+        Number.isFinite(this.global[RETRY_TIMES])
+      const isLastAtrRetry =
+        status === 'pass' || numberOfTestInvocations >= (Number(this.global[RETRY_TIMES]) + 1)
+      const isFinalAtrTestExecution = isAtrEnabled && isLastAtrRetry
+
+      // For ATR: The last execution's status is what the framework reports
+      return { isAtrEnabled, isFinalAtrTestExecution, finalStatus: status }
+    }
+
+    getAttemptToFixResult ({ testName, isAttemptToFix, numberOfExecutedRetries }) {
+      const isAttemptToFixEnabled =
+        this.isTestManagementTestsEnabled &&
+        isAttemptToFix &&
+        Number.isFinite(testManagementAttemptToFixRetries)
+      const isFinalAttemptToFixExecution = isAttemptToFixEnabled &&
+        numberOfExecutedRetries >= (testManagementAttemptToFixRetries + 1)
+
+      let finalStatus
+      if (isAttemptToFixEnabled && isFinalAttemptToFixExecution) {
+        // For Attempt to Fix: 'pass' only if ALL attempts passed, 'fail' if ANY failed
+        const testStatuses = attemptToFixRetriedTestsStatuses.get(testName)
+        finalStatus = testStatuses && testStatuses.every(status => status === 'pass') ? 'pass' : 'fail'
+      }
+
+      return { isAttemptToFixEnabled, isFinalAttemptToFixExecution, finalStatus }
+    }
+
+    getFinalStatus (testName, status, isNewTest, isModifiedTest, isEfdRetry, isAttemptToFix, numberOfTestInvocations) {
+      const numberOfExecutedRetries = retriedTestsToNumAttempts.get(testName) ?? 0
+
+      const efdResult = this.getEfdResult({
+        testName,
+        isNewTest,
+        isModifiedTest,
+        isEfdRetry,
+        numberOfExecutedRetries,
+      })
+      const atrResult = this.getAtrResult({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations })
+      const attemptToFixResult = this.getAttemptToFixResult({
+        testName,
+        isAttemptToFix,
+        numberOfExecutedRetries,
+      })
+
+      // When no retry features are active, every test execution is final
+      const noRetryFeaturesActive =
+        !efdResult.isEfdActive &&
+        !atrResult.isAtrEnabled &&
+        !attemptToFixResult.isAttemptToFixEnabled
+      const isFinalTestExecution = noRetryFeaturesActive ||
+        efdResult.isFinalEfdTestExecution ||
+        atrResult.isFinalAtrTestExecution ||
+        attemptToFixResult.isFinalAttemptToFixExecution
+
+      if (!isFinalTestExecution) {
+        return
+      }
+
+      // If the test is quarantined, regardless of its actual execution result,
+      // the final status of its last execution should be reported as 'skip'.
+      if (this.isTestManagementTestsEnabled &&
+        this.testManagementTestsForThisSuite?.quarantined?.includes(testName)) {
+        return 'skip'
+      }
+
+      return efdResult.finalStatus || attemptToFixResult.finalStatus || atrResult.finalStatus
+    }
+
     teardown () {
       if (this._globalProxy?.propertyToValue) {
         for (const [key] of this._globalProxy.propertyToValue) {
@@ -667,7 +772,7 @@ function getTestEnvironment (pkg, jestVersion) {
           return wrappedTestEnvironment
         }
         return target[prop]
-      }
+      },
     })
   }
   return getWrappedEnvironment(pkg, jestVersion)
@@ -676,9 +781,7 @@ function getTestEnvironment (pkg, jestVersion) {
 function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
   const jestSuitesToRun = getJestSuitesToRun(skippableSuites, originalTests, rootDir || process.cwd())
   hasFilteredSkippableSuites = true
-  log.debug(
-    () => `${jestSuitesToRun.suitesToRun.length} out of ${originalTests.length} suites are going to run.`
-  )
+  log.debug('%d out of %d suites are going to run.', jestSuitesToRun.suitesToRun.length, originalTests.length)
   hasUnskippableSuites = jestSuitesToRun.hasUnskippableSuites
   hasForcedToRunSuites = jestSuitesToRun.hasForcedToRunSuites
 
@@ -692,17 +795,17 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
 
 addHook({
   name: 'jest-environment-node',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, getTestEnvironment)
 
 addHook({
   name: 'jest-environment-jsdom',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, getTestEnvironment)
 
 addHook({
   name: '@happy-dom/jest-environment',
-  versions: ['>=10.0.0']
+  versions: ['>=10.0.0'],
 }, getTestEnvironment)
 
 function getWrappedScheduleTests (scheduleTests, frameworkVersion) {
@@ -856,7 +959,7 @@ function getCliWrapper (isNewJestVersion) {
             isTestManagementTestsEnabled = false
             testManagementTests = {}
           } else {
-            testManagementTests = receivedTestManagementTests
+            testManagementTests = receivedTestManagementTests || {}
           }
         } catch (err) {
           log.error('Jest test management tests error', err)
@@ -892,8 +995,8 @@ function getCliWrapper (isNewJestVersion) {
           numFailedTestSuites,
           numFailedTests,
           numTotalTests,
-          numTotalTestSuites
-        }
+          numTotalTestSuites,
+        },
       } = result
 
       let testCodeCoverageLinesTotal
@@ -914,33 +1017,39 @@ function getCliWrapper (isNewJestVersion) {
        * 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.
        */
+      let numEfdFailedTestsToIgnore = 0
       if (isEarlyFlakeDetectionEnabled) {
-        let numFailedTestsToIgnore = 0
         for (const testStatuses of newTestsTestStatuses.values()) {
           const { pass, fail } = getTestStats(testStatuses)
           if (pass > 0) { // as long as one passes, we'll consider the test passed
-            numFailedTestsToIgnore += fail
+            numEfdFailedTestsToIgnore += fail
           }
         }
         // If every test that failed was an EFD retry, we'll consider the suite passed
-        if (numFailedTestsToIgnore !== 0 && result.results.numFailedTests === numFailedTestsToIgnore) {
+        if (numEfdFailedTestsToIgnore !== 0 && result.results.numFailedTests === numEfdFailedTestsToIgnore) {
           result.results.success = true
         }
       }
 
+      let numFailedQuarantinedTests = 0
+      let numFailedQuarantinedOrDisabledAttemptedToFixTests = 0
       if (isTestManagementTestsEnabled) {
         const failedTests = result
           .results
           .testResults.flatMap(({ testResults, testFilePath: testSuiteAbsolutePath }) => (
             testResults.map(({ fullName: testName, status }) => (
-              { testName, testSuiteAbsolutePath, status }
+              {
+                // Strip @fast-check/jest seed suffix so the name matches what was reported via TEST_NAME
+                testName: testSuiteAbsolutePathsWithFastCheck.has(testSuiteAbsolutePath)
+                  ? testName.replace(SEED_SUFFIX_RE, '')
+                  : 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 testManagementTest = testManagementTests
@@ -971,6 +1080,16 @@ function getCliWrapper (isNewJestVersion) {
         }
       }
 
+      // Combined check: if all failed tests are accounted for by EFD (flaky retries) and/or quarantine,
+      // we should consider the suite passed even when neither check alone covers all failures.
+      if (!result.results.success && (isEarlyFlakeDetectionEnabled || isTestManagementTestsEnabled)) {
+        const totalIgnoredFailures =
+          numEfdFailedTestsToIgnore + numFailedQuarantinedTests + numFailedQuarantinedOrDisabledAttemptedToFixTests
+        if (totalIgnoredFailures !== 0 && result.results.numFailedTests === totalIgnoredFailures) {
+          result.results.success = true
+        }
+      }
+
       // Determine session status after EFD and quarantine checks have potentially modified success
       let status, error
       if (result.results.success) {
@@ -1009,7 +1128,7 @@ function getCliWrapper (isNewJestVersion) {
         isEarlyFlakeDetectionEnabled,
         isEarlyFlakeDetectionFaulty,
         isTestManagementTestsEnabled,
-        onDone
+        onDone,
       })
 
       const waitingResult = await Promise.race([flushPromise, timeoutPromise])
@@ -1018,11 +1137,18 @@ function getCliWrapper (isNewJestVersion) {
         log.error('Timeout waiting for the tracer to flush')
       }
 
+      if (codeCoverageReportCh.hasSubscribers) {
+        const rootDir = result.globalConfig?.rootDir || process.cwd()
+        await new Promise((resolve) => {
+          codeCoverageReportCh.publish({ rootDir, onDone: resolve })
+        })
+      }
+
       numSkippedSuites = 0
 
       return result
     }, {
-      replaceGetter: true
+      replaceGetter: true,
     })
   }
 }
@@ -1051,7 +1177,7 @@ function coverageReporterWrapper (coverageReporter) {
 addHook({
   name: '@jest/core',
   file: 'build/TestScheduler.js',
-  versions: ['>=27.0.0']
+  versions: ['>=27.0.0'],
 }, (testSchedulerPackage, frameworkVersion) => {
   const oldCreateTestScheduler = testSchedulerPackage.createTestScheduler
   const newCreateTestScheduler = async function () {
@@ -1070,7 +1196,7 @@ addHook({
 addHook({
   name: '@jest/core',
   file: 'build/TestScheduler.js',
-  versions: ['>=24.8.0 <27.0.0']
+  versions: ['>=24.8.0 <27.0.0'],
 }, (testSchedulerPackage, frameworkVersion) => {
   shimmer.wrap(
     testSchedulerPackage.default.prototype,
@@ -1081,7 +1207,7 @@ addHook({
 
 addHook({
   name: '@jest/test-sequencer',
-  versions: ['>=28']
+  versions: ['>=28'],
 }, (sequencerPackage, frameworkVersion) => {
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
@@ -1100,18 +1226,18 @@ addHook({
 addHook({
   name: '@jest/reporters',
   file: 'build/coverage_reporter.js',
-  versions: ['>=24.8.0 <26.6.2']
+  versions: ['>=24.8.0 <26.6.2'],
 }, coverageReporterWrapper)
 
 addHook({
   name: '@jest/reporters',
   file: 'build/CoverageReporter.js',
-  versions: ['>=26.6.2']
+  versions: ['>=26.6.2'],
 }, coverageReporterWrapper)
 
 addHook({
   name: '@jest/reporters',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, (reporters) => {
   return shimmer.wrap(reporters, 'CoverageReporter', coverageReporterWrapper, { replaceGetter: true })
 })
@@ -1119,12 +1245,12 @@ addHook({
 addHook({
   name: '@jest/core',
   file: 'build/cli/index.js',
-  versions: ['>=24.8.0 <30.0.0']
+  versions: ['>=24.8.0 <30.0.0'],
 }, getCliWrapper(false))
 
 addHook({
   name: '@jest/core',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, getCliWrapper(true))
 
 function jestAdapterWrapper (jestAdapter, jestVersion) {
@@ -1140,7 +1266,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
       testSourceFile: environment.testSourceFile,
       displayName: environment.displayName,
       frameworkVersion: jestVersion,
-      testSuiteAbsolutePath: environment.testSuiteAbsolutePath
+      testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
     })
     return adapter.apply(this, arguments).then(suiteResults => {
       const { numFailingTests, skipped, failureMessage: errorMessage } = suiteResults
@@ -1168,7 +1294,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
           coverageFiles,
           testSuite: environment.testSourceFile,
           mockedFiles,
-          testSuiteAbsolutePath: environment.testSuiteAbsolutePath
+          testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
         })
       }
       testSuiteFinishCh.publish({ status, errorMessage, testSuiteAbsolutePath: environment.testSuiteAbsolutePath })
@@ -1200,13 +1326,13 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
 addHook({
   name: 'jest-circus',
   file: 'build/runner.js',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, jestAdapterWrapper)
 
 addHook({
   name: 'jest-circus',
   file: 'build/legacy-code-todo-rewrite/jestAdapter.js',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, jestAdapterWrapper)
 
 function configureTestEnvironment (readConfigsResult) {
@@ -1214,9 +1340,9 @@ function configureTestEnvironment (readConfigsResult) {
   testSessionConfigurationCh.publish(configs.map(config => config.testEnvironmentOptions))
   // We can't directly use isCodeCoverageEnabled when reporting coverage in `jestAdapterWrapper`
   // because `jestAdapterWrapper` runs in a different process. We have to go through `testEnvironmentOptions`
-  configs.forEach(config => {
+  for (const config of configs) {
     config.testEnvironmentOptions._ddTestCodeCoverageEnabled = isCodeCoverageEnabled
-  })
+  }
 
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
 
@@ -1227,7 +1353,7 @@ function configureTestEnvironment (readConfigsResult) {
   if (isCodeCoverageEnabled) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
-      collectCoverage: true
+      collectCoverage: true,
     }
     readConfigsResult.globalConfig = globalConfig
   }
@@ -1238,7 +1364,7 @@ function configureTestEnvironment (readConfigsResult) {
     const globalConfig = {
       ...readConfigsResult.globalConfig,
       coverageReporters: ['none'],
-      passWithNoTests: true
+      passWithNoTests: true,
     }
     readConfigsResult.globalConfig = globalConfig
   }
@@ -1265,7 +1391,7 @@ function jestConfigSyncWrapper (jestConfig) {
 addHook({
   name: '@jest/transform',
   versions: ['>=24.8.0'],
-  file: 'build/ScriptTransformer.js'
+  file: 'build/ScriptTransformer.js',
 }, transformPackage => {
   const originalCreateScriptTransformer = transformPackage.createScriptTransformer
 
@@ -1311,18 +1437,18 @@ addHook({
 addHook({
   name: '@jest/core',
   versions: ['>=24.8.0 <30.0.0'],
-  file: 'build/SearchSource.js'
+  file: 'build/SearchSource.js',
 }, searchSourceWrapper)
 
 // from 25.1.0 on, readConfigs becomes async
 addHook({
   name: 'jest-config',
-  versions: ['>=25.1.0']
+  versions: ['>=25.1.0'],
 }, jestConfigAsyncWrapper)
 
 addHook({
   name: 'jest-config',
-  versions: ['24.8.0 - 24.9.0']
+  versions: ['24.8.0 - 24.9.0'],
 }, jestConfigSyncWrapper)
 
 const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
@@ -1333,12 +1459,12 @@ const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'selenium-webdriver/firefox',
   'selenium-webdriver/ie',
   'selenium-webdriver/chromium',
-  'winston'
+  'winston',
 ])
 
 addHook({
   name: 'jest-runtime',
-  versions: ['>=24.8.0']
+  versions: ['>=24.8.0'],
 }, (runtimePackage) => {
   const Runtime = runtimePackage.default ?? runtimePackage
 
@@ -1395,12 +1521,12 @@ addHook({
           const errorMessage = [...this.loggedReferenceErrors][0]
           testSuiteErrorCh.publish({
             errorMessage,
-            testSuiteAbsolutePath: this._testPath
+            testSuiteAbsolutePath: this._testPath,
           })
         } else {
           testSuiteErrorCh.publish({
             errorMessage: 'An error occurred while importing a module',
-            testSuiteAbsolutePath: this._testPath
+            testSuiteAbsolutePath: this._testPath,
           })
         }
       }
@@ -1429,6 +1555,10 @@ function onMessageWrapper (onMessage) {
       workerReportLogsCh.publish(data)
       return
     }
+    if (code === JEST_WORKER_TELEMETRY_PAYLOAD_CODE) { // datadog telemetry payload
+      workerReportTelemetryCh.publish(data)
+      return
+    }
     return onMessage.apply(this, arguments)
   }
 }
@@ -1466,8 +1596,8 @@ function sendWrapper (send) {
           _ddTestManagementTests: suiteTestManagementTests,
           // TODO: figure out if we can reduce the size of the modified files object
           // Can we use `testSuite` (it'd have to be relative to repository root though)
-          _ddModifiedFiles: modifiedFiles
-        }
+          _ddModifiedFiles: modifiedFiles,
+        },
       }
     }
     return send.apply(this, arguments)
@@ -1499,7 +1629,7 @@ function enqueueWrapper (enqueue) {
 addHook({
   name: 'jest-worker',
   versions: ['>=24.9.0 <30.0.0'],
-  file: 'build/workers/ChildProcessWorker.js'
+  file: 'build/workers/ChildProcessWorker.js',
 }, (childProcessWorker) => {
   const ChildProcessWorker = childProcessWorker.default
   shimmer.wrap(ChildProcessWorker.prototype, 'send', sendWrapper)
@@ -1513,7 +1643,7 @@ addHook({
 
 addHook({
   name: 'jest-worker',
-  versions: ['>=30.0.0']
+  versions: ['>=30.0.0'],
 }, (jestWorkerPackage) => {
   shimmer.wrap(jestWorkerPackage.FifoQueue.prototype, 'enqueue', enqueueWrapper)
   shimmer.wrap(jestWorkerPackage.PriorityQueue.prototype, 'enqueue', enqueueWrapper)