dd-trace 6.10.0 → 6.12.0

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

@@ -7,9 +7,18 @@ const { pathToFileURL } = require('url')
 
 const log = require('../../dd-trace/src/log')
 const { getSegment } = require('../../dd-trace/src/util')
+const {
+  finalizeAfterUserHandlers,
+  manualPluginOwner,
+  runUserHandler,
+} = require('../../datadog-plugin-cypress/src/finalization')
 const { channel } = require('./helpers/instrument')
 
 const DD_CONFIG_WRAPPED = Symbol.for('dd-trace.cypress.config.wrapped')
+const DD_CYPRESS_AFTER_SPEC_HANDLER = Symbol.for('dd-trace.cypress.after-spec.handler')
+const DD_CYPRESS_AFTER_RUN_HANDLER = Symbol.for('dd-trace.cypress.after-run.handler')
+const DD_CYPRESS_TASK_HANDLER = Symbol.for('dd-trace.cypress.task.handler')
+const DD_CYPRESS_NOOP_TASK_HANDLER = Symbol.for('dd-trace.cypress.noop-task.handler')
 const BROWSER_INSTRUMENTATION_NOT_INSTALLED =
   'Browser-side Cypress Test Optimization instrumentation was not installed.'
 const CONFIG_INSTRUMENTATION_NOT_INSTALLED =
@@ -184,6 +193,47 @@ function isDatadogTaskRegistration (handler) {
     typeof handler['dd:addTags'] === 'function'
 }
 
+/**
+ * @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
+}
+
+/**
+ * @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
+}
+
+/**
+ * @param {object} manualPlugin manual plugin registration state
+ * @returns {boolean} whether the manual plugin supports error-aware finalization
+ */
+function supportsErrorAwareFinalization (manualPlugin) {
+  return isDatadogAfterSpecHandler(manualPlugin.afterSpecHandler) &&
+    isDatadogAfterRunHandler(manualPlugin.afterRunHandler)
+}
+
+/**
+ * @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
+}
+
+/**
+ * @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
+}
+
 /**
  * @param {unknown} value
  * @returns {boolean}
@@ -393,15 +443,61 @@ function registerManualAfterScreenshotHandlers (on, handlers, datadogHandler) {
  *
  * @param {Function} on Cypress event registration function
  * @param {Function[]} handlers collected after:spec handlers
+ * @param {Function} [datadogHandler] manual Datadog after:spec handler
+ * @param {Function} [cleanup] removes generated support files after an error
  * @returns {void}
  */
