dd-trace 5.104.0 → 5.105.0

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

@@ -62,6 +62,7 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
   shimmer.wrap(Kafka.prototype, 'producer', createProducer => function () {
     const producer = createProducer.apply(this, arguments)
     const originalSend = producer.send
+    const originalSendBatch = producer.sendBatch
     const bootstrapServers = this._brokers
     const cluster = clientToCluster.get(producer)
 
@@ -75,35 +76,46 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
       }
     }
 
-    producer.send = function (...args) {
-      if (!producerStartCh.hasSubscribers) {
-        return originalSend.apply(this, args)
-      }
-
-      // Fast path: kafkajs has fetched metadata, so versions and clusterId
-      // are already on the broker pool.
+    /**
+     * Resolve the negotiated clusterId once and hand it to `call`. Fast path reads
+     * `cluster.brokerPool.metadata` synchronously when kafkajs already fetched it.
+     * Slow path primes `refreshMetadataIfNecessary`, which `sharedPromiseTo`
+     * deduplicates with kafkajs's own internal fetch so total latency is unchanged.
+     *
+     * @param {(clusterId: string | undefined) => Promise<unknown>} call
+     */
+    const withClusterId = (call) => {
       const metadata = cluster?.brokerPool?.metadata
       if (metadata) {
         refreshHeaderSupport()
-        return runSend.call(this, args, metadata.clusterId)
+        return call(metadata.clusterId)
       }
-
-      // Slow path, taken at most once per producer connect cycle. Prime the
-      // metadata fetch kafkajs's send would do internally a few stack frames
-      // later. `sharedPromiseTo` collapses our call and kafkajs's call into a
-      // single round trip, so total latency is unchanged.
       if (typeof cluster?.refreshMetadataIfNecessary !== 'function') {
-        return runSend.call(this, args)
+        return call()
       }
       return cluster.refreshMetadataIfNecessary().then(
         () => {
           refreshHeaderSupport()
-          return runSend.call(this, args, cluster.brokerPool?.metadata?.clusterId)
+          return call(cluster.brokerPool?.metadata?.clusterId)
         },
-        () => runSend.call(this, args)
+        () => call()
       )
     }
 
+    producer.send = function (...args) {
+      if (!producerStartCh.hasSubscribers) {
+        return originalSend.apply(this, args)
+      }
+      return withClusterId((clusterId) => runSend.call(this, args, clusterId))
+    }
+
+    producer.sendBatch = function (...args) {
+      if (!producerStartCh.hasSubscribers) {
+        return originalSendBatch.apply(this, args)
+      }
+      return withClusterId((clusterId) => runSendBatch.call(this, args, clusterId))
+    }
+
     function runSend (args, clusterId) {
       const arg0 = args[0]
       const topic = arg0?.topic
@@ -166,6 +178,98 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
       })
     }
 
