dd-trace 5.21.0 → 5.23.0

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 {

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

@@ -88,12 +88,10 @@ function wrapMethod (method, path, type, hasPeer) {
     return method
   }
 
-  const wrapped = function () {
+  const wrapped = shimmer.wrapFunction(method, method => function () {
     const args = ensureMetadata(this, arguments, 1)
     return callMethod(this, method, args, path, args[1], type, hasPeer)
-  }
-
-  Object.assign(wrapped, method)
+  })
 
   patched.add(wrapped)
 
@@ -101,7 +99,7 @@ function wrapMethod (method, path, type, hasPeer) {
 }
 
 function wrapCallback (ctx, callback = () => { }) {
-  return function (err) {
+  return shimmer.wrapFunction(callback, callback => function (err) {
     if (err) {
       ctx.error = err
       errorChannel.publish(ctx)
@@ -111,7 +109,7 @@ function wrapCallback (ctx, callback = () => { }) {
       return callback.apply(this, arguments)
       // No async end channel needed
     })
-  }
+  })
 }
 
 function createWrapEmit (ctx, hasPeer = false) {

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

@@ -119,7 +119,7 @@ function wrapStream (call, ctx, onCancel) {
 }
 
 function wrapCallback (callback = () => {}, call, ctx, onCancel) {
-  return function (err, value, trailer, flags) {
+  return shimmer.wrapFunction(callback, callback => function (err, value, trailer, flags) {
     if (err) {
       ctx.error = err
       errorChannel.publish(ctx)
@@ -136,7 +136,7 @@ function wrapCallback (callback = () => {}, call, ctx, onCancel) {
       return callback.apply(this, arguments)
       // No async end channel needed
     })
-  }
+  })
 }
 
 function wrapSendStatus (sendStatus, ctx) {

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

@@ -1,12 +1,13 @@
 'use strict'
 
+const tracingChannel = require('dc-polyfill').tracingChannel
 const shimmer = require('../../datadog-shimmer')
-const { addHook, channel, AsyncResource } = require('./helpers/instrument')
+const { addHook, channel } = require('./helpers/instrument')
 
 const handleChannel = channel('apm:hapi:request:handle')
 const routeChannel = channel('apm:hapi:request:route')
 const errorChannel = channel('apm:hapi:request:error')
-const enterChannel = channel('apm:hapi:extension:enter')
+const hapiTracingChannel = tracingChannel('apm:hapi:extension')
 
 function wrapServer (server) {
   return function (options) {
@@ -27,17 +28,17 @@ function wrapServer (server) {
 }
 
 function wrapStart (start) {
-  return function () {
+  return shimmer.wrapFunction(start, start => function () {
     if (this && typeof this.ext === 'function') {
       this.ext('onPreResponse', onPreResponse)
     }
 
     return start.apply(this, arguments)
-  }
+  })
 }
 
 function wrapExt (ext) {
-  return function (events, method, options) {
+  return shimmer.wrapFunction(ext, ext => function (events, method, options) {
     if (events !== null && typeof events === 'object') {
       arguments[0] = wrapEvents(events)
     } else {
@@ -45,7 +46,7 @@ function wrapExt (ext) {
     }
 
     return ext.apply(this, arguments)
-  }
+  })
 }
 
 function wrapDispatch (dispatch) {
@@ -91,19 +92,15 @@ function wrapEvents (events) {
 function wrapHandler (handler) {
   if (typeof handler !== 'function') return handler
 
-  return function (request, h) {
+  return shimmer.wrapFunction(handler, handler => function (request, h) {
     const req = request && request.raw && request.raw.req
 
     if (!req) return handler.apply(this, arguments)
 
-    const asyncResource = new AsyncResource('bound-anonymous-fn')
-
-    return asyncResource.runInAsyncScope(() => {
-      enterChannel.publish({ req })
-
+    return hapiTracingChannel.traceSync(() => {
       return handler.apply(this, arguments)
     })
-  }
+  })
 }
 
 function onPreResponse (request, h) {

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

@@ -98,7 +98,7 @@ for (const packageName of names) {
           log.error(e)
           continue
         }
-        if (!Object.hasOwnProperty(namesAndSuccesses, name)) {
+        if (typeof namesAndSuccesses[`${name}@${version}`] === 'undefined') {
           namesAndSuccesses[`${name}@${version}`] = false
         }
 

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

@@ -52,11 +52,11 @@ function patch (http, methodName) {
         let callback = args.callback
 
         if (callback) {
-          callback = function () {
+          callback = shimmer.wrapFunction(args.callback, cb => function () {
             return asyncStartChannel.runStores(ctx, () => {
-              return args.callback.apply(this, arguments)
+              return cb.apply(this, arguments)
             })
-          }
+          })
         }
 
         const options = args.options

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

@@ -12,8 +12,7 @@ const {
   getTestParametersString,
   addEfdStringToTestName,
   removeEfdStringFromTestName,
-  getIsFaultyEarlyFlakeDetection,
-  NUM_FAILED_TEST_RETRIES
+  getIsFaultyEarlyFlakeDetection
 } = require('../../dd-trace/src/plugins/util/test')
 const {
   getFormattedJestTestParameters,
@@ -132,6 +131,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
 
       this.isEarlyFlakeDetectionEnabled = this.testEnvironmentOptions._ddIsEarlyFlakeDetectionEnabled
       this.isFlakyTestRetriesEnabled = this.testEnvironmentOptions._ddIsFlakyTestRetriesEnabled
+      this.flakyTestRetriesCount = this.testEnvironmentOptions._ddFlakyTestRetriesCount
 
       if (this.isEarlyFlakeDetectionEnabled) {
         const hasKnownTests = !!knownTests.jest
@@ -149,7 +149,7 @@ function getWrappedEnvironment (BaseEnvironment, jestVersion) {
       if (this.isFlakyTestRetriesEnabled) {
         const currentNumRetries = this.global[RETRY_TIMES]
         if (!currentNumRetries) {
-          this.global[RETRY_TIMES] = NUM_FAILED_TEST_RETRIES
+          this.global[RETRY_TIMES] = this.flakyTestRetriesCount
         }
       }
     }
@@ -404,7 +404,7 @@ addHook({
 
 addHook({
   name: '@jest/test-sequencer',
-  versions: ['>=24.8.0']
+  versions: ['>=28']
 }, (sequencerPackage, frameworkVersion) => {
   shimmer.wrap(sequencerPackage.default.prototype, 'shard', shard => function () {
     const shardedTests = shard.apply(this, arguments)
@@ -638,7 +638,7 @@ addHook({
 
 function jestAdapterWrapper (jestAdapter, jestVersion) {
   const adapter = jestAdapter.default ? jestAdapter.default : jestAdapter
-  const newAdapter = shimmer.wrap(adapter, function () {
+  const newAdapter = shimmer.wrapFunction(adapter, adapter => function () {
     const environment = arguments[2]
     if (!environment) {
       return adapter.apply(this, arguments)
@@ -648,6 +648,7 @@ function jestAdapterWrapper (jestAdapter, jestVersion) {
       testSuiteStartCh.publish({
         testSuite: environment.testSuite,
         testEnvironmentOptions: environment.testEnvironmentOptions,
+        testSourceFile: environment.testSourceFile,
         displayName: environment.displayName,
         frameworkVersion: jestVersion
       })
@@ -765,6 +766,7 @@ addHook({
       _ddTestModuleId,
       _ddTestSessionId,
       _ddTestCommand,
+      _ddTestSessionName,
       _ddForcedToRun,
       _ddUnskippable,
       _ddItrCorrelationId,
@@ -773,6 +775,7 @@ addHook({
       _ddEarlyFlakeDetectionNumRetries,
       _ddRepositoryRoot,
       _ddIsFlakyTestRetriesEnabled,
+      _ddFlakyTestRetriesCount,
       ...restOfTestEnvironmentOptions
     } = testEnvironmentOptions
 

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

@@ -17,6 +17,10 @@ const consumerCommitCh = channel('apm:kafkajs:consume:commit')
 const consumerFinishCh = channel('apm:kafkajs:consume:finish')
 const consumerErrorCh = channel('apm:kafkajs:consume:error')
 
+const batchConsumerStartCh = channel('apm:kafkajs:consume-batch:start')
+const batchConsumerFinishCh = channel('apm:kafkajs:consume-batch:finish')
+const batchConsumerErrorCh = channel('apm:kafkajs:consume-batch:error')
+
 function commitsFromEvent (event) {
   const { payload: { groupId, topics } } = event
   const commitList = []
@@ -96,6 +100,17 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
       return createConsumer.apply(this, arguments)
     }
 
+    const eachMessageExtractor = (args) => {
+      const { topic, partition, message } = args[0]
+      return { topic, partition, message, groupId }
+    }
+
+    const eachBatchExtractor = (args) => {
+      const { batch } = args[0]
+      const { topic, partition, messages } = batch
+      return { topic, partition, messages, groupId }
+    }
+
     const consumer = createConsumer.apply(this, arguments)
 
     consumer.on(consumer.events.COMMIT_OFFSETS, commitsFromEvent)
@@ -103,43 +118,64 @@ addHook({ name: 'kafkajs', file: 'src/index.js', versions: ['>=1.4'] }, (BaseKaf
     const run = consumer.run
 
     const groupId = arguments[0].groupId
-    consumer.run = function ({ eachMessage, ...runArgs }) {
-      if (typeof eachMessage !== 'function') return run({ eachMessage, ...runArgs })
+    consumer.run = function ({ eachMessage, eachBatch, ...runArgs }) {
+      eachMessage = wrapFunction(
+        eachMessage,
+        consumerStartCh,
+        consumerFinishCh,
+        consumerErrorCh,
+        eachMessageExtractor
+      )
+
+      eachBatch = wrapFunction(
+        eachBatch,
+        batchConsumerStartCh,
+        batchConsumerFinishCh,
+        batchConsumerErrorCh,
+        eachBatchExtractor
+      )
 
       return run({
-        eachMessage: function (...eachMessageArgs) {
-          const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
-          return innerAsyncResource.runInAsyncScope(() => {
-            const { topic, partition, message } = eachMessageArgs[0]
-            consumerStartCh.publish({ topic, partition, message, groupId })
-            try {
-              const result = eachMessage.apply(this, eachMessageArgs)
-              if (result && typeof result.then === 'function') {
-                result.then(
-                  innerAsyncResource.bind(() => consumerFinishCh.publish(undefined)),
-                  innerAsyncResource.bind(err => {
-                    if (err) {
-                      consumerErrorCh.publish(err)
-                    }
-                    consumerFinishCh.publish(undefined)
-                  })
-                )
-              } else {
-                consumerFinishCh.publish(undefined)
-              }
-
-              return result
-            } catch (e) {
-              consumerErrorCh.publish(e)
-              consumerFinishCh.publish(undefined)
-              throw e
-            }
-          })
-        },
+        eachMessage,
+        eachBatch,
         ...runArgs
       })
     }
+
     return consumer
   })
   return Kafka
 })
+
+const wrapFunction = (fn, startCh, finishCh, errorCh, extractArgs) => {
+  return typeof fn === 'function'
+    ? function (...args) {
+      const innerAsyncResource = new AsyncResource('bound-anonymous-fn')
+      return innerAsyncResource.runInAsyncScope(() => {
+        const extractedArgs = extractArgs(args)
+        startCh.publish(extractedArgs)
+        try {
+          const result = fn.apply(this, args)
+          if (result && typeof result.then === 'function') {
+            result.then(
+              innerAsyncResource.bind(() => finishCh.publish(undefined)),
+              innerAsyncResource.bind(err => {
+                if (err) {
+                  errorCh.publish(err)
+                }
+                finishCh.publish(undefined)
+              })
+            )
+          } else {
+            finishCh.publish(undefined)
+          }
+          return result
+        } catch (e) {
+          errorCh.publish(e)
+          finishCh.publish(undefined)
+          throw e
+        }
+      })
+    }
+    : fn
+}

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

@@ -81,8 +81,8 @@ addHook({
 function wrapCallbackWithFinish (callback, finish) {
   if (typeof callback !== 'function') return callback
 
-  return function () {
+  return shimmer.wrapFunction(callback, callback => function () {
     finish()
     callback.apply(this, arguments)
-  }
+  })
 }

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

@@ -71,7 +71,7 @@ function wrapStack (layer) {
 
     middleware = original || middleware
 
-    const handler = shimmer.wrap(middleware, wrapMiddleware(middleware, layer))
+    const handler = shimmer.wrapFunction(middleware, middleware => wrapMiddleware(middleware, layer))
 
     originals.set(handler, middleware)
 
@@ -84,7 +84,7 @@ function wrapMiddleware (fn, layer) {
 
   const name = fn.name
 
-  return function (ctx, next) {
+  return shimmer.wrapFunction(fn, fn => function (ctx, next) {
     if (!ctx || !enterChannel.hasSubscribers) return fn.apply(this, arguments)
 
     const req = ctx.req
@@ -122,7 +122,7 @@ function wrapMiddleware (fn, layer) {
     } finally {
       exitChannel.publish({ req })
     }
-  }
+  })
 }
 
 function fulfill (ctx, error) {
@@ -142,11 +142,11 @@ function fulfill (ctx, error) {
 }
 
 function wrapNext (req, next) {
-  return function () {
+  return shimmer.wrapFunction(next, next => function () {
     nextChannel.publish({ req })
 
     return next.apply(this, arguments)
-  }
+  })
 }
 
 addHook({ name: 'koa', versions: ['>=2'] }, Koa => {

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

@@ -77,7 +77,7 @@ addHook({ name: 'ldapjs', versions: ['>=2'] }, ldapjs => {
     if (callbackIndex > -1) {
       const callback = arguments[callbackIndex]
       // eslint-disable-next-line n/handle-callback-err
-      arguments[callbackIndex] = shimmer.wrap(callback, function (err, corkedEmitter) {
+      arguments[callbackIndex] = shimmer.wrapFunction(callback, callback => function (err, corkedEmitter) {
         if (corkedEmitter !== null && typeof corkedEmitter === 'object' && typeof corkedEmitter.on === 'function') {
           wrapEmitter(corkedEmitter)
         }

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

@@ -11,7 +11,7 @@ const skipCh = channel('apm:mariadb:pool:skip')
 const unskipCh = channel('apm:mariadb:pool:unskip')
 
 function wrapCommandStart (start, callbackResource) {
-  return function () {
+  return shimmer.wrapFunction(start, start => function () {
     if (!startCh.hasSubscribers) return start.apply(this, arguments)
 
     const resolve = callbackResource.bind(this.resolve)
@@ -44,7 +44,7 @@ function wrapCommandStart (start, callbackResource) {
       startCh.publish({ sql: this.sql, conf: this.opts })
       return start.apply(this, arguments)
     })
-  }
+  })
 }
 
 function wrapCommand (Command) {
@@ -98,7 +98,7 @@ function createWrapQueryCallback (options) {
         arguments.length = arguments.length + 1
       }
 
-      arguments[arguments.length - 1] = asyncResource.bind(function (err) {
+      arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => asyncResource.bind(function (err) {
         if (err) {
           errorCh.publish(err)
         }
@@ -108,7 +108,7 @@ function createWrapQueryCallback (options) {
         if (typeof cb === 'function') {
           return callbackResource.runInAsyncScope(() => cb.apply(this, arguments))
         }
-      })
+      }))
 
       return asyncResource.runInAsyncScope(() => {
         startCh.publish({ sql, conf: options })
@@ -119,7 +119,7 @@ function createWrapQueryCallback (options) {
   }
 }
 
-function wrapConnection (Connection, promiseMethod) {
+function wrapConnection (promiseMethod, Connection) {
   return function (options) {
     Connection.apply(this, arguments)
 
@@ -170,13 +170,13 @@ addHook({ name, file: 'lib/pool.js', versions: ['>=3'] }, (Pool) => {
 })
 
 addHook({ name, file: 'lib/connection.js', versions: ['>=2.5.2 <3'] }, (Connection) => {
-  return shimmer.wrap(Connection, wrapConnection(Connection, '_queryPromise'))
+  return shimmer.wrapFunction(Connection, wrapConnection.bind(null, '_queryPromise'))
 })
 
 addHook({ name, file: 'lib/connection.js', versions: ['>=2.0.4 <=2.5.1'] }, (Connection) => {
-  return shimmer.wrap(Connection, wrapConnection(Connection, 'query'))
+  return shimmer.wrapFunction(Connection, wrapConnection.bind(null, 'query'))
 })
 
 addHook({ name, file: 'lib/pool-base.js', versions: ['>=2.0.4 <3'] }, (PoolBase) => {
-  return shimmer.wrap(PoolBase, wrapPoolBase(PoolBase))
+  return shimmer.wrapFunction(PoolBase, wrapPoolBase)
 })

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

@@ -26,14 +26,14 @@ addHook({ name: 'memcached', versions: ['>=2.2'] }, Memcached => {
       const query = queryCompiler.apply(this, arguments)
       const callback = callbackResource.bind(query.callback)
 
-      query.callback = asyncResource.bind(function (err) {
+      query.callback = shimmer.wrapFunction(callback, callback => asyncResource.bind(function (err) {
         if (err) {
           errorCh.publish(err)
         }
         finishCh.publish()
 
         return callback.apply(this, arguments)
-      })
+      }))
       startCh.publish({ client, server, query })
 
       return query

package/packages/datadog-instrumentations/src/microgateway-core.js

@@ -8,7 +8,9 @@ const routeChannel = channel('apm:microgateway-core:request:route')
 const errorChannel = channel('apm:microgateway-core:request:error')
 
 const name = 'microgateway-core'
-const versions = ['>=2.1']
+
+// TODO Remove " <=3.0.0" when "volos-util-apigee" module is fixed
+const versions = ['>=2.1 <=3.0.0']
 const requestResources = new WeakMap()
 
 function wrapConfigProxyFactory (configProxyFactory) {
@@ -40,7 +42,7 @@ function wrapPluginsFactory (pluginsFactory) {
 }
 
 function wrapNext (req, res, next) {
-  return function nextWithTrace (err) {
+  return shimmer.wrapFunction(next, next => function nextWithTrace (err) {
     const requestResource = requestResources.get(req)
 
     requestResource.runInAsyncScope(() => {
@@ -54,13 +56,13 @@ function wrapNext (req, res, next) {
     })
 
     return next.apply(this, arguments)
-  }
+  })
 }
 
 addHook({ name, versions, file: 'lib/config-proxy-middleware.js' }, configProxyFactory => {
-  return shimmer.wrap(configProxyFactory, wrapConfigProxyFactory(configProxyFactory))
+  return shimmer.wrapFunction(configProxyFactory, wrapConfigProxyFactory)
 })
 
 addHook({ name, versions, file: 'lib/plugins-middleware.js' }, pluginsFactory => {
-  return shimmer.wrap(pluginsFactory, wrapPluginsFactory(pluginsFactory))
+  return shimmer.wrapFunction(pluginsFactory, wrapPluginsFactory)
 })

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

@@ -15,7 +15,7 @@ addHook({
 
   patched.add(mochaEach)
 
-  return shimmer.wrap(mochaEach, function () {
+  return shimmer.wrapFunction(mochaEach, mochaEach => function () {
     const [params] = arguments
     const { it, ...rest } = mochaEach.apply(this, arguments)
     return {