dd-trace 5.100.0 → 5.102.0

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

@@ -1,11 +1,15 @@
 'use strict'
 
+const { performance } = require('node:perf_hooks')
+
 // Capture real timers at module load time, before any test can install fake timers.
 const realSetTimeout = setTimeout
 
 const {
   getTestSuitePath,
   DYNAMIC_NAME_RE,
+  getEfdRetryCount,
+  getMaxEfdRetryCount,
   recordAttemptToFixExecution,
   logAttemptToFixTestExecution,
 } = require('../../../dd-trace/src/plugins/util/test')
@@ -35,6 +39,8 @@ const newTestsWithDynamicNames = new Set()
 const testsAttemptToFix = new Set()
 const testsQuarantined = new Set()
 const testsStatuses = new Map()
+const efdRetryCountByTestFullName = new Map()
+const efdSlowAbortedTests = new Set()
 const attemptToFixExecutions = new Map()
 const loggedAttemptToFixTests = new Set()
 
@@ -70,11 +76,82 @@ function isNewTest (test, knownTests) {
   return !testsForSuite.includes(testName)
 }
 
-function retryTest (test, numRetries, tags) {
+function setEfdRetryCountForTest (test, duration, slowTestRetries) {
+  const testName = getTestFullName(test)
+  if (efdRetryCountByTestFullName.has(testName)) {
+    return
+  }
+  const retryCount = getEfdRetryCount(duration, slowTestRetries || {})
+  efdRetryCountByTestFullName.set(testName, retryCount)
+  if (retryCount === 0) {
+    efdSlowAbortedTests.add(testName)
+  }
+}
+
+function wrapOriginalEfdTest (test, slowTestRetries) {
+  if (test._ddEfdDurationWrapped || typeof test.fn !== 'function') {
+    return
+  }
+  test._ddEfdDurationWrapped = true
+  const originalFn = test.fn
+  test.fn = shimmer.wrapFunction(originalFn, originalFn => function () {
+    const start = performance.now()
+    const recordDuration = () => {
+      setEfdRetryCountForTest(test, performance.now() - start, slowTestRetries)
+    }
+
+    if (originalFn.length > 0) {
+      const args = Array.prototype.slice.call(arguments)
+      args[0] = shimmer.wrapFunction(args[0], done => function (...args) {
+        recordDuration()
+        return done.apply(this, args)
+      })
+      return originalFn.apply(this, args)
+    }
+
+    try {
+      const result = originalFn.apply(this, arguments)
+      if (result?.then) {
+        return result.then(value => {
+          recordDuration()
+          return value
+        }, error => {
+          recordDuration()
+          throw error
+        })
+      }
+      recordDuration()
+      return result
+    } catch (error) {
+      recordDuration()
+      throw error
+    }
+  })
+}
+
+function retryTest (test, numRetries, tags, slowTestRetries) {
   const suite = test.parent
+  const isEfdRetry = tags.includes('_ddIsEfdRetry')
+  if (isEfdRetry) {
+    wrapOriginalEfdTest(test, slowTestRetries)
+  }
   for (let retryIndex = 0; retryIndex < numRetries; retryIndex++) {
     const clonedTest = test.clone()
     suite.addTest(clonedTest)
+    if (isEfdRetry) {
+      clonedTest._ddEfdRetryIndex = retryIndex + 1
+      const originalFn = clonedTest.fn
+      if (typeof originalFn === 'function') {
+        clonedTest.fn = shimmer.wrapFunction(originalFn, originalFn => function (...args) {
+          const efdRetryCount = efdRetryCountByTestFullName.get(getTestFullName(clonedTest))
+          if (efdRetryCount !== undefined && clonedTest._ddEfdRetryIndex > efdRetryCount) {
+            clonedTest._ddShouldSkipEfdRetry = true
+            this.skip()
+          }
+          return originalFn.apply(this, args)
+        })
+      }
+    }
     for (const tag of tags) {
       if (tag) {
         clonedTest[tag] = true
@@ -83,6 +160,14 @@ function retryTest (test, numRetries, tags) {
   }
 }
 
+function getConfiguredEfdRetryCount (config) {
+  const { earlyFlakeDetectionSlowTestRetries } = config
+  if (!earlyFlakeDetectionSlowTestRetries || !Object.keys(earlyFlakeDetectionSlowTestRetries).length) {
+    return config.earlyFlakeDetectionNumRetries
+  }
+  return getMaxEfdRetryCount(earlyFlakeDetectionSlowTestRetries)
+}
+
 function getSuitesByTestFile (root) {
   const suitesByTestFile = {}
   function getSuites (suite) {
@@ -137,8 +222,7 @@ function getTestToContextKey (test) {
   if (!wrappedFunctions.has(test.fn)) {
     return test.fn
   }
-  const originalFn = originalFns.get(test.fn)
-  return originalFn
+  return originalFns.get(test.fn)
 }
 
 function getTestContext (test) {
@@ -147,9 +231,9 @@ function getTestContext (test) {
 }
 
 function runnableWrapper (RunnablePackage, libraryConfig) {
-  shimmer.wrap(RunnablePackage.prototype, 'run', run => function () {
+  shimmer.wrap(RunnablePackage.prototype, 'run', run => function (...args) {
     if (!testFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
     if (libraryConfig?.isFlakyTestRetriesEnabled) {
       this.retries(libraryConfig?.flakyTestRetriesCount)
@@ -175,8 +259,8 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
 
       if (ctx) {
         // we bind the test fn to the correct context
-        const newFn = shimmer.wrapFunction(this.fn, originalFn => function () {
-          return testFnCh.runStores(ctx, () => originalFn.apply(this, arguments))
+        const newFn = shimmer.wrapFunction(this.fn, originalFn => function (...args) {
+          return testFnCh.runStores(ctx, () => originalFn.apply(this, args))
         })
 
         // we store the original function, not to lose it
@@ -187,7 +271,7 @@ function runnableWrapper (RunnablePackage, libraryConfig) {
       }
     }
 
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
   return RunnablePackage
 }
@@ -215,6 +299,17 @@ function getOnTestHandler (isMain) {
       _ddIsModified: isModified,
     } = test
 
+    test._ddStartTime = performance.now()
+
+    if (isEfdRetry) {
+      const efdRetryCount = efdRetryCountByTestFullName.get(getTestFullName(test))
+      if (efdRetryCount !== undefined && test._ddEfdRetryIndex > efdRetryCount) {
+        test.pending = true
+        test._ddShouldSkipEfdRetry = true
+        return
+      }
+    }
+
     const testInfo = {
       testName: test.fullTitle(),
       testSuiteAbsolutePath,
@@ -273,6 +368,7 @@ function getFinalStatus ({
   isAttemptToFix,
   isLastAttemptToFix,
   attemptToFixPassed,
+  hasPassedAnyEfdAttempt,
   isQuarantined,
   isDisabled,
 }) {
@@ -301,7 +397,7 @@ function getFinalStatus ({
     return hasFailedAllRetries ? 'fail' : 'pass'
   }
   if (isEfdRetry && isLastEfdRetry) {
-    return hasFailedAllRetries ? 'fail' : 'pass'
+    return hasPassedAnyEfdAttempt ? 'pass' : 'fail'
   }
   if (isAttemptToFix && isLastAttemptToFix) {
     return attemptToFixPassed ? 'pass' : 'fail'
@@ -314,6 +410,15 @@ function getTestFinishInfo (test, status, config, error) {
   let attemptToFixFailed = false
 
   const testName = getTestFullName(test)
+  if (
+    config.isEarlyFlakeDetectionEnabled &&
+    (test._ddIsNew || test._ddIsModified) &&
+    !test._ddIsEfdRetry &&
+    !efdRetryCountByTestFullName.has(testName)
+  ) {
+    const duration = test.duration > 0 ? test.duration : performance.now() - test._ddStartTime
+    setEfdRetryCountForTest(test, duration, config.earlyFlakeDetectionSlowTestRetries)
+  }
 
   if (testsStatuses.get(testName)) {
     testsStatuses.get(testName).push(status)
@@ -323,12 +428,14 @@ function getTestFinishInfo (test, status, config, error) {
   const testStatuses = testsStatuses.get(testName)
 
   const isLastAttempt = testStatuses.length === config.testManagementAttemptToFixRetries + 1
-  const isLastEfdRetry = testStatuses.length === config.earlyFlakeDetectionNumRetries + 1
+  const efdRetryCount = efdRetryCountByTestFullName.get(testName) ?? getConfiguredEfdRetryCount(config)
+  const isLastEfdRetry = testStatuses.length === efdRetryCount + 1
   const isLastAtrAttempt = getIsLastRetry(test) || (config.isFlakyTestRetriesEnabled && status === 'pass')
 
   // Needed for the getFinalStatus call. This is because EFD does NOT tag as
   // EFD retry the first run of the test. It only tags as retries the clones
-  const isEfdRetry = test._ddIsEfdRetry || (test._ddIsNew && config.isEarlyFlakeDetectionEnabled)
+  const isEfdRetry =
+    test._ddIsEfdRetry || ((test._ddIsNew || test._ddIsModified) && config.isEarlyFlakeDetectionEnabled)
 
   if (test._ddIsAttemptToFix && isLastAttempt) {
     if (testStatuses.includes('fail')) {
@@ -341,7 +448,7 @@ function getTestFinishInfo (test, status, config, error) {
     }
   }
 
-  if (test._ddIsEfdRetry && isLastEfdRetry &&
+  if (test._ddIsEfdRetry && efdRetryCount > 0 && isLastEfdRetry &&
     testStatuses.every(status => status === 'fail')) {
     hasFailedAllRetries = true
   }
@@ -370,6 +477,7 @@ function getTestFinishInfo (test, status, config, error) {
     isAttemptToFix: _ddIsAttemptToFix,
     isLastAttemptToFix: isLastAttempt,
     attemptToFixPassed,
+    hasPassedAnyEfdAttempt: testStatuses.includes('pass'),
     isQuarantined: _ddIsQuarantined,
     isDisabled: _ddIsDisabled,
   })
@@ -391,11 +499,15 @@ function getTestFinishInfo (test, status, config, error) {
     isAttemptToFixRetry,
     isAtrRetry,
     finalStatus,
+    earlyFlakeAbortReason: efdSlowAbortedTests.has(testName) ? 'slow' : undefined,
   }
 }
 
 function getOnTestEndHandler (config) {
   return async function (test) {
+    if (test._ddShouldSkipEfdRetry) {
+      return
+    }
     const ctx = getTestContext(test)
     const status = getTestStatus(test)
 
@@ -518,6 +630,9 @@ function getOnTestRetryHandler (config) {
 
 function getOnPendingHandler () {
   return function (test) {
+    if (test._ddShouldSkipEfdRetry) {
+      return
+    }
     const testStartLine = testToStartLine.get(test)
     const {
       file: testSuiteAbsolutePath,
@@ -587,8 +702,9 @@ function getRunTestsWrapper (runTests, config) {
               if (!test.isPending() && !test._ddIsAttemptToFix && config.isEarlyFlakeDetectionEnabled) {
                 retryTest(
                   test,
-                  config.earlyFlakeDetectionNumRetries,
-                  ['_ddIsModified', '_ddIsEfdRetry']
+                  getConfiguredEfdRetryCount(config),
+                  ['_ddIsModified', '_ddIsEfdRetry'],
+                  config.earlyFlakeDetectionSlowTestRetries
                 )
               }
             }
@@ -606,8 +722,9 @@ function getRunTestsWrapper (runTests, config) {
           if (config.isEarlyFlakeDetectionEnabled && !test._ddIsAttemptToFix && !test._ddIsModified) {
             retryTest(
               test,
-              config.earlyFlakeDetectionNumRetries,
-              ['_ddIsNew', '_ddIsEfdRetry']
+              getConfiguredEfdRetryCount(config),
+              ['_ddIsNew', '_ddIsEfdRetry'],
+              config.earlyFlakeDetectionSlowTestRetries
             )
           }
         }

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

@@ -2,6 +2,7 @@
 
 const { addHook, channel } = require('../helpers/instrument')
 const shimmer = require('../../../datadog-shimmer')
+const { DD_MAJOR } = require('../../../../version')
 
 const {
   runnableWrapper,
@@ -15,6 +16,8 @@ const {
 } = require('./utils')
 require('./common')
 
+const MINIMUM_MOCHA_VERSION = DD_MAJOR >= 6 ? '>=8.0.0' : '>=5.2.0'
+
 const workerFinishCh = channel('ci:mocha:worker:finish')
 
 const config = {}
@@ -24,15 +27,17 @@ addHook({
   versions: ['>=8.0.0'],
   file: 'lib/mocha.js',
 }, (Mocha) => {
-  shimmer.wrap(Mocha.prototype, 'run', run => function () {
+  shimmer.wrap(Mocha.prototype, 'run', run => function (...args) {
     if (this.options._ddIsKnownTestsEnabled) {
       config.isKnownTestsEnabled = true
       config.isEarlyFlakeDetectionEnabled = this.options._ddIsEfdEnabled
       config.knownTests = this.options._ddKnownTests
       config.earlyFlakeDetectionNumRetries = this.options._ddEfdNumRetries
+      config.earlyFlakeDetectionSlowTestRetries = this.options._ddEfdSlowTestRetries ?? {}
       delete this.options._ddIsEfdEnabled
       delete this.options._ddKnownTests
       delete this.options._ddEfdNumRetries
+      delete this.options._ddEfdSlowTestRetries
       delete this.options._ddIsKnownTestsEnabled
     }
     if (this.options._ddIsImpactedTestsEnabled) {
@@ -55,7 +60,7 @@ addHook({
       delete this.options._ddIsFlakyTestRetriesEnabled
       delete this.options._ddFlakyTestRetriesCount
     }
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
 
   return Mocha
@@ -64,14 +69,14 @@ addHook({
 // Runner is also hooked in mocha/main.js, but in here we only generate test events.
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/runner.js',
 }, function (Runner) {
   shimmer.wrap(Runner.prototype, 'runTests', runTests => getRunTestsWrapper(runTests, config))
 
-  shimmer.wrap(Runner.prototype, 'run', run => function () {
+  shimmer.wrap(Runner.prototype, 'run', run => function (...args) {
     if (!workerFinishCh.hasSubscribers) {
-      return run.apply(this, arguments)
+      return run.apply(this, args)
     }
     // We flush when the worker ends with its test file (a mocha instance in a worker runs a single test file)
     this.once('end', () => {
@@ -90,7 +95,7 @@ addHook({
 
     this.on('pending', getOnPendingHandler())
 
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   })
   return Runner
 })
@@ -99,6 +104,6 @@ addHook({
 // Used to set the correct async resource to the test.
 addHook({
   name: 'mocha',
-  versions: ['>=5.2.0'],
+  versions: [MINIMUM_MOCHA_VERSION],
   file: 'lib/runnable.js',
 }, (runnablePackage) => runnableWrapper(runnablePackage, config))

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

@@ -22,26 +22,22 @@ addHook({ name: 'mongodb-core', versions: ['2 - 3.1.9'] }, Server => {
   shimmer.wrap(cursorProto, '_getmore', _getmore => wrapCursor(_getmore, 'getMore', 'getMore'))
   shimmer.wrap(cursorProto, '_find', _find => wrapQuery(_find, '_find'))
   shimmer.wrap(cursorProto, 'kill', kill => wrapCursor(kill, 'killCursors', 'killCursors'))
-  return Server
 })
 
 addHook({ name: 'mongodb', versions: ['>=4 <4.6.0'], file: 'lib/cmap/connection.js' }, Connection => {
   const proto = Connection.Connection.prototype
   shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command'))
   shimmer.wrap(proto, 'query', query => wrapConnectionCommand(query, 'query'))
-  return Connection
 })
 
 addHook({ name: 'mongodb', versions: ['>=4.6.0 <6.4.0'], file: 'lib/cmap/connection.js' }, Connection => {
   const proto = Connection.Connection.prototype
   shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command'))
-  return Connection
 })
 
 addHook({ name: 'mongodb', versions: ['>=6.4.0'], file: 'lib/cmap/connection.js' }, Connection => {
   const proto = Connection.Connection.prototype
   shimmer.wrap(proto, 'command', command => wrapConnectionCommand(command, 'command', undefined, instrumentPromise))
-  return Connection
 })
 
 addHook({ name: 'mongodb', versions: ['>=3.3 <4'], file: 'lib/core/wireprotocol/index.js' }, wp => wrapWp(wp))
@@ -50,12 +46,10 @@ addHook({ name: 'mongodb-core', versions: ['>=3.2'], file: 'lib/wireprotocol/ind
 
 addHook({ name: 'mongodb-core', versions: ['~3.1.10'], file: 'lib/wireprotocol/3_2_support.js' }, WireProtocol => {
   shimmer.wrap(WireProtocol.prototype, 'command', command => wrapUnifiedCommand(command, 'command'))
-  return WireProtocol
 })
 
 addHook({ name: 'mongodb-core', versions: ['~3.1.10'], file: 'lib/wireprotocol/2_6_support.js' }, WireProtocol => {
   shimmer.wrap(WireProtocol.prototype, 'command', command => wrapUnifiedCommand(command, 'command'))
-  return WireProtocol
 })
 
 addHook({ name: 'mongodb', versions: ['>=3.5.4 <4.11.0'], file: 'lib/utils.js' }, util => {
@@ -71,7 +65,6 @@ addHook({ name: 'mongodb', versions: ['>=3.5.4 <4.11.0'], file: 'lib/utils.js' }
 
     return maybePromise.apply(this, arguments)
   })
-  return util
 })
 
 function wrapWp (wp) {
@@ -86,17 +79,16 @@ function wrapWp (wp) {
 }
 
 function wrapUnifiedCommand (command, operation, name) {
-  const wrapped = function (server, ns, ops) {
+  return function (server, ns, ops) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
     }
     return instrument(operation, command, this, arguments, server, ns, ops, { name })
   }
-  return wrapped
 }
 
 function wrapConnectionCommand (command, operation, name, instrumentFn = instrument) {
-  const wrapped = function (ns, ops) {
+  return function (ns, ops) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
     }
@@ -109,43 +101,38 @@ function wrapConnectionCommand (command, operation, name, instrumentFn = instrum
     ns = `${ns.db}.${ns.collection}`
     return instrumentFn(operation, command, this, arguments, topology, ns, ops, { name })
   }
-  return wrapped
 }
 
 function wrapQuery (query, operation, name) {
-  const wrapped = function () {
+  return function (...args) {
     if (!startCh.hasSubscribers) {
-      return query.apply(this, arguments)
+      return query.apply(this, args)
     }
     const pool = this.server.s.pool
     const ns = this.ns
     const ops = this.cmd
-    return instrument(operation, query, this, arguments, pool, ns, ops)
+    return instrument(operation, query, this, args, pool, ns, ops)
   }
-
-  return wrapped
 }
 
 function wrapCursor (cursor, operation, name) {
-  const wrapped = function () {
+  return function (...args) {
     if (!startCh.hasSubscribers) {
-      return cursor.apply(this, arguments)
+      return cursor.apply(this, args)
     }
     const pool = this.server.s.pool
     const ns = this.ns
-    return instrument(operation, cursor, this, arguments, pool, ns, {}, { name })
+    return instrument(operation, cursor, this, args, pool, ns, {}, { name })
   }
-  return wrapped
 }
 
 function wrapCommand (command, operation, name) {
-  const wrapped = function (ns, ops) {
+  return function (ns, ops) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
     }
     return instrument(operation, command, this, arguments, this, ns, ops, { name })
   }
-  return wrapped
 }
 
 function instrument (operation, command, instance, args, server, ns, ops, options = {}) {

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

@@ -35,22 +35,22 @@ addHook({ name: 'mongodb', versions: ['>=3.3 <5', '5', '>=6'] }, mongodb => {
     const useTwoArguments = collectionMethodsWithTwoFilters.includes(methodName)
 
     shimmer.wrap(mongodb.Collection.prototype, methodName, method => {
-      return function () {
+      return function (...args) {
         if (!startCh.hasSubscribers) {
-          return method.apply(this, arguments)
+          return method.apply(this, args)
         }
 
         const ctx = {
-          filters: [arguments[0]],
+          filters: [args[0]],
           methodName,
         }
 
         if (useTwoArguments) {
-          ctx.filters.push(arguments[1])
+          ctx.filters.push(args[1])
         }
 
         return startCh.runStores(ctx, () => {
-          return method.apply(this, arguments)
+          return method.apply(this, args)
         })
       }
     })

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

@@ -66,14 +66,14 @@ addHook({
     if (!(methodName in Model)) continue
 
     shimmer.wrap(Model, methodName, method => {
-      return function wrappedModelMethod () {
+      return function wrappedModelMethod (...args) {
         if (!startCh.hasSubscribers) {
-          return method.apply(this, arguments)
+          return method.apply(this, args)
         }
 
-        const filters = [arguments[0]]
+        const filters = [args[0]]
         if (useTwoArguments) {
-          filters.push(arguments[1])
+          filters.push(args[1])
         }
 
         let callbackWrapped = false
@@ -84,10 +84,10 @@ addHook({
           if (typeof args[lastArgumentIndex] === 'function') {
             // is a callback, wrap it to execute finish()
             shimmer.wrap(args, lastArgumentIndex, originalCb => {
-              return function () {
+              return function (...args) {
                 finishCh.publish(ctx)
 
-                return originalCb.apply(this, arguments)
+                return originalCb.apply(this, args)
               }
             })
 
@@ -101,19 +101,19 @@ addHook({
         }
 
         return startCh.runStores(ctx, () => {
-          wrapCallbackIfExist(arguments, ctx)
+          wrapCallbackIfExist(args, ctx)
 
-          const res = method.apply(this, arguments)
+          const res = method.apply(this, args)
 
           // if it is not callback, wrap exec method and its then
           if (!callbackWrapped) {
             shimmer.wrap(res, 'exec', originalExec => {
-              return function wrappedExec () {
+              return function wrappedExec (...args) {
                 if (!callbackWrapped) {
-                  wrapCallbackIfExist(arguments, ctx)
+                  wrapCallbackIfExist(args, ctx)
                 }
 
-                const execResult = originalExec.apply(this, arguments)
+                const execResult = originalExec.apply(this, args)
 
                 if (callbackWrapped || typeof execResult?.then !== 'function') {
                   return execResult
@@ -121,27 +121,27 @@ addHook({
 
                 // wrap them method, wrap resolve and reject methods
                 shimmer.wrap(execResult, 'then', originalThen => {
-                  return function wrappedThen () {
-                    const resolve = arguments[0]
-                    const reject = arguments[1]
+                  return function wrappedThen (...args) {
+                    const resolve = args[0]
+                    const reject = args[1]
 
-                    arguments[0] = shimmer.wrapFunction(resolve, resolve => function wrappedResolve () {
+                    args[0] = shimmer.wrapFunction(resolve, resolve => function wrappedResolve (...args) {
                       finishCh.publish(ctx)
 
                       if (resolve) {
-                        return resolve.apply(this, arguments)
+                        return resolve.apply(this, args)
                       }
                     })
 
-                    arguments[1] = shimmer.wrapFunction(reject, reject => function wrappedReject () {
+                    args[1] = shimmer.wrapFunction(reject, reject => function wrappedReject (...args) {
                       finishCh.publish(ctx)
 
                       if (reject) {
-                        return reject.apply(this, arguments)
+                        return reject.apply(this, args)
                       }
                     })
 
-                    return originalThen.apply(this, arguments)
+                    return originalThen.apply(this, args)
                   }
                 })
 
@@ -165,8 +165,8 @@ addHook({
   versions: ['6', '>=7'],
   file: 'lib/helpers/query/sanitizeFilter.js',
 }, sanitizeFilter => {
-  return shimmer.wrapFunction(sanitizeFilter, sanitizeFilter => function wrappedSanitizeFilter () {
-    const sanitizedObject = sanitizeFilter.apply(this, arguments)
+  return shimmer.wrapFunction(sanitizeFilter, sanitizeFilter => function wrappedSanitizeFilter (...args) {
+    const sanitizedObject = sanitizeFilter.apply(this, args)
 
     if (sanitizeFilterFinishCh.hasSubscribers) {
       sanitizeFilterFinishCh.publish({

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

@@ -42,22 +42,22 @@ addHook({
     if (!(methodName in Query.prototype)) continue
 
     shimmer.wrap(Query.prototype, methodName, method => {
-      return function () {
+      return function (...args) {
         if (prepareCh.hasSubscribers) {
-          const filters = getFilters(arguments, methodName)
+          const filters = getFilters(args, methodName)
           if (filters?.length) {
             prepareCh.publish({ filters })
           }
         }
 
-        return method.apply(this, arguments)
+        return method.apply(this, args)
       }
     })
   }
 
   shimmer.wrap(Query.prototype, 'exec', originalExec => {
-    return function wrappedExec () {
-      return tracingCh.tracePromise(originalExec, {}, this, arguments)
+    return function wrappedExec (...args) {
+      return tracingCh.tracePromise(originalExec, {}, this, args)
     }
   })
 

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

@@ -6,7 +6,7 @@ const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const multerReadCh = channel('datadog:multer:read:finish')
 
 function publishRequestBodyAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     if (multerReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const body = req.body
@@ -16,7 +16,7 @@ function publishRequestBodyAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 
@@ -25,8 +25,8 @@ addHook({
   file: 'lib/make-middleware.js',
   versions: ['^1.4.4-lts.1'],
 }, makeMiddleware => {
-  return shimmer.wrapFunction(makeMiddleware, makeMiddleware => function () {
-    const middleware = makeMiddleware.apply(this, arguments)
+  return shimmer.wrapFunction(makeMiddleware, makeMiddleware => function (...args) {
+    const middleware = makeMiddleware.apply(this, args)
 
     return shimmer.wrapFunction(middleware, middleware => function wrapMulterMiddleware (req, res, next) {
       const nextResource = new AsyncResource('bound-anonymous-fn')