dd-trace 5.100.0 → 5.102.0

package/packages/datadog-instrumentations/src/azure-durable-functions.js

@@ -38,14 +38,14 @@ function entityWrapper (method) {
 }
 
 function entityHandler (handler, entityName) {
-  return function () {
-    if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, arguments)
+  return function (...args) {
+    if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, args)
 
-    const entityContext = arguments[0]
+    const entityContext = args[0]
     return azureDurableFunctionsChannel.traceSync(
       handler,
       { trigger: 'Entity', functionName: entityName, operationName: entityContext?.df?.operationName },
-      this, ...arguments)
+      this, ...args)
   }
 }
 
@@ -55,19 +55,19 @@ function activityHandler (method) {
       const isAsync =
         handler && handler.constructor && handler.constructor.name === 'AsyncFunction'
 
-      return function () {
-        if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, arguments)
+      return function (...args) {
+        if (!azureDurableFunctionsChannel.hasSubscribers) return handler.apply(this, args)
 
         // use tracePromise if this is an async handler. otherwise, use traceSync
         return isAsync
           ? azureDurableFunctionsChannel.tracePromise(
             handler,
             { trigger: 'Activity', functionName: activityName },
-            this, ...arguments)
+            this, ...args)
           : azureDurableFunctionsChannel.traceSync(
             handler,
             { trigger: 'Activity', functionName: activityName },
-            this, ...arguments)
+            this, ...args)
       }
     })
     return method.apply(this, arguments)

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

