dd-trace 6.16.0 → 6.18.0

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

@@ -18,6 +18,9 @@ const {
   getEfdRetryCountForDuration,
   hasEfdRetries,
 } = require('../../dd-trace/src/ci-visibility/efd-retry-policy')
+const {
+  getDynamicAtrRetryCount,
+} = require('../../dd-trace/src/ci-visibility/dynamic-atr-retries')
 const { FINAL_FLUSH_FALLBACK_DELAY, FINAL_FLUSH_TIMEOUT } =
   require('../../dd-trace/src/ci-visibility/final-flush')
 const {
@@ -85,6 +88,8 @@ const testFinishCh = channel('ci:jest:test:finish')
 const testErrCh = channel('ci:jest:test:err')
 const testFnCh = channel('ci:jest:test:fn')
 const testSuiteHookFnCh = channel('ci:jest:test-suite:hook:fn')
+const consoleLogSubmissionCh = channel('ci:log-submission:console')
+const logSubmissionFlushCh = channel('ci:log-submission:flush')
 
 const skippableSuitesCh = channel('ci:jest:test-suite:skippable')
 const libraryConfigurationCh = channel('ci:jest:library-configuration')
@@ -104,6 +109,10 @@ const CHILD_MESSAGE_CALL = 1
 const FLUSH_TIMEOUT = FINAL_FLUSH_TIMEOUT + FINAL_FLUSH_FALLBACK_DELAY + 5000
 const JEST_SESSION_STATE = Symbol.for('dd-trace:jest:session')
 const JEST_BAIL_REPORTER_PATH = require.resolve('./jest/bail-reporter')
+const JEST_CIRCUS_TEST_RUNNER_PATH = /(?:^|[\\/])jest-circus(?:[\\/]|$)/
+const UNSUPPORTED_JEST_TEST_RUNNER_WARNING =
+  'dd-trace Test Optimization supports jest-circus; another test runner was detected; ' +
+  'suite and test events may be incomplete.'
 const DD_JEST_HANDLE_TEST_EVENT_WRAPPED = Symbol('dd-trace:jest:handle-test-event-wrapped')
 const DD_JEST_HANDLE_TEST_EVENT_DATADOG = Symbol('dd-trace:jest:handle-test-event-datadog')
 const DD_JEST_CONCURRENT_TEST_ORIGINAL = Symbol('dd-trace:jest:concurrent-test-original')
@@ -171,6 +180,14 @@ const efdExpectedExecutions = new Map()
 const efdSlowAbortedTests = new Set()
 // Tests whose first execution determines the duration-based EFD retry count.
 const efdCandidates = new Set()
+// Per-declaration dynamic ATR retry count, retained across attempts of the same Jest test object.
+const dynamicAtrRetryCountByTest = new Map()
+// Jest only accepts a suite-wide retry ceiling. Terminal dynamic failures are
+// temporarily cleared to keep that ceiling from scheduling another retry, then
+// restored before Jest reports the suite result.
+const dynamicAtrFinalErrorsByTest = new Map()
+// Custom environments may prevent extensions after their base constructor runs.
+const dynamicAtrResultHandlerRegistrations = new WeakMap()
 // Tests that are genuinely new (not in known tests list).
 const newTests = new Set()
 const testSuiteJestObjects = new Map()
@@ -235,6 +252,7 @@ const MINIMUM_JEST_TEST_SCHEDULER_VERSION = DD_MAJOR >= 6 ? '>=28.0.0' : '>=27.0
 const MINIMUM_JEST_COVERAGE_BACKFILL_VERSION = '>=28.0.0'
 const atrSuppressedErrors = new Map()
 let hasWarnedDeprecatedJestVersion = false
+let hasWarnedUnsupportedJestTestRunner = false
 let isJestCoverageBackfillSupported = false
 let hasFinishedTestSession = false
 let jestEachBind
@@ -256,7 +274,6 @@ function getJestRepositoryRoot (readConfigsResult) {
  * Returns true if the data was sent (worker mode), false if in main process (runInBand).
  *
  * @param {string[]} testNames
- * @returns {boolean}
  */
 function sendQuarantineInfoToMainProcess (testNames) {
   const payload = [JEST_WORKER_QUARANTINE_PAYLOAD_CODE, JSON.stringify(testNames)]
@@ -310,6 +327,20 @@ function warnDeprecatedJestVersion (frameworkVersion) {
   )
 }
 
+/** @param {object[]} configs resolved Jest project configurations */
+function warnIfUnsupportedJestTestRunner (configs) {
+  if (hasWarnedUnsupportedJestTestRunner || !testSessionConfigurationCh.hasSubscribers) return
+
+  const usesUnsupportedTestRunner = getEnvironmentVariable('JEST_JASMINE') === '1' ||
+    configs.some(config => !JEST_CIRCUS_TEST_RUNNER_PATH.test(config.testRunner))
+
+  if (usesUnsupportedTestRunner) {
+    hasWarnedUnsupportedJestTestRunner = true
+    // eslint-disable-next-line no-console
+    console.warn(UNSUPPORTED_JEST_TEST_RUNNER_WARNING)
+  }
+}
+
 function getTestEnvironmentOptions (config) {
   if (config.projectConfig && config.projectConfig.testEnvironmentOptions) { // newer versions
     return config.projectConfig.testEnvironmentOptions
@@ -342,7 +373,6 @@ function getTestStats (testStatuses) {
  *   totalCount: number,
  *   efdFailureCount: number
  * } | undefined} ignoredFailures
- * @returns {string}
  */
 function formatIgnoredFailuresSummary (ignoredFailures) {
   if (!ignoredFailures?.efdFailureCount) return ''
@@ -515,7 +545,6 @@ function getOriginalConcurrentTest (concurrentTest) {
  *
  * @param {(...args: unknown[]) => unknown} wrappedConcurrentTest
  * @param {(...args: unknown[]) => unknown} originalConcurrentTest
- * @returns {void}
  */
 function setOriginalConcurrentTest (wrappedConcurrentTest, originalConcurrentTest) {
   Object.defineProperty(wrappedConcurrentTest, DD_JEST_CONCURRENT_TEST_ORIGINAL, {
@@ -524,6 +553,31 @@ function setOriginalConcurrentTest (wrappedConcurrentTest, originalConcurrentTes
   })
 }
 
+/**
+ * Stops further retries only after Jest's test-result handlers have observed the failure.
+ *
+ * @param {{ name: string, test?: { errors: unknown[] } }} event
+ */
+function suppressDynamicAtrErrors (event) {
+  if (event.name === 'test_done' && dynamicAtrFinalErrorsByTest.has(event.test)) {
+    event.test.errors = []
+  }
+}
+
+/**
+ * Restores terminal failures before custom environments inspect the completed describe block.
+ *
+ * @param {{ name: string }} event
+ */
+function restoreDynamicAtrErrors (event) {
+  if (event.name !== 'run_describe_finish' || dynamicAtrFinalErrorsByTest.size === 0) return
+
+  for (const [test, errors] of dynamicAtrFinalErrorsByTest) {
+    test.errors = errors
+  }
+  dynamicAtrFinalErrorsByTest.clear()
+}
+
 /**
  * Wraps a custom Jest environment handler so Datadog still observes events even
  * when the custom environment does not call `super.handleTestEvent`.
@@ -542,6 +596,7 @@ function getWrappedCustomHandleTestEvent (handleTestEvent, datadogHandleTestEven
   }
 
   const wrappedHandleTestEvent = function (event, state) {
+    restoreDynamicAtrErrors(event)
     const result = handleTestEvent.call(this, event, state)
     const runDatadogHandler = value => {
       if (isDatadogJestEventHandled(event)) return value
@@ -573,7 +628,6 @@ function getWrappedCustomHandleTestEvent (handleTestEvent, datadogHandleTestEven
  * @param {object} test
  * @param {boolean} hasFocusedTests
  * @param {RegExp|undefined} testNamePattern
- * @returns {boolean}
  */
 function isJestTestSkipped (test, hasFocusedTests, testNamePattern) {
   if (
@@ -642,11 +696,14 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       this.isEarlyFlakeDetectionEnabled = this.testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled
       this.isFlakyTestRetriesEnabled = this.testEnvironmentOptions._ddIsFlakyTestRetriesEnabled
       this.flakyTestRetriesCount = this.testEnvironmentOptions._ddFlakyTestRetriesCount
+      this.isDynamicAtrEnabled = this.testEnvironmentOptions._ddIsDynamicAtrEnabled
+      this.dynamicAtrBuckets = this.testEnvironmentOptions._ddDynamicAtrBuckets
       this.isDiEnabled = this.testEnvironmentOptions._ddIsDiEnabled
       this.isKnownTestsEnabled = this.testEnvironmentOptions._ddIsKnownTestsEnabled
       this.isTestManagementTestsEnabled = this.testEnvironmentOptions._ddIsTestManagementTestsEnabled
       this.isImpactedTestsEnabled = this.testEnvironmentOptions._ddIsImpactedTestsEnabled
       this.hasConcurrentTests = false
+      this.concurrentTestState = undefined
       this.concurrentTestContexts = new Map()
       this.concurrentTestStates = new WeakMap()
       this.concurrentTestSourceFns = new WeakMap()
@@ -678,7 +735,18 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (this.isFlakyTestRetriesEnabled) {
         const currentNumRetries = this.global[RETRY_TIMES]
         if (!currentNumRetries) {
-          this.global[RETRY_TIMES] = this.flakyTestRetriesCount
+          // 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) {
+            this.global[RETRY_TIMES] = Math.max(
+              1,
+              this.dynamicAtrBuckets
+                ? Math.max(...this.dynamicAtrBuckets)
+                : this.#earlyFlakeDetectionRetryPolicy.schedulingRetryCount
+            )
+          } else {
+            this.global[RETRY_TIMES] = this.flakyTestRetriesCount
+          }
         }
       }
 
@@ -733,7 +801,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * Rebuilds serial `test.each` so every generated row function keeps its parameters.
      *
      * @param {Function|undefined} test
-     * @returns {void}
      */
     bindTestEach (test) {
       if (typeof test?.each !== 'function') return
@@ -782,7 +849,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * in older Jest versions execute inside their test span context.
      *
      * @param {object} state
-     * @returns {void}
      */
     wrapConcurrentTest (state) {
       this.concurrentTestState = state
@@ -794,7 +860,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {Function|undefined} test
      * @param {object} state
-     * @returns {void}
      */
     wrapConcurrentTestGlobals (test, state) {
       if (!state) return
@@ -814,7 +879,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * @param {object} target
      * @param {string} methodName
      * @param {object} state
-     * @returns {void}
      */
     wrapConcurrentTestFunction (target, methodName, state) {
       let concurrentTest = target?.[methodName]
@@ -860,7 +924,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {Function} concurrentTest
      * @param {boolean} needsEachError
-     * @returns {void}
      */
     bindConcurrentEach (concurrentTest, needsEachError) {
       if (typeof concurrentTest?.each !== 'function') return
@@ -1000,7 +1063,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {Error|undefined} asyncError
      * @param {Function|undefined} testFn
-     * @returns {boolean}
      */
     isTestModified (asyncError, testFn) {
       if (!this.isImpactedTestsEnabled || !asyncError || typeof testFn !== 'function') return false
@@ -1038,7 +1100,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {string} testName
      * @param {object} ctx
-     * @returns {void}
      */
     removeConcurrentTestContext (testName, ctx) {
       const contexts = this.concurrentTestContexts.get(testName)
@@ -1058,7 +1119,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {string} name
      * @param {unknown[]} params
-     * @returns {void}
      */
     setNameToParams (name, params) {
       this.nameToParams[name] = [...params]
@@ -1069,7 +1129,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {string} name
      * @param {unknown[]|object} params
-     * @returns {void}
      */
     appendNameToParams (name, params) {
       if (this.nameToParams[name]) {
@@ -1082,7 +1141,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     /**
      * @param {object} concurrentTestState
      * @param {number|undefined} startedAt
-     * @returns {void}
      */
     completePre30ConcurrentTest (concurrentTestState, startedAt) {
       if (!concurrentTestState.trackEfdCompletion) return
@@ -1123,12 +1181,10 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     enqueueDetachedEfdRetry (retryGate, ctx, run) {
       /**
        * @param {() => void} resolve
-       * @returns {void}
        */
       const enqueue = (resolve) => {
         /**
          * @param {boolean} shouldRun
-         * @returns {void}
          */
         const onDecision = (shouldRun) => {
           if (!shouldRun) {
@@ -1147,7 +1203,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           const retry = { ctx, resolve, start }
           /**
            * @param {unknown} error
-           * @returns {void}
            */
           const onRejected = (error) => {
             retry.ctx.detachedEfdRetryError = error
@@ -1206,9 +1261,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       })
     }
 
-    /**
-     * @returns {void}
-     */
     drainDetachedEfdRetries () {
       const queue = this.#detachedEfdRetryQueue
       if (!queue) return
@@ -1225,7 +1277,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
     /**
      * @param {DetachedEfdRetry} retry
-     * @returns {void}
      */
     finishDetachedEfdRetry (retry) {
       this.#activeDetachedEfdRetries--
@@ -1238,7 +1289,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {() => unknown} run
      * @param {(error?: Error) => void} done
-     * @returns {void}
      */
     runCallbackEfdRetry (run, done) {
       let result
@@ -1324,7 +1374,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * `handleTestEvent` without calling `super.handleTestEvent`.
      *
      * @param {(event: object, state: object) => Promise<void>|void} datadogHandleTestEvent
-     * @returns {void}
      */
     wrapCustomHandleTestEvent (datadogHandleTestEvent) {
       const descriptor = Object.getOwnPropertyDescriptor(this, 'handleTestEvent')
@@ -1471,7 +1520,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * Registers retry tests while Jest still accepts additions to the test tree.
      *
      * @param {JestRetryOptions} options
-     * @returns {number}
      */
     retryTest ({
       concurrentTestState: registeredConcurrentTestState,
@@ -1557,7 +1605,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * `add_test` dispatch, where Jest would report it as a test file error.
      *
      * @param {JestRetryOptions} retryOptions
-     * @returns {boolean}
      */
     registerRetryTests (retryOptions) {
       // Jest turns later additions into "Cannot add a test after tests have started running".
@@ -1606,7 +1653,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * @param {string} testName
      * @param {object} executedTest The Jest test node that selected the retry count.
      * @param {number} [retryCount] Retries to keep. Every retry is dropped when omitted.
-     * @returns {number} Retries left to run.
      */
     discardEfdRetries (testName, executedTest, retryCount = 0) {
       const siblings = getTestEntries(executedTest.parent)
@@ -1655,7 +1701,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      * @param {object} describeBlock
      * @param {boolean} hasFocusedTests
      * @param {RegExp|undefined} testNamePattern
-     * @returns {number}
      */
     markPre30ConcurrentTests (describeBlock, hasFocusedTests, testNamePattern) {
       if (describeBlock.mode === 'skip') return 0
@@ -1687,7 +1732,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     /**
      * @param {object} describeBlock
      * @param {object} state
-     * @returns {void}
      */
     preparePre30ConcurrentTests (describeBlock, state) {
       const testNamePattern = state.testNamePattern
@@ -1705,7 +1749,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
     /**
      * @param {object[]} tests
-     * @returns {void}
      */
     orderConcurrentEfdRetries (tests) {
       if (!this.#efdRetryGatesByName) return
@@ -1727,7 +1770,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     /**
      * @param {string} testName
      * @param {number} durationMs
-     * @returns {void}
      */
     determineEfdRetries (testName, durationMs) {
       if (efdDeterminedRetries.has(testName)) return
@@ -1746,9 +1788,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
-    /**
-     * @returns {void}
-     */
     removeDiscardedEfdRetries () {
       if (!this.#discardedEfdRetryTests) return
 
@@ -1774,7 +1813,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {object} event
      * @param {object} state
-     * @returns {void}
      */
     handleAddTestEvent (event, state) {
       if (event.concurrent) {
@@ -1879,11 +1917,17 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         this.handleAddTestEvent(event, state)
       }
 
+      restoreDynamicAtrErrors(event)
+
       if (super.handleTestEvent) {
         await super.handleTestEvent(event, state)
       }
 
-      if (event.name === 'setup') {
+      if (event.name === 'run_start') {
+        const registerResultHandler = dynamicAtrResultHandlerRegistrations.get(this)
+        dynamicAtrResultHandlerRegistrations.delete(this)
+        registerResultHandler?.()
+      } else if (event.name === 'setup') {
         this.wrapConcurrentTest(state)
         this.bindTestEach(this.global.test)
       }
@@ -2190,7 +2234,24 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
         // ATR: set failedAllTests when all auto test retries were exhausted and every attempt failed
         if (this.isFlakyTestRetriesEnabled && !isAttemptToFix && !isEfdRetry) {
-          const maxRetries = Number(this.global[RETRY_TIMES]) || 0
+          // Dynamic ATR: after the first attempt, compute the duration-based retry budget.
+          if (
+            this.isDynamicAtrEnabled &&
+            event.test?.invocations === 1 &&
+            !dynamicAtrRetryCountByTest.has(event.test)
+          ) {
+            const dynamicCount = getDynamicAtrRetryCount(
+              event.test.duration ?? 0,
+              this.#earlyFlakeDetectionRetryPolicy,
+              this.dynamicAtrBuckets
+            )
+            // Jest captures this ceiling when it starts running the describe block.
+            const nativeRetryCount = Math.max(0, Number.parseInt(this.global[RETRY_TIMES], 10) || 0)
+            dynamicAtrRetryCountByTest.set(event.test, Math.min(dynamicCount, nativeRetryCount))
+          }
+          const maxRetries = this.isDynamicAtrEnabled && dynamicAtrRetryCountByTest.has(event.test)
+            ? dynamicAtrRetryCountByTest.get(event.test)
+            : (Number(this.global[RETRY_TIMES]) || 0)
           if (event.test?.invocations === maxRetries + 1 && status === 'fail') {
             failedAllTests = true
           }
@@ -2199,7 +2260,12 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         const promises = {}
         const numRetries = this.global[RETRY_TIMES]
         const numTestExecutions = event.test?.invocations
-        const willBeRetriedByAutoTestRetry = numRetries > 0 && numTestExecutions - 1 < numRetries
+        // Dynamic ATR: use the per-test duration-based count instead of the global flat limit.
+        const dynamicAtrCount = this.isDynamicAtrEnabled && dynamicAtrRetryCountByTest.has(event.test)
+          ? dynamicAtrRetryCountByTest.get(event.test)
+          : undefined
+        const effectiveMaxRetries = dynamicAtrCount === undefined ? numRetries : dynamicAtrCount
+        const willBeRetriedByAutoTestRetry = effectiveMaxRetries > 0 && numTestExecutions - 1 < effectiveMaxRetries
         const isFailedTestReplayAllowed = !this.hasConcurrentTests
         const willBeRetriedByFailedTestReplay = isFailedTestReplayAllowed && willBeRetriedByAutoTestRetry
         const mightHitBreakpoint = this.isDiEnabled && isFailedTestReplayAllowed && numTestExecutions >= 2
@@ -2216,6 +2282,11 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           }
         }
 
+        // Quarantine must consume terminal failures before we save errors for Jest's final result.
+        if (dynamicAtrCount !== undefined && failedAllTests && event.test.errors?.length) {
+          dynamicAtrFinalErrorsByTest.set(event.test, event.test.errors)
+        }
+
         const ctx = testContexts.get(event.test)
         if (!ctx) {
           log.warn('"ci:jest:test_done": no context found for test "%s"', testName)
@@ -2241,7 +2312,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           !!ctx.isModified,
           isEfdRetry,
           isAttemptToFix,
-          numTestExecutions)
+          numTestExecutions,
+          dynamicAtrCount)
 
         if (status === 'fail') {
           const shouldSetProbe = this.isDiEnabled && willBeRetriedByFailedTestReplay && numTestExecutions === 1
@@ -2310,6 +2382,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         efdDeterminedRetries.clear()
         efdExpectedExecutions.clear()
         efdSlowAbortedTests.clear()
+        dynamicAtrRetryCountByTest.clear()
         efdCandidates.clear()
         newTests.clear()
         retriedTestsToNumAttempts.clear()
@@ -2365,14 +2438,15 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       return { isEfdEnabled, isEfdActive, isFinalEfdTestExecution, finalStatus }
     }
 
-    getAtrResult ({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations }) {
+    getAtrResult ({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations, dynamicAtrRetryCount }) {
+      const maxRetries = dynamicAtrRetryCount ?? Number(this.global[RETRY_TIMES])
       const isAtrEnabled =
         this.isFlakyTestRetriesEnabled &&
         !isEfdRetry &&
         !isAttemptToFix &&
-        Number.isFinite(this.global[RETRY_TIMES])
+        Number.isFinite(maxRetries)
       const isLastAtrRetry =
-        status === 'pass' || numberOfTestInvocations >= (Number(this.global[RETRY_TIMES]) + 1)
+        status === 'pass' || numberOfTestInvocations >= (maxRetries + 1)
       const isFinalAtrTestExecution = isAtrEnabled && isLastAtrRetry
 
       // For ATR: The last execution's status is what the framework reports
@@ -2404,7 +2478,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       isModifiedTest,
       isEfdRetry,
       isAttemptToFix,
-      numberOfTestInvocations
+      numberOfTestInvocations,
+      dynamicAtrRetryCount
     ) {
       const numberOfExecutedRetries = retriedTestsToNumAttempts.get(testName) ?? 0
 
@@ -2413,7 +2488,13 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         isNewTest,
         isModifiedTest,
       })
-      const atrResult = this.getAtrResult({ status, isEfdRetry, isAttemptToFix, numberOfTestInvocations })
+      const atrResult = this.getAtrResult({
+        status,
+        isEfdRetry,
+        isAttemptToFix,
+        numberOfTestInvocations,
+        dynamicAtrRetryCount,
+      })
       const attemptToFixResult = this.getAttemptToFixResult({
         testName,
         isAttemptToFix,
@@ -2735,7 +2816,10 @@ async function waitForTestSessionFinish (payload) {
 
   publishWithCompletion(testSessionFinishCh, payload, onDone)
 
-  const waitingResult = await Promise.race([flushPromise, timeoutPromise])
+  const waitingResult = await Promise.race([
+    Promise.all([flushPromise, getChannelPromise(logSubmissionFlushCh)]),
+    timeoutPromise,
+  ])
 
   if (waitingResult === 'timeout') {
     log.error('Timeout waiting for the tracer to flush')
@@ -3088,6 +3172,7 @@ function getCliWrapper (isNewJestVersion) {
         results: {
           numFailedTestSuites,
           numFailedTests,
+          numPassedTests,
           numRuntimeErrorTestSuites = 0,
           numTotalTests,
           numTotalTestSuites,
@@ -3258,14 +3343,19 @@ function getCliWrapper (isNewJestVersion) {
 
       // Determine session status after EFD and quarantine checks have potentially modified success
       let status, error
+      const hasExecutedTests = numPassedTests > 0 || numFailedTests > 0 || numSuppressedQuarantinedTests > 0
+      const testSessionEmptyReason = result.results.success && !hasExecutedTests
+        ? (numTotalTests > 0 || isSuitesSkipped ? 'all_tests_skipped' : 'zero_tests')
+        : undefined
       if (result.results.success) {
-        status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
+        status = testSessionEmptyReason ? 'skip' : 'pass'
       } else {
         status = 'fail'
         error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
       }
 
       await waitForTestSessionFinish(getTestSessionFinishPayload(status, error, {
+        testSessionEmptyReason,
         ...getTestSessionCoveragePayload(result.results, result.globalConfig?.rootDir),
       }))
 
@@ -3322,7 +3412,6 @@ function cleanupTestSuiteState (testSuiteAbsolutePath) {
  * Rechecks custom handlers after Jest has finished constructing the environment.
  *
  * @param {object} environment
- * @returns {void}
  */
 function wrapEnvironmentCustomHandleTestEvent (environment) {
   const datadogHandleTestEvent = environment[DD_JEST_HANDLE_TEST_EVENT_DATADOG]
@@ -3426,7 +3515,7 @@ addHook({
   versions: [DD_MAJOR >= 6 ? '>=28.0.0' : '>=26.6.2'],
 }, coverageReporterWrapper)
 
-function jestAdapterWrapper (jestAdapter, jestVersion) {
+function jestAdapterWrapper (jestAdapter, jestVersion, isIitm, hookMeta) {
   const adapter = jestAdapter.default ?? jestAdapter
   const newAdapter = shimmer.wrapFunction(adapter, adapter => function (...args) {
     const environment = args[2]
@@ -3436,6 +3525,18 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
 
     wrapEnvironmentCustomHandleTestEvent(environment)
 
+    if (environment.isDynamicAtrEnabled && environment.isFlakyTestRetriesEnabled) {
+      // Register at run_start, after Circus installs its per-test reporter and snapshot handlers.
+      dynamicAtrResultHandlerRegistrations.set(environment, () => {
+        if (satisfies(jestVersion, '>=30.0.0')) {
+          environment.global[Symbol.for('EVENT_HANDLERS')].push(suppressDynamicAtrErrors)
+        } else {
+          const circusState = args[3].requireInternalModule(path.join(hookMeta.moduleBaseDir, 'build/state.js'))
+          circusState.addEventHandler(suppressDynamicAtrErrors)
+        }
+      })
+    }
+
     testSuiteStartCh.publish({
       testSuite: environment.testSuite,
       testEnvironmentOptions: environment.testEnvironmentOptions,
@@ -3547,6 +3648,7 @@ addHook({
 }, jestAdapterWrapper)
 
 function configureTestEnvironment (readConfigsResult) {
+  warnIfUnsupportedJestTestRunner(readConfigsResult.configs)
   repositoryRoot = getJestRepositoryRoot(readConfigsResult)
   isUserCodeCoverageEnabled = !!readConfigsResult.globalConfig.collectCoverage
   const isCodeCoverageEnabledBecauseOfUs = shouldCollectJestCoverageForTia() && !isUserCodeCoverageEnabled
@@ -3628,6 +3730,8 @@ const DD_TEST_ENVIRONMENT_OPTION_KEYS = [
   '_ddTestCodeCoverageEnabled',
   '_ddIsFlakyTestRetriesEnabled',
   '_ddFlakyTestRetriesCount',
+  '_ddIsDynamicAtrEnabled',
+  '_ddDynamicAtrBuckets',
   '_ddItrSkippingEnabledTags',
   '_ddIsDiEnabled',
   '_ddIsKnownTestsEnabled',
@@ -3744,6 +3848,19 @@ const JEST_LOGGING_LIBRARIES = new Set([
 const disabledJestInstrumentations = new Set(
   getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',')
 )
+
+addHook({
+  name: '@jest/console',
+  versions: [MINIMUM_JEST_VERSION],
+}, jestConsole => {
+  const isConsoleDisabled = disabledJestInstrumentations.has('console') ||
+    disabledJestInstrumentations.has('node:console')
+  if (!isConsoleDisabled && consoleLogSubmissionCh.hasSubscribers) {
+    require('./console').wrapJestConsole(jestConsole)
+  }
+  return jestConsole
+})
+
 const LIBRARIES_BYPASSING_JEST_REQUIRE_ENGINE = new Set([
   'selenium-webdriver',
   'selenium-webdriver/chrome',
@@ -3887,7 +4004,6 @@ function requireOutsideJestRequireEngine (runtime, moduleName) {
  * @param {object} runtime
  * @param {string} from
  * @param {string} moduleName
- * @returns {void}
  */
 function recordJestEsmLoggingModulePath (runtime, from, moduleName) {
   if (
@@ -3933,7 +4049,6 @@ function getJestEsmLoggingModuleName (runtime, from, modulePath) {
 
 /**
  * @param {object} runtime
- * @returns {void}
  */
 function wrapJestEsmLoader (runtime) {
   const esmLoader = runtime?.esmLoader
@@ -3994,7 +4109,6 @@ function getJestBypassModulePath (runtime, from, moduleName) {
  * @param {object} runtime
  * @param {string} from
  * @param {string} moduleName
- * @returns {string}
  */
 function resolveJestModulePath (runtime, from, moduleName) {
   if (path.isAbsolute(moduleName)) return moduleName

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

@@ -128,7 +128,6 @@ function wrapCallbackWithFinish (callback, finish, context) {
 
 /**
  * @param {{ pool?: { numFree?: () => number, numPendingAcquires?: () => number } }} client
- * @returns {boolean}
  */
 function knexHasIdleConnection (client) {
   const pool = client.pool