+    function runSendBatch (args, clusterId) {
+      const arg0 = args[0]
+      const inputTopicMessages = Array.isArray(arg0?.topicMessages) ? arg0.topicMessages : []
+      if (inputTopicMessages.length === 0) {
+        return originalSendBatch.apply(this, args)
+      }
+
+      // One ctx per topicMessages entry — kafkajs implements `send` as a single-entry
+      // `sendBatch` (`producer/messageProducer.js`), so one span per entry is the same
+      // unit `send` already produces. Cloning only happens for valid arrays so kafkajs
+      // still sees and rejects a caller's malformed `messages` field.
+      const outputEntries = new Array(inputTopicMessages.length)
+      const ctxList = []
+      let cloned = false
+      for (let i = 0; i < inputTopicMessages.length; i++) {
+        const entry = inputTopicMessages[i]
+        const topic = entry?.topic
+        const rawMessages = entry?.messages
+        let entryMessages = rawMessages
+        if (Array.isArray(rawMessages) && rawMessages.length > 0) {
+          entryMessages = cloneMessages(rawMessages, !disableHeaderInjection)
+          outputEntries[i] = { ...entry, messages: entryMessages }
+          cloned = true
+        } else {
+          outputEntries[i] = entry
+        }
+        ctxList.push({
+          bootstrapServers,
+          clusterId,
+          disableHeaderInjection,
+          messages: Array.isArray(entryMessages) ? entryMessages : [],
+          topic,
+        })
+      }
+      if (cloned) {
+        args[0] = { ...arg0, topicMessages: outputEntries }
+      }
+
+      for (const ctx of ctxList) {
+        producerStartCh.runStores(ctx, noop)
+      }
+
+      let result
+      try {
+        result = originalSendBatch.apply(this, args)
+      } catch (error) {
+        failProduceBatch(ctxList, error)
+        throw error
+      }
+
+      result.then(
+        (res) => {
+          for (const ctx of ctxList) {
+            ctx.result = res
+            producerFinishCh.publish(ctx)
+          }
+          // kafkajs returns a single aggregated response covering every topic;
+          // commit fires once so the plugin's `setOffset` loop runs once per
+          // entry of the response, not once per span.
+          producerCommitCh.publish(ctxList[0])
+        },
+        (error) => failProduceBatch(ctxList, error)
+      )
+
+      return result
+    }
+
+    /**
+     * Tag every open ctx with the shared error, then publish error + finish so the
+     * plugin closes each span. The mixed-version safety net (broker advertised
+     * Produce v3+ but the leader rejected the headers) fires at most once per
+     * failed batch and short-circuits subsequent sends to the disabled path.
+     *
+     * @param {Array<object>} ctxList
+     * @param {Error} error
+     */
+    function failProduceBatch (ctxList, error) {
+      if (error?.name === 'KafkaJSProtocolError' && error.type === 'UNKNOWN') {
+        disableHeaderInjection = true
+        refreshHeaderSupport = noop
+        log.error(
+          // eslint-disable-next-line @stylistic/max-len
+          'Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). Please look at broker logs for more information. Tracer message header injection for Kafka is disabled.'
+        )
+      }
+      for (const ctx of ctxList) {
+        ctx.error = error
+        producerErrorCh.publish(ctx)
+        producerFinishCh.publish(ctx)
+      }
+    }
+
     return producer
   })
 

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

@@ -6,16 +6,21 @@ const { DD_MAJOR } = require('../../../../version')
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
 const { isMarkedAsUnskippable } = require('../../../datadog-plugin-jest/src/util')
