dd-trace 6.16.0 → 6.18.0

package/packages/datadog-instrumentations/src/claude-agent-sdk.js

@@ -353,7 +353,6 @@ function getToolResultContent (chunk, toolUseId) {
  * @param {SessionContext | null | undefined} sessionCtx
  * @param {GetLifecycle} getLifecycle
  * @param {ToolLifecycle} lifecycle
- * @returns {number} index in chunks where the next step should start iteration
  */
 function processTool (chunks, startIndex, toolUseId, sessionCtx, getLifecycle, lifecycle) {
   let chunkIndex = startIndex
@@ -412,7 +411,6 @@ function processTool (chunks, startIndex, toolUseId, sessionCtx, getLifecycle, l
  * @param {StepContext | null | undefined} stepCtx
  * @param {SessionContext | null | undefined} sessionCtx
  * @param {GetLifecycle} getLifecycle
- * @returns {number} index in chunks where the next step should start iteration
  */
 function processStep (
   chunks,

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

@@ -0,0 +1,97 @@
+'use strict'
+
+const shimmer = require('../../datadog-shimmer')
+const { channel } = require('./helpers/instrument')
+
+const configureCh = channel('ci:log-submission:console:configure')
+const logSubmissionCh = channel('ci:log-submission:console')
+const vitestSuiteStartCh = channel('ci:vitest:test-suite:start')
+const methods = ['error', 'warn']
+const methodSet = new Set(methods)
+const wrappedTargets = new WeakSet()
+
+let callDepth = 0
+let configuredGetLogHolder
+let isVitestConsoleSubscribed = false
+
+/**
+ * @param {string} method
+ * @param {unknown[]} args
+ * @param {(() => { dd: object } | undefined) | undefined} getLogHolder
+ */
+function publishLog (method, args, getLogHolder) {
+  if (!logSubmissionCh.hasSubscribers) return
+
+  try {
+    const logHolder = (getLogHolder || configuredGetLogHolder)?.()
+    if (logHolder) logSubmissionCh.publish({ args, logHolder, method })
+  } catch {}
+}
+
+/**
+ * @param {object} target
+ * @param {(() => { dd: object } | undefined) | undefined} [getLogHolder]
+ */
+function wrapConsole (target, getLogHolder) {
+  if (!target || wrappedTargets.has(target)) return
+
+  wrappedTargets.add(target)
+  for (const method of methods) {
+    if (typeof target[method] !== 'function') continue
+
+    // Global console methods are bound at runtime, so source rewriting cannot intercept them.
+    try {
+      shimmer.wrap(target, method, original => function () {
+        const shouldPublish = callDepth++ === 0
+        try {
+          const result = original.apply(this, arguments)
+          if (shouldPublish) publishLog(method, [...arguments], getLogHolder)
+          return result
+        } finally {
+          callDepth--
+        }
+      })
+    } catch {}
+  }
+}
+
+/**
+ * @param {{ BufferedConsole?: Function, CustomConsole?: Function }} jestConsole
+ * @param {(() => { dd: object } | undefined) | undefined} [getLogHolder]
+ */
+function wrapJestConsole (jestConsole, getLogHolder) {
+  if (!getLogHolder && !configuredGetLogHolder) return
+
+  const { BufferedConsole, CustomConsole } = jestConsole
+
+  if (BufferedConsole && !wrappedTargets.has(BufferedConsole)) {
+    wrappedTargets.add(BufferedConsole)
+    // Jest bundles and exports these adapter classes differently across versions, so wrap their runtime exports.
+    shimmer.wrap(BufferedConsole, 'write', original => function (buffer, method, message) {
+      const result = original.apply(this, arguments)
+      if (methodSet.has(method)) publishLog(method, [message], getLogHolder)
+      return result
+    })
+  }
+
+  if (CustomConsole && !wrappedTargets.has(CustomConsole)) {
+    wrappedTargets.add(CustomConsole)
+    shimmer.wrap(CustomConsole.prototype, '_logError', original => function (method, message) {
+      const result = original.apply(this, arguments)
+      if (methodSet.has(method)) publishLog(method, [message], getLogHolder)
+      return result
+    })
+  }
+}
+
+configureCh.subscribe(({ getLogHolder } = {}) => {
+  configuredGetLogHolder = getLogHolder
+  wrapConsole(globalThis.console)
+  if (!isVitestConsoleSubscribed) {
+    isVitestConsoleSubscribed = true
+    // Vitest replaces the global console after tracer startup and before the first suite starts.
+    vitestSuiteStartCh.subscribe(() => wrapConsole(globalThis.console))
+  }
+})
+
+module.exports = { wrapConsole, wrapJestConsole }

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

@@ -12,6 +12,7 @@ const {
   getEfdRetryCountForDuration,
   hasEfdRetries,
 } = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
+const { getDynamicAtrRetryCount } = require('../../dd-trace/src/ci-visibility/dynamic-atr-retries')
 const {
   getCoveredFilesFromCoverage,
   getExecutableFilesFromCoverage,
@@ -77,7 +78,6 @@ const CUCUMBER_RETRY_NAME_SUFFIX = / ?\(attempt \d+(?:, retried)?\) ?$/
  *
  * @param {string} testName
  * @param {boolean} isRetry
- * @returns {string}
  */
 function getCucumberTestName (testName, isRetry) {
   return isRetry ? testName.replace(CUCUMBER_RETRY_NAME_SUFFIX, '') : testName
@@ -129,6 +129,8 @@ let earlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
 let earlyFlakeDetectionFaultyThreshold = 0
 let isEarlyFlakeDetectionFaulty = false
 let isFlakyTestRetriesEnabled = false
+let isDynamicAtrEnabled = false
+let dynamicAtrBuckets
 let isKnownTestsEnabled = false
 let isTestManagementTestsEnabled = false
 let isImpactedTestsEnabled = false
@@ -142,9 +144,6 @@ let isSuitesSkipped = false
 let areAllSuitesSkipped = false
 let repositoryRoot
 
-/**
- * @returns {boolean}
- */
 function shouldRunEarlyFlakeDetection () {
   return isEarlyFlakeDetectionEnabled && hasEfdRetries(earlyFlakeDetectionRetryPolicy)
 }
@@ -243,7 +242,9 @@ function configureParallelWorkerWorldParameters (options) {
     isKnownTestsEnabled = false
     options.worldParameters._ddIsEarlyFlakeDetectionEnabled = false
     options.worldParameters._ddIsKnownTestsEnabled = false
-    options.worldParameters._ddEarlyFlakeDetectionRetryPolicy = EMPTY_EFD_RETRY_POLICY
+    options.worldParameters._ddEarlyFlakeDetectionRetryPolicy = isDynamicAtrEnabled
+      ? earlyFlakeDetectionRetryPolicy
+      : EMPTY_EFD_RETRY_POLICY
   }
 
   if (isImpactedTestsEnabled) {
@@ -253,6 +254,8 @@ function configureParallelWorkerWorldParameters (options) {
 
   options.worldParameters._ddIsFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
   options.worldParameters._ddNumTestRetries = numTestRetries
+  options.worldParameters._ddIsDynamicAtrEnabled = isDynamicAtrEnabled
+  options.worldParameters._ddDynamicAtrBuckets = dynamicAtrBuckets
 
   if (isTestManagementTestsEnabled) {
     options.worldParameters._ddIsTestManagementTestsEnabled = true
@@ -282,8 +285,7 @@ function readParallelWorkerWorldParameters (options) {
   if (isImpactedTestsEnabled) {
     modifiedFiles = worldParameters._ddModifiedFiles
   }
-  isFlakyTestRetriesEnabled = !!worldParameters._ddIsFlakyTestRetriesEnabled
-  numTestRetries = worldParameters._ddNumTestRetries ?? 0
+  readParallelWorkerAtrParameters(worldParameters)
   isTestManagementTestsEnabled = !!worldParameters._ddIsTestManagementTestsEnabled
   if (isTestManagementTestsEnabled) {
     testManagementTests = worldParameters._ddTestManagementTests
@@ -291,6 +293,25 @@ function readParallelWorkerWorldParameters (options) {
   }
 }
 
+/**
+ * @param {object} worldParameters
+ * @param {boolean} [worldParameters._ddIsFlakyTestRetriesEnabled]
+ * @param {number} [worldParameters._ddNumTestRetries]
+ * @param {boolean} [worldParameters._ddIsDynamicAtrEnabled]
+ * @param {number[]} [worldParameters._ddDynamicAtrBuckets]
+ * @param {import('../../dd-trace/src/ci-visibility/efd-retry-policy').EfdRetryPolicy}
+ *   [worldParameters._ddEarlyFlakeDetectionRetryPolicy]
+ */
+function readParallelWorkerAtrParameters (worldParameters) {
+  isFlakyTestRetriesEnabled = !!worldParameters._ddIsFlakyTestRetriesEnabled
+  numTestRetries = worldParameters._ddNumTestRetries ?? 0
+  isDynamicAtrEnabled = !!worldParameters._ddIsDynamicAtrEnabled
+  dynamicAtrBuckets = worldParameters._ddDynamicAtrBuckets
+  if (isDynamicAtrEnabled) {
+    earlyFlakeDetectionRetryPolicy = worldParameters._ddEarlyFlakeDetectionRetryPolicy ?? EMPTY_EFD_RETRY_POLICY
+  }
+}
+
 function handleDdWorkerMessage (message) {
   if (Array.isArray(message)) {
     const [messageCode, payload] = message
@@ -430,7 +451,8 @@ function getWrappedHandleWorkerThreadEvent (handleEventFromWorker) {
 
     const result = handleEventFromWorker.apply(this, arguments)
 
-    if (envelope.testCaseFinished && assembledTestCase?.pickle && eventDataCollector) {
+    if (envelope.testCaseFinished && !envelope.testCaseFinished.willBeRetried &&
+      assembledTestCase?.pickle && eventDataCollector) {
       const worstTestStepResult =
         eventDataCollector.getTestCaseAttempt(envelope.testCaseFinished.testCaseStartedId).worstTestStepResult
       handleParallelTestCaseFinished(assembledTestCase.pickle, worstTestStepResult)
@@ -713,6 +735,17 @@ function publishRetriedAttempt (runner, state) {
   const isFirstAttempt = currentAttempt === 0
   const isAtrRetry = !isFirstAttempt && isFlakyTestRetriesEnabled
 
+  if (isFirstAttempt && isDynamicAtrEnabled && isFlakyTestRetriesEnabled) {
+    state.dynamicAtrRetryCount = getDynamicAtrRetryCount(
+      performance.now() - state.executionStart,
+      earlyFlakeDetectionRetryPolicy,
+      dynamicAtrBuckets
+    )
+    // Native retries revisit maxAttempts before the next attempt in both runner
+    // generations. EFD and Attempt to Fix disable native retries, so never reach here.
+    runner.maxAttempts = state.dynamicAtrRetryCount + 1
+  }
+
   // ATR: record this attempt as failed so when run().finally runs (after retry) we have all statuses
   if (isFlakyTestRetriesEnabled) {
     const nameForKey = getCucumberTestName(runner.pickle.name, currentAttempt > 0)
@@ -768,6 +801,12 @@ function wrapRun (pl, isLatestVersion, version) {
       return run.apply(this, args)
     }
 
+    // Cucumber 8–10 workers construct runners directly, without the newer
+    // runTestCase wrapper that reads the coordinator's configuration.
+    if (getEnvironmentVariable('CUCUMBER_WORKER_ID') && satisfies(version, '>=8.0.0 <11.0.0')) {
+      readParallelWorkerAtrParameters(this.worldParameters)
+    }
+
     const testFileAbsolutePath = this.pickle.uri
     const testSuitePath = getTestSuitePath(testFileAbsolutePath, process.cwd())
 
@@ -808,6 +847,7 @@ function wrapRun (pl, isLatestVersion, version) {
       }
       let promise
       const executionStart = performance.now()
+      state.executionStart = executionStart
 
       testFnCh.runStores(ctx, () => {
         promise = run.apply(this, args)
@@ -922,7 +962,9 @@ function wrapRun (pl, isLatestVersion, version) {
           const atrStatuses = atrStatusesByScenarioKey.get(atrKey)
           const pickleStatuses = lastStatusByPickleId.get(this.pickle.id)
           const statusesToCheck = atrStatuses?.length >= (numTestRetries + 1) ? atrStatuses : pickleStatuses
-          if (statusesToCheck && statusesToCheck.length === numTestRetries + 1 &&
+          if (state.dynamicAtrRetryCount !== undefined) {
+            hasFailedAllRetries = status === 'fail' && state.numAttempt === state.dynamicAtrRetryCount
+          } else if (statusesToCheck && statusesToCheck.length === numTestRetries + 1 &&
             statusesToCheck.every(s => s === 'fail')) {
             hasFailedAllRetries = true
           }
@@ -959,7 +1001,8 @@ function wrapRun (pl, isLatestVersion, version) {
 
         // Notice that ATR is handled using cucumber native retries features.
         // Therefore, if we reach this point, we are certain that it's the last ATR execution
-        const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry && numTestRetries > 0
+        const isLastAtrRetry = isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry &&
+          numTestRetries > 0 && this.maxAttempts > 1
 
         const statuses = lastStatusByPickleId.get(this.pickle.id)
         const isLastEfdRetry = isEfdRetry && statuses?.length === efdRetryCount + 1
@@ -1100,8 +1143,17 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
     isSuitesSkippingEnabled = isItrEnabled && configurationResponse.libraryConfig?.isSuitesSkippingEnabled
     isCoverageReportUploadEnabled = configurationResponse.libraryConfig?.isCoverageReportUploadEnabled
     isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
+    isDynamicAtrEnabled = configurationResponse.libraryConfig?.isDynamicAtrEnabled === true &&
+      satisfies(frameworkVersion, '>=8.0.0')
+    dynamicAtrBuckets = configurationResponse.libraryConfig?.dynamicAtrBuckets
     const configRetryCount = configurationResponse.libraryConfig?.flakyTestRetriesCount
     numTestRetries = (typeof configRetryCount === 'number' && configRetryCount > 0) ? configRetryCount : 0
+    if (isDynamicAtrEnabled) {
+      // Reserve enough native attempts until the first failure determines its budget.
+      numTestRetries = Math.max(1, dynamicAtrBuckets
+        ? Math.max(...dynamicAtrBuckets)
+        : earlyFlakeDetectionRetryPolicy.schedulingRetryCount)
+    }
     isKnownTestsEnabled = configurationResponse.libraryConfig?.isKnownTestsEnabled
     isTestManagementTestsEnabled = configurationResponse.libraryConfig?.isTestManagementEnabled
     testManagementAttemptToFixRetries = configurationResponse.libraryConfig?.testManagementAttemptToFixRetries
@@ -1204,6 +1256,10 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       options.retry = numTestRetries
     }
 
+    if (isParallel && !isCoordinator) {
+      configureParallelWorkerWorldParameters(options)
+    }
+
     atrStatusesByScenarioKey.clear()
     attemptToFixTestsByTestFullname.clear()
     efdRetryCountByPickleId.clear()
@@ -1272,8 +1328,17 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       global.__coverage__ = fromCoverageMapToCoverage(originalCoverageMap)
     }
 
+    const testCaseAttempts = (this.eventDataCollector || eventDataCollector).getTestCaseAttempts()
+    const getStatus = satisfies(frameworkVersion, '>=7.3.0') ? getStatusFromResultLatest : getStatusFromResult
+    const hasExecutedTests = testCaseAttempts.some(({ worstTestStepResult }) =>
+      getStatus(worstTestStepResult).status !== 'skip'
+    )
+    const testSessionEmptyReason = success && !hasExecutedTests
+      ? (testCaseAttempts.length > 0 || skippedSuites.length > 0 ? 'all_tests_skipped' : 'zero_tests')
+      : undefined
     const flushPromise = getChannelPromise(sessionFinishCh, {
-      status: success ? 'pass' : 'fail',
+      status: testSessionEmptyReason ? 'skip' : (success ? 'pass' : 'fail'),
+      testSessionEmptyReason,
       isSuitesSkipped,
       testCodeCoverageLinesTotal,
       testSessionCoverageFiles,
@@ -1550,7 +1615,7 @@ function getWrappedParseWorkerMessage (parseWorkerMessageFunction, isNewVersion,
     const parseWorkerResponse = parseWorkerMessageFunction.apply(this, arguments)
 
     // after calling `parseWorkerMessageFunction`, the test status can already be read
-    if (parsed.testCaseFinished) {
+    if (parsed.testCaseFinished && !parsed.testCaseFinished.willBeRetried) {
       let worstTestStepResult
       if (isNewVersion && eventDataCollector) {
         pickle = this.inProgress[worker.id].pickle

package/packages/datadog-instrumentations/src/cypress-config.js

@@ -51,7 +51,6 @@ const noopTask = {
 /**
  * @param {FileSystemError} error filesystem error
  * @param {string} fallbackPath path used when the error does not include one
- * @returns {string} concise error description
  */
 function formatFileSystemError (error, fallbackPath) {
   const code = error?.code || error?.name || 'UNKNOWN'
@@ -64,7 +63,6 @@ function formatFileSystemError (error, fallbackPath) {
  * @param {FileCreationFailure[]} failures failed directory attempts
  * @param {string} consequence effect on Cypress instrumentation
  * @param {boolean} [customerVisible] whether to report the failure without requiring debug logging
- * @returns {void}
  */
 function warnFileCreationFailures (artifact, failures, consequence, customerVisible = false) {
   let details = ''
@@ -89,7 +87,6 @@ function warnFileCreationFailures (artifact, failures, consequence, customerVisi
  *
  * @param {string} message printf-style error message
  * @param {...unknown} args message arguments
- * @returns {void}
  */
 function logBrowserInstrumentationError (message, ...args) {
   // eslint-disable-next-line no-console
@@ -98,7 +95,6 @@ function logBrowserInstrumentationError (message, ...args) {
 
 /**
  * @param {string} filePath generated file to remove
- * @returns {void}
  */
 function removeGeneratedFile (filePath) {
   try {
@@ -118,7 +114,6 @@ function removeGeneratedFile (filePath) {
  * Removes project-local support files when Cypress exits without firing
  * after:run, as happens in open mode without experimental run events.
  *
- * @returns {void}
  */
 function removeGeneratedFilesAtExit () {
   exitCleanupRegistered = false
@@ -128,7 +123,6 @@ function removeGeneratedFilesAtExit () {
 
 /**
  * @param {string[]} filePaths generated support files
- * @returns {void}
  */
 function registerGeneratedFilesForExitCleanup (filePaths) {
   for (const filePath of filePaths) generatedFilesForExitCleanup.add(filePath)
@@ -140,7 +134,6 @@ function registerGeneratedFilesForExitCleanup (filePaths) {
 
 /**
  * @param {string[]} filePaths generated support files
- * @returns {void}
  */
 function cleanupGeneratedFiles (filePaths) {
   for (const filePath of filePaths) {
@@ -160,7 +153,6 @@ function cleanupGeneratedFiles (filePaths) {
  *
  * @param {string} filePath generated file path
  * @param {string} content generated file content
- * @returns {void}
  */
 function writeExclusiveFile (filePath, content) {
   let descriptor
@@ -189,7 +181,6 @@ function writeExclusiveFile (filePath, content) {
 
 /**
  * @param {unknown} handler Cypress task registration
- * @returns {boolean}
  */
 function isDatadogTaskRegistration (handler) {
   return !!handler && typeof handler === 'object' &&
@@ -201,7 +192,6 @@ function isDatadogTaskRegistration (handler) {
 
 /**
  * @param {unknown} handler Cypress after:run handler
- * @returns {boolean} whether this is the handler registered by the manual Datadog plugin
  */
 function isDatadogAfterRunHandler (handler) {
   return typeof handler === 'function' && handler[DD_CYPRESS_AFTER_RUN_HANDLER] === true
@@ -209,7 +199,6 @@ function isDatadogAfterRunHandler (handler) {
 
 /**
  * @param {unknown} handler Cypress after:spec handler
- * @returns {boolean} whether this is the handler registered by the manual Datadog plugin
  */
 function isDatadogAfterSpecHandler (handler) {
   return typeof handler === 'function' && handler[DD_CYPRESS_AFTER_SPEC_HANDLER] === true
@@ -217,7 +206,6 @@ function isDatadogAfterSpecHandler (handler) {
 
 /**
  * @param {object} manualPlugin manual plugin registration state
- * @returns {boolean} whether the manual plugin supports error-aware finalization
  */
 function supportsErrorAwareFinalization (manualPlugin) {
   return isDatadogAfterSpecHandler(manualPlugin.afterSpecHandler) &&
@@ -226,7 +214,6 @@ function supportsErrorAwareFinalization (manualPlugin) {
 
 /**
  * @param {unknown} handler Cypress task handler map
- * @returns {boolean} whether the current manual Datadog plugin owns the task map
  */
 function isCurrentDatadogTaskRegistration (handler) {
   return !!handler && handler[DD_CYPRESS_TASK_HANDLER] === manualPluginOwner
@@ -234,7 +221,6 @@ function isCurrentDatadogTaskRegistration (handler) {
 
 /**
  * @param {unknown} handler Cypress task handler map
- * @returns {boolean} whether the manual plugin registered only fallback tasks
  */
 function isDatadogNoopTaskRegistration (handler) {
   return !!handler && handler[DD_CYPRESS_NOOP_TASK_HANDLER] === true
@@ -242,7 +228,6 @@ function isDatadogNoopTaskRegistration (handler) {
 
 /**
  * @param {unknown} value
- * @returns {boolean}
  */
 function isPlainObject (value) {
   if (!value || typeof value !== 'object') return false
@@ -278,7 +263,6 @@ function mergeReturnedConfig (config, updatedConfig) {
 /**
  * @param {string} rootPath parent path
  * @param {string} candidatePath path that should be inside rootPath
- * @returns {boolean}
  */
 function isPathInside (rootPath, candidatePath) {
   const relativePath = path.relative(path.resolve(rootPath), path.resolve(candidatePath))
@@ -288,7 +272,6 @@ function isPathInside (rootPath, candidatePath) {
 /**
  * @param {string} fromDirectory directory containing the importing file
  * @param {string} importedFile file to import
- * @returns {string}
  */
 function getRelativeImportPath (fromDirectory, importedFile) {
   let relativePath = path.relative(fromDirectory, importedFile).split(path.sep).join('/')
@@ -420,7 +403,6 @@ function injectSupportFile (config) {
  * @param {Function} on Cypress event registration function
  * @param {Function[]} handlers collected after:screenshot handlers
  * @param {Function|undefined} datadogHandler manual Datadog screenshot handler
- * @returns {void}
  */
 function registerManualAfterScreenshotHandlers (on, handlers, datadogHandler) {
   const userHandlers = handlers.filter(handler => handler !== datadogHandler)
@@ -444,16 +426,16 @@ function registerManualAfterScreenshotHandlers (on, handlers, datadogHandler) {
 }
 
 /**
- * Registers one Cypress after:spec handler that runs every collected handler
+ * Registers one Cypress lifecycle handler that runs every collected handler
  * in registration order. Cypress 10+ otherwise keeps only the last handler.
  *
  * @param {Function} on Cypress event registration function
- * @param {Function[]} handlers collected after:spec handlers
- * @param {Function} [datadogHandler] manual Datadog after:spec handler
+ * @param {'before:run'|'after:spec'} event lifecycle event
+ * @param {Function[]} handlers collected lifecycle handlers
+ * @param {Function} [datadogHandler] Datadog lifecycle handler
  * @param {Function} [cleanup] removes generated support files after an error
- * @returns {void}
  */
-function registerAfterSpecHandlers (on, handlers, datadogHandler, cleanup) {
+function registerLifecycleHandlers (on, event, handlers, datadogHandler, cleanup) {
   const userHandlers = datadogHandler
     ? handlers.filter(handler => handler !== datadogHandler)
     : handlers
@@ -461,27 +443,31 @@ function registerAfterSpecHandlers (on, handlers, datadogHandler, cleanup) {
   if (userHandlers.length === 0) {
     if (datadogHandler) {
       if (cleanup) {
-        on('after:spec', (...args) => Promise.resolve().then(() => datadogHandler(...args)).catch((error) => {
+        on(event, (...args) => Promise.resolve().then(() => datadogHandler(...args)).catch((error) => {
           cleanup()
           throw error
         }))
       } else {
-        on('after:spec', datadogHandler)
+        on(event, datadogHandler)
       }
     }
     return
   }
 
-  on('after:spec', (spec, results) => {
+  on(event, (...args) => {
     const callHandler = datadogHandler
-      ? handler => runUserHandler(() => handler(spec, results))
-      : handler => handler(spec, results)
+      ? handler => runUserHandler(() => handler(...args))
+      : handler => handler(...args)
     const chain = userHandlers.reduce(
       (promise, handler) => promise.then(() => callHandler(handler)),
       Promise.resolve()
     )
     if (!datadogHandler) return chain
-    const finalization = finalizeAfterUserHandlers(chain, (...args) => datadogHandler(spec, results, ...args))
+    const finalization = finalizeAfterUserHandlers(chain, (...errors) => {
+      // A failed setup hook must abort the run before Datadog starts its session.
+      if (event === 'before:run' && errors.length > 0) return
+      return datadogHandler(...args, ...errors)
+    })
     if (!cleanup) return finalization
     return finalization.catch((error) => {
       cleanup()
@@ -495,7 +481,6 @@ function registerAfterSpecHandlers (on, handlers, datadogHandler, cleanup) {
  * sessions in interactive mode.
  *
  * @param {object} config Cypress resolved config object
- * @returns {void}
  */
 function enableInteractiveRunEvents (config) {
   if (config.isInteractive && config.experimentalInteractiveRunEvents !== true) {
@@ -534,6 +519,9 @@ function registerDdTraceHooks (
   if (generatedSupportFiles) registerGeneratedFilesForExitCleanup(generatedSupportFiles)
 
   const cleanupWrapper = () => {
+    // Open mode reuses this support file across runs, including failed setup attempts.
+    // The registered process-exit cleanup owns its lifetime instead.
+    if (config.isInteractive) return
     if (generatedSupportFiles) cleanupGeneratedFiles(generatedSupportFiles)
   }
 
@@ -557,8 +545,13 @@ function registerDdTraceHooks (
     })
   }
 
+  const registerBeforeRun = handler => {
+    registerLifecycleHandlers(on, 'before:run', userBeforeRunHandlers, handler, cleanupWrapper)
+  }
+
   const registerNoopHandlers = () => {
-    registerAfterSpecHandlers(on, userAfterSpecHandlers)
+    registerBeforeRun()
+    registerLifecycleHandlers(on, 'after:spec', userAfterSpecHandlers)
     for (const h of userAfterScreenshotHandlers) on('after:screenshot', h)
     registerAfterRunWithCleanup()
     on('task', noopTask)
@@ -575,8 +568,8 @@ function registerDdTraceHooks (
         manualPlugin.initialConfig.experimentalInteractiveRunEvents = config.experimentalInteractiveRunEvents
       }
     }
-    for (const handler of userBeforeRunHandlers) on('before:run', handler)
-    registerAfterSpecHandlers(on, userAfterSpecHandlers, manualPlugin.afterSpecHandler, cleanupWrapper)
+    registerBeforeRun(manualPlugin.beforeRunHandler)
+    registerLifecycleHandlers(on, 'after:spec', userAfterSpecHandlers, manualPlugin.afterSpecHandler, cleanupWrapper)
     registerManualAfterScreenshotHandlers(on, userAfterScreenshotHandlers, manualPlugin.afterScreenshotHandler)
     registerAfterRunWithCleanup(manualPlugin.afterRunHandler)
     on('task', manualPlugin.taskHandler)
@@ -592,8 +585,6 @@ function registerDdTraceHooks (
     )
   }
 
-  for (const handler of userBeforeRunHandlers) on('before:run', handler)
-
   if (!setupNodeEventsCh.hasSubscribers) {
     registerNoopHandlers()
     return config
@@ -608,6 +599,7 @@ function registerDdTraceHooks (
     userAfterSpecHandlers,
     userAfterRunHandlers,
     userAfterScreenshotHandlers,
+    registerBeforeRun,
     cleanupWrapper,
     registered: false,
     configPromise: undefined,
@@ -740,7 +732,6 @@ function wrapConfig (config) {
  * (`.js`, `.ts`) are loaded as ESM or CJS.
  *
  * @param {string} filePath absolute path to a file under the project
- * @returns {boolean}
  */
 function isUnderEsmPackage (filePath) {
   let dir = path.dirname(filePath)
@@ -759,7 +750,6 @@ function isUnderEsmPackage (filePath) {
 /**
  * @param {string} originalConfigFile absolute path to the original config file
  * @param {string} wrapperDirectory directory for the generated wrapper
- * @returns {string} path to the generated wrapper file
  */
 function createConfigWrapper (originalConfigFile, wrapperDirectory) {
   // Match the module mode Cypress would use for the user's original config
@@ -815,7 +805,6 @@ module.exports = cypressConfig.wrapConfig(originalConfig)
 
 /**
  * @param {string} projectRoot
- * @returns {boolean}
  */
 function isTypeScript6OrNewer (projectRoot) {
   try {

package/packages/datadog-instrumentations/src/helpers/bundler-register.js

@@ -13,6 +13,7 @@ const {
 } = require('./instrumentation-utils')
 const hooks = require('./hooks')
 const instrumentations = require('./instrumentations')
+const { isRewriteActivationEnabled } = require('./rewriter/targets')
 const disabledInstrumentations = getDisabledInstrumentations()
 
 // register.js has now set up ritm (require-in-the-middle). In bundled
@@ -94,6 +95,11 @@ dc.subscribe(CHANNEL, (message) => {
   const name = payload.package
   if (disabledInstrumentations.has(name)) return
 
+  if (payload.activate && isRewriteActivationEnabled(name)) {
+    loadChannel.publish({ name })
+    return
+  }
+
   const isPrefixedWithNode = name.startsWith('node:')
   const isNodeModule = isPrefixedWithNode || !hooks[name]
 

package/packages/datadog-instrumentations/src/helpers/channel.js

@@ -20,7 +20,6 @@ function getCompletion (onDone) {
  * @param {import('node:diagnostics_channel').Channel} channel
  * @param {Record<string, unknown>} payload
  * @param {(...args: T) => void} onDone
- * @returns {void}
  */
 function publishWithCompletion (channel, payload, onDone) {
   const complete = getCompletion(onDone)
@@ -33,7 +32,6 @@ function publishWithCompletion (channel, payload, onDone) {
  * @param {import('node:diagnostics_channel').Channel} channel
  * @param {Record<string, unknown> & { onDone?: (...args: T) => void }} payload
  * @param {(...args: T) => void} onDone
- * @returns {void}
  */
 function runStoresWithCompletion (channel, payload, onDone) {
   const complete = getCompletion(onDone)

package/packages/datadog-instrumentations/src/helpers/check-require-cache.js

@@ -69,6 +69,7 @@ const earlyLoadFrameworks = new Map([
  */
 module.exports.checkForRequiredModules = function () {
   const packages = require('./hooks')
+  const { isRewriteTargetName } = require('./rewriter/targets')
   const naughties = new Set()
   const frameworksSeen = new Set()
   let didWarn = false
@@ -98,7 +99,7 @@ module.exports.checkForRequiredModules = function () {
       continue
     }
 
-    if (naughties.has(pkg) || !(pkg in packages)) continue
+    if (naughties.has(pkg) || (!(pkg in packages) && !isRewriteTargetName(pkg))) continue
 
     loadOrderWarnings.push(
       () => `Warning: Package '${pkg}' was loaded before dd-trace! This may break instrumentation.`