dd-trace 5.106.0 → 5.108.0

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

@@ -86,7 +86,10 @@ const CHILD_MESSAGE_CALL = 1
 
 // Maximum time we'll wait for the tracer to flush
 const FLUSH_TIMEOUT = 10_000
+const JEST_SESSION_STATE = Symbol.for('dd-trace:jest:session')
+const JEST_BAIL_REPORTER_PATH = require.resolve('./jest/bail-reporter')
 const isJestWorker = !!getEnvironmentVariable('JEST_WORKER_ID')
+const jestSessionState = globalThis[JEST_SESSION_STATE] || (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')
@@ -166,6 +169,7 @@ const MINIMUM_JEST_COVERAGE_BACKFILL_VERSION = '>=28.0.0'
 const atrSuppressedErrors = new Map()
 let hasWarnedDeprecatedJestVersion = false
 let isJestCoverageBackfillSupported = false
+let hasFinishedTestSession = false
 
 // Track quarantined tests whose errors were suppressed, keyed by "suite › testName"
 const quarantinedFailingTests = new Set()
@@ -1218,6 +1222,25 @@ function getCoverageBackfillRequire (CoverageReporter) {
   return require
 }
 
+function addDatadogBailReporter (globalConfig) {
+  if (!globalConfig.bail) return globalConfig
+
+  const reporters = globalConfig.reporters || [['default', {}]]
+  for (const [reporter] of reporters) {
+    if (reporter === JEST_BAIL_REPORTER_PATH) {
+      return globalConfig
+    }
+  }
+
+  return {
+    ...globalConfig,
+    reporters: [
+      ...reporters,
+      [JEST_BAIL_REPORTER_PATH, {}],
+    ],
+  }
+}
+
 function getTestContexts (tests) {
   if (!tests?.length) return
 
@@ -1283,6 +1306,115 @@ function applySkippedCoverageToJestCoverageMap (coverageMap, rootDir) {
   )
 }
 
+function getSessionFinishError (results) {
+  const numFailedTestSuites = results?.numFailedTestSuites || 0
+  const numFailedTests = results?.numFailedTests || 0
+
+  return new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
+}
+
+function getTestSessionCoveragePayload (results, fallbackRootDir) {
+  const payload = {}
+  if (!shouldReportCodeCoverageLinesPct()) return payload
+
+  try {
+    const coverageMap = results?.coverageMap || lastCoverageMap
+    const coverageRootDir = lastCoverageMapRootDir ||
+      repositoryRoot ||
+      fallbackRootDir ||
+      process.cwd()
+    if (isSuitesSkipped) {
+      applySkippedCoverageToJestCoverageMap(coverageMap, coverageRootDir)
+    }
+    payload.testCodeCoverageLinesTotal = getTestCoverageLinesPercentage(
+      coverageMap,
+      undefined,
+      coverageRootDir
+    )
+    if (isTiaCoverageBackfillEnabled()) {
+      payload.testSessionCoverageFiles = getExecutableFilesFromCoverage(coverageMap).map(({ filename, bitmap }) => ({
+        filename: getTestSuitePath(filename, coverageRootDir),
+        bitmap,
+      }))
+    }
+  } catch {
+    // ignore errors
+  }
+
+  return payload
+}
+
+function getNumBailFailures (results) {
+  const numFailedTests = results?.numFailedTests || 0
+  const numFailedSuites = results?.numRuntimeErrorTestSuites === undefined
+    ? (numFailedTests === 0 ? results?.numFailedTestSuites || 0 : 0)
+    : results.numRuntimeErrorTestSuites
+
+  return numFailedTests + numFailedSuites
+}
+
+function shouldFinishBailTestSession (globalConfig, results) {
+  return !!globalConfig?.bail && getNumBailFailures(results) >= globalConfig.bail
+}
+
+async function waitForTestSessionFinish (payload) {
+  if (!testSessionFinishCh.hasSubscribers || hasFinishedTestSession) return
+
+  hasFinishedTestSession = true
+
+  let timeoutId
+
+  const flushPromise = new Promise((resolve) => {
+    payload.onDone = () => {
+      clearTimeout(timeoutId)
+      resolve()
+    }
+  })
+
+  const timeoutPromise = new Promise((resolve) => {
+    timeoutId = realSetTimeout(() => {
+      resolve('timeout')
+    }, FLUSH_TIMEOUT)
+    timeoutId.unref?.()
+  })
+
+  testSessionFinishCh.publish(payload)
+
+  const waitingResult = await Promise.race([flushPromise, timeoutPromise])
+
+  if (waitingResult === 'timeout') {
+    log.error('Timeout waiting for the tracer to flush')
+  }
+}
+
+function getTestSessionFinishPayload (status, error, extra = {}) {
+  return {
+    status,
+    isSuitesSkipped,
+    isSuitesSkippingEnabled,
+    isCodeCoverageEnabled,
+    isCoverageReportUploadEnabled,
+    numSkippedSuites,
+    hasUnskippableSuites,
+    hasForcedToRunSuites,
+    error,
+    isEarlyFlakeDetectionEnabled,
+    isEarlyFlakeDetectionFaulty,
+    isTestManagementTestsEnabled,
+    ...extra,
+  }
+}
+
+async function finishBailTestSession (results, fallbackRootDir) {
+  await waitForTestSessionFinish(getTestSessionFinishPayload(
+    'fail',
+    getSessionFinishError(results),
+    getTestSessionCoveragePayload(results, fallbackRootDir)
+  ))
+}
+
+jestSessionState.finishBailTestSession = finishBailTestSession
+
 function reporterDispatcherWrapper (reporterDispatcherPackage) {
   const ReporterDispatcher = reporterDispatcherPackage.default ?? reporterDispatcherPackage
   if (ReporterDispatcher?.prototype?.onRunComplete) {
@@ -1351,7 +1483,11 @@ function wrapCoverageReporter (CoverageReporter, hookMeta) {
     }
     lastCoverageMap = coverageMap
     lastCoverageMapRootDir = rootDir
-    return onRunComplete.call(this, coverageContexts, results)
+    const result = await onRunComplete.call(this, coverageContexts, results)
+    if (shouldFinishBailTestSession(this._globalConfig, results)) {
+      await finishBailTestSession(results, rootDir)
+    }
+    return result
   })
 }
 