@@ -6,8 +6,8 @@ const { wrapThen } = require('./helpers/promise')
 
 function createGetNewLibraryCopyWrap (originalLib) {
   return function wrapGetNewLibraryCopy (getNewLibraryCopy) {
-    return function getNewLibraryCopyWithTrace () {
-      const libraryCopy = getNewLibraryCopy.apply(this, arguments)
+    return function getNewLibraryCopyWithTrace (...args) {
+      const libraryCopy = getNewLibraryCopy.apply(this, args)
       shimmer.wrap(libraryCopy.prototype, '_then', wrapThen)
       shimmer.wrap(libraryCopy, 'getNewLibraryCopy', createGetNewLibraryCopyWrap(originalLib))
       return libraryCopy

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

@@ -6,7 +6,7 @@ const { channel, addHook, AsyncResource } = require('./helpers/instrument')
 const bodyParserReadCh = channel('datadog:body-parser:read:finish')
 
 function publishRequestBodyAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     if (bodyParserReadCh.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)
   })
 }
 

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

@@ -100,13 +100,13 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 4.3'], patchDefault: false }
 })
 
 addHook({ name: 'cassandra-driver', versions: ['>=3.3'], file: 'lib/request-execution.js' }, RequestExecution => {
-  shimmer.wrap(RequestExecution.prototype, '_sendOnConnection', _sendOnConnection => function () {
+  shimmer.wrap(RequestExecution.prototype, '_sendOnConnection', _sendOnConnection => function (...args) {
     if (!startCh.hasSubscribers) {
-      return _sendOnConnection.apply(this, arguments)
+      return _sendOnConnection.apply(this, args)
     }
     startCtx = { hostname: this._connection.address, port: this._connection.port, ...startCtx }
     connectCh.publish(startCtx)
-    return _sendOnConnection.apply(this, arguments)
+    return _sendOnConnection.apply(this, args)
   })
   return RequestExecution
 })
@@ -122,9 +122,9 @@ addHook({ name: 'cassandra-driver', versions: ['3.3 - 4.3'], file: 'lib/request-
       return start.apply(this, arguments)
     }
 
-    arguments[0] = function () {
+    arguments[0] = function (...args) {
       startCtx = { hostname: execution._connection.address, port: execution._connection.port, ...startCtx }
-      return connectCh.runStores(startCtx, getHostCallback, this, ...arguments)
+      return connectCh.runStores(startCtx, getHostCallback, this, ...args)
     }
 
     return start.apply(this, arguments)
@@ -143,9 +143,9 @@ addHook({ name: 'cassandra-driver', versions: ['3 - 3.2'], file: 'lib/request-ha
       return send.apply(this, arguments)
     }
 
-    arguments[2] = function () {
+    arguments[2] = function (...args) {
       startCtx = { hostname: handler.connection.address, port: handler.connection.port, ...startCtx }
-      return connectCh.runStores(startCtx, callback, this, ...arguments)
+      return connectCh.runStores(startCtx, callback, this, ...args)
     }
 
     return send.apply(this, arguments)

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

@@ -82,12 +82,12 @@ function createContextFromChildProcessInfo (childProcessInfo) {
 
 function wrapChildProcessSyncMethod (returnError, shell = false) {
   return function wrapMethod (childProcessMethod) {
-    return function () {
-      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-        return childProcessMethod.apply(this, arguments)
+    return function (...args) {
+      if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+        return childProcessMethod.apply(this, args)
       }
 
-      const callArgs = [...arguments]
+      const callArgs = [...args]
       const childProcessInfo = normalizeArgs(callArgs, shell)
       const context = createContextFromChildProcessInfo(childProcessInfo)
       context.callArgs = callArgs
@@ -118,12 +118,12 @@ function wrapChildProcessSyncMethod (returnError, shell = false) {
 }
 
 function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
-  return function () {
-    if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-      return customPromisifyMethod.apply(this, arguments)
+  return function (...args) {
+    if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+      return customPromisifyMethod.apply(this, args)
     }
 
-    const callArgs = [...arguments]
+    const callArgs = [...args]
     const childProcessInfo = normalizeArgs(callArgs, shell)
 
     const context = createContextFromChildProcessInfo(childProcessInfo)
@@ -170,12 +170,12 @@ function wrapChildProcessCustomPromisifyMethod (customPromisifyMethod, shell) {
 
 function wrapChildProcessAsyncMethod (ChildProcess, shell = false) {
   return function wrapMethod (childProcessMethod) {
-    function wrappedChildProcessMethod () {
-      if (!childProcessChannel.start.hasSubscribers || arguments.length === 0) {
-        return childProcessMethod.apply(this, arguments)
+    function wrappedChildProcessMethod (...args) {
+      if (!childProcessChannel.start.hasSubscribers || args.length === 0) {
+        return childProcessMethod.apply(this, args)
       }
 
-      const callArgs = [...arguments]
+      const callArgs = [...args]
       const childProcessInfo = normalizeArgs(callArgs, shell)
 
       const context = createContextFromChildProcessInfo(childProcessInfo)

package/packages/datadog-instrumentations/src/confluentinc-kafka-javascript.js

@@ -47,8 +47,8 @@ function instrumentBaseModule (module) {
   // Helper function to wrap producer classes
   function wrapProducerClass (ProducerClass, className) {
     return shimmer.wrap(module, className, function wrapProducer (Original) {
-      return function wrappedProducer () {
-        const producer = new Original(...arguments)
+      return function wrappedProducer (...args) {
+        const producer = new Original(...args)
 
         // Hook the produce method
         if (typeof producer?.produce === 'function') {
@@ -94,9 +94,9 @@ function instrumentBaseModule (module) {
   // Helper function to wrap consumer classes
   function wrapConsumerClass (ConsumerClass, className) {
     return shimmer.wrap(module, className, function wrapConsumer (Original) {
-      return function wrappedConsumer () {
-        const consumer = new Original(...arguments)
-        const groupId = this.groupId || (arguments[0]?.['group.id'])
+      return function wrappedConsumer (...args) {
+        const consumer = new Original(...args)
+        const groupId = this.groupId || (args[0]?.['group.id'])
 
         // Wrap the consume method
         if (typeof consumer?.consume === 'function') {
@@ -196,11 +196,11 @@ function instrumentKafkaJS (kafkaJS) {
         // Wrap the producer method if it exists
         if (typeof kafka?.producer === 'function') {
           shimmer.wrap(kafka, 'producer', function wrapProducerMethod (producerMethod) {
-            return function wrappedProducerMethod () {
-              const producer = producerMethod.apply(this, arguments)
+            return function wrappedProducerMethod (...args) {
+              const producer = producerMethod.apply(this, args)
 
-              if (!brokers && arguments?.[0]?.['bootstrap.servers']) {
-                kafka._ddBrokers = arguments[0]['bootstrap.servers']
+              if (!brokers && args?.[0]?.['bootstrap.servers']) {
+                kafka._ddBrokers = args[0]['bootstrap.servers']
               }
 
               // Wrap the send method of the producer

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

@@ -59,16 +59,16 @@ function wrapLayerHandle (layer) {
 
   const original = layer.handle
 
-  return shimmer.wrapFunction(original, original => function () {
-    if (!enterChannel.hasSubscribers) return original.apply(this, arguments)
+  return shimmer.wrapFunction(original, original => function (...args) {
+    if (!enterChannel.hasSubscribers) return original.apply(this, args)
 
-    const lastIndex = arguments.length - 1
+    const lastIndex = args.length - 1
     const name = original._name || original.name
-    const req = arguments[arguments.length > 3 ? 1 : 0]
-    const next = arguments[lastIndex]
+    const req = args[args.length > 3 ? 1 : 0]
+    const next = args[lastIndex]
 
     if (typeof next === 'function') {
-      arguments[lastIndex] = wrapNext(req, next)
+      args[lastIndex] = wrapNext(req, next)
     }
 
     const route = layer.route
@@ -76,7 +76,7 @@ function wrapLayerHandle (layer) {
     enterChannel.publish({ name, req, route })
 
     try {
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     } catch (error) {
       errorChannel.publish({ req, error })
       nextChannel.publish({ req })

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

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

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

@@ -6,8 +6,8 @@ const { channel, addHook } = require('./helpers/instrument')
 const cookieParseCh = channel('datadog:cookie:parse:finish')
 
 function wrapParse (originalParse) {
-  return function () {
-    const cookies = originalParse.apply(this, arguments)
+  return function (...args) {
+    const cookies = originalParse.apply(this, args)
     if (cookieParseCh.hasSubscribers && cookies) {
       cookieParseCh.publish({ cookies })
     }

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

@@ -77,25 +77,25 @@ function wrap (prefix, fn) {
   const finishCh = channel(prefix + ':finish')
   const errorCh = channel(prefix + ':error')
 
-  const wrapped = function () {
+  return function (...args) {
     if (!startCh.hasSubscribers) {
-      return fn.apply(this, arguments)
+      return fn.apply(this, args)
     }
 
-    const callbackIndex = findCallbackIndex(arguments, 1)
+    const callbackIndex = findCallbackIndex(args, 1)
 
-    if (callbackIndex < 0) return fn.apply(this, arguments)
+    if (callbackIndex < 0) return fn.apply(this, args)
 
     const ctx = { bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts }
     return startCh.runStores(ctx, () => {
-      const cb = arguments[callbackIndex]
+      const cb = args[callbackIndex]
 
-      arguments[callbackIndex] = shimmer.wrapFunction(cb, (cb) => {
-        return wrapCallbackFinish(cb, this, arguments, errorCh, finishCh, ctx, prefix)
+      args[callbackIndex] = shimmer.wrapFunction(cb, (cb) => {
+        return wrapCallbackFinish(cb, this, args, errorCh, finishCh, ctx, prefix)
       })
 
       try {
-        return fn.apply(this, arguments)
+        return fn.apply(this, args)
       } catch (error) {
         ctx.error = error
         void error.stack // trigger getting the stack at the original throwing point
@@ -105,7 +105,6 @@ function wrap (prefix, fn) {
       }
     })
   }
-  return wrapped
 }
 
 // semver >=2 <3
@@ -174,12 +173,12 @@ function wrapCBandPromise (fn, name, startData, thisArg, args) {
 
 function wrapWithName (name) {
   return function (operation) {
-    return function () { // no arguments used by us
+    return function (...args) { // no arguments used by us
       return wrapCBandPromise(operation, name, {
         collection: { name: this._name || '_default' },
         bucket: { name: this._scope._bucket._name },
         seedNodes: this._dd_connStr,
-      }, this, arguments)
+      }, this, args)
     }
   }
 }
@@ -240,8 +239,6 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Buc
   wrapAllNames(['upsert', 'insert', 'replace', 'append', 'prepend'], name => {
     shimmer.wrap(Bucket.prototype, name, fn => wrap(`apm:couchbase:${name}`, fn))
   })
-
-  return Bucket
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cluster => {
@@ -251,42 +248,36 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cl
 
   shimmer.wrap(Cluster.prototype, 'query', query => wrapQuery(query))
   shimmer.wrap(Cluster.prototype, 'openBucket', openBucket => {
-    return function () {
-      const bucket = openBucket.apply(this, arguments)
+    return function (...args) {
+      const bucket = openBucket.apply(this, args)
       const hosts = this.dsnObj.hosts
       bucket._dd_hosts = hosts.map(hostAndPort => hostAndPort.join(':')).join(',')
       return bucket
     }
   })
-  return Cluster
 })
 
 // semver >=3 <3.2.0
 
 addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^3.0.7', '^3.1.3'] }, Bucket => {
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
-    return function () {
-      const collection = getCollection.apply(this, arguments)
+    return function (...args) {
+      const collection = getCollection.apply(this, args)
       const connStr = this._cluster._connStr
       collection._dd_connStr = connStr
       return collection
     }
   })
-
-  return Bucket
 })
 
 addHook({ name: 'couchbase', file: 'lib/collection.js', versions: ['^3.0.7', '^3.1.3'] }, Collection => {
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
     shimmer.wrap(Collection.prototype, name, wrapWithName(name))
   })
-
-  return Collection
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.3'] }, Cluster => {
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
-  return Cluster
 })
 
 // semver >=3.2.2
@@ -298,27 +289,22 @@ addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.2'] }
   wrapAllNames(['upsert', 'insert', 'replace'], name => {
     shimmer.wrap(Collection.prototype, name, wrapWithName(name))
   })
-
-  return collection
 })
 
 addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.2'] }, bucket => {
   const Bucket = bucket.Bucket
   shimmer.wrap(Bucket.prototype, 'collection', getCollection => {
-    return function () {
-      const collection = getCollection.apply(this, arguments)
+    return function (...args) {
+      const collection = getCollection.apply(this, args)
       const connStr = this._cluster._connStr
       collection._dd_connStr = connStr
       return collection
     }
   })
-
-  return bucket
 })
 
 addHook({ name: 'couchbase', file: 'dist/cluster.js', versions: ['>=3.2.2'] }, (cluster) => {
   const Cluster = cluster.Cluster
 
   shimmer.wrap(Cluster.prototype, 'query', wrapV3Query)
-  return cluster
 })

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

@@ -47,12 +47,12 @@ addHook({ name: 'crypto' }, crypto => {
 
 function wrapCryptoMethod (channel) {
   function wrapMethod (cryptoMethod) {
-    return function () {
-      if (channel.hasSubscribers && arguments.length > 0) {
-        const algorithm = arguments[0]
+    return function (...args) {
+      if (channel.hasSubscribers && args.length > 0) {
+        const algorithm = args[0]
         channel.publish({ algorithm })
       }
-      return cryptoMethod.apply(this, arguments)
+      return cryptoMethod.apply(this, args)
     }
   }
   return wrapMethod