dd-trace 5.101.0 → 5.103.0

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

@@ -11,6 +11,14 @@ const startCh = channel('apm:mongodb:query:start')
 const finishCh = channel('apm:mongodb:query:finish')
 const errorCh = channel('apm:mongodb:query:error')
 
+// Per-Connection cached topology shape (mongodb >= 4). The Connection's `address` is immutable
+// for the lifetime of the connection, so we synthesize the `{ s: { options } }` envelope the
+// plugin expects only once per connection. A WeakMap keeps the cache off the foreign Connection
+// instance — no extra own-key visible to `Reflect.ownKeys`, `Object.freeze`, or another tracer's
+// instrumentation walking the connection.
+/** @type {WeakMap<object, { s: { options: { host?: string, port?: string } } }>} */
+const topologyCache = new WeakMap()
+
 addHook({ name: 'mongodb-core', versions: ['2 - 3.1.9'] }, Server => {
   const serverProto = Server.Server.prototype
   shimmer.wrap(serverProto, 'command', command => wrapCommand(command, 'command'))
@@ -22,26 +30,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 +54,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 +73,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,66 +87,75 @@ 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) {
+  const opts = { name }
+  return function (ns, ops) {
     if (!startCh.hasSubscribers) {
       return command.apply(this, arguments)
     }
-    const hostParts = typeof this.address === 'string' ? this.address.split(':') : ''
-    const options = hostParts.length === 2
-      ? { host: hostParts[0], port: hostParts[1] }
-      : {} // no port means the address is a random UUID so no host either
-    const topology = { s: { options } }
-
-    ns = `${ns.db}.${ns.collection}`
-    return instrumentFn(operation, command, this, arguments, topology, ns, ops, { name })
+    let topology = topologyCache.get(this)
+    if (topology === undefined) {
+      topology = synthesizeTopology(this.address)
+      topologyCache.set(this, topology)
+    }
+    return instrumentFn(operation, command, this, arguments, topology, `${ns.db}.${ns.collection}`, ops, opts)
+  }
+}
+
+/**
+ * @param {string} address
+ * @returns {{ s: { options: { host?: string, port?: string } } }}
+ */
+function synthesizeTopology (address) {
+  if (typeof address === 'string') {
+    const colon = address.indexOf(':')
+    // Match the previous `.split(':')` length-2 check: exactly one colon with non-empty parts on both sides.
+    if (colon > 0 && colon < address.length - 1 && !address.includes(':', colon + 1)) {
+      return { s: { options: { host: address.slice(0, colon), port: address.slice(colon + 1) } } }
+    }
   }
-  return wrapped
+  // No port means the address is a random UUID, an IPv6 form, or otherwise unparseable, so no host either.
+  return { s: { options: {} } }
 }
 
 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 = {}) {
@@ -184,6 +194,8 @@ function instrument (operation, command, instance, args, server, ns, ops, option
   })
 }
 
+module.exports = { synthesizeTopology }
+
 function instrumentPromise (operation, command, instance, args, server, ns, ops, options = {}) {
   const name = options.name || (ops && Object.keys(ops)[0])
 

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')

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)