dd-trace 5.101.0 → 5.102.0

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

@@ -8,24 +8,24 @@ addHook({ name: 'mysql', file: 'lib/Connection.js', versions: ['>=2'] }, Connect
   const finishCh = channel('apm:mysql:query:finish')
   const errorCh = channel('apm:mysql:query:error')
 
-  shimmer.wrap(Connection.prototype, 'query', query => function () {
+  shimmer.wrap(Connection.prototype, 'query', query => function (...args) {
     if (!startCh.hasSubscribers) {
-      return query.apply(this, arguments)
+      return query.apply(this, args)
     }
 
-    const sql = arguments[0].sql || arguments[0]
+    const sql = args[0].sql || args[0]
     const conf = this.config
     const ctx = { sql, conf }
 
     return startCh.runStores(ctx, () => {
-      if (arguments[0].sql) {
-        arguments[0].sql = ctx.sql
+      if (args[0].sql) {
+        args[0].sql = ctx.sql
       } else {
-        arguments[0] = ctx.sql
+        args[0] = ctx.sql
       }
 
       try {
-        const res = query.apply(this, arguments)
+        const res = query.apply(this, args)
 
         if (res._callback) {
           const cb = res._callback
@@ -63,8 +63,8 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
   const finishPoolQueryCh = channel('datadog:mysql:pool:query:finish')
 
   shimmer.wrap(Pool.prototype, 'getConnection', getConnection => function (cb) {
-    arguments[0] = function () {
-      return connectionFinishCh.runStores(ctx, cb, this, ...arguments)
+    arguments[0] = function (...args) {
+      return connectionFinishCh.runStores(ctx, cb, this, ...args)
     }
 
     const ctx = {}
@@ -74,24 +74,24 @@ addHook({ name: 'mysql', file: 'lib/Pool.js', versions: ['>=2'] }, Pool => {
     return getConnection.apply(this, arguments)
   })
 
-  shimmer.wrap(Pool.prototype, 'query', query => function () {
+  shimmer.wrap(Pool.prototype, 'query', query => function (...args) {
     if (!startPoolQueryCh.hasSubscribers) {
-      return query.apply(this, arguments)
+      return query.apply(this, args)
     }
 
-    const sql = arguments[0].sql || arguments[0]
+    const sql = args[0].sql || args[0]
     const ctx = { sql }
     const finish = () => finishPoolQueryCh.publish(ctx)
 
     return startPoolQueryCh.runStores(ctx, () => {
-      const cb = arguments[arguments.length - 1]
+      const cb = args[args.length - 1]
       if (typeof cb === 'function') {
-        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
-          return finishPoolQueryCh.runStores(ctx, cb, this, ...arguments)
+        args[args.length - 1] = shimmer.wrapFunction(cb, cb => function (...args) {
+          return finishPoolQueryCh.runStores(ctx, cb, this, ...args)
         })
       }
 
-      const retval = query.apply(this, arguments)
+      const retval = query.apply(this, args)
 
       if (retval && retval.then) {
         retval.then(finish).catch(finish)

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

@@ -145,8 +145,8 @@ function wrapConnection (Connection, version) {
 
     if (cached === onResult) return
 
-    const wrapped = function () {
-      return commandFinishCh.runStores(ctx, onResult, this, ...arguments)
+    const wrapped = function (...args) {
+      return commandFinishCh.runStores(ctx, onResult, this, ...args)
     }
 
     wrappedOnResult.set(cmd, wrapped)
@@ -289,8 +289,8 @@ function wrapPoolCluster (PoolCluster) {
   const startOuterQueryCh = channel('datadog:mysql2:outerquery:start')
   const wrappedPoolNamespaces = new WeakSet()
 
-  shimmer.wrap(PoolCluster.prototype, 'of', of => function () {
-    const poolNamespace = of.apply(this, arguments)
+  shimmer.wrap(PoolCluster.prototype, 'of', of => function (...args) {
+    const poolNamespace = of.apply(this, args)
 
     if (startOuterQueryCh.hasSubscribers && !wrappedPoolNamespaces.has(poolNamespace)) {
       shimmer.wrap(poolNamespace, 'query', query => function (sql, values, cb) {

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

@@ -21,16 +21,16 @@ addHook({ name: 'net' }, (net) => {
   // so that we don't miss the dns calls
   require('node:dns')
 
-  shimmer.wrap(net.Socket.prototype, 'connect', connect => function () {
+  shimmer.wrap(net.Socket.prototype, 'connect', connect => function (...args) {
     if (!startICPCh.hasSubscribers || !startTCPCh.hasSubscribers) {
-      return connect.apply(this, arguments)
+      return connect.apply(this, args)
     }
 
-    const options = getOptions(arguments)
-    const lastIndex = arguments.length - 1
-    const callback = arguments[lastIndex]
+    const options = getOptions(args)
+    const lastIndex = args.length - 1
+    const callback = args[lastIndex]
 
-    if (!options) return connect.apply(this, arguments)
+    if (!options) return connect.apply(this, args)
 
     const protocol = options.path ? 'ipc' : 'tcp'
     const startCh = protocol === 'ipc' ? startICPCh : startTCPCh
@@ -39,7 +39,7 @@ addHook({ name: 'net' }, (net) => {
     const ctx = { options }
 
     if (typeof callback === 'function') {
-      arguments[lastIndex] = function (...args) {
+      args[lastIndex] = function (...args) {
         return finishCh.runStores(ctx, callback, this, ...args)
       }
     }
@@ -48,20 +48,26 @@ addHook({ name: 'net' }, (net) => {
       setupListeners(this, protocol, ctx, finishCh, errorCh)
 
       const emit = this.emit
+      let pendingReadyEvents = 2
       this.emit = shimmer.wrapFunction(emit, emit => function (eventName) {
         switch (eventName) {
           case 'ready':
           case 'connect':
+            if (--pendingReadyEvents === 0) this.emit = emit
             return readyCh.runStores(ctx, () => {
               return emit.apply(this, arguments)
             })
+          case 'error':
+          case 'close':
+            this.emit = emit
+            return emit.apply(this, arguments)
           default:
             return emit.apply(this, arguments)
         }
       })
 
       try {
-        return connect.apply(this, arguments)
+        return connect.apply(this, args)
       } catch (err) {
         errorCh.publish(err)
 

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

@@ -17,7 +17,7 @@ addHook({
   setupSettingsCachePath()
 
   // `wrap` is an async function
-  shimmer.wrap(nycPackage.prototype, 'wrap', wrap => function () {
+  shimmer.wrap(nycPackage.prototype, 'wrap', wrap => function (...args) {
     // Only relevant if the config `all` is set to true (for untested code coverage)
     try {
       if (JSON.parse(getEnvironmentVariable('NYC_CONFIG')).all) {
@@ -27,16 +27,16 @@ addHook({
       // ignore errors
     }
 
-    return wrap.apply(this, arguments)
+    return wrap.apply(this, args)
   })
 
   // `report` is an async function, so we wait for it to complete before publishing
-  shimmer.wrap(nycPackage.prototype, 'report', report => function () {
+  shimmer.wrap(nycPackage.prototype, 'report', report => function (...args) {
     if (!codeCoverageReportCh.hasSubscribers) {
-      return report.apply(this, arguments)
+      return report.apply(this, args)
     }
     const nycInstance = this
-    const reportPromise = report.apply(this, arguments)
+    const reportPromise = report.apply(this, args)
 
     if (reportPromise && typeof reportPromise.then === 'function') {
       // Return a new promise that waits for both the report AND the coverage upload

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

@@ -150,18 +150,18 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
   methodNames.shift() // remove leading 'constructor' method
 
   for (const methodName of methodNames) {
-    shimmer.wrap(exports.OpenAIApi.prototype, methodName, fn => function () {
+    shimmer.wrap(exports.OpenAIApi.prototype, methodName, fn => function (...args) {
       if (!ch.start.hasSubscribers) {
-        return fn.apply(this, arguments)
+        return fn.apply(this, args)
       }
 
       const ctx = {
         methodName,
-        args: arguments,
+        args,
         basePath: this.basePath,
       }
 
-      return ch.tracePromise(fn, ctx, this, ...arguments)
+      return ch.tracePromise(fn, ctx, this, ...args)
     })
   }
 
@@ -175,10 +175,10 @@ addHook({ name: 'openai', file: 'dist/api.js', versions: ['>=3.0.0 <4'] }, expor
  */
 function wrapStreamIterator (response, options, ctx) {
   return function (itr) {
-    return function () {
-      const iterator = itr.apply(this, arguments)
-      shimmer.wrap(iterator, 'next', next => function () {
-        return next.apply(this, arguments)
+    return function (...args) {
+      const iterator = itr.apply(this, args)
+      shimmer.wrap(iterator, 'next', next => function (...args) {
+        return next.apply(this, args)
           .then(res => {
             const { done, value: chunk } = res
             onStreamedChunkCh.publish({ ctx, chunk, done })
@@ -215,38 +215,38 @@ for (const extension of extensions) {
       const targetPrototype = exports[targetClass].prototype
 
       for (const methodName of methods) {
-        shimmer.wrap(targetPrototype, methodName, methodFn => function () {
+        shimmer.wrap(targetPrototype, methodName, methodFn => function (...args) {
           if (!ch.start.hasSubscribers) {
-            return methodFn.apply(this, arguments)
+            return methodFn.apply(this, args)
           }
 
           // The OpenAI library lets you set `stream: true` on the options arg to any method
           // However, we only want to handle streamed responses in specific cases
           // chat.completions and completions
-          const stream = streamedResponse && getOption(arguments, 'stream', false)
+          const stream = streamedResponse && getOption(args, 'stream', false)
 
           const client = this._client || this.client
 
           const ctx = {
             methodName: `${baseResource}.${methodName}`,
-            args: arguments,
+            args,
             basePath: client.baseURL,
           }
 
           return ch.start.runStores(ctx, () => {
-            const apiProm = methodFn.apply(this, arguments)
+            const apiProm = methodFn.apply(this, args)
 
             if (baseResource === 'chat.completions' && typeof apiProm._thenUnwrap === 'function') {
               // this should only ever be invoked from a client.beta.chat.completions.parse call
-              shimmer.wrap(apiProm, '_thenUnwrap', origApiPromThenUnwrap => function () {
+              shimmer.wrap(apiProm, '_thenUnwrap', origApiPromThenUnwrap => function (...args) {
                 // TODO(sam.brenner): I wonder if we can patch the APIPromise prototype instead, although
                 // we might not have access to everything we need...
 
                 // this is a new apipromise instance
-                const unwrappedPromise = origApiPromThenUnwrap.apply(this, arguments)
+                const unwrappedPromise = origApiPromThenUnwrap.apply(this, args)
 
-                shimmer.wrap(unwrappedPromise, 'parse', origApiPromParse => function () {
-                  const parsedPromise = origApiPromParse.apply(this, arguments)
+                shimmer.wrap(unwrappedPromise, 'parse', origApiPromParse => function (...args) {
+                  const parsedPromise = origApiPromParse.apply(this, args)
                     .then(body => Promise.all([this.responsePromise, body]))
 
                   return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)
@@ -258,8 +258,8 @@ for (const extension of extensions) {
 
             // wrapping `parse` avoids problematic wrapping of `then` when trying to call
             // `withResponse` in userland code after. This way, we can return the whole `APIPromise`
-            shimmer.wrap(apiProm, 'parse', origApiPromParse => function () {
-              const parsedPromise = origApiPromParse.apply(this, arguments)
+            shimmer.wrap(apiProm, 'parse', origApiPromParse => function (...args) {
+              const parsedPromise = origApiPromParse.apply(this, args)
                 .then(body => Promise.all([this.responsePromise, body]))
 
               return handleUnwrappedAPIPromise(parsedPromise, ctx, stream)

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

@@ -137,21 +137,21 @@ addHook({ name: 'oracledb', versions: ['>=5'], file: 'lib/oracledb.js' }, oracle
     }
   })
   shimmer.wrap(oracledb.Pool.prototype, 'getConnection', getConnection => {
-    return function wrappedGetConnection () {
+    return function wrappedGetConnection (...args) {
       let callback
-      if (typeof arguments[arguments.length - 1] === 'function') {
-        callback = arguments[arguments.length - 1]
+      if (typeof args[args.length - 1] === 'function') {
+        callback = args[args.length - 1]
       }
       if (callback) {
-        arguments[arguments.length - 1] = shimmer.wrapFunction(callback, callback => (err, connection) => {
+        args[args.length - 1] = shimmer.wrapFunction(callback, callback => (err, connection) => {
           if (connection) {
             connectionAttributes.set(connection, poolAttributes.get(this))
           }
           callback(err, connection)
         })
-        getConnection.apply(this, arguments)
+        getConnection.apply(this, args)
       } else {
-        return getConnection.apply(this, arguments).then((connection) => {
+        return getConnection.apply(this, args).then((connection) => {
           connectionAttributes.set(connection, poolAttributes.get(this))
           return connection
         })

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

@@ -40,15 +40,15 @@ function wrapVerify (verify) {
 }
 
 function wrapStrategy (Strategy) {
-  return function wrappedStrategy () {
+  return function wrappedStrategy (...args) {
     // verify function can be either the first or second argument
-    if (typeof arguments[0] === 'function') {
-      arguments[0] = wrapVerify(arguments[0])
+    if (typeof args[0] === 'function') {
+      args[0] = wrapVerify(args[0])
     } else {
-      arguments[1] = wrapVerify(arguments[1])
+      args[1] = wrapVerify(args[1])
     }
 
-    return Strategy.apply(this, arguments)
+    return Strategy.apply(this, args)
   }
 }
 

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

@@ -31,16 +31,16 @@ addHook({ name: 'pg', versions: ['>=8.0.3'] }, pg => {
 })
 
 function wrapQuery (query) {
-  return function () {
+  return function (...args) {
     if (!startCh.hasSubscribers) {
-      return query.apply(this, arguments)
+      return query.apply(this, args)
     }
 
     const processId = this.processID
 
-    const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object'
-      ? arguments[0]
-      : { text: arguments[0] }
+    const pgQuery = args[0] !== null && typeof args[0] === 'object'
+      ? args[0]
+      : { text: args[0] }
 
     const textPropObj = pgQuery.cursor ?? pgQuery
     const textProp = Object.getOwnPropertyDescriptor(textPropObj, 'text')
@@ -80,7 +80,7 @@ function wrapQuery (query) {
 
         // Based on: https://github.com/brianc/node-postgres/blob/54eb0fa216aaccd727765641e7d1cf5da2bc483d/packages/pg/lib/client.js#L510
         const reusingQuery = typeof pgQuery.submit === 'function'
-        const callback = arguments[arguments.length - 1]
+        const callback = args[args.length - 1]
 
         finish(error)
 
@@ -109,9 +109,9 @@ function wrapQuery (query) {
         return Promise.reject(error)
       }
 
-      arguments[0] = pgQuery
+      args[0] = pgQuery
 
-      const retval = query.apply(this, arguments)
+      const retval = query.apply(this, args)
 
       const deperecated = Object.hasOwn(this, '_activeQuery')
       const queryQueue = deperecated ? this._queryQueue : this.queryQueue
@@ -153,18 +153,18 @@ const finish = (ctx) => {
   finishPoolQueryCh.publish(ctx)
 }
 function wrapPoolQuery (query) {
-  return function () {
+  return function (...args) {
     if (!startPoolQueryCh.hasSubscribers) {
-      return query.apply(this, arguments)
+      return query.apply(this, args)
     }
 
-    const pgQuery = arguments[0] !== null && typeof arguments[0] === 'object' ? arguments[0] : { text: arguments[0] }
+    const pgQuery = args[0] !== null && typeof args[0] === 'object' ? args[0] : { text: args[0] }
     const abortController = new AbortController()
 
     const ctx = { query: pgQuery, abortController }
 
     return startPoolQueryCh.runStores(ctx, () => {
-      const cb = arguments[arguments.length - 1]
+      const cb = args[args.length - 1]
 
       if (abortController.signal.aborted) {
         const error = abortController.signal.reason || new Error('Aborted')
@@ -179,13 +179,13 @@ function wrapPoolQuery (query) {
       }
 
       if (typeof cb === 'function') {
-        arguments[arguments.length - 1] = shimmer.wrapFunction(cb, cb => function () {
+        args[args.length - 1] = shimmer.wrapFunction(cb, cb => function (...args) {
           finish(ctx)
-          return cb.apply(this, arguments)
+          return cb.apply(this, args)
         })
       }
 
-      const retval = query.apply(this, arguments)
+      const retval = query.apply(this, args)
 
       if (retval?.then) {
         retval.then(() => {

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

@@ -7,8 +7,8 @@ const {
 } = require('./helpers/instrument')
 
 function wrapPino (symbol, wrapper, pino) {
-  return function pinoWithTrace () {
-    const instance = pino.apply(this, arguments)
+  return function pinoWithTrace (...args) {
+    const instance = pino.apply(this, args)
 
     Object.defineProperty(instance, symbol, {
       configurable: true,
@@ -46,8 +46,8 @@ function wrapPrettifyObject (prettifyObject) {
 
 function wrapPrettyFactory (prettyFactory) {
   const ch = channel('apm:pino:log')
-  return function prettyFactoryWithTrace () {
-    const pretty = prettyFactory.apply(this, arguments)
+  return function prettyFactoryWithTrace (...args) {
+    const pretty = prettyFactory.apply(this, args)
     return function prettyWithTrace (obj) {
       const payload = { message: obj }
       ch.publish(payload)
@@ -60,17 +60,13 @@ function wrapPrettyFactory (prettyFactory) {
 addHook({ name: 'pino', versions: ['2 - 3', '4'], patchDefault: true }, (pino) => {
   const asJsonSym = (pino.symbols && pino.symbols.asJsonSym) || 'asJson'
 
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
-
-  return wrapped
+  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino))
 })
 
 addHook({ name: 'pino', versions: ['>=5 <6.8.0'], patchDefault: true }, (pino) => {
   const asJsonSym = ((pino.default || pino)?.symbols.asJsonSym) || 'asJson'
 
-  const wrapped = shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino.default || pino))
-
-  return wrapped
+  return shimmer.wrapFunction(pino, pino => wrapPino(asJsonSym, wrapAsJson, pino.default || pino))
 })
 
 addHook({ name: 'pino', versions: ['>=6.8.0'], patchDefault: false }, (pino) => {

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

@@ -79,6 +79,7 @@ let testManagementTests = {}
 let isImpactedTestsEnabled = false
 let modifiedFiles = {}
 let quarantinedButNotAttemptToFixFqns = new Set()
+let testsReportedInGenerateSummary = new Set()
 const newTestsWithDynamicNames = new Set()
 const attemptToFixExecutions = new Map()
 const loggedAttemptToFixTests = new Set()
@@ -574,9 +575,9 @@ function testEndHandler ({
 }
 
 function dispatcherRunWrapper (run) {
-  return function () {
+  return function (...args) {
     remainingTestsByFile = getTestsBySuiteFromTestsById(this._testById)
-    return run.apply(this, arguments)
+    return run.apply(this, args)
   }
 }
 
@@ -604,9 +605,9 @@ function dispatcherRunWrapperNew (run) {
 
 function dispatcherHook (dispatcherExport) {
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', dispatcherRunWrapper)
-  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function (...args) {
     const dispatcher = this
-    const worker = createWorker.apply(this, arguments)
+    const worker = createWorker.apply(this, args)
     const projects = getProjectsFromDispatcher(dispatcher)
     sessionProjects = projects
 
@@ -645,9 +646,9 @@ function dispatcherHook (dispatcherExport) {
 
 function dispatcherHookNew (dispatcherExport, runWrapper) {
   shimmer.wrap(dispatcherExport.Dispatcher.prototype, 'run', runWrapper)
-  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function () {
+  shimmer.wrap(dispatcherExport.Dispatcher.prototype, '_createWorker', createWorker => function (...args) {
     const dispatcher = this
-    const worker = createWorker.apply(this, arguments)
+    const worker = createWorker.apply(this, args)
     const projects = getProjectsFromDispatcher(dispatcher)
     sessionProjects = projects
 
@@ -661,8 +662,11 @@ function dispatcherHookNew (dispatcherExport, runWrapper) {
       const test = getTestByTestId(dispatcher, testId)
 
       const isTimeout = status === 'timedOut'
-      const shouldCreateTestSpan = test.expectedStatus === 'skipped'
       const testStatus = STATUS_TO_TEST_STATUS[status]
+      const shouldCreateTestSpan = test.expectedStatus === 'skipped'
+      if (shouldCreateTestSpan && !testToCtx.has(test)) {
+        testBeginHandler(test, getBrowserNameFromProjects(projects, test), true)
+      }
       testEndHandler(
         {
           test,
@@ -835,15 +839,16 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
       // there were tests that did not go through `testBegin` or `testEnd`,
       // because they were skipped
       for (const test of tests) {
+        const alreadyReported = testsReportedInGenerateSummary.has(test)
         const browser = getBrowserNameFromProjects(projects, test)
-        testBeginHandler(test, browser, true)
+        testBeginHandler(test, browser, !alreadyReported)
         testEndHandler({
           test,
           annotations: [],
           testStatus: 'skip',
           error: null,
           isTimeout: false,
-          shouldCreateTestSpan: true,
+          shouldCreateTestSpan: !alreadyReported,
           projects,
         })
       }
@@ -894,6 +899,7 @@ function runAllTestsWrapper (runAllTests, playwrightVersion) {
     startedSuites = []
     remainingTestsByFile = {}
     quarantinedButNotAttemptToFixFqns = new Set()
+    testsReportedInGenerateSummary = new Set()
 
     // TODO: we can trick playwright into thinking the session passed by returning
     // 'passed' here. We might be able to use this for both EFD and Test Management tests.
@@ -1144,7 +1150,7 @@ addHook({
   }
 
   // We need to proxy the createRootSuite function because the function is not configurable
-  const proxy = new Proxy(loadUtilsPackage, {
+  return new Proxy(loadUtilsPackage, {
     get (target, prop) {
       if (prop === 'createRootSuite') {
         return newCreateRootSuite
@@ -1152,8 +1158,6 @@ addHook({
       return target[prop]
     },
   })
-
-  return proxy
 })
 
 // main process hook
@@ -1419,12 +1423,13 @@ addHook({
 })
 
 function generateSummaryWrapper (generateSummary) {
-  return function () {
+  return function (...args) {
     for (const test of this.suite.allTests()) {
       // https://github.com/microsoft/playwright/blob/bf92ffecff6f30a292b53430dbaee0207e0c61ad/packages/playwright/src/reporters/base.ts#L279
       const didNotRun = test.outcome() === 'skipped' &&
         (!test.results.length || test.expectedStatus !== 'skipped')
-      if (didNotRun) {
+      if (didNotRun && !testsReportedInGenerateSummary.has(test)) {
+        testsReportedInGenerateSummary.add(test)
         const {
           _requireFile: testSuiteAbsolutePath,
           location: {
@@ -1451,7 +1456,7 @@ function generateSummaryWrapper (generateSummary) {
         })
       }
     }
-    return generateSummary.apply(this, arguments)
+    return generateSummary.apply(this, args)
   }
 }
 

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

@@ -9,23 +9,23 @@ const deserializeChannel = dc.channel('apm:protobufjs:deserialize-end')
 
 function wrapSerialization (messageClass) {
   if (messageClass?.encode) {
-    shimmer.wrap(messageClass, 'encode', original => function () {
+    shimmer.wrap(messageClass, 'encode', original => function (...args) {
       if (!serializeChannel.hasSubscribers) {
-        return original.apply(this, arguments)
+        return original.apply(this, args)
       }
       serializeChannel.publish({ messageClass: this })
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     })
   }
 }
 
 function wrapDeserialization (messageClass) {
   if (messageClass?.decode) {
-    shimmer.wrap(messageClass, 'decode', original => function () {
+    shimmer.wrap(messageClass, 'decode', original => function (...args) {
       if (!deserializeChannel.hasSubscribers) {
-        return original.apply(this, arguments)
+        return original.apply(this, args)
       }
-      const result = original.apply(this, arguments)
+      const result = original.apply(this, args)
       deserializeChannel.publish({ messageClass: result })
       return result
     })
@@ -34,8 +34,8 @@ function wrapDeserialization (messageClass) {
 
 function wrapSetup (messageClass) {
   if (messageClass?.setup) {
-    shimmer.wrap(messageClass, 'setup', original => function () {
-      const result = original.apply(this, arguments)
+    shimmer.wrap(messageClass, 'setup', original => function (...args) {
+      const result = original.apply(this, args)
 
       wrapSerialization(messageClass)
       wrapDeserialization(messageClass)
@@ -74,8 +74,8 @@ function wrapReflection (protobuf) {
   ]
 
   for (const method of reflectionMethods) {
-    shimmer.wrap(method.target, method.name, original => function () {
-      const result = original.apply(this, arguments)
+    shimmer.wrap(method.target, method.name, original => function (...args) {
+      const result = original.apply(this, args)
       if (result.nested) {
         for (const type in result.nested) {
           wrapSetup(result.nested[type])
@@ -97,8 +97,8 @@ addHook({
   name: 'protobufjs',
   versions: ['>=6.8.0'],
 }, protobuf => {
-  shimmer.wrap(protobuf.Root.prototype, 'load', original => function () {
-    const result = original.apply(this, arguments)
+  shimmer.wrap(protobuf.Root.prototype, 'load', original => function (...args) {
+    const result = original.apply(this, args)
     if (isPromise(result)) {
       return result.then(root => {
         wrapProtobufClasses(root)
@@ -110,14 +110,14 @@ addHook({
     return result
   })
 
-  shimmer.wrap(protobuf.Root.prototype, 'loadSync', original => function () {
-    const root = original.apply(this, arguments)
+  shimmer.wrap(protobuf.Root.prototype, 'loadSync', original => function (...args) {
+    const root = original.apply(this, args)
     wrapProtobufClasses(root)
     return root
   })
 
-  shimmer.wrap(protobuf, 'Type', Original => function () {
-    const typeInstance = new Original(...arguments)
+  shimmer.wrap(protobuf, 'Type', Original => function (...args) {
+    const typeInstance = new Original(...args)
     wrapSetup(typeInstance)
     return typeInstance
   })