dd-trace 5.20.0 → 5.22.0

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.20.0",
+  "version": "5.22.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -72,9 +72,9 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@datadog/native-appsec": "8.0.1",
-    "@datadog/native-iast-rewriter": "2.4.0",
-    "@datadog/native-iast-taint-tracking": "3.0.0",
+    "@datadog/native-appsec": "8.1.1",
+    "@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",
@@ -103,10 +103,10 @@
     "tlhunter-sorted-set": "^0.1.0"
   },
   "devDependencies": {
-    "@types/node": ">=18",
+    "@types/node": "^16.18.103",
     "autocannon": "^4.5.2",
     "aws-sdk": "^2.1446.0",
-    "axios": "^1.6.7",
+    "axios": "^1.7.4",
     "benchmark": "^2.1.4",
     "body-parser": "^1.20.2",
     "chai": "^4.3.7",

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

@@ -43,5 +43,5 @@ addHook({
   versions: ['^3.16.2', '4', '5']
 },
 commandFactory => {
-  return shimmer.wrap(commandFactory, wrapCreateCommand(commandFactory))
+  return shimmer.wrapFunction(commandFactory, f => wrapCreateCommand(f))
 })

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

@@ -55,7 +55,7 @@ function apolloExpress4Hook (express4) {
     return function expressMiddleware (server, options) {
       const originalMiddleware = originalExpressMiddleware.apply(this, arguments)
 
-      return shimmer.wrap(originalMiddleware, function (req, res, next) {
+      return shimmer.wrapFunction(originalMiddleware, originalMiddleware => function (req, res, next) {
         if (!graphqlMiddlewareChannel.start.hasSubscribers) {
           return originalMiddleware.apply(this, arguments)
         }

package/packages/datadog-instrumentations/src/aws-sdk.js

@@ -75,7 +75,7 @@ function wrapSmithySend (send) {
       })
 
       if (typeof cb === 'function') {
-        args[args.length - 1] = function (err, result) {
+        args[args.length - 1] = shimmer.wrapFunction(cb, cb => function (err, result) {
           const message = getMessage(request, err, result)
 
           completeChannel.publish(message)
@@ -89,7 +89,7 @@ function wrapSmithySend (send) {
               responseFinishChannel.publish(message.response.error)
             }
           })
-        }
+        })
       } else { // always a promise
         return send.call(this, command, ...args)
           .then(
@@ -113,7 +113,7 @@ function wrapSmithySend (send) {
 
 function wrapCb (cb, serviceName, request, ar) {
   // eslint-disable-next-line n/handle-callback-err
-  return function wrappedCb (err, response) {
+  return shimmer.wrapFunction(cb, cb => function wrappedCb (err, response) {
     const obj = { request, response }
     return ar.runInAsyncScope(() => {
       channel(`apm:aws:response:start:${serviceName}`).publish(obj)
@@ -141,7 +141,7 @@ function wrapCb (cb, serviceName, request, ar) {
         throw e
       }
     })
-  }
+  })
 }
 
 function getMessage (request, error, result) {

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

@@ -1,12 +1,12 @@
 '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')
 
 function publishRequestBodyAndNext (req, res, next) {
-  return function () {
+  return shimmer.wrapFunction(next, next => function () {
     if (bodyParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const body = req.body
@@ -17,15 +17,27 @@ function publishRequestBodyAndNext (req, res, next) {
     }
 
     return next.apply(this, arguments)
-  }
+  })
 }
 
 addHook({
   name: 'body-parser',
   file: 'lib/read.js',
-  versions: ['>=1.4.0']
+  versions: ['>=1.4.0 <1.20.0']
+}, read => {
+  return shimmer.wrapFunction(read, 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) {
+  return shimmer.wrapFunction(read, read => function (req, res, next) {
     arguments[2] = publishRequestBodyAndNext(req, res, next)
     return read.apply(this, arguments)
   })

package/packages/datadog-instrumentations/src/cassandra-driver.js

@@ -180,12 +180,12 @@ function finish (finishCh, errorCh, error) {
 }
 
 function wrapCallback (finishCh, errorCh, asyncResource, callback) {
-  return asyncResource.bind(function (err) {
+  return shimmer.wrapFunction(callback, callback => asyncResource.bind(function (err) {
     finish(finishCh, errorCh, err)
     if (callback) {
       return callback.apply(this, arguments)
     }
-  })
+  }))
 }
 
 function isRequestValid (exec, args, length) {

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

@@ -133,8 +133,8 @@ function wrapChildProcessAsyncMethod (shell = false) {
 
     if (childProcessMethod[util.promisify.custom]) {
       const wrapedChildProcessCustomPromisifyMethod =
-        shimmer.wrap(childProcessMethod[util.promisify.custom],
-          wrapChildProcessCustomPromisifyMethod(childProcessMethod[util.promisify.custom]), shell)
+        shimmer.wrapFunction(childProcessMethod[util.promisify.custom],
+          promisify => wrapChildProcessCustomPromisifyMethod(promisify, shell))
 
       // should do it in this way because the original property is readonly
       const descriptor = Object.getOwnPropertyDescriptor(childProcessMethod, util.promisify.custom)

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

@@ -59,7 +59,7 @@ function wrapLayerHandle (layer) {
 
   const original = layer.handle
 
-  return shimmer.wrap(original, function () {
+  return shimmer.wrapFunction(original, original => function () {
     if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
 
     const lastIndex = arguments.length - 1
@@ -90,7 +90,7 @@ function wrapLayerHandle (layer) {
 }
 
 function wrapNext (req, next) {
-  return function (error) {
+  return shimmer.wrapFunction(next, next => function (error) {
     if (error) {
       errorChannel.publish({ req, error })
     }
@@ -99,11 +99,11 @@ function wrapNext (req, next) {
     finishChannel.publish({ req })
 
     next.apply(this, arguments)
-  }
+  })
 }
 
 addHook({ name: 'connect', versions: ['>=3'] }, connect => {
-  return shimmer.wrap(connect, wrapConnect(connect))
+  return shimmer.wrapFunction(connect, connect => wrapConnect(connect))
 })
 
 addHook({ name: 'connect', versions: ['2.2.2'] }, connect => {

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

@@ -6,7 +6,7 @@ const { channel, addHook } = require('./helpers/instrument')
 const cookieParserReadCh = channel('datadog:cookie-parser:read:finish')
 
 function publishRequestCookieAndNext (req, res, next) {
-  return function cookieParserWrapper () {
+  return shimmer.wrapFunction(next, next => function cookieParserWrapper () {
     if (cookieParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
 
@@ -18,17 +18,17 @@ function publishRequestCookieAndNext (req, res, next) {
     }
 
     return next.apply(this, arguments)
-  }
+  })
 }
 
 addHook({
   name: 'cookie-parser',
   versions: ['>=1.0.0']
 }, cookieParser => {
-  return shimmer.wrap(cookieParser, function () {
+  return shimmer.wrapFunction(cookieParser, cookieParser => function () {
     const cookieMiddleware = cookieParser.apply(this, arguments)
 
-    return shimmer.wrap(cookieMiddleware, function (req, res, next) {
+    return shimmer.wrapFunction(cookieMiddleware, cookieMiddleware => function (req, res, next) {
       arguments[2] = publishRequestCookieAndNext(req, res, next)
       return cookieMiddleware.apply(this, arguments)
     })

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

@@ -37,7 +37,7 @@ function wrapMaybeInvoke (_maybeInvoke) {
 
     return _maybeInvoke.apply(this, arguments)
   }
-  return shimmer.wrap(_maybeInvoke, wrapped)
+  return wrapped
 }
 
 function wrapQuery (query) {
@@ -51,7 +51,7 @@ function wrapQuery (query) {
     const res = query.apply(this, arguments)
     return res
   }
-  return shimmer.wrap(query, wrapped)
+  return wrapped
 }
 
 function wrap (prefix, fn) {
@@ -76,13 +76,13 @@ function wrap (prefix, fn) {
 
       startCh.publish({ bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts })
 
-      arguments[callbackIndex] = asyncResource.bind(function (error, result) {
+      arguments[callbackIndex] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
         if (error) {
           errorCh.publish(error)
         }
         finishCh.publish(result)
         return cb.apply(this, arguments)
-      })
+      }))
 
       try {
         return fn.apply(this, arguments)
@@ -94,7 +94,7 @@ function wrap (prefix, fn) {
       }
     })
   }
-  return shimmer.wrap(fn, wrapped)
+  return wrapped
 }
 
 // semver >=3
@@ -118,13 +118,13 @@ function wrapCBandPromise (fn, name, startData, thisArg, args) {
         // v3 offers callback or promises event handling
         // NOTE: this does not work with v3.2.0-3.2.1 cluster.query, as there is a bug in the couchbase source code
         const cb = callbackResource.bind(args[cbIndex])
-        args[cbIndex] = asyncResource.bind(function (error, result) {
+        args[cbIndex] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
           if (error) {
             errorCh.publish(error)
           }
           finishCh.publish({ result })
           return cb.apply(thisArg, arguments)
-        })
+        }))
       }
       const res = fn.apply(thisArg, args)
 
@@ -166,8 +166,8 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
   const finishCh = channel('apm:couchbase:query:finish')
   const errorCh = channel('apm:couchbase:query:error')
 
-  Bucket.prototype._maybeInvoke = wrapMaybeInvoke(Bucket.prototype._maybeInvoke)
-  Bucket.prototype.query = wrapQuery(Bucket.prototype.query)
+  shimmer.wrap(Bucket.prototype, '_maybeInvoke', maybeInvoke => wrapMaybeInvoke(maybeInvoke))
+  shimmer.wrap(Bucket.prototype, 'query', query => wrapQuery(query))
 
   shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
     if (!startCh.hasSubscribers) {
@@ -203,15 +203,15 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
   })
 
   wrapAllNames(['upsert', 'insert', 'replace', 'append', 'prepend'], name => {
-    Bucket.prototype[name] = wrap(`apm:couchbase:${name}`, Bucket.prototype[name])
+    shimmer.wrap(Bucket.prototype, name, fn => wrap(`apm:couchbase:${name}`, fn))
   })
 
   return Bucket
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cluster => {
-  Cluster.prototype._maybeInvoke = wrapMaybeInvoke(Cluster.prototype._maybeInvoke)
-  Cluster.prototype.query = wrapQuery(Cluster.prototype.query)
+  shimmer.wrap(Cluster.prototype, '_maybeInvoke', maybeInvoke => wrapMaybeInvoke(maybeInvoke))
+  shimmer.wrap(Cluster.prototype, 'query', query => wrapQuery(query))
 
   shimmer.wrap(Cluster.prototype, 'openBucket', openBucket => {
     return function () {

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

@@ -1,7 +1,6 @@
 'use strict'
 const { createCoverageMap } = require('istanbul-lib-coverage')
 
-const { NUM_FAILED_TEST_RETRIES } = require('../../dd-trace/src/plugins/util/test')
 const { addHook, channel, AsyncResource } = require('./helpers/instrument')
 const shimmer = require('../../datadog-shimmer')
 const log = require('../../dd-trace/src/log')
@@ -28,6 +27,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,
@@ -64,6 +65,7 @@ let isSuitesSkippingEnabled = false
 let isEarlyFlakeDetectionEnabled = false
 let earlyFlakeDetectionNumRetries = 0
 let isFlakyTestRetriesEnabled = false
+let numTestRetries = 0
 let knownTests = []
 let skippedSuites = []
 let isSuitesSkipped = false
@@ -186,7 +188,7 @@ function wrapRun (pl, isLatestVersion) {
       testStartCh.publish(testStartPayload)
     })
     try {
-      this.eventBroadcaster.on('envelope', (testCase) => {
+      this.eventBroadcaster.on('envelope', shimmer.wrapFunction(null, () => (testCase) => {
         // Only supported from >=8.0.0
         if (testCase?.testCaseFinished) {
           const { testCaseFinished: { willBeRetried } } = testCase
@@ -204,7 +206,7 @@ function wrapRun (pl, isLatestVersion) {
             })
           }
         }
-      })
+      }))
       let promise
 
       asyncResource.runInAsyncScope(() => {
@@ -305,6 +307,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false) {
     earlyFlakeDetectionNumRetries = configurationResponse.libraryConfig?.earlyFlakeDetectionNumRetries
     isSuitesSkippingEnabled = configurationResponse.libraryConfig?.isSuitesSkippingEnabled
     isFlakyTestRetriesEnabled = configurationResponse.libraryConfig?.isFlakyTestRetriesEnabled
+    numTestRetries = configurationResponse.libraryConfig?.flakyTestRetriesCount
 
     if (isEarlyFlakeDetectionEnabled) {
       const knownTestsResponse = await getChannelPromise(knownTestsCh)
@@ -342,8 +345,8 @@ function getWrappedStart (start, frameworkVersion, isParallel = false) {
     const processArgv = process.argv.slice(2).join(' ')
     const command = process.env.npm_lifecycle_script || `cucumber-js ${processArgv}`
 
-    if (isFlakyTestRetriesEnabled && !this.options.retry) {
-      this.options.retry = NUM_FAILED_TEST_RETRIES
+    if (isFlakyTestRetriesEnabled && !this.options.retry && numTestRetries > 0) {
+      this.options.retry = numTestRetries
     }
 
     sessionAsyncResource.runInAsyncScope(() => {
@@ -356,10 +359,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/dns.js

@@ -21,16 +21,16 @@ const rrtypeMap = new WeakMap()
 const names = ['dns', 'node:dns']
 
 addHook({ name: names }, dns => {
-  dns.lookup = wrap('apm:dns:lookup', dns.lookup, 2)
-  dns.lookupService = wrap('apm:dns:lookup_service', dns.lookupService, 3)
-  dns.resolve = wrap('apm:dns:resolve', dns.resolve, 2)
-  dns.reverse = wrap('apm:dns:reverse', dns.reverse, 2)
+  shimmer.wrap(dns, 'lookup', fn => wrap('apm:dns:lookup', fn, 2))
+  shimmer.wrap(dns, 'lookupService', fn => wrap('apm:dns:lookup_service', fn, 2))
+  shimmer.wrap(dns, 'resolve', fn => wrap('apm:dns:resolve', fn, 2))
+  shimmer.wrap(dns, 'reverse', fn => wrap('apm:dns:reverse', fn, 2))
 
   patchResolveShorthands(dns)
 
   if (dns.Resolver) {
-    dns.Resolver.prototype.resolve = wrap('apm:dns:resolve', dns.Resolver.prototype.resolve, 2)
-    dns.Resolver.prototype.reverse = wrap('apm:dns:reverse', dns.Resolver.prototype.reverse, 2)
+    shimmer.wrap(dns.Resolver.prototype, 'resolve', fn => wrap('apm:dns:resolve', fn, 2))
+    shimmer.wrap(dns.Resolver.prototype, 'reverse', fn => wrap('apm:dns:reverse', fn, 2))
 
     patchResolveShorthands(dns.Resolver.prototype)
   }
@@ -43,7 +43,7 @@ function patchResolveShorthands (prototype) {
     .filter(method => !!prototype[method])
     .forEach(method => {
       rrtypeMap.set(prototype[method], rrtypes[method])
-      prototype[method] = wrap('apm:dns:resolve', prototype[method], 2, rrtypes[method])
+      shimmer.wrap(prototype, method, fn => wrap('apm:dns:resolve', fn, 2, rrtypes[method]))
     })
 }
 
@@ -72,13 +72,13 @@ function wrap (prefix, fn, expectedArgs, rrtype) {
     return asyncResource.runInAsyncScope(() => {
       startCh.publish(startArgs)
 
-      arguments[arguments.length - 1] = asyncResource.bind(function (error, result) {
+      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error, result) {
         if (error) {
           errorCh.publish(error)
         }
         finishCh.publish(result)
         cb.apply(this, arguments)
-      })
+      }))
 
       try {
         return fn.apply(this, arguments)
@@ -92,5 +92,5 @@ function wrap (prefix, fn, expectedArgs, rrtype) {
     })
   }
 
-  return shimmer.wrap(fn, wrapped)
+  return wrapped
 }

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

@@ -48,12 +48,12 @@ function createWrapSelect () {
     return function () {
       if (arguments.length === 1) {
         const cb = arguments[0]
-        arguments[0] = function (err, connection) {
+        arguments[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
           if (connectCh.hasSubscribers && connection && connection.host) {
             connectCh.publish({ hostname: connection.host.host, port: connection.host.port })
           }
           cb(err, connection)
-        }
+        })
       }
       return request.apply(this, arguments)
     }
@@ -86,10 +86,10 @@ function createWrapRequest (name) {
           if (typeof cb === 'function') {
             cb = parentResource.bind(cb)
 
-            arguments[lastIndex] = asyncResource.bind(function (error) {
+            arguments[lastIndex] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (error) {
               finish(params, error)
               return cb.apply(null, arguments)
-            })
+            }))
             return request.apply(this, arguments)
           } else {
             const promise = request.apply(this, arguments)

package/packages/datadog-instrumentations/src/express-mongo-sanitize.js

@@ -22,15 +22,15 @@ addHook({ name: 'express-mongo-sanitize', versions: ['>=1.0.0'] }, expressMongoS
     return sanitizedObject
   })
 
-  return shimmer.wrap(expressMongoSanitize, function () {
+  return shimmer.wrapFunction(expressMongoSanitize, expressMongoSanitize => function () {
     const middleware = expressMongoSanitize.apply(this, arguments)
 
-    return shimmer.wrap(middleware, function (req, res, next) {
+    return shimmer.wrapFunction(middleware, middleware => function (req, res, next) {
       if (!sanitizeMiddlewareFinished.hasSubscribers) {
         return middleware.apply(this, arguments)
       }
 
-      const wrappedNext = shimmer.wrap(next, function () {
+      const wrappedNext = shimmer.wrapFunction(next, next => function () {
         sanitizeMiddlewareFinished.publish({
           sanitizedProperties: propertiesToSanitize,
           req

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

@@ -49,7 +49,7 @@ addHook({ name: 'express', versions: ['>=4'] }, express => {
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 function publishQueryParsedAndNext (req, res, next) {
-  return function () {
+  return shimmer.wrapFunction(next, next => function () {
     if (queryParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const query = req.query
@@ -60,7 +60,7 @@ function publishQueryParsedAndNext (req, res, next) {
     }
 
     return next.apply(this, arguments)
-  }
+  })
 }
 
 addHook({
@@ -68,10 +68,10 @@ addHook({
   versions: ['>=4'],
   file: 'lib/middleware/query.js'
 }, query => {
-  return shimmer.wrap(query, function () {
+  return shimmer.wrapFunction(query, query => function () {
     const queryMiddleware = query.apply(this, arguments)
 
-    return shimmer.wrap(queryMiddleware, function (req, res, next) {
+    return shimmer.wrapFunction(queryMiddleware, queryMiddleware => function (req, res, next) {
       arguments[2] = publishQueryParsedAndNext(req, res, next)
       return queryMiddleware.apply(this, arguments)
     })

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

@@ -34,12 +34,12 @@ function wrapFastify (fastify, hasParsingEvents) {
 }
 
 function wrapAddHook (addHook) {
-  return function addHookWithTrace (name, fn) {
+  return shimmer.wrapFunction(addHook, addHook => function addHookWithTrace (name, fn) {
     fn = arguments[arguments.length - 1]
 
     if (typeof fn !== 'function') return addHook.apply(this, arguments)
 
-    arguments[arguments.length - 1] = shimmer.wrap(fn, function (request, reply, done) {
+    arguments[arguments.length - 1] = shimmer.wrapFunction(fn, fn => function (request, reply, done) {
       const req = getReq(request)
 
       try {
@@ -78,7 +78,7 @@ function wrapAddHook (addHook) {
     })
 
     return addHook.apply(this, arguments)
-  }
+  })
 }
 
 function onRequest (request, reply, done) {
@@ -151,7 +151,7 @@ function publishError (error, req) {
 }
 
 addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
-  const wrapped = shimmer.wrap(fastify, wrapFastify(fastify, true))
+  const wrapped = shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, true))
 
   wrapped.fastify = wrapped
   wrapped.default = wrapped
@@ -160,9 +160,9 @@ addHook({ name: 'fastify', versions: ['>=3'] }, fastify => {
 })
 
 addHook({ name: 'fastify', versions: ['2'] }, fastify => {
-  return shimmer.wrap(fastify, wrapFastify(fastify, true))
+  return shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, true))
 })
 
 addHook({ name: 'fastify', versions: ['1'] }, fastify => {
-  return shimmer.wrap(fastify, wrapFastify(fastify, false))
+  return shimmer.wrapFunction(fastify, fastify => wrapFastify(fastify, false))
 })

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

@@ -8,5 +8,5 @@ if (globalThis.fetch) {
   const ch = tracingChannel('apm:fetch:request')
   const wrapFetch = createWrapFetch(globalThis.Request, ch)
 
-  globalThis.fetch = shimmer.wrap(fetch, wrapFetch(fetch))
+  globalThis.fetch = shimmer.wrapFunction(fetch, fetch => wrapFetch(fetch))
 }

package/packages/datadog-instrumentations/src/find-my-way.js

@@ -9,11 +9,11 @@ function wrapOn (on) {
   return function onWithTrace (method, path, opts) {
     const index = typeof opts === 'function' ? 2 : 3
     const handler = arguments[index]
-    const wrapper = function (req) {
+    const wrapper = shimmer.wrapFunction(handler, handler => function (req) {
       routeChannel.publish({ req, route: path })
 
       return handler.apply(this, arguments)
-    }
+    })
 
     if (typeof handler === 'function') {
       arguments[index] = wrapper

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

@@ -271,7 +271,7 @@ function createWrapFunction (prefix = '', override = '') {
       if (cb) {
         const outerResource = new AsyncResource('bound-anonymous-fn')
 
-        arguments[lastIndex] = innerResource.bind(function (e) {
+        arguments[lastIndex] = shimmer.wrapFunction(cb, cb => innerResource.bind(function (e) {
           if (e !== null && typeof e === 'object') { // fs.exists receives a boolean
             errorChannel.publish(e)
           }
@@ -279,7 +279,7 @@ function createWrapFunction (prefix = '', override = '') {
           finishChannel.publish()
 
           return outerResource.runInAsyncScope(() => cb.apply(this, arguments))
-        })
+        }))
       }
 
       return innerResource.runInAsyncScope(() => {

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -76,7 +76,7 @@ function wrapMethod (method) {
       if (typeof cb === 'function') {
         const outerAsyncResource = new AsyncResource('bound-anonymous-fn')
 
-        arguments[arguments.length - 1] = innerAsyncResource.bind(function (error) {
+        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => innerAsyncResource.bind(function (error) {
           if (error) {
             requestErrorCh.publish(error)
           }
@@ -84,7 +84,7 @@ function wrapMethod (method) {
           requestFinishCh.publish()
 
           return outerAsyncResource.runInAsyncScope(() => cb.apply(this, arguments))
-        })
+        }))
 
         return method.apply(this, arguments)
       } else {