+const { writeCoverageBackfillToCache } = require('../../../dd-trace/src/ci-visibility/test-optimization-cache')
 const log = require('../../../dd-trace/src/log')
 const { getEnvironmentVariable } = require('../../../dd-trace/src/config/helper')
 const {
   getTestSuitePath,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   fromCoverageMapToCoverage,
-  getCoveredFilenamesFromCoverage,
+  getCoveredFilesFromCoverage,
+  getExecutableFilesFromCoverage,
+  applySkippedCoverageToCoverage,
   mergeCoverage,
   resetCoverage,
   getIsFaultyEarlyFlakeDetection,
+  getRelativeCoverageFiles,
+  getTestCoverageLinesPercentage,
   collectTestOptimizationSummariesFromTraces,
   logTestOptimizationSummary,
   getTestOptimizationRequestResults,
@@ -53,6 +58,8 @@ const unskippableSuites = []
 let suitesToSkip = []
 let isSuitesSkipped = false
 let skippedSuites = []
+let skippableSuitesCoverage = {}
+let skippedSuitesCoverage = {}
 let itrCorrelationId = ''
 let isForcedToRun = false
 const config = {}
@@ -133,10 +140,33 @@ function haveRootTestsFinished (rootTests) {
   return true
 }
 
+function getSuitePath (suite) {
+  return getTestSuitePath(suite.file, process.cwd())
+}
+
+function getSuitesToSkip (originalSuites) {
+  return getSuitesToSkipFromPaths(originalSuites.map(getSuitePath))
+}
+
+function getSuitesToSkipFromPaths (localSuites) {
+  const localSuitesSet = new Set(localSuites)
+  const suitesToSkipForRun = []
+
+  for (const suite of suitesToSkip) {
+    if (localSuitesSet.has(suite)) {
+      suitesToSkipForRun.push(suite)
+    }
+  }
+
+  return suitesToSkipForRun
+}
+
 function getFilteredSuites (originalSuites) {
+  const suitesToSkipForRun = getSuitesToSkip(originalSuites)
+
   return originalSuites.reduce((acc, suite) => {
-    const testPath = getTestSuitePath(suite.file, process.cwd())
-    const shouldSkip = suitesToSkip.includes(testPath)
+    const testPath = getSuitePath(suite)
+    const shouldSkip = suitesToSkipForRun.includes(testPath)
     const isUnskippable = unskippableSuites.includes(suite.file)
     if (shouldSkip && !isUnskippable) {
       acc.skippedSuites.add(testPath)
@@ -144,7 +174,50 @@ function getFilteredSuites (originalSuites) {
       acc.suitesToRun.push(suite)
     }
     return acc
-  }, { suitesToRun: [], skippedSuites: new Set() })
+  }, { suitesToRun: [], skippedSuites: new Set(), suitesToSkipForRun })
+}
+
+function hasSkippableSuitesCoverage () {
+  return skippableSuitesCoverage &&
+    typeof skippableSuitesCoverage === 'object' &&
+    Object.keys(skippableSuitesCoverage).length > 0
+}
+
+function isTiaCoverageBackfillEnabled () {
+  return config.isItrEnabled && config.isCoverageReportUploadEnabled
+}
+
+function getCoverageRootDir () {
+  return config.repositoryRoot || process.cwd()
+}
+
+function shouldReportCodeCoverageLinesPct (hasBackfilledCoverage) {
+  return !isSuitesSkipped || hasBackfilledCoverage
+}
+
+function getSkippedSuitesCoverageForRun () {
+  return isSuitesSkipped && isTiaCoverageBackfillEnabled() && hasSkippableSuitesCoverage()
+    ? skippableSuitesCoverage
+    : {}
+}
+
+function applySkippedCoverageToMochaCoverageMap () {
+  if (!isTiaCoverageBackfillEnabled()) return false
+  return applySkippedCoverageToCoverage(originalCoverageMap, skippedSuitesCoverage, getCoverageRootDir())
+}
+
+function getMochaTestSessionCoverageFiles () {
+  return getRelativeCoverageFiles(getExecutableFilesFromCoverage(originalCoverageMap), getCoverageRootDir())
+}
+
+function resetSuiteSkippingRunState () {
+  isSuitesSkipped = false
+  skippedSuites = []
+  skippableSuitesCoverage = {}
+  skippedSuitesCoverage = {}
+  untestedCoverage = undefined
+  config.repositoryRoot = undefined
+  writeCoverageBackfillToCache({})
 }
 
 function getOnStartHandler (frameworkVersion) {
@@ -218,12 +291,24 @@ function getOnEndHandler (isParallel) {
     testFileToSuiteCtx.clear()
 
     let testCodeCoverageLinesTotal
-    if (global.__coverage__) {
+    let testSessionCoverageFiles
+    if (global.__coverage__ || untestedCoverage) {
       try {
+        let hasBackfilledCoverage = false
         if (untestedCoverage) {
           originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
         }
-        testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
+        hasBackfilledCoverage = applySkippedCoverageToMochaCoverageMap()
+        if (shouldReportCodeCoverageLinesPct(hasBackfilledCoverage)) {
+          testCodeCoverageLinesTotal = getTestCoverageLinesPercentage(
+            originalCoverageMap,
+            undefined,
+            getCoverageRootDir()
+          )
+        }
+        if (isTiaCoverageBackfillEnabled()) {
+          testSessionCoverageFiles = getMochaTestSessionCoverageFiles()
+        }
       } catch {
         // ignore errors
       }
@@ -235,6 +320,7 @@ function getOnEndHandler (isParallel) {
       status,
       isSuitesSkipped,
       testCodeCoverageLinesTotal,
+      testSessionCoverageFiles,
       numSkippedSuites: skippedSuites.length,
       hasForcedToRunSuites: isForcedToRun,
       hasUnskippableSuites: !!unskippableSuites.length,
@@ -276,23 +362,39 @@ function applyTestManagementTestsResponse ({ err, testManagementTests: receivedT
   }
 }
 
-function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFinishRequest) {
+function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFinishRequest, localSuites) {
   const ctx = {
     isParallel,
     frameworkVersion,
   }
   let skippableSuitesResponse
-
-  const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
+  resetSuiteSkippingRunState()
+
+  const onReceivedSkippableSuites = ({
+    err,
+    skippableSuites,
+    itrCorrelationId: responseItrCorrelationId,
+    skippableSuitesCoverage: responseSkippableSuitesCoverage,
+  }) => {
     if (err) {
       suitesToSkip = []
+      skippableSuitesCoverage = {}
     } else {
       suitesToSkip = skippableSuites
       itrCorrelationId = responseItrCorrelationId
+      skippableSuitesCoverage = responseSkippableSuitesCoverage || {}
     }
+    if (localSuites) {
+      suitesToSkip = getSuitesToSkipFromPaths(localSuites)
+      mochaGlobalRunCh.runStores(ctx, () => {
+        onFinishRequest()
+      })
+      return
+    }
+
     // We remove the suites that we skip through ITR
     const filteredSuites = getFilteredSuites(runner.suite.suites)
-    const { suitesToRun } = filteredSuites
+    const { suitesToRun, suitesToSkipForRun } = filteredSuites
 
     isSuitesSkipped = suitesToRun.length !== runner.suite.suites.length
 
@@ -301,6 +403,9 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     runner.suite.suites = suitesToRun
 
     skippedSuites = [...filteredSuites.skippedSuites]
+    suitesToSkip = suitesToSkipForRun
+    skippedSuitesCoverage = getSkippedSuitesCoverageForRun()
+    writeCoverageBackfillToCache(skippedSuitesCoverage, getCoverageRootDir())
 
     mochaGlobalRunCh.runStores(ctx, () => {
       onFinishRequest()
@@ -346,12 +451,13 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     }
   }
 
-  const onReceivedConfiguration = ({ err, libraryConfig }) => {
+  const onReceivedConfiguration = ({ err, libraryConfig, repositoryRoot }) => {
     if (err || !skippableSuitesCh.hasSubscribers || !knownTestsCh.hasSubscribers) {
       return mochaGlobalRunCh.runStores(ctx, () => {
         onFinishRequest()
       })
     }
+    config.repositoryRoot = repositoryRoot
     config.isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
     config.earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
     config.earlyFlakeDetectionSlowTestRetries = libraryConfig.earlyFlakeDetectionSlowTestRetries ?? {}
@@ -360,7 +466,10 @@ function getExecutionConfiguration (runner, isParallel, frameworkVersion, onFini
     config.isTestManagementTestsEnabled = libraryConfig.isTestManagementEnabled
     config.testManagementAttemptToFixRetries = libraryConfig.testManagementAttemptToFixRetries
     config.isImpactedTestsEnabled = libraryConfig.isImpactedTestsEnabled
-    config.isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
+    config.isItrEnabled = libraryConfig.isItrEnabled
+    config.isCodeCoverageEnabled = libraryConfig.isCodeCoverageEnabled
+    config.isCoverageReportUploadEnabled = libraryConfig.isCoverageReportUploadEnabled
+    config.isSuitesSkippingEnabled = config.isItrEnabled && libraryConfig.isSuitesSkippingEnabled
     config.isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
     config.flakyTestRetriesCount = libraryConfig.flakyTestRetriesCount
 
@@ -588,7 +697,7 @@ addHook({
       const status = getRootSuiteStatus(rootTests)
 
       if (global.__coverage__) {
-        const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+        const coverageFiles = getCoveredFilesFromCoverage(global.__coverage__)
         testSuiteCodeCoverageCh.publish({ coverageFiles, suiteFile: file })
         mergeCoverage(global.__coverage__, originalCoverageMap)
         resetCoverage(global.__coverage__)
@@ -786,7 +895,7 @@ addHook({
       }
 
       if (global.__coverage__) {
-        const coverageFiles = getCoveredFilenamesFromCoverage(global.__coverage__)
+        const coverageFiles = getCoveredFilesFromCoverage(global.__coverage__)
 
         testSuiteCodeCoverageCh.publish({
           coverageFiles,
@@ -908,11 +1017,11 @@ addHook({
       }
     }
 
+    const localSuites = files.map(file => getTestSuitePath(file, process.cwd()))
     getExecutionConfiguration(this, true, frameworkVersion, () => {
       if (config.isKnownTestsEnabled) {
-        const testSuites = files.map(file => getTestSuitePath(file, process.cwd()))
         const isFaulty = getIsFaultyEarlyFlakeDetection(
-          testSuites,
+          localSuites,
           config.knownTests?.mocha || {},
           config.earlyFlakeDetectionFaultyThreshold
         )
@@ -937,11 +1046,13 @@ addHook({
         }
         isSuitesSkipped = skippedFiles.length > 0
         skippedSuites = skippedFiles
+        skippedSuitesCoverage = getSkippedSuitesCoverageForRun()
+        writeCoverageBackfillToCache(skippedSuitesCoverage, getCoverageRootDir())
         run.apply(this, [cb, { files: filteredFiles }])
       } else {
         run.apply(this, arguments)
       }
-    })
+    }, localSuites)
 
     return this
   })

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

@@ -0,0 +1,182 @@
+'use strict'
+
+// Shimmer required: NATS consumer paths need argument modification — the user's
+// `opts.callback` is wrapped before being handed to SubscriptionImpl, and the
+// returned subscription's async iterator is wrapped so iterator-style consumers
+// get receive events. Orchestrion can only wrap method calls, not arguments
+// or returned iterables.
+
+const shimmer = require('../../datadog-shimmer')
+const { addHook, channel } = require('./helpers/instrument')
+
+const publishStartCh = channel('apm:nats:publish:start')
+const publishFinishCh = channel('apm:nats:publish:finish')
+const publishErrorCh = channel('apm:nats:publish:error')
+
+const consumeStartCh = channel('apm:nats:consume:start')
+const consumeFinishCh = channel('apm:nats:consume:finish')
+const consumeErrorCh = channel('apm:nats:consume:error')
+
+// Tracks connections that are currently inside a `request`/`requestMany` call
+// so the nested `this.publish(...)` they issue short-circuits without creating
+// a second producer span (the outer request wrap already created one and
+// injected headers — the inner publish would double-count it). A WeakSet avoids
+// changing the shape of the user's connection object.
+const requestsInFlight = new WeakSet()
+
+// Captured from the `lib/headers.js` hook below. The nats-core package always
+// imports `./headers` from `lib/nats.js`, so by the time we wrap `publish` the
+// reference is set. No defensive checks needed at call sites.
+let createHeaders
+
+addHook({ name: '@nats-io/nats-core', versions: ['>=3.0.0'], file: 'lib/headers.js' }, exports => {
+  createHeaders = exports.headers
+  return exports
+})
+
+// transport-node re-exports nats-core internals — the passthrough hook ensures
+// the package name is registered so `withVersions('nats', '@nats-io/transport-node', ...)`
+// can resolve it in plugin tests.
+addHook({ name: '@nats-io/transport-node', versions: ['>=3.0.0'] }, exports => exports)
+
+function wrapSyncProducer (original, type) {
+  return function (subject, data, options) {
+    if (!publishStartCh.hasSubscribers) {
+      return original.apply(this, arguments)
+    }
+    const opts = { ...options }
+    const ctx = { type, subject, data, options: opts, connection: this, createHeaders }
+    return publishStartCh.runStores(ctx, () => {
+      try {
+        return original.call(this, subject, data, opts)
+      } catch (err) {
+        ctx.error = err
+        publishErrorCh.publish(ctx)
+        throw err
+      } finally {
+        publishFinishCh.publish(ctx)
+      }
+    })
+  }
+}
+
+// publish is also wrapped by `wrapSyncProducer`, but request/requestMany call
+// `this.publish(...)` internally. Set a marker on the connection so the inner
+// publish wrap short-circuits — see `wrapPublish`.
+function wrapAsyncProducer (original, type) {
+  return function (subject, data, options) {
+    if (!publishStartCh.hasSubscribers) {
+      return original.apply(this, arguments)
+    }
+    const opts = { ...options }
+    const ctx = { type, subject, data, options: opts, connection: this, createHeaders }
+    return publishStartCh.runStores(ctx, () => {
+      requestsInFlight.add(this)
+      let promise
+      try {
+        // `request`/`requestMany` never throw synchronously — they wrap their own
+        // input validation in a try/catch that returns `Promise.reject`.
+        promise = original.call(this, subject, data, opts)
+      } finally {
+        // The nested `this.publish(...)` runs during the synchronous body of
+        // request/requestMany, so clearing the marker as soon as the call
+        // returns is sufficient — the promise resolution happens later.
+        requestsInFlight.delete(this)
+      }
+      return Promise.resolve(promise).then(
+        result => {
+          ctx.result = result
+          publishFinishCh.publish(ctx)
+          return result
+        },
+        err => {
+          ctx.error = err
+          publishErrorCh.publish(ctx)
+          publishFinishCh.publish(ctx)
+          throw err
+        }
+      )
+    })
+  }
+}
+
+function wrapPublish (original) {
+  const wrapped = wrapSyncProducer(original, 'publish')
+  return function (subject, data, options) {
+    // Called from inside request/requestMany — the outer wrap already produced
+    // a span and injected headers; running the inner wrap would double-count.
+    if (requestsInFlight.has(this)) {
+      return original.apply(this, arguments)
+    }
+    return wrapped.apply(this, arguments)
+  }
+}
+
+function wrapSubscribeCallback (userCallback, subject, connection) {
+  return function (err, message) {
+    if (!message || err) {
+      return userCallback.call(this, err, message)
+    }
+    const ctx = { subject, message, connection }
+    return consumeStartCh.runStores(ctx, () => {
+      try {
+        return userCallback.call(this, err, message)
+      } catch (e) {
+        ctx.error = e
+        consumeErrorCh.publish(ctx)
+        throw e
+      } finally {
+        consumeFinishCh.publish(ctx)
+      }
+    })
+  }
+}
+
+// Iterator-style consumers don't expose a delivery callback we can wrap, so
+// the consume span represents the moment of receipt only — it starts and
+// finishes before the value is yielded to user code, and the user's loop
+// body is not parented under the span.
+function wrapAsyncIteratorFactory (asyncIterator, subject, connection) {
+  return function () {
+    const iterator = asyncIterator.apply(this, arguments)
+    iterator.next = shimmer.wrapCallback(iterator.next, next => function () {
+      return next.apply(this, arguments).then(result => {
+        if (result && !result.done && result.value) {
+          const ctx = { subject, message: result.value, connection }
+          consumeStartCh.runStores(ctx, () => {
+            consumeFinishCh.publish(ctx)
+          })
+        }
+        return result
+      })
+    })
+    return iterator
+  }
+}
+
+addHook({ name: '@nats-io/nats-core', versions: ['>=3.0.0'], file: 'lib/nats.js' }, exports => {
+  const proto = exports.NatsConnectionImpl.prototype
+
+  shimmer.wrap(proto, 'publish', wrapPublish)
+  shimmer.wrap(proto, 'request', request => wrapAsyncProducer(request, 'request'))
+  shimmer.wrap(proto, 'requestMany', requestMany => wrapAsyncProducer(requestMany, 'requestMany'))
+
+  shimmer.wrap(proto, 'subscribe', subscribe => function (subject, opts) {
+    if (!consumeStartCh.hasSubscribers) {
+      return subscribe.apply(this, arguments)
+    }
+
+    const userOpts = opts ?? {}
+    if (typeof userOpts.callback === 'function') {
+      arguments[1] = { ...userOpts, callback: wrapSubscribeCallback(userOpts.callback, subject, this) }
+      return subscribe.apply(this, arguments)
+    }
+
+    const sub = subscribe.apply(this, arguments)
+    shimmer.wrap(sub, Symbol.asyncIterator, asyncIterator =>
+      wrapAsyncIteratorFactory(asyncIterator, subject, this))
+    return sub
+  })
+
+  return exports
+})

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

@@ -2,7 +2,12 @@
 
 const shimmer = require('../../datadog-shimmer')
 const { getEnvironmentVariable } = require('../../dd-trace/src/config/helper')
-const { setupSettingsCachePath } = require('../../dd-trace/src/ci-visibility/test-optimization-cache')
+const {
+  readCoverageBackfillFromCache,
+  readCoverageBackfillRootDirFromCache,
+  setupSettingsCachePath,
+} = require('../../dd-trace/src/ci-visibility/test-optimization-cache')
+const { applySkippedCoverageToCoverage } = require('../../dd-trace/src/plugins/util/test')
 const { addHook, channel } = require('./helpers/instrument')
 
 const codeCoverageWrapCh = channel('ci:nyc:wrap')
@@ -16,6 +21,38 @@ addHook({
   // when dd-trace fetches library configuration
   setupSettingsCachePath()
 
+  if (nycPackage.prototype.getCoverageMapFromAllCoverageFiles) {
+    // Some test frameworks receive skipped-suite coverage in the test process, but nyc merges reports later in the nyc
+    // process. Reuse the settings cache path as the process handoff so nyc can backfill skipped files before reporting.
+    shimmer.wrap(
+      nycPackage.prototype,
+      'getCoverageMapFromAllCoverageFiles',
+      getCoverageMapFromAllCoverageFiles => function (...args) {
+        const coverageMap = getCoverageMapFromAllCoverageFiles.apply(this, args)
+        const applyCoverageBackfill = (resolvedCoverageMap) => {
+          try {
+            if (!resolvedCoverageMap) {
+              return resolvedCoverageMap
+            }
+            applySkippedCoverageToCoverage(
+              resolvedCoverageMap,
+              readCoverageBackfillFromCache(),
+              readCoverageBackfillRootDirFromCache() || this.cwd
+            )
+          } catch {
+            // Do not break nyc's report generation if the cached backfill is stale or malformed.
+          }
+          return resolvedCoverageMap
+        }
+
+        if (coverageMap && typeof coverageMap.then === 'function') {
+          return coverageMap.then(applyCoverageBackfill)
+        }
+        return applyCoverageBackfill(coverageMap)
+      }
+    )
+  }
+
   // `wrap` is an async function
   shimmer.wrap(nycPackage.prototype, 'wrap', wrap => function (...args) {
     // Only relevant if the config `all` is set to true (for untested code coverage)