dd-trace 6.11.0 → 6.13.0

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

@@ -14,6 +14,7 @@ const {
   takePoolWaitTime,
   wrapPoolQueryMethod,
 } = require('./helpers/pool-acquire')
+const { wrapCallbackBundle, wrapPromiseBundle } = require('./mariadb-bundle')
 
 const commandAddCh = channel('apm:mariadb:command:add')
 const connectionStartCh = channel('apm:mariadb:connection:start')
@@ -443,3 +444,9 @@ addHook({ name, file: 'lib/connection.js', versions: ['>=2.0.4 <=2.5.1'] }, (Con
 addHook({ name, file: 'lib/pool-base.js', versions: ['>=2.0.4 <3'] }, (PoolBase) => {
   return shimmer.wrapFunction(PoolBase, wrapPoolBase)
 })
+
+// MariaDB 3.5.3 added single-file CommonJS bundles that do not load the original source modules at runtime.
+// Matching their generated, minified internals would couple instrumentation to unstable bundle output, so wrap
+// the runtime objects returned by the public factories instead.
+addHook({ name, versions: ['>=3.5.3'] }, wrapPromiseBundle)
+addHook({ name, file: 'dist/callback.cjs', versions: ['>=3.5.3'] }, wrapCallbackBundle)

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

@@ -299,6 +299,9 @@ function retryTest (test, numRetries, tags, retryPolicy) {
         clonedTest[tag] = true
       }
     }
+    if (clonedTest._ddIsQuarantined && !clonedTest._ddIsAttemptToFix) {
+      testsQuarantined.add(clonedTest)
+    }
   }
 }
 
@@ -1146,7 +1149,7 @@ function getRunTestsWrapper (runTests, config) {
                 retryTest(
                   test,
                   config.earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
-                  ['_ddIsModified', '_ddIsEfdRetry'],
+                  ['_ddIsModified', '_ddIsEfdRetry', test._ddIsQuarantined && '_ddIsQuarantined'],
                   config.earlyFlakeDetectionRetryPolicy
                 )
               }
@@ -1165,7 +1168,7 @@ function getRunTestsWrapper (runTests, config) {
             retryTest(
               test,
               config.earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
-              ['_ddIsNew', '_ddIsEfdRetry'],
+              ['_ddIsNew', '_ddIsEfdRetry', test._ddIsQuarantined && '_ddIsQuarantined'],
               config.earlyFlakeDetectionRetryPolicy
             )
           }

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

@@ -6,6 +6,8 @@ const {
   addHook,
 } = require('./helpers/instrument')
 
