dd-trace 5.133.0 → 5.134.0

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

@@ -64,7 +64,7 @@ const {
   getChannelPromise,
   publishWithCompletion,
 } = require('./helpers/channel')
-const { addHook, channel } = require('./helpers/instrument')
+const { addHook, channel, getHooks, tracingChannel } = require('./helpers/instrument')
 
 const testSessionStartCh = channel('ci:jest:session:start')
 const testSessionFinishCh = channel('ci:jest:session:finish')
@@ -125,6 +125,7 @@ const jestSessionState = (globalThis[JEST_SESSION_STATE] ||= {})
 
 // https://github.com/jestjs/jest/blob/41f842a46bb2691f828c3a5f27fc1d6290495b82/packages/jest-circus/src/types.ts#L9C8-L9C54
 const RETRY_TIMES = Symbol.for('RETRY_TIMES')
+const RETRY_TIMES_SETTER = Symbol.for('RETRY_TIMES_SETTER')
 
 let skippableSuites = []
 let skippableSuitesCoverage
@@ -195,6 +196,7 @@ const dynamicAtrResultHandlerRegistrations = new WeakMap()
 // Tests that are genuinely new (not in known tests list).
 const newTests = new Set()
 const testSuiteJestObjects = new Map()
+const deferredTestSuiteFinishes = new Map()
 const testSuiteDatadogEnvironments = new Map()
 const wrappedJestGlobals = new WeakSet()
 const wrappedJestEsmLoaders = new WeakSet()
@@ -741,9 +743,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
       }
 
+      this.hasAutomaticRetries = false
       if (this.isFlakyTestRetriesEnabled) {
         const currentNumRetries = this.global[RETRY_TIMES]
         if (!currentNumRetries) {
+          this.hasAutomaticRetries = true
           // When dynamic ATR is enabled, use the max bucket value as the initial count.
           // The actual duration-based count is computed per test after the first attempt.
           if (this.isDynamicAtrEnabled) {
@@ -2445,7 +2449,16 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         }
 
         let isAtrRetry = false
-        if (this.isFlakyTestRetriesEnabled && event.test?.invocations > 1 && !isAttemptToFix && !isEfdRetry) {
+        let hasAutomaticRetries = this.hasAutomaticRetries || dynamicAtrRetryCountByTest.has(event.test)
+        // Describe retries suppress per-test retries throughout the block, including nested describes.
+        for (let block = event.test.parent; block; block = block.parent) {
+          if (state.describeRetryOptions?.has(block)) {
+            hasAutomaticRetries = false
+            break
+          }
+        }
+        if (this.isFlakyTestRetriesEnabled && hasAutomaticRetries &&
+          event.test?.invocations > 1 && !isAttemptToFix && !isEfdRetry) {
           isAtrRetry = true
         }
 
@@ -2652,19 +2665,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
       }
-      const clearActiveTestSuite = () => {
-        realSetTimeout(() => {
-          if (activeTestSuiteAbsolutePath === this.testSuiteAbsolutePath) {
-            activeTestSuiteAbsolutePath = undefined
-          }
-        }, 0)
-      }
-      const result = super.teardown()
-      if (result?.then) {
-        return result.finally(clearActiveTestSuite)
-      }
-      clearActiveTestSuite()
-      return result
+      return super.teardown()
     }
   }
 }
@@ -3492,22 +3493,48 @@ function shouldWaitForTestSuiteFinish (environment) {
   return isJestWorker && environment.globalConfig?.workerIdleMemoryLimit !== undefined
 }
 
