dd-trace 6.16.0 → 6.17.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')
@@ -171,6 +176,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()
@@ -256,7 +269,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)]
@@ -342,7 +354,6 @@ function getTestStats (testStatuses) {
  *   totalCount: number,
  *   efdFailureCount: number
  * } | undefined} ignoredFailures
- * @returns {string}
  */
 function formatIgnoredFailuresSummary (ignoredFailures) {
   if (!ignoredFailures?.efdFailureCount) return ''
@@ -515,7 +526,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 +534,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 +577,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 +609,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 +677,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 +716,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 +782,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 +830,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 +841,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {Function|undefined} test
      * @param {object} state
-     * @returns {void}
      */
     wrapConcurrentTestGlobals (test, state) {
       if (!state) return
@@ -814,7 +860,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 +905,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {Function} concurrentTest
      * @param {boolean} needsEachError
-     * @returns {void}
      */
     bindConcurrentEach (concurrentTest, needsEachError) {
       if (typeof concurrentTest?.each !== 'function') return
@@ -1000,7 +1044,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 +1081,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {string} testName
      * @param {object} ctx
-     * @returns {void}
      */
     removeConcurrentTestContext (testName, ctx) {
       const contexts = this.concurrentTestContexts.get(testName)
@@ -1058,7 +1100,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {string} name
      * @param {unknown[]} params
-     * @returns {void}
      */
     setNameToParams (name, params) {
       this.nameToParams[name] = [...params]
@@ -1069,7 +1110,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {string} name
      * @param {unknown[]|object} params
-     * @returns {void}
      */
     appendNameToParams (name, params) {
       if (this.nameToParams[name]) {
@@ -1082,7 +1122,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     /**
      * @param {object} concurrentTestState
      * @param {number|undefined} startedAt
-     * @returns {void}
      */
     completePre30ConcurrentTest (concurrentTestState, startedAt) {
       if (!concurrentTestState.trackEfdCompletion) return
@@ -1123,12 +1162,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 +1184,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           const retry = { ctx, resolve, start }
           /**
            * @param {unknown} error
-           * @returns {void}
            */
           const onRejected = (error) => {
             retry.ctx.detachedEfdRetryError = error
@@ -1206,9 +1242,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       })
     }
 
-    /**
-     * @returns {void}
-     */
     drainDetachedEfdRetries () {
       const queue = this.#detachedEfdRetryQueue
       if (!queue) return
@@ -1225,7 +1258,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
     /**
      * @param {DetachedEfdRetry} retry
-     * @returns {void}
      */
     finishDetachedEfdRetry (retry) {
       this.#activeDetachedEfdRetries--
@@ -1238,7 +1270,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {() => unknown} run
      * @param {(error?: Error) => void} done
-     * @returns {void}
      */
     runCallbackEfdRetry (run, done) {
       let result
@@ -1324,7 +1355,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 +1501,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 +1586,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 +1634,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 +1682,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 +1713,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     /**
      * @param {object} describeBlock
      * @param {object} state
-     * @returns {void}
      */
     preparePre30ConcurrentTests (describeBlock, state) {
       const testNamePattern = state.testNamePattern
@@ -1705,7 +1730,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
     /**
      * @param {object[]} tests
-     * @returns {void}
      */
     orderConcurrentEfdRetries (tests) {
       if (!this.#efdRetryGatesByName) return
@@ -1727,7 +1751,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
     /**
      * @param {string} testName
      * @param {number} durationMs
-     * @returns {void}
      */
     determineEfdRetries (testName, durationMs) {
       if (efdDeterminedRetries.has(testName)) return
@@ -1746,9 +1769,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       }
     }
 
-    /**
-     * @returns {void}
-     */
     removeDiscardedEfdRetries () {
       if (!this.#discardedEfdRetryTests) return
 
@@ -1774,7 +1794,6 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
      *
      * @param {object} event
      * @param {object} state
-     * @returns {void}
      */
     handleAddTestEvent (event, state) {
       if (event.concurrent) {
@@ -1879,11 +1898,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 +2215,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 +2241,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 +2263,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 +2293,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
           !!ctx.isModified,
           isEfdRetry,
           isAttemptToFix,
-          numTestExecutions)
+          numTestExecutions,
+          dynamicAtrCount)
 
         if (status === 'fail') {
           const shouldSetProbe = this.isDiEnabled && willBeRetriedByFailedTestReplay && numTestExecutions === 1
@@ -2310,6 +2363,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
         efdDeterminedRetries.clear()
         efdExpectedExecutions.clear()
         efdSlowAbortedTests.clear()
+        dynamicAtrRetryCountByTest.clear()
         efdCandidates.clear()
         newTests.clear()
         retriedTestsToNumAttempts.clear()
@@ -2365,14 +2419,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 +2459,8 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       isModifiedTest,
       isEfdRetry,
       isAttemptToFix,
-      numberOfTestInvocations
+      numberOfTestInvocations,
+      dynamicAtrRetryCount
     ) {
       const numberOfExecutedRetries = retriedTestsToNumAttempts.get(testName) ?? 0
 
@@ -2413,7 +2469,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 +2797,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')
@@ -3258,14 +3323,16 @@ function getCliWrapper (isNewJestVersion) {
 
       // Determine session status after EFD and quarantine checks have potentially modified success
       let status, error
+      const isExpectedEmptySession = numTotalTests === 0 && numTotalTestSuites === 0
       if (result.results.success) {
-        status = numTotalTests === 0 && numTotalTestSuites === 0 ? 'skip' : 'pass'
+        status = isExpectedEmptySession ? 'skip' : 'pass'
       } else {
         status = 'fail'
         error = new Error(`Failed test suites: ${numFailedTestSuites}. Failed tests: ${numFailedTests}`)
       }
 
       await waitForTestSessionFinish(getTestSessionFinishPayload(status, error, {
+        isExpectedEmptySession: result.results.success && isExpectedEmptySession,
         ...getTestSessionCoveragePayload(result.results, result.globalConfig?.rootDir),
       }))
 
@@ -3322,7 +3389,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 +3492,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 +3502,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,
@@ -3628,6 +3706,8 @@ const DD_TEST_ENVIRONMENT_OPTION_KEYS = [
   '_ddTestCodeCoverageEnabled',
   '_ddIsFlakyTestRetriesEnabled',
   '_ddFlakyTestRetriesCount',
+  '_ddIsDynamicAtrEnabled',
+  '_ddDynamicAtrBuckets',
   '_ddItrSkippingEnabledTags',
   '_ddIsDiEnabled',
   '_ddIsKnownTestsEnabled',
@@ -3744,6 +3824,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 +3980,6 @@ function requireOutsideJestRequireEngine (runtime, moduleName) {
  * @param {object} runtime
  * @param {string} from
  * @param {string} moduleName
- * @returns {void}
  */
 function recordJestEsmLoggingModulePath (runtime, from, moduleName) {
   if (
@@ -3933,7 +4025,6 @@ function getJestEsmLoggingModuleName (runtime, from, modulePath) {
 
 /**
  * @param {object} runtime
- * @returns {void}
  */
 function wrapJestEsmLoader (runtime) {
   const esmLoader = runtime?.esmLoader
@@ -3994,7 +4085,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