-function registerAfterSpecHandlers (on, handlers) {
-  if (handlers.length === 0) return
+function registerAfterSpecHandlers (on, handlers, datadogHandler, cleanup) {
+  const userHandlers = datadogHandler
+    ? handlers.filter(handler => handler !== datadogHandler)
+    : handlers
 
-  on('after:spec', (spec, results) => handlers.reduce(
-    (chain, handler) => chain.then(() => handler(spec, results)),
-    Promise.resolve()
-  ))
+  if (userHandlers.length === 0) {
+    if (datadogHandler) {
+      if (cleanup) {
+        on('after:spec', (...args) => Promise.resolve().then(() => datadogHandler(...args)).catch((error) => {
+          cleanup()
+          throw error
+        }))
+      } else {
+        on('after:spec', datadogHandler)
+      }
+    }
+    return
+  }
+
+  on('after:spec', (spec, results) => {
+    const callHandler = datadogHandler
+      ? handler => runUserHandler(() => handler(spec, results))
+      : handler => handler(spec, results)
+    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))
+    if (!cleanup) return finalization
+    return finalization.catch((error) => {
+      cleanup()
+      throw error
+    })
+  })
+}
+
+/**
+ * Enables the Cypress lifecycle events needed to finish Test Optimization
+ * sessions in interactive mode.
+ *
+ * @param {object} config Cypress resolved config object
+ * @returns {void}
+ */
+function enableInteractiveRunEvents (config) {
+  if (config.isInteractive && config.experimentalInteractiveRunEvents !== true) {
+    config.experimentalInteractiveRunEvents = true
+    log.warn(
+      'Datadog enabled Cypress experimentalInteractiveRunEvents so Test Optimization can finish the test session.'
+    )
+  }
 }
 
 /**
@@ -412,6 +508,7 @@ function registerAfterSpecHandlers (on, handlers) {
  *
  * @param {Function} on Cypress event registration function
  * @param {object} config Cypress resolved config object
+ * @param {Function[]} userBeforeRunHandlers user's before:run handlers collected from wrappedOn
  * @param {Function[]} userAfterSpecHandlers user's after:spec handlers collected from wrappedOn
  * @param {Function[]} userAfterRunHandlers user's after:run handlers collected from wrappedOn
  * @param {Function[]} userAfterScreenshotHandlers user's after:screenshot handlers collected from wrappedOn
@@ -421,6 +518,7 @@ function registerAfterSpecHandlers (on, handlers) {
 function registerDdTraceHooks (
   on,
   config,
+  userBeforeRunHandlers,
   userAfterSpecHandlers,
   userAfterRunHandlers,
   userAfterScreenshotHandlers,
@@ -433,13 +531,23 @@ function registerDdTraceHooks (
     if (generatedSupportFiles) cleanupGeneratedFiles(generatedSupportFiles)
   }
 
-  const registerAfterRunWithCleanup = () => {
+  const registerAfterRunWithCleanup = (datadogHandler) => {
+    const handlers = datadogHandler
+      ? userAfterRunHandlers.filter(handler => handler !== datadogHandler)
+      : userAfterRunHandlers
+
     on('after:run', (results) => {
-      const chain = userAfterRunHandlers.reduce(
-        (p, h) => p.then(() => h(results)),
+      const callHandler = datadogHandler
+        ? handler => runUserHandler(() => handler(results))
+        : handler => handler(results)
+      const chain = handlers.reduce(
+        (promise, handler) => promise.then(() => callHandler(handler)),
         Promise.resolve()
       )
-      return chain.finally(cleanupWrapper)
+      if (!datadogHandler) return chain.finally(cleanupWrapper)
+
+      return finalizeAfterUserHandlers(chain, (...args) => datadogHandler(results, ...args))
+        .finally(cleanupWrapper)
     })
   }
 
@@ -450,13 +558,36 @@ function registerDdTraceHooks (
     on('task', noopTask)
   }
 
-  if (manualPlugin.detected) {
-    registerAfterSpecHandlers(on, userAfterSpecHandlers)
+  if (manualPlugin.detected &&
+    (manualPlugin.isNoop ||
+      manualPlugin.ownsCurrentPlugin ||
+      supportsErrorAwareFinalization(manualPlugin) ||
+      !setupNodeEventsCh.hasSubscribers)) {
+    if (manualPlugin.afterRunHandler) {
+      enableInteractiveRunEvents(config)
+      if (manualPlugin.initialConfig !== config) {
+        manualPlugin.initialConfig.experimentalInteractiveRunEvents = config.experimentalInteractiveRunEvents
+      }
+    }
+    for (const handler of userBeforeRunHandlers) on('before:run', handler)
+    registerAfterSpecHandlers(on, userAfterSpecHandlers, manualPlugin.afterSpecHandler, cleanupWrapper)
     registerManualAfterScreenshotHandlers(on, userAfterScreenshotHandlers, manualPlugin.afterScreenshotHandler)
-    registerAfterRunWithCleanup()
+    registerAfterRunWithCleanup(manualPlugin.afterRunHandler)
+    on('task', manualPlugin.taskHandler)
     return config
   }
 
+  if (manualPlugin.detected) {
+    userBeforeRunHandlers = userBeforeRunHandlers.filter(handler => handler !== manualPlugin.beforeRunHandler)
+    userAfterSpecHandlers = userAfterSpecHandlers.filter(handler => handler !== manualPlugin.afterSpecHandler)
+    userAfterRunHandlers = userAfterRunHandlers.filter(handler => handler !== manualPlugin.afterRunHandler)
+    userAfterScreenshotHandlers = userAfterScreenshotHandlers.filter(
+      handler => handler !== manualPlugin.afterScreenshotHandler
+    )
+  }
+
+  for (const handler of userBeforeRunHandlers) on('before:run', handler)
+
   if (!setupNodeEventsCh.hasSubscribers) {
     registerNoopHandlers()
     return config
@@ -483,6 +614,7 @@ function registerDdTraceHooks (
     return config
   }
 
+  enableInteractiveRunEvents(config)
   return payload.configPromise || config
 }
 
@@ -492,28 +624,60 @@ function registerDdTraceHooks (
  */
 function wrapSetupNodeEvents (originalSetupNodeEvents) {
   return function ddSetupNodeEvents (on, config) {
+    const userBeforeRunHandlers = []
     const userAfterSpecHandlers = []
     const userAfterRunHandlers = []
     const userAfterScreenshotHandlers = []
     const manualPlugin = {
       detected: false,
+      initialConfig: config,
+      beforeRunHandler: undefined,
+      afterSpecHandler: undefined,
+      afterRunHandler: undefined,
       afterScreenshotHandler: undefined,
+      taskHandler: undefined,
+      ownsCurrentPlugin: false,
+      isNoop: false,
     }
+    const recentRegistrations = []
 
     const wrappedOn = (event, handler) => {
-      if (event === 'after:spec') {
+      if (event === 'before:run') {
+        userBeforeRunHandlers.push(handler)
+      } else if (event === 'after:spec') {
         userAfterSpecHandlers.push(handler)
+        if (isDatadogAfterSpecHandler(handler)) manualPlugin.afterSpecHandler = handler
       } else if (event === 'after:run') {
         userAfterRunHandlers.push(handler)
+        if (isDatadogAfterRunHandler(handler)) manualPlugin.afterRunHandler = handler
       } else if (event === 'after:screenshot') {
         userAfterScreenshotHandlers.push(handler)
       } else {
         if (event === 'task' && isDatadogTaskRegistration(handler)) {
           manualPlugin.detected = true
-          manualPlugin.afterScreenshotHandler = userAfterScreenshotHandlers.at(-1)
+          manualPlugin.ownsCurrentPlugin = isCurrentDatadogTaskRegistration(handler)
+          manualPlugin.isNoop = isDatadogNoopTaskRegistration(handler)
+          const afterRun = recentRegistrations.at(-1)
+          const afterSpec = recentRegistrations.at(-2)
+          const possibleAfterScreenshot = recentRegistrations.at(-3)
+          const hasAfterScreenshot = possibleAfterScreenshot?.event === 'after:screenshot'
+          const beforeRun = hasAfterScreenshot ? recentRegistrations.at(-4) : possibleAfterScreenshot
+          if (!manualPlugin.isNoop &&
+            beforeRun?.event === 'before:run' &&
+            afterSpec?.event === 'after:spec' &&
+            afterRun?.event === 'after:run') {
+            manualPlugin.beforeRunHandler ||= beforeRun.handler
+            manualPlugin.afterSpecHandler ||= afterSpec.handler
+            manualPlugin.afterRunHandler ||= afterRun.handler
+            if (hasAfterScreenshot) manualPlugin.afterScreenshotHandler ||= possibleAfterScreenshot.handler
+          }
+          manualPlugin.taskHandler = handler
+        } else {
+          on(event, handler)
         }
-        on(event, handler)
       }
+      recentRegistrations.push({ event, handler })
+      if (recentRegistrations.length > 4) recentRegistrations.shift()
     }
 
     const maybePromise = originalSetupNodeEvents
@@ -525,6 +689,7 @@ function wrapSetupNodeEvents (originalSetupNodeEvents) {
         return registerDdTraceHooks(
           on,
           mergeReturnedConfig(config, result),
+          userBeforeRunHandlers,
           userAfterSpecHandlers,
           userAfterRunHandlers,
           userAfterScreenshotHandlers,
@@ -536,6 +701,7 @@ function wrapSetupNodeEvents (originalSetupNodeEvents) {
     return registerDdTraceHooks(
       on,
       mergeReturnedConfig(config, maybePromise),
+      userBeforeRunHandlers,
       userAfterSpecHandlers,
       userAfterRunHandlers,
       userAfterScreenshotHandlers,

package/packages/datadog-instrumentations/src/cypress-legacy-finalizers.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { shouldDeferLegacyFinalization } = require('../../datadog-plugin-cypress/src/finalization')
+const Hook = require('./helpers/hook')
+
+const DD_CYPRESS_LEGACY_FINALIZER_WRAPPED = Symbol.for('dd-trace.cypress.legacy-finalizer.wrapped')
+const LEGACY_FINALIZER_MODULES = new Set([
+  'dd-trace/packages/datadog-plugin-cypress/src/after-run.js',
+  'dd-trace/packages/datadog-plugin-cypress/src/after-spec.js',
+])
+
+/**
+ * @param {Function} finalizer standalone Datadog Cypress finalizer
+ * @returns {Function} context-aware finalizer
+ */
+function wrapLegacyFinalizer (finalizer) {
+  if (finalizer[DD_CYPRESS_LEGACY_FINALIZER_WRAPPED]) return finalizer
+
+  function wrappedLegacyFinalizer () {
+    if (shouldDeferLegacyFinalization()) return
+    return finalizer.apply(this, arguments)
+  }
+  wrappedLegacyFinalizer[DD_CYPRESS_LEGACY_FINALIZER_WRAPPED] = true
+  return wrappedLegacyFinalizer
+}
+
+Hook(['dd-trace'], { internals: true }, (moduleExports, moduleName) => {
+  if (!LEGACY_FINALIZER_MODULES.has(moduleName.replaceAll('\\', '/'))) return moduleExports
+  return wrapLegacyFinalizer(moduleExports)
+})

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

@@ -8,6 +8,8 @@ const {
   wrapConfig,
 } = require('./cypress-config')
 
+require('./cypress-legacy-finalizers')
+
 const MINIMUM_CYPRESS_VERSION = DD_MAJOR >= 6 ? '>=12.0.0' : '>=10.2.0'
 
 // Wrap defineConfig() so configs are instrumented when loaded in Cypress's

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

@@ -146,6 +146,7 @@ function wrapHookDone (ctx, request, reply, req, name, doneCallback) {
     ctx.error = error
     publishError(ctx)
 
+    // eslint-disable-next-line no-restricted-syntax -- arbitrary cookie names; publishing {} sets a WAF address
     const hasCookies = request.cookies && Object.keys(request.cookies).length > 0
 
     if (cookieParserReadCh.hasSubscribers && hasCookies && !cookiesPublished.has(req)) {
@@ -193,6 +194,7 @@ function preHandler (request, reply, done) {
   const res = getRes(reply)
   const ctx = { req, res }
 
+  // eslint-disable-next-line no-restricted-syntax -- arbitrary body keys; publishing {} sets a WAF address
   const hasBody = request.body && Object.keys(request.body).length > 0
 
   // For multipart/form-data, the body is not available until after preValidation hook

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

@@ -0,0 +1,22 @@
+'use strict'
+
+const shimmer = require('../../../datadog-shimmer')
+const { channel } = require('./instrument')
+
+/**
+ * @param {{ prototype: object }} Logger
+ * @param {string} id
+ */
+module.exports = function wrapLogger (Logger, id) {
+  const logCh = channel(`apm:${id}:log`)
+  shimmer.wrap(Logger.prototype, '_emit', emit => {
+    return function wrappedEmit (rec) {
+      if (logCh.hasSubscribers) {
+        const payload = { message: rec }
+        logCh.publish(payload)
+        arguments[0] = payload.message
+      }
+      return emit.apply(this, arguments)
+    }
+  })
+}

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

@@ -70,6 +70,7 @@ module.exports = {
   'aws-sdk': () => require('../aws-sdk'),
   bluebird: () => require('../bluebird'),
   'body-parser': () => require('../body-parser'),
+  'browser-bunyan': () => require('../browser-bunyan'),
   bullmq: () => require('../bullmq'),
   bunyan: () => require('../bunyan'),
   'cassandra-driver': () => require('../cassandra-driver'),
@@ -110,7 +111,7 @@ module.exports = {
   'light-my-request': () => require('../light-my-request'),
   'limitd-client': () => require('../limitd-client'),
   lodash: () => require('../lodash'),
-  mariadb: () => require('../mariadb'),
+  mariadb: { esmFirst: true, fn: () => require('../mariadb') },
   memcached: () => require('../memcached'),
   mercurius: () => require('../mercurius'),
   'microgateway-core': () => require('../microgateway-core'),

package/packages/datadog-instrumentations/src/helpers/pool-acquire.js

@@ -518,10 +518,11 @@ function runPoolQueryConnectionCallback (
  * @param {unknown} error
  * @param {Record<string, unknown>} acquireCtx
  * @param {AcquireErrorChannels} channels
+ * @param {number} [poolWaitTime]
  */
-function reportPoolAcquireError (start, error, acquireCtx, channels) {
+function reportPoolAcquireError (start, error, acquireCtx, channels, poolWaitTime) {
   acquireCtx.error = error
-  acquireCtx.poolWaitTime = acquireWait(start)
+  acquireCtx.poolWaitTime = poolWaitTime ?? acquireWait(start)
   if (start !== undefined) acquireCtx.startTime = performance.timeOrigin + start
   channels.acquireStartCh.publish(acquireCtx)
   channels.acquireFinishCh.publish(acquireCtx)
@@ -536,11 +537,14 @@ function reportPoolAcquireError (start, error, acquireCtx, channels) {
  * @param {Function} callback
  * @param {unknown} thisArg
  * @param {ArgumentsLike} args
+ * @param {number} [poolWaitTime]
  * @returns {unknown}
  */
-function runPoolAcquireError (start, error, acquireCtx, channels, connectionCtx, callback, thisArg, args) {
+function runPoolAcquireError (
+  start, error, acquireCtx, channels, connectionCtx, callback, thisArg, args, poolWaitTime
+) {
   return channels.connectionFinishCh.runStores(connectionCtx, () => {
-    reportPoolAcquireError(start, error, acquireCtx, channels)
+    reportPoolAcquireError(start, error, acquireCtx, channels, poolWaitTime)
     return callback.apply(thisArg, args)
   })
 }
@@ -613,6 +617,7 @@ function takeClusterAcquire (key) {
 }
 
 module.exports = {
+  acquireWait,
   clearPoolWaitTime,
   dispatchesAcquireSynchronously,
   isPoolQueryAcquire,

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

@@ -112,14 +112,6 @@ for (const name of names) {
     }
 
     for (const { file, versions, hook, filePattern, patchDefault } of instrumentations[name]) {
-      if (isIitm && patchDefault === !!moduleExports.default) {
-        if (patchDefault) {
-          moduleExports = moduleExports.default
-        } else {
-          return moduleExports
-        }
-      }
-
       const fullFilename = filename(name, file)
 
       let matchesFile = moduleName === fullFilename
@@ -134,6 +126,16 @@ for (const name of names) {
       }
 
       if (matchesFile && matchVersion(moduleVersion, versions)) {
+        // IITM invokes this callback for every module in the package. Only unwrap the namespace after its file and
+        // version match, otherwise a default export from an unrelated internal module can replace that module.
+        if (isIitm && patchDefault === !!moduleExports.default) {
+          if (patchDefault) {
+            moduleExports = moduleExports.default
+          } else {
+            return moduleExports
+          }
+        }
+
         // Do not log in case of an error to prevent duplicate telemetry for the same integration version.
         instrumentedIntegrationsSuccess.set(`${name}@${moduleVersion}`, true)
         try {

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

@@ -97,7 +97,9 @@ const itrSkippedSuitesCh = channel('ci:jest:itr:skipped-suites')
 const CHILD_MESSAGE_CALL = 1
 
 // Maximum time we'll wait for the tracer to flush
-const FLUSH_TIMEOUT = 10_000
+// The exporter has a 10-second bounded final-flush deadline. Leave enough time
+// for its completion callback before Jest's --forceExit fallback takes over.
+const FLUSH_TIMEOUT = 12_000
 const JEST_SESSION_STATE = Symbol.for('dd-trace:jest:session')
 const JEST_BAIL_REPORTER_PATH = require.resolve('./jest/bail-reporter')
 const DD_JEST_HANDLE_TEST_EVENT_WRAPPED = Symbol('dd-trace:jest:handle-test-event-wrapped')
@@ -110,7 +112,7 @@ const jestSessionState = (globalThis[JEST_SESSION_STATE] ||= {})
 const RETRY_TIMES = Symbol.for('RETRY_TIMES')
 
 let skippableSuites = []
-let skippableSuitesCoverage = {}
+let skippableSuitesCoverage
 let skippedSuitesCoverage = {}
 let knownTests = {}
 let isCodeCoverageEnabled = false
@@ -131,7 +133,7 @@ let isTestManagementTestsEnabled = false
 let testManagementTests = {}
 let testManagementAttemptToFixRetries = 0
 let isImpactedTestsEnabled = false
-let modifiedFiles = {}
+let modifiedFiles
 let repositoryRoot
 let lastCoverageMap
 let lastCoverageMapRootDir
@@ -688,8 +690,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       if (this.isImpactedTestsEnabled) {
         try {
-          const hasImpactedTests = Object.keys(modifiedFiles).length > 0
-          this.modifiedFiles = hasImpactedTests ? modifiedFiles : this.testEnvironmentOptions._ddModifiedFiles
+          this.modifiedFiles = modifiedFiles ?? this.testEnvironmentOptions._ddModifiedFiles
         } catch (e) {
           log.error('Error parsing impacted tests', e)
           this.isImpactedTestsEnabled = false
@@ -2489,12 +2490,6 @@ function getRepositoryRootFromTest (test, fallbackRootDir) {
   return getRepositoryRootFromConfig(test?.context?.config, fallbackRootDir)
 }
 
-function hasSkippableSuitesCoverage () {
-  return skippableSuitesCoverage &&
-    typeof skippableSuitesCoverage === 'object' &&
-    Object.keys(skippableSuitesCoverage).length > 0
-}
-
 function shouldCollectJestCoverageForTia () {
   return shouldReportJestSuiteCoverageForTia() ||
     (isJestCoverageBackfillSupported && isItrEnabled && isCoverageReportUploadEnabled)
@@ -2605,7 +2600,7 @@ function resetLibraryConfiguration () {
   testManagementTests = {}
   testManagementAttemptToFixRetries = 0
   isImpactedTestsEnabled = false
-  modifiedFiles = {}
+  modifiedFiles = undefined
   repositoryRoot = undefined
 }
 
@@ -2627,13 +2622,14 @@ function applySuiteSkipping (originalTests, rootDir, frameworkVersion) {
 
   isSuitesSkipped ||= jestSuitesToRun.suitesToRun.length !== originalTests.length
   numSkippedSuites += jestSuitesToRun.skippedSuites.length
-  skippedSuitesCoverage = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
+  const hasSkippableSuitesCoverage = skippableSuitesCoverage !== undefined
+  skippedSuitesCoverage = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage
     ? skippableSuitesCoverage
     : {}
   coverageBackfillContexts = isSuitesSkipped && isTiaCoverageBackfillEnabled()
     ? getTestContexts(originalTests)
     : undefined
-  coverageBackfillFiles = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
+  coverageBackfillFiles = isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage
     ? getCoverageBackfillFiles(skippableSuitesCoverage, repositoryRoot, getTestSuitePath)
     : undefined
 
@@ -3022,10 +3018,10 @@ function getCliWrapper (isNewJestVersion) {
             skippableSuitesCoverage: receivedSkippableSuitesCoverage,
           } = skippableSuitesResponse || await getChannelPromise(skippableSuitesCh)
           if (err) {
-            skippableSuitesCoverage = {}
+            skippableSuitesCoverage = undefined
           } else {
             skippableSuites = receivedSkippableSuites
-            skippableSuitesCoverage = receivedSkippableSuitesCoverage || {}
+            skippableSuitesCoverage = receivedSkippableSuitesCoverage
           }
           skippedSuitesCoverage = {}
         } catch (err) {
@@ -3066,7 +3062,19 @@ function getCliWrapper (isNewJestVersion) {
         frameworkVersion: jestVersion,
       })
 
-      const result = await runCLI.apply(this, arguments)
+      let result
+      try {
+        result = await runCLI.apply(this, arguments)
+      } catch (error) {
+        try {
+          await waitForTestSessionFinish(getTestSessionFinishPayload('fail', error, {
+            isTestSessionFinalizationError: true,
+          }))
+        } catch (finalizationError) {
+          log.error('Jest test session finalization error: %s', finalizationError)
+        }
+        throw error
+      }
 
       const {
         results: {