@@ -1462,12 +1598,12 @@ function getCliWrapper (isNewJestVersion) {
       )
     }
     return shimmer.wrap(cli, 'runCLI', runCLI => async function () {
-      let onDone
       if (!libraryConfigurationCh.hasSubscribers) {
         return runCLI.apply(this, arguments)
       }
 
       resetSuiteSkippingRunState()
+      hasFinishedTestSession = false
 
       try {
         const { err, libraryConfig } = await getChannelPromise(libraryConfigurationCh, {
@@ -1576,7 +1712,6 @@ function getCliWrapper (isNewJestVersion) {
 
       const {
         results: {
-          coverageMap: resultCoverageMap,
           numFailedTestSuites,
           numFailedTests,
           numRuntimeErrorTestSuites = 0,
@@ -1591,36 +1726,6 @@ function getCliWrapper (isNewJestVersion) {
       const hasRunLevelFailure = runExecError != null || wasInterrupted === true
       const mustNotFlipSuccess = hasSuiteLevelFailures || hasRunLevelFailure
 
-      let testCodeCoverageLinesTotal
-      let testSessionCoverageFiles
-      const shouldReportTestSessionCoverage = isTiaCoverageBackfillEnabled()
-
-      if (shouldReportCodeCoverageLinesPct()) {
-        try {
-          const coverageMap = resultCoverageMap || lastCoverageMap
-          const coverageRootDir = lastCoverageMapRootDir ||
-            repositoryRoot ||
-            result.globalConfig?.rootDir ||
-            process.cwd()
-          if (isSuitesSkipped) {
-            applySkippedCoverageToJestCoverageMap(coverageMap, coverageRootDir)
-          }
-          testCodeCoverageLinesTotal = getTestCoverageLinesPercentage(
-            coverageMap,
-            undefined,
-            coverageRootDir
-          )
-          if (shouldReportTestSessionCoverage) {
-            testSessionCoverageFiles = getExecutableFilesFromCoverage(coverageMap).map(({ filename, bitmap }) => ({
-              filename: getTestSuitePath(filename, coverageRootDir),
-              bitmap,
-            }))
-          }
-        } catch {
-          // ignore errors
-        }
-      }
-
       /**
        * If Early Flake Detection (EFD) is enabled the logic is as follows:
        * - If all attempts for a test are failing, the test has failed and we will let the test process fail.
@@ -1774,46 +1879,9 @@ function getCliWrapper (isNewJestVersion) {
         error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
       }
 
-      let timeoutId
-
-      // Pass the resolve callback to defer it to DC listener
-      const flushPromise = new Promise((resolve) => {
-        onDone = () => {
-          clearTimeout(timeoutId)
-          resolve()
-        }
-      })
-
-      const timeoutPromise = new Promise((resolve) => {
-        timeoutId = realSetTimeout(() => {
-          resolve('timeout')
-        }, FLUSH_TIMEOUT)
-        timeoutId.unref?.()
-      })
-
-      testSessionFinishCh.publish({
-        status,
-        isSuitesSkipped,
-        isSuitesSkippingEnabled,
-        isCodeCoverageEnabled,
-        isCoverageReportUploadEnabled,
-        testCodeCoverageLinesTotal,
-        testSessionCoverageFiles,
-        numSkippedSuites,
-        hasUnskippableSuites,
-        hasForcedToRunSuites,
-        error,
-        isEarlyFlakeDetectionEnabled,
-        isEarlyFlakeDetectionFaulty,
-        isTestManagementTestsEnabled,
-        onDone,
-      })
-
-      const waitingResult = await Promise.race([flushPromise, timeoutPromise])
-
-      if (waitingResult === 'timeout') {
-        log.error('Timeout waiting for the tracer to flush')
-      }
+      await waitForTestSessionFinish(getTestSessionFinishPayload(status, error, {
+        ...getTestSessionCoveragePayload(result.results, result.globalConfig?.rootDir),
+      }))
 
       if (codeCoverageReportCh.hasSubscribers) {
         const rootDir = result.globalConfig?.rootDir || process.cwd()
@@ -2100,6 +2168,8 @@ function configureTestEnvironment (readConfigsResult) {
     log.warn("Jest's '--forceExit' flag has been passed. This may cause loss of data.")
   }
 
+  readConfigsResult.globalConfig = addDatadogBailReporter(readConfigsResult.globalConfig)
+
   if (isSuitesSkippingEnabled) {
     // If suite skipping is enabled, we pass `passWithNoTests` in case every test gets skipped.
     const globalConfig = {

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

@@ -24,6 +24,7 @@ const {
   collectTestOptimizationSummariesFromTraces,
   logTestOptimizationSummary,
   getTestOptimizationRequestResults,
+  isModifiedTest,
 } = require('../../../dd-trace/src/plugins/util/test')
 
 const {
@@ -39,6 +40,7 @@ const {
   getOnPendingHandler,
   testFileToSuiteCtx,
   newTests,
+  efdTests,
   testsQuarantined,
   getTestFullName,
   getRunTestsWrapper,
@@ -191,6 +193,23 @@ function getCoverageRootDir () {
   return config.repositoryRoot || process.cwd()
 }
 
+/**
+ * Recomputes whether a parallel worker result belongs to a modified suite.
+ *
+ * In parallel mode, `_ddIsModified` is set on Mocha Test objects inside the worker.
+ * The main process receives `Test.prototype.serialize()` output for test events,
+ * and that fixed serialization drops custom properties. We still need modified-test
+ * bookkeeping in the main process for EFD failure suppression, so infer it again
+ * from the suite path.
+ *
+ * @param {string} testSuiteAbsolutePath
+ * @returns {boolean}
+ */
+function isModifiedTestSuite (testSuiteAbsolutePath) {
+  const testPath = getTestSuitePath(testSuiteAbsolutePath, getCoverageRootDir())
+  return isModifiedTest(testPath, null, null, config.modifiedFiles, 'mocha')
+}
+
 function shouldReportCodeCoverageLinesPct (hasBackfilledCoverage) {
   return !isSuitesSkipped || hasBackfilledCoverage
 }
@@ -252,12 +271,13 @@ function getOnEndHandler (isParallel) {
        * The rationale behind is the following: you may still be able to block your CI pipeline by gating
        * on flakiness (the test will be considered flaky), but you may choose to unblock the pipeline too.
        */
-      for (const tests of Object.values(newTests)) {
-        const failingNewTests = tests.filter(test => isTestFailed(test))
-        const areAllNewTestsFailing = failingNewTests.length === tests.length
-        if (failingNewTests.length && !areAllNewTestsFailing) {
-          this.stats.failures -= failingNewTests.length
-          this.failures -= failingNewTests.length
+      for (const tests of Object.values(efdTests)) {
+        const failingEfdTests = tests.filter(test => isTestFailed(test))
+        const areAllEfdTestsFailing = failingEfdTests.length === tests.length
+        const nonQuarantinedFailingEfdTests = failingEfdTests.filter(test => !testsQuarantined.has(test))
+        if (nonQuarantinedFailingEfdTests.length && !areAllEfdTestsFailing) {
+          this.stats.failures -= nonQuarantinedFailingEfdTests.length
+          this.failures -= nonQuarantinedFailingEfdTests.length
         }
       }
     }
@@ -1139,10 +1159,15 @@ addHook({
       .events
       .filter(event => event.eventName === 'test end')
       .map(event => event.data)
+    const isModified = config.isImpactedTestsEnabled && isModifiedTestSuite(testSuiteAbsolutePath)
 
     for (const test of tests) {
+      const testProperties = getTestProperties(test, config.testManagementTests)
+      const isAttemptToFix = config.isTestManagementTestsEnabled && testProperties.isAttemptToFix
+
       // `newTests` is filled in the worker process, so we need to use the test results to fill it here too.
-      if (config.isKnownTestsEnabled && isNewTest(test, config.knownTests)) {
+      const isNew = config.isKnownTestsEnabled && isNewTest(test, config.knownTests)
+      if (isNew) {
         const testFullName = getTestFullName(test)
         const tests = newTests[testFullName]
 
@@ -1152,8 +1177,18 @@ addHook({
           newTests[testFullName] = [test]
         }
       }
+      // `efdTests` is filled in the worker process, so we need to use the test results to fill it here too.
+      if (!isAttemptToFix && (isNew || isModified)) {
+        const testFullName = getTestFullName(test)
+        const tests = efdTests[testFullName]
+
+        if (tests) {
+          tests.push(test)
+        } else {
+          efdTests[testFullName] = [test]
+        }
+      }
       // `testsQuarantined` is filled in the worker process, so we need to use the test results to fill it here too.
-      const testProperties = getTestProperties(test, config.testManagementTests)
       if (config.isTestManagementTestsEnabled && testProperties.isQuarantined && !testProperties.isAttemptToFix) {
         testsQuarantined.add(test)
       }

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

@@ -35,6 +35,7 @@ const testToStartLine = new WeakMap()
 const testFileToSuiteCtx = new Map()
 const wrappedFunctions = new WeakSet()
 const newTests = {}
+const efdTests = {}
 const newTestsWithDynamicNames = new Set()
 const testsAttemptToFix = new Set()
 const testsQuarantined = new Set()
@@ -129,14 +130,61 @@ function wrapOriginalEfdTest (test, slowTestRetries) {
   })
 }
 
+/**
+ * Disables Mocha's native retry mechanism for Datadog-managed clone retries.
+ * @param {{ retries?: (count: number) => void }} test
+ * @returns {void}
+ */
+function disableMochaRetries (test) {
+  if (typeof test.retries === 'function') {
+    test.retries(0)
+  }
+}
+
+/**
+ * Checks whether a runnable belongs to a Datadog-managed clone retry feature.
+ * @param {{
+ *   _ddIsAttemptToFix?: boolean,
+ *   _ddIsEfdRetry?: boolean,
+ *   _ddIsModified?: boolean,
+ *   _ddIsNew?: boolean
+ * }} test
+ * @param {{ isEarlyFlakeDetectionEnabled?: boolean }} config
+ * @returns {boolean}
+ */
+function isDatadogManagedRetryTest (test, config) {
+  return test._ddIsAttemptToFix ||
+    test._ddIsEfdRetry ||
+    (config.isEarlyFlakeDetectionEnabled && (test._ddIsNew || test._ddIsModified))
+}
+
+/**
+ * Checks whether a runnable belongs to an Early Flake Detection execution.
+ * @param {{
+ *   _ddIsAttemptToFix?: boolean,
+ *   _ddIsEfdRetry?: boolean,
+ *   _ddIsModified?: boolean,
+ *   _ddIsNew?: boolean
+ * }} test
+ * @param {{ isEarlyFlakeDetectionEnabled?: boolean }} config
+ * @returns {boolean}
+ */
+function isEarlyFlakeDetectionTest (test, config) {
+  return !test._ddIsAttemptToFix &&
+    config.isEarlyFlakeDetectionEnabled &&
+    (test._ddIsEfdRetry || test._ddIsNew || test._ddIsModified)
+}
+
 function retryTest (test, numRetries, tags, slowTestRetries) {
   const suite = test.parent
   const isEfdRetry = tags.includes('_ddIsEfdRetry')
+  disableMochaRetries(test)
   if (isEfdRetry) {
     wrapOriginalEfdTest(test, slowTestRetries)
   }
   for (let retryIndex = 0; retryIndex < numRetries; retryIndex++) {
     const clonedTest = test.clone()
+    disableMochaRetries(clonedTest)
     suite.addTest(clonedTest)
     if (isEfdRetry) {
       clonedTest._ddEfdRetryIndex = retryIndex + 1
@@ -205,6 +253,21 @@ function getTestFullName (test) {
   return `mocha.${getTestSuitePath(test.file, process.cwd())}.${test.fullTitle()}`
 }
 
+/**
+ * Records every attempt for a test grouped by its full test name.
+ * @param {Record<string, Array<{ file: string, fullTitle: () => string }>>} testsByFullName
+ * @param {{ file: string, fullTitle: () => string }} test
+ * @returns {void}
+ */
+function recordTestAttempt (testsByFullName, test) {
+  const testFullName = getTestFullName(test)
+  if (testsByFullName[testFullName]) {
+    testsByFullName[testFullName].push(test)
+  } else {
+    testsByFullName[testFullName] = [test]
+  }
+}
+
 function getTestStatus (test) {
   if (test.isPending()) {
     return 'skip'
@@ -230,14 +293,38 @@ function getTestContext (test) {
   return testToContext.get(key)
 }
 
+/**
+ * Copies Test Management metadata from Mocha's original runnable to its native retry clone.
+ * @param {{
+ *   _retriedTest?: {
+ *     _ddIsDisabled?: boolean,
+ *     _ddIsQuarantined?: boolean
+ *   },
+ *   _ddIsDisabled?: boolean,
+ *   _ddIsQuarantined?: boolean
+ * }} test
+ */
+function inheritDatadogPropertiesFromRetriedTest (test) {
+  const retriedTest = test._retriedTest
+  if (!retriedTest) return
+
+  if (retriedTest._ddIsDisabled) {
+    test._ddIsDisabled = true
+  }
+  if (retriedTest._ddIsQuarantined) {
+    test._ddIsQuarantined = true
+  }
+
+  if (test._ddIsQuarantined && !test._ddIsAttemptToFix) {
+    testsQuarantined.add(test)
+  }
+}
+
 function runnableWrapper (RunnablePackage, libraryConfig) {
   shimmer.wrap(RunnablePackage.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
       return run.apply(this, args)
     }
-    if (libraryConfig?.isFlakyTestRetriesEnabled) {
-      this.retries(libraryConfig?.flakyTestRetriesCount)
-    }
     // The reason why the wrapping logic is here is because we need to cover
     // `afterEach` and `beforeEach` hooks as well.
     // It can't be done in `getOnTestHandler` because it's only called for tests.
@@ -245,6 +332,7 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
     const isAfterEach = this.parent._afterEach.includes(this)
 
     const isTestHook = isBeforeEach || isAfterEach
+    const test = isTestHook ? this.ctx.currentTest : this
 
     // we restore the original user defined function
     if (wrappedFunctions.has(this.fn)) {
@@ -253,8 +341,20 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
       wrappedFunctions.delete(this.fn)
     }
 
+    if (isDatadogManagedRetryTest(test, libraryConfig)) {
+      disableMochaRetries(this)
+      if (typeof args[0] === 'function') {
+        const onRunnableFinished = args[0]
+        args[0] = function () {
+          disableMochaRetries(test)
+          return onRunnableFinished.apply(this, arguments)
+        }
+      }
+    } else if (libraryConfig?.isFlakyTestRetriesEnabled) {
+      this.retries(libraryConfig.flakyTestRetriesCount)
+    }
+
     if (isTestHook || this.type === 'test') {
-      const test = isTestHook ? this.ctx.currentTest : this
       const ctx = getTestContext(test)
 
       if (ctx) {
@@ -288,6 +388,8 @@ function getOnTestHandler (isMain) {
       wrappedFunctions.delete(test.fn)
     }
 
+    inheritDatadogPropertiesFromRetriedTest(test)
+
     const {
       file: testSuiteAbsolutePath,
       title,
@@ -340,12 +442,10 @@ function getOnTestHandler (isMain) {
     }
     // We want to store the result of the new tests
     if (isNew) {
-      const testFullName = getTestFullName(test)
-      if (newTests[testFullName]) {
-        newTests[testFullName].push(test)
-      } else {
-        newTests[testFullName] = [test]
-      }
+      recordTestAttempt(newTests, test)
+    }
+    if (!isAttemptToFix && (isNew || isModified)) {
+      recordTestAttempt(efdTests, test)
     }
 
     if (!isAttemptToFix && isDisabled) {
@@ -371,13 +471,16 @@ function getFinalStatus ({
   hasPassedAnyEfdAttempt,
   isQuarantined,
   isDisabled,
+  isFinalAttempt,
 }) {
   // Note that intermediate executions DO NOT report a final status tag
 
-  // Intermediate EFD and ATF executions must not carry a final status, regardless of quarantine/disabled state
+  // Intermediate executions must not carry a final status, regardless of quarantine/disabled state
+  const isExternalIntermediateExecution = !isEfdRetry && !isAttemptToFix && !isFinalAttempt
   const isIntermediateExecution =
     (isEfdRetry && !isLastEfdRetry) ||
-    (isAttemptToFix && !isLastAttemptToFix)
+    (isAttemptToFix && !isLastAttemptToFix) ||
+    isExternalIntermediateExecution
   if (isIntermediateExecution) {
     return
   }
@@ -411,8 +514,7 @@ function getTestFinishInfo (test, status, config, error) {
 
   const testName = getTestFullName(test)
   if (
-    config.isEarlyFlakeDetectionEnabled &&
-    (test._ddIsNew || test._ddIsModified) &&
+    isEarlyFlakeDetectionTest(test, config) &&
     !test._ddIsEfdRetry &&
     !efdRetryCountByTestFullName.has(testName)
   ) {
@@ -434,8 +536,7 @@ function getTestFinishInfo (test, status, config, error) {
 
   // Needed for the getFinalStatus call. This is because EFD does NOT tag as
   // EFD retry the first run of the test. It only tags as retries the clones
-  const isEfdRetry =
-    test._ddIsEfdRetry || ((test._ddIsNew || test._ddIsModified) && config.isEarlyFlakeDetectionEnabled)
+  const isEfdRetry = isEarlyFlakeDetectionTest(test, config)
 
   if (test._ddIsAttemptToFix && isLastAttempt) {
     if (testStatuses.includes('fail')) {
@@ -463,6 +564,7 @@ function getTestFinishInfo (test, status, config, error) {
   const isAtrRetry = config.isFlakyTestRetriesEnabled &&
     !test._ddIsAttemptToFix &&
     !test._ddIsEfdRetry
+  const isFinalAttempt = status !== 'fail' || test._currentRetry >= test._retries
 
   const { isFlakyTestRetriesEnabled } = config
   const { _ddIsAttemptToFix, _ddIsQuarantined, _ddIsDisabled } = test
@@ -480,6 +582,7 @@ function getTestFinishInfo (test, status, config, error) {
     hasPassedAnyEfdAttempt: testStatuses.includes('pass'),
     isQuarantined: _ddIsQuarantined,
     isDisabled: _ddIsDisabled,
+    isFinalAttempt,
   })
 
   if (_ddIsAttemptToFix) {
@@ -661,7 +764,14 @@ function getOnTestRetryHandler (config) {
         config.isFlakyTestRetriesEnabled &&
         !test._ddIsAttemptToFix &&
         !test._ddIsEfdRetry
-      testRetryCh.publish({ isFirstAttempt, err, willBeRetried, test, isAtrRetry, ...ctx.currentStore })
+      testRetryCh.publish({
+        isFirstAttempt,
+        err,
+        willBeRetried,
+        test,
+        isAtrRetry,
+        ...ctx.currentStore,
+      })
     }
     const key = getTestToContextKey(test)
     testToContext.delete(key)
@@ -796,6 +906,7 @@ module.exports = {
   testFileToSuiteCtx,
   getRunTestsWrapper,
   newTests,
+  efdTests,
   newTestsWithDynamicNames,
   testsQuarantined,
   testsAttemptToFix,

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

@@ -6,7 +6,8 @@ const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const multerReadCh = channel('datadog:multer:read:finish')
 
 function publishRequestBodyAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function (...args) {
+  // Mirror next's name/arity so wrapCallback skips its per-call identity rewrite.
+  return shimmer.wrapCallback(next, original => function next (_error) {
     if (multerReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const body = req.body
@@ -16,7 +17,7 @@ function publishRequestBodyAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, args)
+    return original.apply(this, arguments)
   })
 }