+/**
+ * @param {string} testSuiteAbsolutePath
+ */
+function finishTestSuiteAfterRun (testSuiteAbsolutePath) {
+  const clearActiveTestSuite = () => {
+    realSetTimeout(() => {
+      if (activeTestSuiteAbsolutePath === testSuiteAbsolutePath) {
+        activeTestSuiteAbsolutePath = undefined
+      }
+    }, 0)
+  }
+  const payload = deferredTestSuiteFinishes.get(testSuiteAbsolutePath)
+  deferredTestSuiteFinishes.delete(testSuiteAbsolutePath)
+  if (payload) {
+    return getChannelPromise(testSuiteFinishCh, { ...payload, waitForFinish: true })
+      .finally(clearActiveTestSuite)
+  }
+  return clearActiveTestSuite()
+}
+
+tracingChannel('orchestrion:jest-runner:runTestInternal').end.subscribe((message) => {
+  const ctx = /** @type {{ arguments: [string, ...unknown[]], result: Promise<unknown> }} */ (message)
+  const [testSuiteAbsolutePath] = ctx.arguments
+  // Jest's runner awaits the complete custom teardown before this promise settles.
+  ctx.result = ctx.result.finally(() => finishTestSuiteAfterRun(testSuiteAbsolutePath))
+})
+
+for (const hook of getHooks('jest-runner').values()) addHook(hook, moduleExports => moduleExports)
+
 /**
  * @param {Record<string, unknown>} payload
- * @param {boolean} waitForFinish
+ * @param {InstanceType<ReturnType<typeof getWrappedEnvironment>>} environment
  */
-function publishTestSuiteFinish (payload, waitForFinish) {
+function publishTestSuiteFinish (payload, environment) {
   if (!testSuiteFinishCh.hasSubscribers) return
 
-  if (!waitForFinish) {
-    testSuiteFinishCh.publish(payload)
+  if (shouldWaitForTestSuiteFinish(environment)) {
+    deferredTestSuiteFinishes.set(environment.testSuiteAbsolutePath, payload)
     return
   }
 
-  return getChannelPromise(testSuiteFinishCh, {
-    ...payload,
-    waitForFinish,
-  })
+  testSuiteFinishCh.publish(payload)
 }
 
 function cleanupTestSuiteState (testSuiteAbsolutePath) {
@@ -3684,48 +3711,24 @@ function jestAdapterWrapper (jestAdapter, jestVersion, isIitm, hookMeta) {
           testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
         })
       }
-      const waitForFinish = shouldWaitForTestSuiteFinish(environment)
       const finishPayload = {
         status,
         errorMessage,
         testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
       }
-      if (waitForFinish) {
-        const finishPromise = publishTestSuiteFinish(finishPayload, waitForFinish)
-        if (finishPromise) {
-          return finishPromise.then(() => {
-            // Cleanup per-suite state to avoid memory leaks
-            cleanupTestSuiteState(environment.testSuiteAbsolutePath)
-
-            return suiteResults
-          })
-        }
-      }
-      publishTestSuiteFinish(finishPayload, waitForFinish)
+      publishTestSuiteFinish(finishPayload, environment)
 
       // Cleanup per-suite state to avoid memory leaks
       cleanupTestSuiteState(environment.testSuiteAbsolutePath)
 
       return suiteResults
     }).catch(error => {
-      const waitForFinish = shouldWaitForTestSuiteFinish(environment)
       const finishPayload = {
         status: 'fail',
         error,
         testSuiteAbsolutePath: environment.testSuiteAbsolutePath,
       }
-      if (waitForFinish) {
-        const finishPromise = publishTestSuiteFinish(finishPayload, waitForFinish)
-        if (finishPromise) {
-          return finishPromise.then(() => {
-            // Cleanup per-suite state to avoid memory leaks
-            cleanupTestSuiteState(environment.testSuiteAbsolutePath)
-
-            throw error
-          })
-        }
-      }
-      publishTestSuiteFinish(finishPayload, waitForFinish)
+      publishTestSuiteFinish(finishPayload, environment)
 
       // Cleanup per-suite state to avoid memory leaks
       cleanupTestSuiteState(environment.testSuiteAbsolutePath)
@@ -3978,12 +3981,11 @@ const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'selenium-webdriver/chromium',
 ])
 
