dd-trace 4.43.0 → 4.45.0

package/ext/formats.d.ts

@@ -5,6 +5,7 @@ declare const formats: {
   HTTP_HEADERS: typeof opentracing.FORMAT_HTTP_HEADERS
   BINARY: typeof opentracing.FORMAT_BINARY
   LOG: 'log'
+  TEXT_MAP_DSM: 'text_map_dsm'
 }
 
 export = formats

package/ext/formats.js

@@ -4,5 +4,6 @@ module.exports = {
   TEXT_MAP: 'text_map',
   HTTP_HEADERS: 'http_headers',
   BINARY: 'binary',
-  LOG: 'log'
+  LOG: 'log',
+  TEXT_MAP_DSM: 'text_map_dsm'
 }

package/index.d.ts

@@ -1837,9 +1837,10 @@ declare namespace tracer {
       /**
        * Construct a new TracerProvider to register with @opentelemetry/api
        *
+       * @param config Configuration object for the TracerProvider
        * @returns TracerProvider A TracerProvider instance
        */
-      new(): TracerProvider;
+      new(config?: Record<string, unknown>): TracerProvider;
 
       /**
        * Returns a Tracer, creating one if one with the given name and version is

package/init.js

@@ -2,22 +2,10 @@
 
 const path = require('path')
 const Module = require('module')
-const telemetry = require('./packages/dd-trace/src/telemetry/init-telemetry')
 const semver = require('semver')
-
-function isTrue (envVar) {
-  return ['1', 'true', 'True'].includes(envVar)
-}
-
-// eslint-disable-next-line no-console
-let log = { info: isTrue(process.env.DD_TRACE_DEBUG) ? console.log : () => {} }
-if (semver.satisfies(process.versions.node, '>=16')) {
-  const Config = require('./packages/dd-trace/src/config')
-  log = require('./packages/dd-trace/src/log')
-
-  // eslint-disable-next-line no-new
-  new Config() // we need this to initialize the logger
-}
+const log = require('./packages/dd-trace/src/log')
+const { isTrue } = require('./packages/dd-trace/src/util')
+const telemetry = require('./packages/dd-trace/src/telemetry/init-telemetry')
 
 let initBailout = false
 let clobberBailout = false

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "4.43.0",
+  "version": "4.45.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -33,6 +33,7 @@
     "test:profiler": "tap \"packages/dd-trace/test/profiling/**/*.spec.js\"",
     "test:profiler:ci": "npm run test:profiler -- --coverage --nyc-arg=--include=\"packages/dd-trace/src/profiling/**/*.js\"",
     "test:integration": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/*.spec.js\"",
+    "test:integration:appsec": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/appsec/*.spec.js\"",
     "test:integration:cucumber": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cucumber/*.spec.js\"",
     "test:integration:cypress": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/cypress/*.spec.js\"",
     "test:integration:jest": "mocha --timeout 60000 -r \"packages/dd-trace/test/setup/core.js\" \"integration-tests/jest/*.spec.js\"",
@@ -72,8 +73,8 @@
   },
   "dependencies": {
     "@datadog/native-appsec": "8.0.1",
-    "@datadog/native-iast-rewriter": "2.3.1",
-    "@datadog/native-iast-taint-tracking": "3.0.0",
+    "@datadog/native-iast-rewriter": "2.4.1",
+    "@datadog/native-iast-taint-tracking": "3.1.0",
     "@datadog/native-metrics": "^2.0.0",
     "@datadog/pprof": "5.3.0",
     "@datadog/sketches-js": "^2.1.0",

package/packages/datadog-instrumentations/src/body-parser.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const shimmer = require('../../datadog-shimmer')
-const { channel, addHook } = require('./helpers/instrument')
+const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 
 const bodyParserReadCh = channel('datadog:body-parser:read:finish')
 
@@ -23,7 +23,19 @@ function publishRequestBodyAndNext (req, res, next) {
 addHook({
   name: 'body-parser',
   file: 'lib/read.js',
-  versions: ['>=1.4.0']
+  versions: ['>=1.4.0 <1.20.0']
+}, read => {
+  return shimmer.wrap(read, function (req, res, next) {
+    const nextResource = new AsyncResource('bound-anonymous-fn')
+    arguments[2] = nextResource.bind(publishRequestBodyAndNext(req, res, next))
+    return read.apply(this, arguments)
+  })
+})
+
+addHook({
+  name: 'body-parser',
+  file: 'lib/read.js',
+  versions: ['>=1.20.0']
 }, read => {
   return shimmer.wrap(read, function (req, res, next) {
     arguments[2] = publishRequestBodyAndNext(req, res, next)

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

@@ -28,6 +28,8 @@ const workerReportTraceCh = channel('ci:cucumber:worker-report:trace')
 
 const itrSkippedSuitesCh = channel('ci:cucumber:itr:skipped-suites')
 
+const getCodeCoverageCh = channel('ci:nyc:get-coverage')
+
 const {
   getCoveredFilenamesFromCoverage,
   resetCoverage,
@@ -356,10 +358,18 @@ function getWrappedStart (start, frameworkVersion, isParallel = false) {
 
     const success = await start.apply(this, arguments)
 
+    let untestedCoverage
+    if (getCodeCoverageCh.hasSubscribers) {
+      untestedCoverage = await getChannelPromise(getCodeCoverageCh)
+    }
+
     let testCodeCoverageLinesTotal
 
     if (global.__coverage__) {
       try {
+        if (untestedCoverage) {
+          originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
+        }
         testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
       } catch (e) {
         // ignore errors

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

@@ -72,7 +72,6 @@ module.exports = {
   'microgateway-core': () => require('../microgateway-core'),
   mocha: () => require('../mocha'),
   'mocha-each': () => require('../mocha'),
-  workerpool: () => require('../mocha'),
   moleculer: () => require('../moleculer'),
   mongodb: () => require('../mongodb'),
   'mongodb-core': () => require('../mongodb-core'),
@@ -89,6 +88,7 @@ module.exports = {
   'node:http2': () => require('../http2'),
   'node:https': () => require('../http'),
   'node:net': () => require('../net'),
+  nyc: () => require('../nyc'),
   oracledb: () => require('../oracledb'),
   openai: () => require('../openai'),
   paperplane: () => require('../paperplane'),
@@ -113,5 +113,6 @@ module.exports = {
   undici: () => require('../undici'),
   vitest: { esmFirst: true, fn: () => require('../vitest') },
   when: () => require('../when'),
-  winston: () => require('../winston')
+  winston: () => require('../winston'),
+  workerpool: () => require('../mocha')
 }

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

@@ -29,6 +29,10 @@ if (!disabledInstrumentations.has('fetch')) {
   require('../fetch')
 }
 
+if (!disabledInstrumentations.has('process')) {
+  require('../process')
+}
+
 const HOOK_SYMBOL = Symbol('hookExportsMap')
 
 if (DD_TRACE_DEBUG && DD_TRACE_DEBUG.toLowerCase() !== 'false') {
@@ -86,18 +90,22 @@ for (const packageName of names) {
       }
 
       if (matchesFile) {
-        const version = moduleVersion || getVersion(moduleBaseDir)
+        let version = moduleVersion
+        try {
+          version = version || getVersion(moduleBaseDir)
+        } catch (e) {
+          log.error(`Error getting version for "${name}": ${e.message}`)
+          log.error(e)
+          continue
+        }
         if (!Object.hasOwnProperty(namesAndSuccesses, name)) {
-          namesAndSuccesses[name] = {
-            success: false,
-            version
-          }
+          namesAndSuccesses[`${name}@${version}`] = false
         }
 
         if (matchVersion(version, versions)) {
           // Check if the hook already has a set moduleExport
           if (hook[HOOK_SYMBOL].has(moduleExports)) {
-            namesAndSuccesses[name].success = true
+            namesAndSuccesses[`${name}@${version}`] = true
             return moduleExports
           }
 
@@ -117,19 +125,20 @@ for (const packageName of names) {
               `integration_version:${version}`
             ])
           }
-          namesAndSuccesses[name].success = true
+          namesAndSuccesses[`${name}@${version}`] = true
         }
       }
     }
-    for (const name of Object.keys(namesAndSuccesses)) {
-      const { success, version } = namesAndSuccesses[name]
-      if (!success && !seenCombo.has(`${name}@${version}`)) {
+    for (const nameVersion of Object.keys(namesAndSuccesses)) {
+      const [name, version] = nameVersion.split('@')
+      const success = namesAndSuccesses[nameVersion]
+      if (!success && !seenCombo.has(nameVersion)) {
         telemetry('abort.integration', [
           `integration:${name}`,
           `integration_version:${version}`
         ])
-        log.info(`Found incompatible integration version: ${name}@${version}`)
-        seenCombo.add(`${name}@${version}`)
+        log.info(`Found incompatible integration version: ${nameVersion}`)
+        seenCombo.add(nameVersion)
       }
     }
 

package/packages/datadog-instrumentations/src/http/client.js

@@ -43,7 +43,9 @@ function patch (http, methodName) {
         return request.apply(this, arguments)
       }
 
-      const ctx = { args, http }
+      const abortController = new AbortController()
+
+      const ctx = { args, http, abortController }
 
       return startChannel.runStores(ctx, () => {
         let finished = false
@@ -107,6 +109,10 @@ function patch (http, methodName) {
             return emit.apply(this, arguments)
           }
 
+          if (abortController.signal.aborted) {
+            req.destroy(abortController.signal.reason || new Error('Aborted'))
+          }
+
           return req
         } catch (e) {
           ctx.error = e

package/packages/datadog-instrumentations/src/http/server.js

@@ -12,6 +12,7 @@ const errorServerCh = channel('apm:http:server:request:error')
 const finishServerCh = channel('apm:http:server:request:finish')
 const startWriteHeadCh = channel('apm:http:server:response:writeHead:start')
 const finishSetHeaderCh = channel('datadog:http:server:response:set-header:finish')
+const startSetHeaderCh = channel('datadog:http:server:response:set-header:start')
 
 const requestFinishedSet = new WeakSet()
 
@@ -24,6 +25,12 @@ addHook({ name: httpNames }, http => {
   shimmer.wrap(http.ServerResponse.prototype, 'writeHead', wrapWriteHead)
   shimmer.wrap(http.ServerResponse.prototype, 'write', wrapWrite)
   shimmer.wrap(http.ServerResponse.prototype, 'end', wrapEnd)
+  shimmer.wrap(http.ServerResponse.prototype, 'setHeader', wrapSetHeader)
+  shimmer.wrap(http.ServerResponse.prototype, 'removeHeader', wrapAppendOrRemoveHeader)
+  // Added in node v16.17.0
+  if (http.ServerResponse.prototype.appendHeader) {
+    shimmer.wrap(http.ServerResponse.prototype, 'appendHeader', wrapAppendOrRemoveHeader)
+  }
   return http
 })
 
@@ -65,9 +72,7 @@ function wrapEmit (emit) {
           // TODO: should this always return true ?
           return this.listenerCount(eventName) > 0
         }
-        if (finishSetHeaderCh.hasSubscribers) {
-          wrapSetHeader(res)
-        }
+
         return emit.apply(this, arguments)
       } catch (err) {
         errorServerCh.publish(err)
@@ -81,16 +86,6 @@ function wrapEmit (emit) {
   }
 }
 
-function wrapSetHeader (res) {
-  shimmer.wrap(res, 'setHeader', setHeader => {
-    return function (name, value) {
-      const setHeaderResult = setHeader.apply(this, arguments)
-      finishSetHeaderCh.publish({ name, value, res })
-      return setHeaderResult
-    }
-  })
-}
-
 function wrapWriteHead (writeHead) {
   return function wrappedWriteHead (statusCode, reason, obj) {
     if (!startWriteHeadCh.hasSubscribers) {
@@ -159,6 +154,48 @@ function wrapWrite (write) {
   }
 }
 
+function wrapSetHeader (setHeader) {
+  return function wrappedSetHeader (name, value) {
+    if (!startSetHeaderCh.hasSubscribers && !finishSetHeaderCh.hasSubscribers) {
+      return setHeader.apply(this, arguments)
+    }
+
+    if (startSetHeaderCh.hasSubscribers) {
+      const abortController = new AbortController()
+      startSetHeaderCh.publish({ res: this, abortController })
+
+      if (abortController.signal.aborted) {
+        return
+      }
+    }
+
+    const setHeaderResult = setHeader.apply(this, arguments)
+
+    if (finishSetHeaderCh.hasSubscribers) {
+      finishSetHeaderCh.publish({ name, value, res: this })
+    }
+
+    return setHeaderResult
+  }
+}
+
+function wrapAppendOrRemoveHeader (originalMethod) {
+  return function wrappedAppendOrRemoveHeader () {
+    if (!startSetHeaderCh.hasSubscribers) {
+      return originalMethod.apply(this, arguments)
+    }
+
+    const abortController = new AbortController()
+    startSetHeaderCh.publish({ res: this, abortController })
+
+    if (abortController.signal.aborted) {
+      return this
+    }
+
+    return originalMethod.apply(this, arguments)
+  }
+}
+
 function wrapEnd (end) {
   return function wrappedEnd () {
     if (!startWriteHeadCh.hasSubscribers) {

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

@@ -47,6 +47,7 @@ const config = {}
 
 // We'll preserve the original coverage here
 const originalCoverageMap = createCoverageMap()
+let untestedCoverage
 
 // test channels
 const testStartCh = channel('ci:mocha:test:start')
@@ -66,6 +67,8 @@ const testSessionStartCh = channel('ci:mocha:session:start')
 const testSessionFinishCh = channel('ci:mocha:session:finish')
 const itrSkippedSuitesCh = channel('ci:mocha:itr:skipped-suites')
 
+const getCodeCoverageCh = channel('ci:nyc:get-coverage')
+
 function getFilteredSuites (originalSuites) {
   return originalSuites.reduce((acc, suite) => {
     const testPath = getTestSuitePath(suite.file, process.cwd())
@@ -131,6 +134,9 @@ function getOnEndHandler (isParallel) {
     let testCodeCoverageLinesTotal
     if (global.__coverage__) {
       try {
+        if (untestedCoverage) {
+          originalCoverageMap.merge(fromCoverageMapToCoverage(untestedCoverage))
+        }
         testCodeCoverageLinesTotal = originalCoverageMap.getCoverageSummary().lines.pct
       } catch (e) {
         // ignore errors
@@ -153,6 +159,83 @@ function getOnEndHandler (isParallel) {
   })
 }
 
+function getExecutionConfiguration (runner, onFinishRequest) {
+  const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
+
+  const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
+    if (err) {
+      suitesToSkip = []
+    } else {
+      suitesToSkip = skippableSuites
+      itrCorrelationId = responseItrCorrelationId
+    }
+    // We remove the suites that we skip through ITR
+    const filteredSuites = getFilteredSuites(runner.suite.suites)
+    const { suitesToRun } = filteredSuites
+
+    isSuitesSkipped = suitesToRun.length !== runner.suite.suites.length
+
+    log.debug(
+      () => `${suitesToRun.length} out of ${runner.suite.suites.length} suites are going to run.`
+    )
+
+    runner.suite.suites = suitesToRun
+
+    skippedSuites = Array.from(filteredSuites.skippedSuites)
+
+    onFinishRequest()
+  }
+
+  const onReceivedKnownTests = ({ err, knownTests: receivedKnownTests }) => {
+    if (err) {
+      knownTests = []
+      isEarlyFlakeDetectionEnabled = false
+    } else {
+      knownTests = receivedKnownTests
+    }
+
+    if (isSuitesSkippingEnabled) {
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    } else {
+      onFinishRequest()
+    }
+  }
+
+  const onReceivedConfiguration = ({ err, libraryConfig }) => {
+    if (err || !skippableSuitesCh.hasSubscribers || !knownTestsCh.hasSubscribers) {
+      return onFinishRequest()
+    }
+
+    isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
+    isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
+    earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
+    isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
+
+    config.isEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
+    config.isSuitesSkippingEnabled = isSuitesSkippingEnabled
+    config.earlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
+    config.isFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
+
+    if (isEarlyFlakeDetectionEnabled) {
+      knownTestsCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedKnownTests)
+      })
+    } else if (isSuitesSkippingEnabled) {
+      skippableSuitesCh.publish({
+        onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+      })
+    } else {
+      onFinishRequest()
+    }
+  }
+
+  libraryConfigurationCh.publish({
+    onDone: mochaRunAsyncResource.bind(onReceivedConfiguration)
+  })
+}
+
 // In this hook we delay the execution with options.delay to grab library configuration,
 // skippable and known tests.
 // It is called but skipped in parallel mode.
@@ -161,7 +244,6 @@ addHook({
   versions: ['>=5.2.0'],
   file: 'lib/mocha.js'
 }, (Mocha) => {
-  const mochaRunAsyncResource = new AsyncResource('bound-anonymous-fn')
   shimmer.wrap(Mocha.prototype, 'run', run => function () {
     // Workers do not need to request any data, just run the tests
     if (!testStartCh.hasSubscribers || process.env.MOCHA_WORKER_ID || this.options.parallel) {
@@ -181,79 +263,17 @@ addHook({
       }
     })
 
-    const onReceivedSkippableSuites = ({ err, skippableSuites, itrCorrelationId: responseItrCorrelationId }) => {
-      if (err) {
-        suitesToSkip = []
-      } else {
-        suitesToSkip = skippableSuites
-        itrCorrelationId = responseItrCorrelationId
-      }
-      // We remove the suites that we skip through ITR
-      const filteredSuites = getFilteredSuites(runner.suite.suites)
-      const { suitesToRun } = filteredSuites
-
-      isSuitesSkipped = suitesToRun.length !== runner.suite.suites.length
-
-      log.debug(
-        () => `${suitesToRun.length} out of ${runner.suite.suites.length} suites are going to run.`
-      )
-
-      runner.suite.suites = suitesToRun
-
-      skippedSuites = Array.from(filteredSuites.skippedSuites)
-
-      global.run()
-    }
-
-    const onReceivedKnownTests = ({ err, knownTests: receivedKnownTests }) => {
-      if (err) {
-        knownTests = []
-        isEarlyFlakeDetectionEnabled = false
-      } else {
-        knownTests = receivedKnownTests
-      }
-
-      if (isSuitesSkippingEnabled) {
-        skippableSuitesCh.publish({
-          onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
-        })
-      } else {
-        global.run()
-      }
-    }
-
-    const onReceivedConfiguration = ({ err, libraryConfig }) => {
-      if (err || !skippableSuitesCh.hasSubscribers || !knownTestsCh.hasSubscribers) {
-        return global.run()
-      }
-
-      isEarlyFlakeDetectionEnabled = libraryConfig.isEarlyFlakeDetectionEnabled
-      isSuitesSkippingEnabled = libraryConfig.isSuitesSkippingEnabled
-      earlyFlakeDetectionNumRetries = libraryConfig.earlyFlakeDetectionNumRetries
-      isFlakyTestRetriesEnabled = libraryConfig.isFlakyTestRetriesEnabled
-
-      config.isEarlyFlakeDetectionEnabled = isEarlyFlakeDetectionEnabled
-      config.isSuitesSkippingEnabled = isSuitesSkippingEnabled
-      config.earlyFlakeDetectionNumRetries = earlyFlakeDetectionNumRetries
-      config.isFlakyTestRetriesEnabled = isFlakyTestRetriesEnabled
-
-      if (isEarlyFlakeDetectionEnabled) {
-        knownTestsCh.publish({
-          onDone: mochaRunAsyncResource.bind(onReceivedKnownTests)
-        })
-      } else if (isSuitesSkippingEnabled) {
-        skippableSuitesCh.publish({
-          onDone: mochaRunAsyncResource.bind(onReceivedSkippableSuites)
+    getExecutionConfiguration(runner, () => {
+      if (getCodeCoverageCh.hasSubscribers) {
+        getCodeCoverageCh.publish({
+          onDone: (receivedCodeCoverage) => {
+            untestedCoverage = receivedCodeCoverage
+            global.run()
+          }
         })
       } else {
         global.run()
       }
-    }
-
-    mochaRunAsyncResource.runInAsyncScope(() => {
-      libraryConfigurationCh.publish({
-        onDone: mochaRunAsyncResource.bind(onReceivedConfiguration)
-      })
     })
 
     return runner
@@ -395,9 +415,13 @@ addHook({
       }
 
       const asyncResource = testFileToSuiteAr.get(suite.file)
-      asyncResource.runInAsyncScope(() => {
-        testSuiteFinishCh.publish(status)
-      })
+      if (asyncResource) {
+        asyncResource.runInAsyncScope(() => {
+          testSuiteFinishCh.publish(status)
+        })
+      } else {
+        log.warn(() => `No AsyncResource found for suite ${suite.file}`)
+      }
     })
 
     return run.apply(this, arguments)
@@ -424,23 +448,29 @@ addHook({
   versions: ['>=6.0.0'],
   file: 'src/WorkerHandler.js'
 }, (workerHandlerPackage) => {
-  shimmer.wrap(workerHandlerPackage.prototype, 'exec', exec => function (message, [testSuiteAbsolutePath]) {
+  shimmer.wrap(workerHandlerPackage.prototype, 'exec', exec => function (_, path) {
     if (!testStartCh.hasSubscribers) {
       return exec.apply(this, arguments)
     }
+    if (!path?.length) {
+      return exec.apply(this, arguments)
+    }
+    const [testSuiteAbsolutePath] = path
+    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-    this.worker.on('message', function (message) {
+    function onMessage (message) {
       if (Array.isArray(message)) {
         const [messageCode, payload] = message
         if (messageCode === MOCHA_WORKER_TRACE_PAYLOAD_CODE) {
-          testSessionAsyncResource.runInAsyncScope(() => {
+          testSuiteAsyncResource.runInAsyncScope(() => {
             workerReportTraceCh.publish(payload)
           })
         }
       }
-    })
+    }
+
+    this.worker.on('message', onMessage)
 
-    const testSuiteAsyncResource = new AsyncResource('bound-anonymous-fn')
     testSuiteAsyncResource.runInAsyncScope(() => {
       testSuiteStartCh.publish({
         testSuiteAbsolutePath
@@ -455,12 +485,14 @@ addHook({
           testSuiteAsyncResource.runInAsyncScope(() => {
             testSuiteFinishCh.publish(status)
           })
+          this.worker.off('message', onMessage)
         },
         (err) => {
           testSuiteAsyncResource.runInAsyncScope(() => {
             testSuiteErrorCh.publish(err)
             testSuiteFinishCh.publish('fail')
           })
+          this.worker.off('message', onMessage)
         }
       )
       return promise
@@ -469,6 +501,7 @@ addHook({
         testSuiteErrorCh.publish(err)
         testSuiteFinishCh.publish('fail')
       })
+      this.worker.off('message', onMessage)
       throw err
     }
   })

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

@@ -0,0 +1,23 @@
+const { addHook, channel } = require('./helpers/instrument')
+const shimmer = require('../../datadog-shimmer')
+
+const codeCoverageWrapCh = channel('ci:nyc:wrap')
+
+addHook({
+  name: 'nyc',
+  versions: ['>=17']
+}, (nycPackage) => {
+  shimmer.wrap(nycPackage.prototype, 'wrap', wrap => async function () {
+    // Only relevant if the config `all` is set to true
+    try {
+      if (JSON.parse(process.env.NYC_CONFIG).all) {
+        codeCoverageWrapCh.publish(this)
+      }
+    } catch (e) {
+      // ignore errors
+    }
+
+    return wrap.apply(this, arguments)
+  })
+  return nycPackage
+})