+const logSubmissionCh = channel('ci:log-submission:log')
+
 /**
  * @param {string} symbol
  * @param {(original: Function) => Function} wrapper
@@ -36,13 +38,22 @@ function wrapAsJson (asJson) {
     obj = arguments[0] = obj || {}
 
     // Caller-provided `dd` wins -- skip the splice so a bespoke `dd` survives.
+    let line
     if (!jsonCh.hasSubscribers || Object.hasOwn(obj, 'dd')) {
-      return asJson.apply(this, arguments)
+      line = asJson.apply(this, arguments)
+    } else {
+      const payload = { line: asJson.apply(this, arguments) }
+      jsonCh.publish(payload)
+      line = payload.line
+    }
+
+    // Submit the serialized line for agentless log collection only when trace
+    // correlation is active, matching the Bunyan contract.
+    if (jsonCh.hasSubscribers && logSubmissionCh.hasSubscribers) {
+      logSubmissionCh.publish({ source: 'pino', message: line })
     }
 
-    const payload = { line: asJson.apply(this, arguments) }
-    jsonCh.publish(payload)
-    return payload.line
+    return line
   }
 }
 

package/packages/datadog-instrumentations/src/playwright-reporter.js

@@ -3,6 +3,9 @@
 const { channel } = require('dc-polyfill')
 
 const reporterErrorCh = channel('ci:playwright:reporter:error')
+const reporterRunSummaryCh = channel('ci:playwright:reporter:run-summary')
+const reporterSuiteHookErrorCh = channel('ci:playwright:reporter:suite-hook-error')
+const suitesWithHookErrors = new Set()
 const PLAYWRIGHT_REPORTER_ERROR_MESSAGE = 'Error in reporter'
 const PLAYWRIGHT_REPORTER_ERROR_CALLER_RE =
   /^\s*at wrapAsync .*?[\\/]playwright[\\/]lib[\\/]runner[\\/]index\.js:\d+:\d+\)?$/
@@ -27,7 +30,53 @@ function isPlaywrightReporterError (message) {
   }
 }
 
+/**
+ * Returns whether a finalized Playwright result contains a failed suite hook.
+ *
+ * @param {Array<object>} steps
+ * @returns {boolean}
+ */
+function hasFailedSuiteHook (steps) {
+  if (!steps) return false
+
+  for (const step of steps) {
+    if (step.error && (step.title === 'beforeAll hook' || step.title === 'afterAll hook')) return true
+    if (hasFailedSuiteHook(step.steps)) return true
+  }
+  return false
+}
+
 class DatadogPlaywrightReporter {
+  /**
+   * Creates a reporter that observes the finalized Playwright result independently of user reporters.
+   *
+   * @param {object} [options]
+   * @param {boolean} [options.captureReporterErrors]
+   */
+  constructor ({ captureReporterErrors = true } = {}) {
+    this.captureReporterErrors = captureReporterErrors
+    this.fatalErrorCount = 0
+  }
+
+  /**
+   * Identifies this reporter as implementing Playwright's reporter v2 contract.
+   *
+   * @returns {'v2'}
+   */
+  version () {
+    return 'v2'
+  }
+
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @param {object} config
+   * @returns {void}
+   */
+  onConfigure (config) {
+    this.failOnFlakyTests = config.failOnFlakyTests
+  }
+
   /**
    * Restores console error after Playwright completes the reporter lifecycle.
    *
@@ -45,12 +94,96 @@ class DatadogPlaywrightReporter {
     DatadogPlaywrightReporter.originalConsoleError = undefined
   }
 
+  /**
+   * Records the suite so finalized test outcomes can be counted in onEnd.
+   *
+   * @param {object} configOrSuite
+   * @param {object} [suite]
+   * @returns {void}
+   */
+  onBegin (configOrSuite, suite) {
+    this.suite = suite || configOrSuite
+    if (suite) this.failOnFlakyTests = configOrSuite.failOnFlakyTests
+    suitesWithHookErrors.clear()
+  }
+
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @returns {void}
+   */
+  onTestBegin () {}
+
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @returns {void}
+   */
+  onStdOut () {}
+
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @returns {void}
+   */
+  onStdErr () {}
+
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @returns {void}
+   */
+  onTestEnd () {}
+
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @returns {void}
+   */
+  onStepBegin () {}
+
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @returns {void}
+   */
+  onStepEnd () {}
+
   /**
    * Marks the beginning of reporter finalization so later reporter errors can be identified.
    *
    * @returns {void}
    */
   onEnd () {
+    let failureCount = this.fatalErrorCount
+    let quarantinedFailureCount = 0
+    let hasIncompleteTests = suitesWithHookErrors.size > 0
+    const tests = this.suite?.allTests?.()
+    if (tests) {
+      for (const test of tests) {
+        const outcome = test.outcome()
+        const finalResult = test.results.at(-1)
+        hasIncompleteTests ||= hasFailedSuiteHook(finalResult?.steps)
+        if (outcome === 'unexpected' || (outcome === 'flaky' && this.failOnFlakyTests)) {
+          failureCount += 1
+          const finalResultStatus = finalResult?.status
+          const hasFailed = finalResultStatus === 'failed' || finalResultStatus === 'timedOut'
+          if (outcome === 'unexpected' && hasFailed && test._ddIsQuarantined && !test._ddIsAttemptToFix) {
+            quarantinedFailureCount += 1
+          }
+        } else if (outcome === 'skipped' && !test._ddShouldSkipEfdRetry &&
+          (!test._ddIsDisabled || test._ddIsAttemptToFix)) {
+          const { results } = test
+          hasIncompleteTests ||= results.some(result => result.status === 'interrupted') ||
+            !results.length || test.expectedStatus !== 'skipped'
+        }
+      }
+    }
+    reporterRunSummaryCh.publish({ failureCount, quarantinedFailureCount, hasIncompleteTests })
+    suitesWithHookErrors.clear()
+
+    if (!this.captureReporterErrors) return
+
     this.isFinalizing = true
     // Playwright 1.60 and 1.61 only expose reporter errors through this exact console call.
     // eslint-disable-next-line no-console
@@ -76,6 +209,13 @@ class DatadogPlaywrightReporter {
     DatadogPlaywrightReporter.consoleError = consoleError
   }
 
+  /**
+   * Implements the reporter v2 lifecycle hook required by older Playwright versions.
+   *
+   * @returns {void}
+   */
+  onExit () {}
+
   /**
    * Reports errors emitted by Playwright while later reporters are finalizing.
    *
@@ -83,7 +223,11 @@ class DatadogPlaywrightReporter {
    * @returns {void}
    */
   onError (error) {
-    if (this.isFinalizing) reporterErrorCh.publish(error)
+    if (this.isFinalizing) {
+      reporterErrorCh.publish(error)
+    } else {
+      this.fatalErrorCount += 1
+    }
   }
 
   /**
@@ -96,4 +240,8 @@ class DatadogPlaywrightReporter {
   }
 }
 
+reporterSuiteHookErrorCh.subscribe((testSuiteAbsolutePath) => {
+  suitesWithHookErrors.add(testSuiteAbsolutePath)
+})
+
 module.exports = DatadogPlaywrightReporter

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

@@ -46,6 +46,8 @@ const testSessionStartCh = channel('ci:playwright:session:start')
 const testSessionConfigurationCh = channel('ci:playwright:session:configuration')
 const testSessionFinishCh = channel('ci:playwright:session:finish')
 const reporterErrorCh = channel('ci:playwright:reporter:error')
+const reporterRunSummaryCh = channel('ci:playwright:reporter:run-summary')
+const reporterSuiteHookErrorCh = channel('ci:playwright:reporter:suite-hook-error')
 
 const libraryConfigurationCh = channel('ci:playwright:library-configuration')
 const knownTestsCh = channel('ci:playwright:known-tests')
@@ -57,6 +59,7 @@ const testSuiteStartCh = channel('ci:playwright:test-suite:start')
 const testSuiteFinishCh = channel('ci:playwright:test-suite:finish')
 
 const workerReportCh = channel('ci:playwright:worker:report')
+const logSubmissionFlushCh = channel('ci:log-submission:flush')
 const workerReportTelemetryCh = channel('ci:playwright:worker-report:telemetry')
 const testPageGotoCh = channel('ci:playwright:test:page-goto')
 
@@ -111,7 +114,7 @@ let testManagementAttemptToFixRetries = 0
 let testManagementTests = {}
 let isImpactedTestsEnabled = false
 let modifiedFiles = {}
-let quarantinedButNotAttemptToFixFqns = new Set()
+let playwrightRunSummary
 let recordedTestOptimizationExecutions = new Set()
 let testsReportedInGenerateSummary = new Set()
 const newTestsWithDynamicNames = new Set()
@@ -785,6 +788,7 @@ function finishTestSuiteIfDone (testSuiteAbsolutePath, projects) {
       testSourceLine: test.location.line,
       browserName,
       isNew: test._ddIsNew,
+      isAttemptToFix: test._ddIsAttemptToFix,
       isDisabled: test._ddIsDisabled,
       isModified: test._ddIsModified,
       isQuarantined: test._ddIsQuarantined,
@@ -832,6 +836,7 @@ function testEndHandler ({
 
     if (hookError) {
       addErrorToTestSuite(testSuiteAbsolutePath, hookError)
+      reporterSuiteHookErrorCh.publish(testSuiteAbsolutePath)
     }
     return
   }
@@ -917,9 +922,7 @@ function testEndHandler ({
 
   // Check if all EFD retries failed
   const efdRetryCount = getEfdRetryCountForTest(test)
-  if (efdRetryCount > 0 && testStatuses.length === efdRetryCount + 1 &&
-    (test._ddIsNew || test._ddIsModified) &&
-    isEarlyFlakeDetectionEnabled &&
+  if (isEfdManagedTest && efdRetryCount > 0 && testStatuses.length === efdRetryCount + 1 &&
     testStatuses.every(status => status === 'fail')) {
     test._ddHasFailedAllRetries = true
   }
@@ -1083,7 +1086,7 @@ function onDispatcherCreateWorker (dispatcher, worker) {
 
   const projects = getProjectsFromDispatcher(dispatcher)
   sessionProjects = projects
-  const automaticFailureScreenshotPathsByTestId = new Map()
+  const automaticFailureScreenshotsByTestId = new Map()
 
   if (disabledTestIds.size && !worker[kDdPlaywrightWorkerHostInstrumented] &&
       typeof worker.runTestGroup === 'function') {
@@ -1108,19 +1111,21 @@ function onDispatcherCreateWorker (dispatcher, worker) {
     const test = getTestByTestId(dispatcher, testId)
     if (!test) return
 
+    automaticFailureScreenshotsByTestId.clear()
     const browser = getBrowserNameFromProjects(projects, test)
     const shouldCreateTestSpan = test.expectedStatus === 'skipped'
     testBeginHandler(test, browser, shouldCreateTestSpan)
   })
-  worker.on('attach', ({ testId, path, _ddIsAutomaticFailureScreenshot }) => {
+  worker.on('attach', (attachment) => {
+    const { testId, _ddIsAutomaticFailureScreenshot } = attachment
     if (!_ddIsAutomaticFailureScreenshot) return
 
-    let screenshotPaths = automaticFailureScreenshotPathsByTestId.get(testId)
-    if (!screenshotPaths) {
-      screenshotPaths = new Set()
-      automaticFailureScreenshotPathsByTestId.set(testId, screenshotPaths)
+    let screenshots = automaticFailureScreenshotsByTestId.get(testId)
+    if (!screenshots) {
+      screenshots = []
+      automaticFailureScreenshotsByTestId.set(testId, screenshots)
     }
-    screenshotPaths.add(path)
+    screenshots.push(attachment)
   })
   worker.on('testEnd', ({ testId, status, errors, annotations }) => {
     const test = getTestByTestId(dispatcher, testId)
@@ -1144,19 +1149,20 @@ function onDispatcherCreateWorker (dispatcher, worker) {
       }
     )
     const testResult = test.results.at(-1)
-    const automaticFailureScreenshotPaths = automaticFailureScreenshotPathsByTestId.get(testId)
-    automaticFailureScreenshotPathsByTestId.delete(testId)
-    if (testStatus === 'fail' && automaticFailureScreenshotPaths?.size && testResult?.attachments?.length) {
-      const screenshots = []
-      for (const attachment of testResult.attachments) {
-        if (automaticFailureScreenshotPaths.has(attachment.path)) {
-          screenshots.push(attachment)
+    if (isFailureScreenshotUploadEnabled &&
+        !shouldCreateTestSpan &&
+        !test._ddShouldSkipEfdRetry &&
+        !disabledTestIds.has(testId)) {
+      let screenshots
+      if (testStatus === 'fail') {
+        screenshots = automaticFailureScreenshotsByTestId.get(testId)
+        if (!screenshots) {
+          screenshots = []
+          automaticFailureScreenshotsByTestId.set(testId, screenshots)
         }
       }
-      if (screenshots.length) {
-        worker[kDdPlaywrightFailureScreenshots] ??= []
-        worker[kDdPlaywrightFailureScreenshots].push(screenshots)
-      }
+      worker[kDdPlaywrightFailureScreenshots] ??= []
+      worker[kDdPlaywrightFailureScreenshots].push(screenshots)
     }
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
@@ -1259,6 +1265,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
   return async function (config) {
     reporterError = undefined
     hasReporterError = false
+    playwrightRunSummary = undefined
     let restoreReporterConsoleError
     if (satisfies(playwrightVersion, '>=1.60.0') && config?.config) {
       const DatadogPlaywrightReporter = require('./playwright-reporter')
@@ -1433,23 +1440,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     const sessionStatus = runAllTestsReturn.status || runAllTestsReturn
 
     if (isTestManagementTestsEnabled && sessionStatus === 'failed') {
-      let totalFailedTestCount = 0
-      let totalPureQuarantinedFailedTestCount = 0
-
-      for (const [fqn, testStatuses] of testsToTestStatuses) {
-        // Only count as failed if the final status (after retries) is 'fail'
-        const lastStatus = testStatuses.at(-1)
-        if (lastStatus === 'fail') {
-          totalFailedTestCount += 1
-          if (quarantinedButNotAttemptToFixFqns.has(fqn)) {
-            totalPureQuarantinedFailedTestCount += 1
-          }
-        }
-      }
-
-      const totalIgnorableFailures = totalPureQuarantinedFailedTestCount
-
-      if (totalFailedTestCount > 0 && totalFailedTestCount === totalIgnorableFailures) {
+      const { failureCount, quarantinedFailureCount, hasIncompleteTests } = playwrightRunSummary || {}
+      if (!hasIncompleteTests && quarantinedFailureCount > 0 && quarantinedFailureCount === failureCount) {
         runAllTestsReturn = 'passed'
         preventedToFail = true
       }
@@ -1476,7 +1468,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 
     startedSuites = []
     remainingTestsByFile = {}
-    quarantinedButNotAttemptToFixFqns = new Set()
+    playwrightRunSummary = undefined
     recordedTestOptimizationExecutions = new Set()
     testsReportedInGenerateSummary = new Set()
     efdManagedTestKeys.clear()
@@ -1507,6 +1499,8 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
 function reportersHook (reportersPackage) {
   return shimmer.wrap(reportersPackage, 'createReporters', createReporters => async function () {
     const reporters = await createReporters.apply(this, arguments)
+    const DatadogPlaywrightReporter = require('./playwright-reporter')
+    reporters.unshift(new DatadogPlaywrightReporter({ captureReporterErrors: false }))
     for (const reporter of reporters) {
       if (instrumentedPlaywrightReporters.has(reporter)) continue
 
@@ -1663,6 +1657,10 @@ reporterErrorCh.subscribe((error) => {
   recordReporterError(error)
 })
 
+reporterRunSummaryCh.subscribe((runSummary) => {
+  playwrightRunSummary = runSummary
+})
+
 /**
  * Records a reporter failure even when the reporter throws a falsy value.
  *
@@ -1894,11 +1892,6 @@ function processRootSuite (createRootSuiteReturnValue) {
       }
       if (testProperties.quarantined) {
         test._ddIsQuarantined = true
-        if (!testProperties.attemptToFix) {
-          // Do not skip quarantined tests, let them run and overwrite results post-run if they fail
-          const testFqn = getTestFullyQualifiedName(test)
-          quarantinedButNotAttemptToFixFqns.add(testFqn)
-        }
       }
       if (testProperties.attemptToFix) {
         test._ddIsAttemptToFix = true
@@ -1938,7 +1931,10 @@ function processRootSuite (createRootSuiteReturnValue) {
     const fileSuitesWithImpactedTestsToProjects = new Map()
     for (const impactedTest of impactedTests) {
       impactedTest._ddIsModified = true
-      if (shouldRunEarlyFlakeDetection() && impactedTest.expectedStatus !== 'skipped') {
+      if (shouldRunEarlyFlakeDetection() && impactedTest.expectedStatus !== 'skipped' &&
+        !impactedTest._ddIsAttemptToFix) {
+        // Prevent ATR or `--retries` from retrying tests that EFD manages.
+        impactedTest.retries = 0
         markEfdManagedTest(impactedTest)
         const fileSuite = getSuiteType(impactedTest, 'file')
         if (!fileSuitesWithImpactedTestsToProjects.has(fileSuite)) {
@@ -1946,14 +1942,15 @@ function processRootSuite (createRootSuiteReturnValue) {
         }
       }
     }
-    // If something change in the file, all tests in the file are impacted, hence the () => true filter
+    // If something changes in the file, all tests in the file are impacted, except attempt-to-fix tests managed above.
     applyRetriesToTests(
       fileSuitesWithImpactedTestsToProjects,
-      () => true,
+      (test) => !test._ddIsAttemptToFix,
       [
         '_ddIsModified',
         '_ddIsEfdRetry',
         (test) => (isKnownTestsEnabled && isNewTest(test) ? '_ddIsNew' : null),
+        (test) => test._ddIsQuarantined && '_ddIsQuarantined',
       ],
       earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
       (copiedTest, originalTest, retryIndex) => {
@@ -1981,7 +1978,8 @@ function processRootSuite (createRootSuiteReturnValue) {
       const fileSuitesWithNewTestsToProjects = new Map()
       for (const newTest of newTests) {
         newTest._ddIsNew = true
-        if (shouldRunEarlyFlakeDetection() && newTest.expectedStatus !== 'skipped' && !newTest._ddIsModified) {
+        if (shouldRunEarlyFlakeDetection() && newTest.expectedStatus !== 'skipped' &&
+          !newTest._ddIsModified && !newTest._ddIsAttemptToFix) {
           // Prevent ATR or `--retries` from retrying tests that EFD manages.
           newTest.retries = 0
           markEfdManagedTest(newTest)
@@ -1994,8 +1992,12 @@ function processRootSuite (createRootSuiteReturnValue) {
 
       applyRetriesToTests(
         fileSuitesWithNewTestsToProjects,
-        isNewTest,
-        ['_ddIsNew', '_ddIsEfdRetry'],
+        (test) => !test._ddIsAttemptToFix && isNewTest(test),
+        [
+          '_ddIsNew',
+          '_ddIsEfdRetry',
+          (test) => test._ddIsQuarantined && '_ddIsQuarantined',
+        ],
         earlyFlakeDetectionRetryPolicy.schedulingRetryCount,
         (copiedTest, originalTest, retryIndex) => {
           markEfdRetryTest(copiedTest, retryIndex, originalTest)
@@ -2214,7 +2216,8 @@ addHook({
 
 function instrumentWorkerMainMethods (workerMain) {
   if (!workerMain || workerMain[kDdPlaywrightWorkerInstrumented] ||
-      typeof workerMain._runTest !== 'function' || typeof workerMain.dispatchEvent !== 'function') {
+      typeof workerMain._runTest !== 'function' || typeof workerMain.dispatchEvent !== 'function' ||
+      typeof workerMain.gracefullyClose !== 'function') {
     return workerMain
   }
 
@@ -2230,6 +2233,15 @@ function instrumentWorkerMainMethods (workerMain) {
     return runTestGroup.apply(this, arguments)
   })
 
+  // Playwright >=1.60 creates WorkerMain through a runtime factory, which Orchestrion cannot wrap statically.
+  shimmer.wrap(workerMain, 'gracefullyClose', gracefullyClose => async function () {
+    try {
+      return await gracefullyClose.apply(this, arguments)
+    } finally {
+      await getChannelPromise(logSubmissionFlushCh)
+    }
+  })
+
   shimmer.wrap(workerMain, '_runTest', _runTest => async function (test) {
     if (this[kDdPlaywrightDisabledTestIds]?.has(test.id)) {
       test._ddIsDisabled = true
@@ -2395,7 +2407,7 @@ function instrumentWorkerMainMethods (workerMain) {
   // We reproduce what happens in `Dispatcher#_onStepBegin` and `Dispatcher#_onStepEnd`,
   // since `startTime` and `duration` are not available directly in the worker process
   shimmer.wrap(workerMain, 'dispatchEvent', dispatchEvent => function (event, payload) {
-    if (event === 'testBegin' || event === 'testEnd') {
+    if (event === 'testBegin') {
       automaticFailureScreenshotPaths.clear()
     } else if (event === 'stepBegin') {
       stepInfoByStepId[payload.stepId] = {
@@ -2447,6 +2459,7 @@ function generateSummaryWrapper (generateSummary) {
             line: testSourceLine,
           },
           _ddIsNew: isNew,
+          _ddIsAttemptToFix: isAttemptToFix,
           _ddIsDisabled: isDisabled,
           _ddIsModified: isModified,
           _ddIsQuarantined: isQuarantined,
@@ -2461,6 +2474,7 @@ function generateSummaryWrapper (generateSummary) {
           testSourceLine,
           browserName,
           isNew,
+          isAttemptToFix,
           isDisabled,
           isModified,
           isQuarantined,

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

@@ -1058,7 +1058,7 @@ function getRepeatedTestReport (task, testName, testSuiteAbsolutePath, testPrope
   const errors = browserEnvironment
     ? normalizeVitestBrowserErrors(result?.errors)
     : result?.errors || []
-  const finalAttemptStatus = finalStatus(statuses)
+  const finalAttemptStatus = finalStatus(statuses, testProperties)
   const hasFailure = finalAttemptStatus === 'fail'
   const attempts = []
   const attemptCount = getRepeatedAttemptCount(task, statuses)
@@ -1095,8 +1095,7 @@ function getRepeatedTestReport (task, testName, testSuiteAbsolutePath, testPrope
         testProperties,
         type,
         statuses,
-        isFinalAttempt,
-        hasFailure
+        isFinalAttempt
       ),
       isRetry: index > 0,
       status: attemptStatus,
@@ -1136,11 +1135,10 @@ function getRepeatedTestReport (task, testName, testSuiteAbsolutePath, testPrope
  * @param {'attempt_to_fix'|'early_flake_detection'|'external'} type
  * @param {string[]} statuses
  * @param {boolean} isFinalAttempt
- * @param {boolean} hasFailure
  * @returns {boolean}
  */
-function hasFailedAllManagedRetries (task, testProperties, type, statuses, isFinalAttempt, hasFailure) {
-  if (!isFinalAttempt || !hasFailure || statuses.length === 0 || !statuses.every(status => status === 'fail')) {
+function hasFailedAllManagedRetries (task, testProperties, type, statuses, isFinalAttempt) {
+  if (!isFinalAttempt || statuses.length === 0 || !statuses.every(status => status === 'fail')) {
     return false
   }
 
@@ -1165,7 +1163,8 @@ function getAttemptToFixFinalStatus (statuses) {
   return statuses.includes('fail') ? 'fail' : 'pass'
 }
 
-function getEarlyFlakeDetectionFinalStatus (statuses) {
+function getEarlyFlakeDetectionFinalStatus (statuses, testProperties) {
+  if (testProperties.isDisabled || testProperties.isQuarantined) return 'skip'
   return statuses.includes('pass') ? 'pass' : 'fail'
 }
 
@@ -1274,7 +1273,6 @@ function reportFinalTestAttempt (testReport) {
         testProperties,
         'external',
         ['fail'],
-        true,
         true
       ),
       isRetry: (result?.retryCount || 0) > 0 || (result?.repeatCount || 0) > 0,
@@ -1604,15 +1602,18 @@ function splitNodeOptions (nodeOptions) {
 }
 
 function serializeNodeOptions (tokens) {
-  const serializedTokens = []
+  let serializedTokens = ''
+  let hasSerializedToken = false
   for (const token of tokens) {
+    if (hasSerializedToken) serializedTokens += ' '
     if (NODE_OPTIONS_QUOTE_RE.test(token)) {
-      serializedTokens.push(JSON.stringify(token))
+      serializedTokens += JSON.stringify(token)
     } else {
-      serializedTokens.push(token)
+      serializedTokens += token
     }
+    hasSerializedToken = true
   }
-  return serializedTokens.join(' ')
+  return serializedTokens
 }
 
 function getTestSpecificationProject (testSpecification) {

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

@@ -5,6 +5,7 @@ const { performance } = require('node:perf_hooks')
 const { fileURLToPath } = require('node:url')
 const { isMainThread, parentPort } = require('node:worker_threads')
 
+const { channel } = require('dc-polyfill')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
 const { getEfdRetryCountForDuration } = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
@@ -40,10 +41,12 @@ const {
 } = require('./vitest-util')
 
 const EFD_SUITE_ADMISSION_TIMEOUT_MS = 5000
+const logSubmissionFlushCh = channel('ci:log-submission:flush')
 const taskToCtx = new WeakMap()
 const taskToTestProperties = new WeakMap()
 const taskToStatuses = new WeakMap()
 const taskToReportedErrorCount = new WeakMap()
+const runnersWithLogSubmissionCleanup = new WeakSet()
 const attemptToFixTaskToStatuses = new WeakMap()
 const fileToHasConcurrentTests = new WeakMap()
 const fileToEfdSuiteAdmission = new WeakMap()
@@ -954,6 +957,14 @@ addHook({
     if (!testSuiteFinishCh.hasSubscribers) {
       return startTests.apply(this, arguments)
     }
+    const runner = arguments[1]
+    // Vitest 3+ exposes the only awaited worker-shutdown boundary; older versions keep timer/before-exit behavior.
+    if (logSubmissionFlushCh.hasSubscribers &&
+        typeof runner?.onCleanupWorkerContext === 'function' &&
+        !runnersWithLogSubmissionCleanup.has(runner)) {
+      runnersWithLogSubmissionCleanup.add(runner)
+      runner.onCleanupWorkerContext(() => getChannelPromise(logSubmissionFlushCh))
+    }
     // From >=3.0.1, the first arguments changes from a string to an object containing the filepath
     const testSuiteAbsolutePath = testPaths[0]?.filepath || testPaths[0]
     const providedContext = getProvidedContext()