dd-trace 6.9.0 → 6.11.0

package/packages/datadog-instrumentations/src/vitest-main-no-worker-init.js

@@ -47,6 +47,7 @@ const VITEST_NO_WORKER_INIT_ACTIVE_ENV = 'DD_TEST_OPT_VITEST_NO_WORKER_INIT_ACTI
 const VITEST_NO_WORKER_INIT_REQUEST_ENV = 'DD_EXPERIMENTAL_TEST_OPT_VITEST_NO_WORKER_INIT'
 const VITEST_NO_WORKER_INIT_MINIMUM_VERSION = '3.2.6'
 const VITEST_DEFAULT_POOL = 'forks'
+const VITEST_BROWSER_EFD_SUITE_ADMISSION_COMMAND = '__dd_vitest_efd_suite_admission'
 const VITEST_NO_WORKER_INIT_SETUP_FILE = path.join(
   __dirname,
   '..',
@@ -69,6 +70,7 @@ const VITEST_BROWSER_URL_RE = /https?:\/\/[^\s)"'>\]]+/g
 let hasWarnedDisabledIsolate = false
 let hasWarnedUnsupportedVersion = false
 let nodeOptionsBeforeNoWorkerInit
+let reserveEarlyFlakeDetectionSuite
 
 function noop () {}
 
@@ -322,6 +324,7 @@ function isEarlyFlakeDetectionActive (state) {
 
 function configure (ctx, frameworkVersion, testSpecifications, setupData, options) {
   const { shouldReportTestModule, state } = options
+  reserveEarlyFlakeDetectionSuite = options.reserveEarlyFlakeDetectionSuite
   addSetupFileToVitestConfigs(ctx, VITEST_NO_WORKER_INIT_SETUP_FILE, testSpecifications)
   addVitestBrowserSetupFileAccess(testSpecifications)
 
@@ -341,6 +344,8 @@ function configure (ctx, frameworkVersion, testSpecifications, setupData, option
       attemptToFixTests: getSelectedTestManagementTests(testManagementTestsBySuite, 'isAttemptToFix'),
       disabledTests: getSelectedTestManagementTests(testManagementTestsBySuite, 'isDisabled'),
       earlyFlakeDetectionRetryPolicy: state.earlyFlakeDetectionRetryPolicy,
+      efdSuiteAdmissionBrowserCommand: VITEST_BROWSER_EFD_SUITE_ADMISSION_COMMAND,
+      isEfdSuiteAdmissionEnabled: state.isEfdSuiteAdmissionEnabled,
       isEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionActive(state),
       isRumCorrelationEnabled: !canRaceRumCorrelation(ctx, testSpecifications),
       knownTests: knownTestsBySuite || {},
@@ -443,6 +448,18 @@ function configureVitestBrowserSetupFile (viteConfig) {
   }
 }
 
+/**
+ * Reserves EFD retries for a suite executing in Vitest Browser Mode.
+ *
+ * @param {unknown} _context
+ * @param {string} testSuite
+ * @param {unknown} hasNewTest
+ * @returns {boolean}
+ */
+function handleBrowserEfdSuiteAdmission (_context, testSuite, hasNewTest) {
+  return reserveEarlyFlakeDetectionSuite?.(testSuite, hasNewTest === true) === true
+}
+
 /**
  * Allows Vite to serve the Datadog setup file after its default workspace detection has run.
  *
@@ -451,7 +468,9 @@ function configureVitestBrowserSetupFile (viteConfig) {
  */
 function allowVitestBrowserSetupFile (viteConfig) {
   const allow = viteConfig.server?.fs?.allow
-  if (allow && !allow.includes(VITEST_NO_WORKER_INIT_SETUP_FILE)) {
+  if (!allow) return
+
+  if (!allow.includes(VITEST_NO_WORKER_INIT_SETUP_FILE)) {
     allow.push(VITEST_NO_WORKER_INIT_SETUP_FILE)
   }
 }
@@ -471,10 +490,16 @@ function addVitestBrowserSetupFileAccess (testSpecifications) {
     if (!isBrowserTestSpecification(testSpecification)) continue
 
     const browserServerProject = project?._parent || project
-    if (!browserServerProject || configuredProjects.has(browserServerProject)) continue
+    if (!browserServerProject) continue
+
+    addVitestBrowserCommand(safeConfig(project))
+    if (configuredProjects.has(browserServerProject)) continue
 
     configuredProjects.add(browserServerProject)
+    addVitestBrowserCommand(safeConfig(browserServerProject))
     browserServerProject.options ||= {}
+    browserServerProject.options.browser ||= {}
+    addVitestBrowserCommand(browserServerProject.options)
     browserServerProject.options.plugins ||= []
     if (!browserServerProject.options.plugins.includes(VITEST_BROWSER_SETUP_FILE_PLUGIN)) {
       browserServerProject.options.plugins.push(VITEST_BROWSER_SETUP_FILE_PLUGIN)
@@ -482,6 +507,20 @@ function addVitestBrowserSetupFileAccess (testSpecifications) {
   }
 }
 
+/**
+ * Adds the private EFD admission command to a Vitest Browser Mode configuration.
+ *
+ * @param {object|undefined} config
+ * @returns {void}
+ */
+function addVitestBrowserCommand (config) {
+  const browserConfig = config?.browser
+  if (!browserConfig) return
+
+  browserConfig.commands ||= {}
+  browserConfig.commands[VITEST_BROWSER_EFD_SUITE_ADMISSION_COMMAND] = handleBrowserEfdSuiteAdmission
+}
+
 function getNoWorkerInitVitestConfigs (ctx, testSpecifications) {
   const configs = new Set()
   if (Array.isArray(testSpecifications)) {
@@ -847,7 +886,7 @@ function createMainProcessReporter (reporterState) {
       !isAttemptToFix &&
       state.isKnownTestsEnabled &&
       knownTests &&
-      !state.isEarlyFlakeDetectionFaulty &&
+      (state.isEfdSuiteAdmissionEnabled || !state.isEarlyFlakeDetectionFaulty) &&
       !knownTests.includes(testName)
     )
     const isModified = testProperties?.isModified === true
@@ -861,7 +900,7 @@ function createMainProcessReporter (reporterState) {
     return {
       isAttemptToFix,
       isDisabled: testManagementProperties.isDisabled,
-      isEarlyFlakeDetection: (isNew || isModified) && isEarlyFlakeDetectionActive(state),
+      isEarlyFlakeDetection: task.meta?.__ddTestOptEfdRetries !== undefined,
       isFlakyTestRetries,
       isQuarantined: testManagementProperties.isQuarantined,
       isModified,

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

@@ -4,6 +4,8 @@ const path = require('node:path')
 const { fileURLToPath } = require('node:url')
 const { MessagePort } = require('node:worker_threads')
 
+const satisfies = require('../../../vendor/dist/semifies')
+
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
 const { EMPTY_EFD_RETRY_POLICY } = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
@@ -12,16 +14,19 @@ const {
   VITEST_WORKER_COVERAGE_PAYLOAD_CODE,
   VITEST_WORKER_LOGS_PAYLOAD_CODE,
   VITEST_WORKER_TELEMETRY_PAYLOAD_CODE,
+  VITEST_WORKER_EFD_SUITE_ADMISSION_REQUEST_CODE,
+  VITEST_WORKER_EFD_SUITE_ADMISSION_RESPONSE_CODE,
   collectTestOptimizationSummariesFromTraces,
+  getIsFaultyEarlyFlakeDetection,
   logTestOptimizationSummary,
   TEST_IMPACT_ANALYSIS_ALL_TESTS_SKIPPED_MESSAGE,
   getTestOptimizationRequestResults,
   getTestSuitePath,
   isModifiedTest,
+  isMarkedAsUnskippable,
   recordTestManagementExecution,
   recordAttemptToFixExecution,
 } = require('../../dd-trace/src/plugins/util/test')
-const { isMarkedAsUnskippable } = require('../../datadog-plugin-jest/src/util')
 const { getChannelPromise } = require('./helpers/channel')
 const { addHook, channel } = require('./helpers/instrument')
 const noWorkerInit = require('./vitest-main-no-worker-init')
@@ -38,7 +43,6 @@ const {
   testSessionConfigurationCh,
   libraryConfigurationCh,
   knownTestsCh,
-  isEarlyFlakeDetectionFaultyCh,
   testManagementTestsCh,
   modifiedFilesCh,
   workerReportTraceCh,
@@ -50,6 +54,7 @@ const {
   findExportByName,
   getTypeTasks,
   getWorkspaceProject,
+  parseProvidedContextValue,
   setProvidedContext,
   getVitestTestProperties,
 } = require('./vitest-util')
@@ -62,10 +67,12 @@ const coverageWrappedProviders = new WeakSet()
 const finishWrappedContexts = new WeakSet()
 const runFilesWrappedPrototypes = new WeakSet()
 const activeRunFilesContexts = new WeakSet()
+const runErrorsByContext = new WeakMap()
 let isFlakyTestRetriesEnabled = false
 let flakyTestRetriesCount = 0
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
+let earlyFlakeDetectionFaultyThreshold = 0
 let isEarlyFlakeDetectionFaulty = false
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
@@ -97,6 +104,10 @@ let hasRunnableSuites = false
 let hasSelectedSuites = false
 let itrCorrelationId
 let tiaRepositoryRoot = process.cwd()
+let activeNoWorkerInitState
+let isEfdSuiteAdmissionEnabled = false
+let maximumSuitesWithNewTests = 0
+const suitesWithNewTests = new Set()
 const tinyPoolClassWrappers = new WeakMap()
 const itrSkippedSuitesCh = channel('ci:vitest:itr:skipped-suites')
 const skippableSuitesCh = channel('ci:vitest:test-suite:skippable')
@@ -223,6 +234,100 @@ function getNormalizedTestSuitePath (testFilepath, repositoryRoot) {
   return getTestSuitePath(realpath(testSuiteAbsolutePath), realpath(repositoryRoot))
 }
 
+/**
+ * Resets suite-level EFD admission state between Vitest runs.
+ *
+ * @returns {void}
+ */
+function resetEfdSuiteTracker () {
+  activeNoWorkerInitState = undefined
+  isEfdSuiteAdmissionEnabled = false
+  maximumSuitesWithNewTests = 0
+  suitesWithNewTests.clear()
+}
+
+/**
+ * Returns whether a Vitest pool has a transport for runtime EFD suite admission.
+ *
+ * @param {string|undefined} pool
+ * @returns {boolean}
+ */
+function isEfdSuiteAdmissionPool (pool) {
+  return pool === undefined || pool === 'forks' || pool === 'threads' || pool === 'browser'
+}
+
+/**
+ * Returns whether Vitest exposes the worker transports used for runtime EFD suite admission.
+ *
+ * @param {string} frameworkVersion
+ * @param {object[]|undefined} testSpecifications
+ * @param {object} ctx
+ * @returns {boolean}
+ */
+function supportsEfdSuiteAdmission (frameworkVersion, testSpecifications, ctx) {
+  if (!satisfies(frameworkVersion, '>=4.0.0')) return false
+  const defaultPool = ctx?.config?.pool
+  if (!Array.isArray(testSpecifications) || testSpecifications.length === 0) {
+    return isEfdSuiteAdmissionPool(defaultPool)
+  }
+
+  for (const testSpecification of testSpecifications) {
+    const pool = getTestSpecificationPool(testSpecification) || defaultPool
+    if (!isEfdSuiteAdmissionPool(pool)) return false
+  }
+  return true
+}
+
+/**
+ * Configures the EFD threshold against the unique suites selected by Vitest.
+ *
+ * @param {string[]} testFilepaths
+ * @param {string} repositoryRoot
+ * @returns {void}
+ */
+function configureEfdSuiteTracker (testFilepaths, repositoryRoot) {
+  const testSuites = new Set()
+  for (const testFilepath of testFilepaths) {
+    testSuites.add(getNormalizedTestSuitePath(testFilepath, repositoryRoot))
+  }
+
+  maximumSuitesWithNewTests = Math.floor(Math.max(
+    earlyFlakeDetectionFaultyThreshold,
+    testSuites.size * earlyFlakeDetectionFaultyThreshold / 100
+  ))
+  isEfdSuiteAdmissionEnabled = true
+}
+
+/**
+ * Returns whether a suite may schedule EFD retries and records runnable suites with new tests.
+ *
+ * @param {string} testSuite
+ * @param {boolean} hasNewTest
+ * @returns {boolean}
+ */
+function reserveEarlyFlakeDetectionSuite (testSuite, hasNewTest) {
+  if (!isEfdSuiteAdmissionEnabled || typeof testSuite !== 'string') return false
+  if (isEarlyFlakeDetectionFaulty) return false
+
+  if (hasNewTest) {
+    suitesWithNewTests.add(testSuite)
+    if (suitesWithNewTests.size > maximumSuitesWithNewTests) {
+      isEarlyFlakeDetectionEnabled = false
+      isEarlyFlakeDetectionFaulty = true
+      if (activeNoWorkerInitState) {
+        activeNoWorkerInitState.isEarlyFlakeDetectionEnabled = false
+        activeNoWorkerInitState.isEarlyFlakeDetectionFaulty = true
+      }
+      log.warn(
+        'Early Flake Detection retries are disabled because the number of suites with new tests is too high.'
+      )
+      return false
+    }
+  }
+
+  return true
+}
+
 function resetSuiteSkippingRunState () {
   skippableSuites = []
   resetAppliedSuiteSkippingState()
@@ -543,6 +648,7 @@ function resetLibraryConfig () {
   flakyTestRetriesCount = 0
   isEarlyFlakeDetectionEnabled = false
   earlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
+  earlyFlakeDetectionFaultyThreshold = 0
   isEarlyFlakeDetectionFaulty = false
   isDiEnabled = false
   isKnownTestsEnabled = false
@@ -558,6 +664,7 @@ function applyLibraryConfig (libraryConfig) {
   flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
   isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
   earlyFlakeDetectionRetryPolicy = libraryConfig.earlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
+  earlyFlakeDetectionFaultyThreshold = libraryConfig.earlyFlakeDetectionFaultyThreshold ?? 0
   isEarlyFlakeDetectionFaulty = false
   isDiEnabled = libraryConfig.isDiEnabled
   isKnownTestsEnabled = libraryConfig.isKnownTestsEnabled
@@ -573,6 +680,7 @@ function resetMainProcessProvidedContext (ctx) {
     _ddIsDiEnabled: false,
     _ddIsEarlyFlakeDetectionEnabled: false,
     _ddEarlyFlakeDetectionRetryPolicy: EMPTY_EFD_RETRY_POLICY,
+    _ddIsEfdSuiteAdmissionEnabled: false,
     _ddIsFlakyTestRetriesEnabled: false,
     _ddFlakyTestRetriesCount: 0,
     _ddFlakyTestRetriesIncludesUnnamedProject: false,
@@ -616,6 +724,7 @@ async function runMainProcessSetup (
   }
 
   resetSuiteSkippingRunState()
+  resetEfdSuiteTracker()
   isVitestBrowserModeActive ||= shouldInstallBrowserReporter
   isTestImpactAnalysisDisabled =
     disableTestImpactAnalysis || shouldInstallNoWorkerInit || isVitestBrowserModeActive
@@ -732,21 +841,27 @@ async function runMainProcessSetup (
       const currentTestFilepaths = await getCurrentTestFilepaths()
 
       if (isValidKnownTests(knownTests)) {
-        isEarlyFlakeDetectionFaultyCh.publish({
-          knownTests: knownTests.vitest,
-          testFilepaths: currentTestFilepaths,
-          onDone: (isFaulty) => {
-            isEarlyFlakeDetectionFaulty = isFaulty
-          },
-        })
-        if (isEarlyFlakeDetectionFaulty) {
-          isEarlyFlakeDetectionEnabled = false
-          log.warn('New test detection is disabled because the number of new tests is too high.')
+        if (!shouldInstallNoWorkerInit && supportsEfdSuiteAdmission(frameworkVersion, testSpecifications, ctx)) {
+          configureEfdSuiteTracker(currentTestFilepaths, repositoryRoot)
         } else {
+          const projectSuites = currentTestFilepaths.map(testFilepath => getTestSuitePath(testFilepath, repositoryRoot))
+          isEarlyFlakeDetectionFaulty = getIsFaultyEarlyFlakeDetection(
+            projectSuites,
+            knownTests.vitest,
+            earlyFlakeDetectionFaultyThreshold
+          )
+          if (isEarlyFlakeDetectionFaulty) {
+            isEarlyFlakeDetectionEnabled = false
+            log.warn('New test detection is disabled because the number of new tests is too high.')
+          }
+        }
+
+        if (!isEarlyFlakeDetectionFaulty) {
           knownTestsBySuite = knownTests.vitest
           shouldSendTestProperties = true
           if (!shouldInstallNoWorkerInit) {
             setProvidedContext(ctx, {
+              _ddIsEfdSuiteAdmissionEnabled: isEfdSuiteAdmissionEnabled,
               _ddIsKnownTestsEnabled: isKnownTestsEnabled,
               _ddIsEarlyFlakeDetectionEnabled: isEarlyFlakeDetectionEnabled,
               _ddEarlyFlakeDetectionRetryPolicy: earlyFlakeDetectionRetryPolicy,
@@ -821,6 +936,7 @@ async function runMainProcessSetup (
     const reporterTestSpecifications = shouldInstallNoWorkerInit
       ? testSpecifications
       : getBrowserTestSpecifications(testSpecifications)
+    activeNoWorkerInitState = getNoWorkerInitState()
     noWorkerInit.configure(ctx, frameworkVersion, reporterTestSpecifications, {
       knownTests,
       knownTestsBySuite,
@@ -832,8 +948,9 @@ async function runMainProcessSetup (
       testPropertiesByFilepath: testPropertiesByFilepath || {},
       testSessionConfiguration,
     }, {
+      reserveEarlyFlakeDetectionSuite,
       shouldReportTestModule: shouldInstallBrowserReporter ? isBrowserTestModule : undefined,
-      state: getNoWorkerInitState(),
+      state: activeNoWorkerInitState,
     })
   }
 
@@ -846,6 +963,7 @@ function getNoWorkerInitState () {
   return {
     attemptToFixExecutions,
     earlyFlakeDetectionRetryPolicy,
+    isEfdSuiteAdmissionEnabled,
     isEarlyFlakeDetectionEnabled,
     isEarlyFlakeDetectionFaulty,
     isFlakyTestRetriesEnabled,
@@ -1078,15 +1196,18 @@ function getFinishWrapper (exitOrClose) {
     }
 
     const failedSuites = this.state.getFailedFilepaths()
-    let error
-    if (failedSuites.length) {
+    const runError = runErrorsByContext.get(this)
+    runErrorsByContext.delete(this)
+    let error = runError
+    if (!error && failedSuites.length) {
       error = new Error(`Test suites failed: ${failedSuites.length}.`)
     }
 
     const flushPromise = getChannelPromise(testSessionFinishCh, {
-      status: areAllSuitesSkipped ? 'skip' : getSessionStatus(this.state),
+      status: runError ? 'fail' : (areAllSuitesSkipped ? 'skip' : getSessionStatus(this.state)),
       testCodeCoverageLinesTotal,
       error,
+      isTestSessionFinalizationError: Boolean(runError),
       isEarlyFlakeDetectionEnabled,
       isEarlyFlakeDetectionFaulty,
       isTestManagementTestsEnabled,
@@ -1172,8 +1293,9 @@ function getTestSpecificationOptions (testSpecification) {
 function getTestSpecificationPool (testSpecification) {
   const options = getTestSpecificationOptions(testSpecification)
   const project = getTestSpecificationProject(testSpecification)
-  return options?.pool || project?.config?.pool || project?.serializedConfig?.pool || project?.pool ||
-    testSpecification?.pool
+  const filePool = Array.isArray(testSpecification) ? testSpecification[1]?.pool : undefined
+  return options?.pool || filePool || project?.config?.pool || project?.serializedConfig?.pool ||
+    project?.pool || testSpecification?.pool
 }
 
 /**
@@ -1258,6 +1380,9 @@ function wrapVitestRunFiles (Vitest, frameworkVersion) {
     activeRunFilesContexts.add(this)
     try {
       return await runFiles.apply(this, arguments)
+    } catch (error) {
+      runErrorsByContext.set(this, error)
+      throw error
     } finally {
       activeRunFilesContexts.delete(this)
     }
@@ -1328,7 +1453,7 @@ function getMainProcessProvidedContext (ctx) {
     const providedContext = workspaceProject.getProvidedContext?.() || workspaceProject._provided || {}
 
     return {
-      testPropertiesByFilepath: providedContext._ddTestPropertiesByFilepath || {},
+      testPropertiesByFilepath: parseProvidedContextValue(providedContext._ddTestPropertiesByFilepath) || {},
     }
   } catch {
     return {
@@ -1559,6 +1684,7 @@ async function reportTypecheckFile (file, sessionConfiguration, frameworkVersion
   }
 
   await getChannelPromise(testSuiteFinishCh, {
+    deferFlush: true,
     frameworkVersion,
     status: getTypecheckTaskStatus(file),
     ...testSuiteCtx.currentStore,
@@ -1750,7 +1876,10 @@ function getWrappedOn (on) {
     arguments[1] = shimmer.wrapFunction(callback, callback => function (message) {
       if (message.type !== 'Buffer' && Array.isArray(message)) {
         const [interprocessCode, data] = message
-        if (handleWorkerReport(interprocessCode, data)) {
+        if (
+          handleEfdAdmissionMessage(this, interprocessCode, data) ||
+          handleWorkerReport(interprocessCode, data)
+        ) {
           // If we execute the callback vitest crashes, as the message is not supported
           return
         }
@@ -1761,6 +1890,37 @@ function getWrappedOn (on) {
   }
 }
 
+/**
+ * Handles an EFD suite admission request sent through a Vitest worker transport.
+ *
+ * @param {object} workerProcess
+ * @param {number} interprocessCode
+ * @param {object} data
+ * @returns {boolean}
+ */
+function handleEfdAdmissionMessage (workerProcess, interprocessCode, data) {
+  if (interprocessCode !== VITEST_WORKER_EFD_SUITE_ADMISSION_REQUEST_CODE) return false
+
+  const response = [VITEST_WORKER_EFD_SUITE_ADMISSION_RESPONSE_CODE, {
+    allowed: reserveEarlyFlakeDetectionSuite(data?.testSuite, data?.hasNewTest === true),
+    requestId: data?.requestId,
+  }]
+  try {
+    if (typeof workerProcess.send === 'function') {
+      workerProcess.send(response, (error) => {
+        if (error) {
+          log.error('Could not send Vitest EFD suite admission response: %s', error.message)
+        }
+      })
+    } else {
+      workerProcess.postMessage(response)
+    }
+  } catch (error) {
+    log.error('Could not send Vitest EFD suite admission response: %s', error?.message)
+  }
+  return true
+}
+
 function handleWorkerReport (interprocessCode, data) {
   if (interprocessCode === VITEST_WORKER_TRACE_PAYLOAD_CODE) {
     collectTestOptimizationSummariesFromTraces(data, {

package/packages/datadog-instrumentations/src/vitest-util.js

@@ -29,10 +29,12 @@ const testSessionFinishCh = channel('ci:vitest:session:finish')
 const testSessionConfigurationCh = channel('ci:vitest:session:configuration')
 const libraryConfigurationCh = channel('ci:vitest:library-configuration')
 const knownTestsCh = channel('ci:vitest:known-tests')
-const isEarlyFlakeDetectionFaultyCh = channel('ci:vitest:is-early-flake-detection-faulty')
 const testManagementTestsCh = channel('ci:vitest:test-management-tests')
 const modifiedFilesCh = channel('ci:vitest:modified-files')
 
+const CLOSING_SCRIPT_TAG_RE = /<\/script/i
+const SERIALIZED_CONTEXT_PREFIX = '\u0000dd-vitest-context:'
+
 const workerReportTraceCh = channel('ci:vitest:worker-report:trace')
 const workerReportCoverageCh = channel('ci:vitest:worker-report:coverage')
 const workerReportLogsCh = channel('ci:vitest:worker-report:logs')
@@ -105,18 +107,72 @@ function getWorkspaceProject (ctx) {
 
 function setProvidedContext (ctx, values, warningMessage) {
   try {
-    Object.assign(getWorkspaceProject(ctx)._provided, values)
+    const providedContext = getWorkspaceProject(ctx)._provided
+    for (const key of Object.keys(values)) {
+      providedContext[key] = key.startsWith('_dd')
+        ? makeProvidedContextBrowserSafe(values[key])
+        : values[key]
+    }
   } catch {
     log.warn(warningMessage)
   }
 }
 
+/**
+ * Prevent Vitest Browser Mode from terminating its inline bootstrap script with Datadog metadata.
+ *
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+function makeProvidedContextBrowserSafe (value) {
+  if (typeof value !== 'string' && (typeof value !== 'object' || value === null)) return value
+  if (typeof value === 'string' && !CLOSING_SCRIPT_TAG_RE.test(value)) return value
+
+  const serializedValue = JSON.stringify(value)
+  return CLOSING_SCRIPT_TAG_RE.test(serializedValue)
+    ? SERIALIZED_CONTEXT_PREFIX + serializedValue.replaceAll('<', String.raw`\u003c`)
+    : value
+}
+
+/**
+ * Restore context serialized by makeProvidedContextBrowserSafe.
+ *
+ * @param {unknown} value
+ * @returns {unknown}
+ */
+function parseProvidedContextValue (value) {
+  if (typeof value !== 'string' || !value.startsWith(SERIALIZED_CONTEXT_PREFIX)) return value
+
+  let parsedValue
+  try {
+    parsedValue = JSON.parse(value.slice(SERIALIZED_CONTEXT_PREFIX.length))
+  } catch {}
+  return parsedValue
+}
+
+/**
+ * Restores Datadog context values serialized for Vitest Browser Mode.
+ *
+ * @param {Record<string, unknown>} values
+ * @returns {Record<string, unknown>}
+ */
+function parseProvidedContextValues (values) {
+  const parsedValues = {}
+  for (const key of Object.keys(values)) {
+    if (key.startsWith('_dd')) {
+      parsedValues[key] = parseProvidedContextValue(values[key])
+    }
+  }
+  return parsedValues
+}
+
 function getProvidedContext () {
   try {
     const {
       _ddIsEarlyFlakeDetectionEnabled,
+      _ddIsEfdSuiteAdmissionEnabled: isEfdSuiteAdmissionEnabled,
       _ddIsDiEnabled,
-      _ddTestPropertiesByFilepath: testPropertiesByFilepath,
+      _ddTestPropertiesByFilepath,
       _ddEarlyFlakeDetectionRetryPolicy: earlyFlakeDetectionRetryPolicy,
       _ddIsKnownTestsEnabled: isKnownTestsEnabled,
       _ddIsTestManagementTestsEnabled: isTestManagementTestsEnabled,
@@ -135,11 +191,13 @@ function getProvidedContext () {
       _ddItrCorrelationId: itrCorrelationId,
       _ddUnskippableSuites: unskippableSuites,
       _ddForcedToRunSuites: forcedToRunSuites,
-    } = globalThis.__vitest_worker__.providedContext
+    } = parseProvidedContextValues(globalThis.__vitest_worker__.providedContext)
     const retryPolicy = earlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
+    const testPropertiesByFilepath = _ddTestPropertiesByFilepath || {}
 
     return {
       isDiEnabled: _ddIsDiEnabled,
+      isEfdSuiteAdmissionEnabled,
       isEarlyFlakeDetectionEnabled: _ddIsEarlyFlakeDetectionEnabled && hasEfdRetries(retryPolicy),
       testPropertiesByFilepath,
       earlyFlakeDetectionRetryPolicy: retryPolicy,
@@ -165,6 +223,7 @@ function getProvidedContext () {
     log.error('Vitest workers could not parse provided context, so some features will not work.')
     return {
       isDiEnabled: false,
+      isEfdSuiteAdmissionEnabled: false,
       isEarlyFlakeDetectionEnabled: false,
       testPropertiesByFilepath: {},
       earlyFlakeDetectionRetryPolicy: EMPTY_EFD_RETRY_POLICY,
@@ -258,7 +317,6 @@ module.exports = {
   testSessionConfigurationCh,
   libraryConfigurationCh,
   knownTestsCh,
-  isEarlyFlakeDetectionFaultyCh,
   testManagementTestsCh,
   modifiedFilesCh,
   workerReportTraceCh,
@@ -273,6 +331,7 @@ module.exports = {
   getTestName,
   getWorkspaceProject,
   setProvidedContext,
+  parseProvidedContextValue,
   getProvidedContext,
   isFlakyTestRetriesEnabledForTask,
   getVitestTestProperties,