-function recordMockedFile (suiteFilePath, moduleName) {
+function recordMockedFile (suiteFilePath, moduleName, from = suiteFilePath) {
   if (!suiteFilePath || typeof moduleName !== 'string') return
 
   const existingMockedFiles = testSuiteMockedFiles.get(suiteFilePath) || []
-  const suiteDir = path.dirname(suiteFilePath)
-  const mockPath = path.resolve(suiteDir, moduleName)
+  const mockPath = path.resolve(path.dirname(from), moduleName)
   existingMockedFiles.push(mockPath)
   testSuiteMockedFiles.set(suiteFilePath, existingMockedFiles)
 }
@@ -4018,14 +4020,24 @@ function getMockedFiles (suiteFilePath) {
   return staticMockedFiles
 }
 
-function wrapJestObject (jestObject, suiteFilePath) {
+function wrapJestObject (jestObject, suiteFilePath, from = suiteFilePath) {
   if (!jestObject || !suiteFilePath || wrappedJestObjects.has(jestObject)) return
 
   testSuiteJestObjects.set(suiteFilePath, jestObject)
   wrappedJestObjects.add(jestObject)
 
+  // retryTimes is created per runtime, so wrap the returned public API object.
+  shimmer.wrap(jestObject, 'retryTimes', retryTimes => function () {
+    const environment = testSuiteDatadogEnvironments.get(suiteFilePath)
+    // Older Jest versions ignore entireDescribe and still replace the global budget.
+    if (environment && !(arguments[1]?.entireDescribe && environment.global[RETRY_TIMES_SETTER])) {
+      environment.hasAutomaticRetries = false
+    }
+    return retryTimes.apply(this, arguments)
+  })
+
   shimmer.wrap(jestObject, 'mock', mock => function (moduleName) {
-    recordMockedFile(suiteFilePath, moduleName)
+    recordMockedFile(suiteFilePath, moduleName, from)
     return mock.apply(this, arguments)
   })
 }
@@ -4039,7 +4051,7 @@ function wrapJestGlobalsForRuntime (runtime) {
   wrappedJestGlobals.add(jestGlobals)
   shimmer.wrap(jestGlobals, 'jestObjectFor', jestObjectFor => function (from) {
     const jestObject = jestObjectFor.apply(this, arguments)
-    wrapJestObject(jestObject, from)
+    wrapJestObject(jestObject, runtime._testPath || from, from)
     return jestObject
   })
 }
@@ -4334,9 +4346,9 @@ addHook({
   if (typeof Runtime.prototype._createJestObjectFor === 'function') {
     shimmer.wrap(Runtime.prototype, '_createJestObjectFor', _createJestObjectFor => function (from) {
       const result = _createJestObjectFor.apply(this, arguments)
-      const suiteFilePath = this._testPath || from
+      const suiteFilePath = this._testPath || this._environment?.testSuiteAbsolutePath || from
 
-      wrapJestObject(result, suiteFilePath)
+      wrapJestObject(result, suiteFilePath, from)
       return result
     })
   }

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

@@ -43,6 +43,9 @@ const originalEfdFns = new WeakMap()
 const originalFns = new WeakMap()
 const originalPendingByTest = new WeakMap()
 const originalRetriesByTest = new WeakMap()
+let automaticRetryTests = new WeakSet()
+let automaticRetryAttempts = new WeakMap()
+let nativeRetryTests = new WeakSet()
 const testToStartLine = new WeakMap()
 const testFileToSuiteCtx = new Map()
 const datadogRetryOriginals = new WeakMap()
@@ -346,6 +349,9 @@ function resetRunState (rootSuite) {
   efdRetryCountByTestFullName.clear()
   efdSlowAbortedTests.clear()
   suiteHookFailureSuites.clear()
+  automaticRetryTests = new WeakSet()
+  automaticRetryAttempts = new WeakMap()
+  nativeRetryTests = new WeakSet()
   dynamicAtrRetryCountByTest = new WeakMap()
   attemptToFixExecutions.clear()
   loggedAttemptToFixTests.clear()
@@ -423,7 +429,7 @@ function isMochaRetry (test) {
 }
 
 function getIsLastRetry (test) {
-  return test._currentRetry === test._retries
+  return test._currentRetry >= test._retries
 }
 
 function getTestFullName (test) {
@@ -534,6 +540,18 @@ function inheritDatadogPropertiesFromRetriedTest (test) {
 
 function runnableWrapper (RunnablePackage, libraryConfig) {
   const Runnable = RunnablePackage.Runnable ?? RunnablePackage
+  // Mocha 12 can load its ESM class through require() without the ESM rewriter.
+  // Intercept the exported prototype to observe setters in both injection modes.
+  shimmer.wrap(Runnable.prototype, 'retries', retries => function () {
+    if (arguments.length && automaticRetryTests.delete(this)) {
+      const originalTest = this._retriedTest || this
+      // afterEach can change this runnable after Mocha has already copied its budget into a queued clone.
+      if (!automaticRetryAttempts.get(originalTest)?.has(this._currentRetry + 1)) {
+        nativeRetryTests.add(originalTest)
+      }
+    }
+    return retries.apply(this, arguments)
+  })
   shimmer.wrap(Runnable.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
       return run.apply(this, args)
@@ -559,11 +577,12 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
           return onRunnableFinished.apply(this, arguments)
         }
       }
-    } else if (libraryConfig?.isFlakyTestRetriesEnabled) {
+    } else if (libraryConfig?.isFlakyTestRetriesEnabled && !nativeRetryTests.has(test._retriedTest || test)) {
       if (!originalRetriesByTest.has(test)) {
         const originalRetries = originalRetriesByTest.get(test._retriedTest) ?? test.retries()
         originalRetriesByTest.set(test, originalRetries)
       }
+      automaticRetryTests.delete(test)
       if (libraryConfig.isDynamicAtrEnabled) {
         // Dynamic ATR: set the max possible retries initially.
         // The actual duration-based count is computed after the first attempt.
@@ -581,6 +600,7 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
       } else {
         test.retries(libraryConfig.flakyTestRetriesCount)
       }
+      automaticRetryTests.add(test)
     }
 
     if (isTestHook || this.type === 'test') {
@@ -833,6 +853,7 @@ function getTestFinishInfo (test, status, config, error) {
 
   const isAttemptToFixRetry = test._ddIsAttemptToFix && testStatuses.length > 1
   const isAtrRetry = config.isFlakyTestRetriesEnabled &&
+    automaticRetryAttempts.get(test._retriedTest || test)?.has(test._currentRetry) &&
     !test._ddIsAttemptToFix &&
     !test._ddIsEfdRetry
   const isFinalAttempt = isTerminalHookFailure || status !== 'fail' || test._currentRetry >= test._retries
@@ -1178,9 +1199,20 @@ function getOnFailHandler (isMain, config) {
 
 function getOnTestRetryHandler (config) {
   return function (test, err) {
+    if (automaticRetryTests.has(test)) {
+      // Mocha has already queued the clone; later budget changes cannot change its scheduling owner.
+      const originalTest = test._retriedTest || test
+      let attempts = automaticRetryAttempts.get(originalTest)
+      if (!attempts) {
+        attempts = new Set()
+        automaticRetryAttempts.set(originalTest, attempts)
+      }
+      attempts.add(test._currentRetry + 1)
+    }
     const isFirstAttempt = test._currentRetry === 0
     const isDynamicAtrTest = config.isDynamicAtrEnabled &&
       config.isFlakyTestRetriesEnabled &&
+      automaticRetryTests.has(test) &&
       !test._ddIsAttemptToFix &&
       !isEarlyFlakeDetectionTest(test, config)
     if (isDynamicAtrTest && isFirstAttempt) {
@@ -1217,6 +1249,7 @@ function publishTestRetry (test, err, config) {
     const willBeRetried = test._currentRetry < test._retries
     const isAtrRetry = !isFirstAttempt &&
       config.isFlakyTestRetriesEnabled &&
+      automaticRetryAttempts.get(test._retriedTest || test)?.has(test._currentRetry) &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
     const promises = {}

package/packages/datadog-instrumentations/src/nova-sonic/session.js

@@ -33,7 +33,7 @@ class Turn {
   textEnd
   completionId
   metrics = { input_tokens: 0, output_tokens: 0, total_tokens: 0 }
-  missingAudioMetrics = new Set()
+  missingModalityMetrics = new Set()
   emitted = false
 }
 
@@ -86,7 +86,9 @@ class SonicSession {
   #sessionId = randomUUID()
   #providerSessionId
   #totals = { input_tokens: 0, output_tokens: 0 }
-  #audioTotals = { input: 0, output: 0 }
+  #modalityTotals = {
+    input_audio_tokens: 0, output_audio_tokens: 0, input_text_tokens: 0, output_text_tokens: 0,
+  }
 
   /** @param {(descriptor: object) => void} emit */
   constructor (emit) {
@@ -389,21 +391,28 @@ class SonicSession {
       target.metrics[key] += delta
       target.metrics.total_tokens += delta
 
-      // Speech usage is a subset of these totals, never another charge to total_tokens.
-      const audioKey = `${direction}_audio_tokens`
-      const audioTotal = data.details?.total?.[direction]?.speechTokens
-      const previous = this.#audioTotals[direction]
-      const valid = Number.isSafeInteger(audioTotal) && audioTotal >= 0 && audioTotal <= total &&
-        (previous === undefined || audioTotal >= previous)
-      const audioDelta = valid && previous !== undefined ? audioTotal - previous : undefined
-      this.#audioTotals[direction] = valid ? audioTotal : delta ? undefined : previous
-      if (audioDelta === undefined || audioDelta > delta) {
-        if (delta || audioDelta > delta) {
-          target.missingAudioMetrics.add(audioKey)
-          delete target.metrics[audioKey]
+      // Each modality is a subset of the aggregate and has its own cumulative baseline.
+      // Missing text must not discard valid speech or charge a previous turn's gap.
+      let remaining = delta
+      for (const [modality, field] of [['audio', 'speechTokens'], ['text', 'textTokens']]) {
+        const modalityKey = `${direction}_${modality}_tokens`
+        const modalityTotal = data.details?.total?.[direction]?.[field]
+        const previous = this.#modalityTotals[modalityKey]
+        const valid = Number.isSafeInteger(modalityTotal) && modalityTotal >= 0 && modalityTotal <= total &&
+          (previous === undefined || modalityTotal >= previous)
+        const modalityDelta = valid && previous !== undefined ? modalityTotal - previous : undefined
+        this.#modalityTotals[modalityKey] = valid ? modalityTotal : delta ? undefined : previous
+        if (modalityDelta === undefined || modalityDelta > remaining) {
+          if (delta || modalityDelta > remaining) {
+            target.missingModalityMetrics.add(modalityKey)
+            delete target.metrics[modalityKey]
+          }
+        } else {
+          remaining -= modalityDelta
+          if (!target.missingModalityMetrics.has(modalityKey)) {
+            target.metrics[modalityKey] = (target.metrics[modalityKey] ?? 0) + modalityDelta
+          }
         }
-      } else if (!target.missingAudioMetrics.has(audioKey)) {
-        target.metrics[audioKey] = (target.metrics[audioKey] ?? 0) + audioDelta
       }
     }
   }

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

@@ -1077,6 +1077,7 @@ function testEndHandler ({
       : undefined
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
+      hasAutomaticRetries(test, projects) &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
 
@@ -1340,6 +1341,7 @@ function onDispatcherCreateWorker (dispatcher, worker) {
     }
     const isAtrRetry = testResult?.retry > 0 &&
       isFlakyTestRetriesEnabled &&
+      hasAutomaticRetries(test, projects) &&
       !test._ddIsAttemptToFix &&
       !test._ddIsEfdRetry
 

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

@@ -58,19 +58,30 @@ function wrapConstructEventAsync (constructEventAsync) {
   }
 }
 
+const wrappedMethods = new WeakSet()
+
+// Stripe >=9 <11.10 and >=18 share `webhooks` across clients. Stripe >=11.10 <18
+// creates it per client. checkout.sessions and paymentIntents are separate for each client.
+// Rewrapping shared webhook methods adds one layer per client, causing duplicate
+// publications and eventually a stack overflow. Track installed functions so replacements
+// still get wrapped and restored wrappers are reused.
+/**
+ * @param {object|undefined} target
+ * @param {string} name
+ * @param {Function} wrapper
+ */
+function wrapOnce (target, name, wrapper) {
+  if (typeof target?.[name] !== 'function' || wrappedMethods.has(target[name])) return
+
+  shimmer.wrap(target, name, wrapper)
+  wrappedMethods.add(target[name])
+}
+
 function instrumentStripeInstance (stripe) {
-  if (typeof stripe.checkout?.sessions?.create === 'function') {
-    shimmer.wrap(stripe.checkout.sessions, 'create', wrapSessionCreate)
-  }
-  if (typeof stripe.paymentIntents?.create === 'function') {
-    shimmer.wrap(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
-  }
-  if (typeof stripe.webhooks?.constructEvent === 'function') {
-    shimmer.wrap(stripe.webhooks, 'constructEvent', wrapConstructEvent)
-  }
-  if (typeof stripe.webhooks?.constructEventAsync === 'function') {
-    shimmer.wrap(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
-  }
+  wrapOnce(stripe.checkout?.sessions, 'create', wrapSessionCreate)
+  wrapOnce(stripe.paymentIntents, 'create', wrapPaymentIntentCreate)
+  wrapOnce(stripe.webhooks, 'constructEvent', wrapConstructEvent)
+  wrapOnce(stripe.webhooks, 'constructEventAsync', wrapConstructEventAsync)
 }
 
 // stripe <22: the constructor mutates this (when invoked with 'new') and

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

@@ -934,6 +934,7 @@ function createMainProcessReporter (reporterState) {
       isDynamicAtrEnabled: state.isDynamicAtrEnabled,
       flakyTestRetriesIncludesUnnamedProject: flakyTestRetriesConfiguration.includesUnnamedProject,
       flakyTestRetriesProjectNames: flakyTestRetriesConfiguration.projectNames,
+      flakyTestRetriesUseRetryMarker: flakyTestRetriesConfiguration.usesRetryMarker,
     }, task)
 
     return {

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

@@ -680,6 +680,7 @@ function resetMainProcessProvidedContext (ctx) {
     _ddIsEfdSuiteAdmissionEnabled: false,
     _ddIsFlakyTestRetriesEnabled: false,
     _ddFlakyTestRetriesCount: 0,
+    _ddFlakyTestRetriesUseRetryMarker: false,
     _ddIsDynamicAtrEnabled: false,
     _ddDynamicAtrBuckets: undefined,
     _ddFlakyTestRetriesIncludesUnnamedProject: false,
@@ -823,7 +824,7 @@ async function runMainProcessSetup (
     }
   }
 
-  const flakyTestRetriesConfiguration = configureFlakyTestRetries(ctx, testSpecifications)
+  const flakyTestRetriesConfiguration = configureFlakyTestRetries(ctx, testSpecifications, frameworkVersion)
   if (flakyTestRetriesConfiguration) {
     setProvidedContext(ctx, {
       _ddIsFlakyTestRetriesEnabled: isFlakyTestRetriesEnabled,
@@ -832,6 +833,7 @@ async function runMainProcessSetup (
       _ddDynamicAtrBuckets: dynamicAtrBuckets,
       _ddFlakyTestRetriesIncludesUnnamedProject: flakyTestRetriesConfiguration.includesUnnamedProject,
       _ddFlakyTestRetriesProjectNames: flakyTestRetriesConfiguration.projectNames,
+      _ddFlakyTestRetriesUseRetryMarker: flakyTestRetriesConfiguration.usesRetryMarker,
     }, 'Could not send library configuration to workers.')
   }
 
@@ -1038,7 +1040,7 @@ function shouldUseBrowserReporter (frameworkVersion, testSpecifications) {
     testSpecifications.some(isBrowserTestSpecification)
 }
 
-function configureFlakyTestRetries (ctx, testSpecifications) {
+function configureFlakyTestRetries (ctx, testSpecifications, frameworkVersion) {
   if (!isFlakyTestRetriesEnabled || (!isDynamicAtrEnabled && flakyTestRetriesCount <= 0)) return
 
   const maximumDynamicAtrRetries = dynamicAtrBuckets
@@ -1047,13 +1049,14 @@ function configureFlakyTestRetries (ctx, testSpecifications) {
   const retryCount = isDynamicAtrEnabled
     ? Math.max(1, maximumDynamicAtrRetries)
     : flakyTestRetriesCount
+  const usesRetryMarker = isDynamicAtrEnabled || satisfies(frameworkVersion, '>=4.1.0')
   let configured = false
   let includesUnnamedProject = false
   const projectNames = []
   for (const { config, projectName } of getVitestProjectConfigs(ctx, testSpecifications)) {
     if (!config.retry || config.retry.__ddTestOptAtr) {
       // The serializable marker survives task inheritance and setup refreshes, unlike numeric retry counts.
-      config.retry = isDynamicAtrEnabled ? { count: retryCount, __ddTestOptAtr: true } : retryCount
+      config.retry = usesRetryMarker ? { count: retryCount, __ddTestOptAtr: true } : retryCount
       configured = true
       if (projectName) {
         projectNames.push(projectName)
@@ -1068,6 +1071,7 @@ function configureFlakyTestRetries (ctx, testSpecifications) {
   return {
     includesUnnamedProject,
     projectNames,
+    usesRetryMarker,
   }
 }
 

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

@@ -182,6 +182,7 @@ function getProvidedContext () {
       _ddDynamicAtrBuckets: dynamicAtrBuckets,
       _ddFlakyTestRetriesIncludesUnnamedProject: flakyTestRetriesIncludesUnnamedProject,
       _ddFlakyTestRetriesProjectNames: flakyTestRetriesProjectNames,
+      _ddFlakyTestRetriesUseRetryMarker: flakyTestRetriesUseRetryMarker,
       _ddIsImpactedTestsEnabled: isImpactedTestsEnabled,
       _ddTestSessionId: testSessionId,
       _ddTestModuleId: testModuleId,
@@ -211,6 +212,7 @@ function getProvidedContext () {
       dynamicAtrBuckets,
       flakyTestRetriesIncludesUnnamedProject,
       flakyTestRetriesProjectNames,
+      flakyTestRetriesUseRetryMarker,
       isImpactedTestsEnabled,
       testSessionId,
       testModuleId,
@@ -254,8 +256,9 @@ function getProvidedContext () {
 }
 
 function isFlakyTestRetriesEnabledForTask (providedContext, task) {
-  if (!providedContext.isFlakyTestRetriesEnabled) return false
-  if (providedContext.isDynamicAtrEnabled && !task.retry?.__ddTestOptAtr) return false
+  if (!providedContext.isFlakyTestRetriesEnabled || task.meta?.__ddTestOptNativeRetry) return false
+  if ((providedContext.isDynamicAtrEnabled || providedContext.flakyTestRetriesUseRetryMarker) &&
+    !task.retry?.__ddTestOptAtr) return false
 
   const { flakyTestRetriesProjectNames } = providedContext
   if (!Array.isArray(flakyTestRetriesProjectNames)) return true

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

@@ -2,6 +2,14 @@
 
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
 const { isTrue } = require('../../dd-trace/src/util')
+const { channel } = require('./helpers/instrument')
+
+channel('tracing:orchestrion:@vitest/runner:createTestTask:end').subscribe(({ arguments: args, result: task }) => {
+  // Suite options have already been merged here, including overrides equal to ATR's count.
+  if (args[1]?.retry !== undefined && task?.meta) {
+    task.meta = { ...task.meta, __ddTestOptNativeRetry: true }
+  }
+})
 
 if (getEnvironmentVariable('DD_VITEST_WORKER') === '1') {
   const VITEST_NO_WORKER_INIT_ACTIVE_ENV = 'DD_TEST_OPT_VITEST_NO_WORKER_INIT_ACTIVE'

package/packages/datadog-plugin-cypress/src/cypress-plugin.js

@@ -1664,6 +1664,7 @@ class CypressPlugin {
           cypressTestStatus = CYPRESS_STATUS_TO_TEST_STATUS[cypressTest.attempts[attemptIndex].state]
           const isAtrRetry = attemptIndex > 0 &&
             this.isFlakyTestRetriesEnabled &&
+            (!finishedTest.hasNativeRetries || this.isDynamicAtrEnabled) &&
             !finishedTest.isAttemptToFix &&
             !finishedTest.isEfdRetry
           if (attemptIndex > 0) {
@@ -2154,6 +2155,7 @@ class CypressPlugin {
           isEfdRetry,
           isAttemptToFix,
           isModified,
+          hasNativeRetries,
           duration,
           isQuarantined: isQuarantinedFromSupport,
           isDisabled: isDisabledFromSupport,
@@ -2354,6 +2356,7 @@ class CypressPlugin {
           isEfdRetry,
           isEfdManagedTest,
           isAttemptToFix,
+          hasNativeRetries,
         }
         if (this.finishedTestsByFile[testSuite]) {
           this.finishedTestsByFile[testSuite].push(finishedTest)

package/packages/datadog-plugin-cypress/src/support.js

@@ -523,6 +523,8 @@ afterEach(function () {
     isEfdRetry: currentTest._ddIsEfdRetry,
     isAttemptToFix: currentTest._ddIsAttemptToFix,
     isModified: currentTest._ddIsModified,
+    hasNativeRetries: !!(currentTest._testConfig && currentTest._testConfig.unverifiedTestConfig &&
+      currentTest._testConfig.unverifiedTestConfig.retries !== undefined),
     duration: currentTest.duration,
     // Mark suppressed tests so the plugin can tag them with the correct test management reason.
     isQuarantined: isTestManagementTestThatFailed && suppressedTestFailure.isQuarantined,