dd-trace 5.101.0 → 5.102.0

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

@@ -18,8 +18,6 @@ const rrtypes = {
   resolveSoa: 'SOA',
 }
 
-const rrtypeMap = new WeakMap()
-
 addHook({ name: 'dns' }, dns => {
   const lookup = createCallbackInstrumentor('apm:dns:lookup', { captureResult: true })
   const lookupService = createCallbackInstrumentor('apm:dns:lookup_service', { captureResult: true })
@@ -46,7 +44,6 @@ addHook({ name: 'dns' }, dns => {
 function patchResolveShorthands (prototype, resolve) {
   for (const method of Object.keys(rrtypes)) {
     if (prototype[method]) {
-      rrtypeMap.set(prototype[method], rrtypes[method])
       shimmer.wrap(prototype, method, resolve(buildArgsContext(rrtypes[method])))
     }
   }

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

@@ -24,24 +24,21 @@ function wrapTransportPrototype (Transport) {
 addHook({ name: '@elastic/elasticsearch', file: 'lib/Transport.js', versions: ['>=5.6.16 <8', '>=8'] }, Transport => {
   shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
   shimmer.wrap(Transport.prototype, 'getConnection', createWrapGetConnection('elasticsearch'))
-  return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/transport.js', versions: ['>=10'] }, Transport => {
   shimmer.wrap(Transport.prototype, 'request', createWrapRequest('elasticsearch'))
-  return Transport
 })
 
 addHook({ name: 'elasticsearch', file: 'src/lib/connection_pool.js', versions: ['>=10'] }, ConnectionPool => {
-  shimmer.wrap(ConnectionPool.prototype, 'select', createWrapSelect('elasticsearch'))
-  return ConnectionPool
+  shimmer.wrap(ConnectionPool.prototype, 'select', createWrapSelect())
 })
 
 function createWrapGetConnection (name) {
   const connectCh = channel(`apm:${name}:query:connect`)
   return function wrapRequest (request) {
-    return function () {
-      const connection = request.apply(this, arguments)
+    return function (...args) {
+      const connection = request.apply(this, args)
       if (connectCh.hasSubscribers && connection && connection.url) {
         connectCh.publish(connection.url)
       }
@@ -53,17 +50,17 @@ function createWrapGetConnection (name) {
 function createWrapSelect () {
   const connectCh = channel('apm:elasticsearch:query:connect')
   return function wrapRequest (request) {
-    return function () {
-      if (arguments.length === 1) {
-        const cb = arguments[0]
-        arguments[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
+    return function (...args) {
+      if (args.length === 1) {
+        const cb = args[0]
+        args[0] = shimmer.wrapFunction(cb, cb => function (err, connection) {
           if (connectCh.hasSubscribers && connection && connection.host) {
             connectCh.publish({ hostname: connection.host.host, port: connection.host.port })
           }
           cb(err, connection)
         })
       }
-      return request.apply(this, arguments)
+      return request.apply(this, args)
     }
   }
 }

package/packages/datadog-instrumentations/src/express-mongo-sanitize.js

@@ -12,8 +12,8 @@ const sanitizeMiddlewareFinished = channel('datadog:express-mongo-sanitize:filte
 const propertiesToSanitize = ['body', 'params', 'headers', 'query']
 
 addHook({ name: 'express-mongo-sanitize', versions: ['>=1.0.0'] }, expressMongoSanitize => {
-  shimmer.wrap(expressMongoSanitize, 'sanitize', sanitize => function () {
-    const sanitizedObject = sanitize.apply(this, arguments)
+  shimmer.wrap(expressMongoSanitize, 'sanitize', sanitize => function (...args) {
+    const sanitizedObject = sanitize.apply(this, args)
 
     if (sanitizeMethodFinished.hasSubscribers) {
       sanitizeMethodFinished.publish({ sanitizedObject })
@@ -22,21 +22,21 @@ addHook({ name: 'express-mongo-sanitize', versions: ['>=1.0.0'] }, expressMongoS
     return sanitizedObject
   })
 
-  return shimmer.wrapFunction(expressMongoSanitize, expressMongoSanitize => function () {
-    const middleware = expressMongoSanitize.apply(this, arguments)
+  return shimmer.wrapFunction(expressMongoSanitize, expressMongoSanitize => function (...args) {
+    const middleware = expressMongoSanitize.apply(this, args)
 
     return shimmer.wrapFunction(middleware, middleware => function (req, res, next) {
       if (!sanitizeMiddlewareFinished.hasSubscribers) {
         return middleware.apply(this, arguments)
       }
 
-      const wrappedNext = shimmer.wrapFunction(next, next => function () {
+      const wrappedNext = shimmer.wrapFunction(next, next => function (...args) {
         sanitizeMiddlewareFinished.publish({
           sanitizedProperties: propertiesToSanitize,
           req,
         })
 
-        return next.apply(this, arguments)
+        return next.apply(this, args)
       })
 
       return middleware.call(this, req, res, wrappedNext)

package/packages/datadog-instrumentations/src/express-session.js

@@ -8,7 +8,7 @@ const sessionMiddlewareFinishCh = channel('datadog:express-session:middleware:fi
 function wrapSessionMiddleware (sessionMiddleware) {
   return function wrappedSessionMiddleware (req, res, next) {
     shimmer.wrap(arguments, 2, function wrapNext (next) {
-      return function wrappedNext () {
+      return function wrappedNext (...args) {
         if (sessionMiddlewareFinishCh.hasSubscribers) {
           const abortController = new AbortController()
 
@@ -17,7 +17,7 @@ function wrapSessionMiddleware (sessionMiddleware) {
           if (abortController.signal.aborted) return
         }
 
-        return next.apply(this, arguments)
+        return next.apply(this, args)
       }
     })
 
@@ -26,8 +26,8 @@ function wrapSessionMiddleware (sessionMiddleware) {
 }
 
 function wrapSession (session) {
-  return function wrappedSession () {
-    const sessionMiddleware = session.apply(this, arguments)
+  return function wrappedSession (...args) {
+    const sessionMiddleware = session.apply(this, args)
 
     return shimmer.wrapFunction(sessionMiddleware, wrapSessionMiddleware)
   }

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

@@ -54,13 +54,12 @@ function wrapResponseRender (render) {
 
     const abortController = new AbortController()
     return responseRenderChannel.traceSync(
-      function () {
+      function (...args) {
         if (abortController.signal.aborted) {
-          const error = abortController.signal.reason || new Error('Aborted')
-          throw error
+          throw abortController.signal.reason || new Error('Aborted')
         }
 
-        return render.apply(this, arguments)
+        return render.apply(this, args)
       },
       {
         req: this.req,
@@ -173,7 +172,7 @@ addHook({ name: 'express', versions: ['4'], file: 'lib/express.js' }, express =>
 const queryParserReadCh = channel('datadog:query:read:finish')
 
 function publishQueryParsedAndNext (req, res, next) {
-  return shimmer.wrapFunction(next, next => function () {
+  return shimmer.wrapFunction(next, next => function (...args) {
     if (queryParserReadCh.hasSubscribers && req) {
       const abortController = new AbortController()
       const query = req.query
@@ -183,7 +182,7 @@ function publishQueryParsedAndNext (req, res, next) {
       if (abortController.signal.aborted) return
     }
 
-    return next.apply(this, arguments)
+    return next.apply(this, args)
   })
 }
 
@@ -192,8 +191,8 @@ addHook({
   versions: ['4'],
   file: 'lib/middleware/query.js',
 }, query => {
-  return shimmer.wrapFunction(query, query => function () {
-    const queryMiddleware = query.apply(this, arguments)
+  return shimmer.wrapFunction(query, query => function (...args) {
+    const queryMiddleware = query.apply(this, args)
 
     return shimmer.wrapFunction(queryMiddleware, queryMiddleware => function (req, res, next) {
       arguments[2] = publishQueryParsedAndNext(req, res, next)
@@ -205,9 +204,9 @@ addHook({
 const processParamsStartCh = channel('datadog:express:process_params:start')
 function wrapProcessParamsMethod (requestPositionInArguments) {
   return function wrapProcessParams (original) {
-    return function wrappedProcessParams () {
+    return function wrappedProcessParams (...args) {
       if (processParamsStartCh.hasSubscribers) {
-        const req = arguments[requestPositionInArguments]
+        const req = args[requestPositionInArguments]
         const abortController = new AbortController()
 
         processParamsStartCh.publish({
@@ -220,7 +219,7 @@ function wrapProcessParamsMethod (requestPositionInArguments) {
         if (abortController.signal.aborted) return
       }
 
-      return original.apply(this, arguments)
+      return original.apply(this, args)
     }
   }
 }

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

@@ -25,8 +25,8 @@ const bodyPublished = new WeakSet()
 function wrapFastify (fastify, hasParsingEvents) {
   if (typeof fastify !== 'function') return fastify
 
-  return function fastifyWithTrace () {
-    const app = fastify.apply(this, arguments)
+  return function fastifyWithTrace (...args) {
+    const app = fastify.apply(this, args)
 
     if (!app || typeof app.addHook !== 'function') return app
 

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

@@ -165,13 +165,13 @@ function initDirAsyncIteratorProperties (iterator) {
 
 function createWrapDirAsyncIterator () {
   return function wrapDirAsyncIterator (asyncIterator) {
-    return function wrappedAsyncIterator () {
+    return function wrappedAsyncIterator (...args) {
       if (!kDirReadPromisified || !kDirClosePromisified) {
         initDirAsyncIteratorProperties(this)
       }
       wrap(this, kDirReadPromisified, createWrapFunction('dir.', 'read'))
       wrap(this, kDirClosePromisified, createWrapFunction('dir.', 'close'))
-      return asyncIterator.apply(this, arguments)
+      return asyncIterator.apply(this, args)
     }
   }
 }
@@ -231,12 +231,12 @@ function createWatchWrapFunction (override = '') {
     const name = override || original.name
     const method = name
     const operation = name
-    return function () {
-      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
-      const ctx = getMessage(method, watchMethods[operation], arguments, this)
+    return function (...args) {
+      if (!startChannel.hasSubscribers) return original.apply(this, args)
+      const ctx = getMessage(method, watchMethods[operation], args, this)
       return startChannel.runStores(ctx, () => {
         try {
-          const result = original.apply(this, arguments)
+          const result = original.apply(this, args)
           finishChannel.runStores(ctx, () => {})
           return result
         } catch (error) {
@@ -256,14 +256,14 @@ function createWrapFunction (prefix = '', override = '') {
     const method = `${prefix}${name}`
     const operation = name.match(/^(.+?)(Sync)?(\.native)?$/)[1]
 
-    return function () {
-      if (!startChannel.hasSubscribers) return original.apply(this, arguments)
+    return function (...args) {
+      if (!startChannel.hasSubscribers) return original.apply(this, args)
 
-      const lastIndex = arguments.length - 1
-      const cb = typeof arguments[lastIndex] === 'function' && arguments[lastIndex]
+      const lastIndex = args.length - 1
+      const cb = typeof args[lastIndex] === 'function' && args[lastIndex]
       const params = getMethodParamsRelationByPrefix(prefix)[operation]
       const abortController = new AbortController()
-      const ctx = { ...getMessage(method, params, arguments, this), abortController }
+      const ctx = { ...getMessage(method, params, args, this), abortController }
 
       const finish = function (error, cb = () => {}) {
         if (error !== null && typeof error === 'object') { // fs.exists receives a boolean
@@ -274,7 +274,7 @@ function createWrapFunction (prefix = '', override = '') {
       }
 
       if (cb) {
-        arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (e) {
+        args[lastIndex] = shimmer.wrapFunction(cb, cb => function (e) {
           return finish(e, () => cb.apply(this, arguments))
         })
       }
@@ -290,13 +290,13 @@ function createWrapFunction (prefix = '', override = '') {
             finish(error)
             throw error
           } else if (cb) {
-            arguments[lastIndex](error)
+            args[lastIndex](error)
             return
           }
         }
 
         try {
-          const result = original.apply(this, arguments)
+          const result = original.apply(this, args)
           if (cb) return result
           if (result && typeof result.then === 'function') {
             // TODO method open returning promise and filehandle prototype not initialized, initialize it

package/packages/datadog-instrumentations/src/google-cloud-pubsub.js

@@ -167,17 +167,17 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/su
    * Flow: message.ack() -> store context -> acknowledge() API -> retrieve context
    */
   if (Message?.prototype?.ack) {
-    shimmer.wrap(Message.prototype, 'ack', originalAck => function () {
+    shimmer.wrap(Message.prototype, 'ack', originalAck => function (...args) {
       if (this.ackId) {
         const ctx = {
           message: this,
           ackId: this.ackId,
         }
 
-        return messageAckStoreCh.runStores(ctx, originalAck, this, ...arguments)
+        return messageAckStoreCh.runStores(ctx, originalAck, this, ...args)
       }
 
-      return originalAck.apply(this, arguments)
+      return originalAck.apply(this, args)
     })
   }
 
@@ -212,7 +212,7 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/le
     return receiveFinishCh.runStores(ctx || { message }, remove, this, ...arguments)
   })
 
-  shimmer.wrap(LeaseManager.prototype, 'clear', clear => function () {
+  shimmer.wrap(LeaseManager.prototype, 'clear', clear => function (...args) {
     if (this._messages) {
       for (const message of this._messages.values()) {
         const ctx = messageContexts.get(message)
@@ -222,10 +222,8 @@ addHook({ name: '@google-cloud/pubsub', versions: ['>=1.2'], file: 'build/src/le
         }
       }
     }
-    return clear.apply(this, arguments)
+    return clear.apply(this, args)
   })
-
-  return obj
 })
 
 /**

package/packages/datadog-instrumentations/src/google-genai.js

@@ -46,10 +46,10 @@ function wrapGenerateContent (method) {
 }
 
 function wrapStreamIterator (iterator, ctx) {
-  return function () {
-    const itr = iterator.apply(this, arguments)
-    shimmer.wrap(itr, 'next', next => function () {
-      return next.apply(this, arguments)
+  return function (...args) {
+    const itr = iterator.apply(this, args)
+    shimmer.wrap(itr, 'next', next => function (...args) {
+      return next.apply(this, args)
         .then(res => {
           const { done, value: chunk } = res
           onStreamedChunkCh.publish({ ctx, chunk, done })

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

@@ -49,9 +49,9 @@ function wrapHandler (func, name) {
         }
 
         shimmer.wrap(call, 'emit', emit => {
-          return function () {
+          return function (...args) {
             return emitChannel.runStores(ctx, () => {
-              return emit.apply(this, arguments)
+              return emit.apply(this, args)
             })
           }
         })

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

@@ -28,12 +28,12 @@ function wrapServer (server) {
 }
 
 function wrapStart (start) {
-  return shimmer.wrapFunction(start, start => function () {
+  return shimmer.wrapFunction(start, start => function (...args) {
     if (this && typeof this.ext === 'function') {
       this.ext('onPreResponse', onPreResponse)
     }
 
-    return start.apply(this, arguments)
+    return start.apply(this, args)
   })
 }
 

package/packages/datadog-instrumentations/src/helpers/callback-instrumentor.js

@@ -32,20 +32,20 @@ function createCallbackInstrumentor (prefix, { captureResult = false } = {}) {
 
   return function instrument (buildContext) {
     return function wrap (fn) {
-      return function () {
-        const lastIndex = arguments.length - 1
-        const cb = arguments[lastIndex]
+      return function (...args) {
+        const lastIndex = args.length - 1
+        const cb = args[lastIndex]
         if (!startCh.hasSubscribers || typeof cb !== 'function') {
-          return fn.apply(this, arguments)
+          return fn.apply(this, args)
         }
 
-        const ctx = buildContext(this, arguments)
+        const ctx = buildContext(this, args)
         if (ctx === undefined) {
-          return fn.apply(this, arguments)
+          return fn.apply(this, args)
         }
 
         return startCh.runStores(ctx, () => {
-          arguments[lastIndex] = shimmer.wrapFunction(cb, cb => function (error, ...rest) {
+          args[lastIndex] = shimmer.wrapFunction(cb, cb => function (error, ...rest) {
             if (error) {
               ctx.error = error
               errorCh.publish(ctx)
@@ -57,7 +57,7 @@ function createCallbackInstrumentor (prefix, { captureResult = false } = {}) {
           })
 
           try {
-            return fn.apply(this, arguments)
+            return fn.apply(this, args)
           } catch (error) {
             void error.stack // trigger getting the stack at the original throwing point
             ctx.error = error

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

@@ -21,9 +21,9 @@ exports.wrapThen = function wrapThen (origThen) {
 function wrapCallback (ar, callback) {
   if (typeof callback !== 'function') return callback
 
-  return function () {
+  return function (...args) {
     return ar.runInAsyncScope(() => {
-      return callback.apply(this, arguments)
+      return callback.apply(this, args)
     })
   }
 }

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

@@ -56,10 +56,10 @@ function wrapNext (req, route, next) {
   return shimmer.wrapFunction(
     next,
     (next) =>
-      function () {
+      function (...args) {
         nextChannel.publish({ req, route })
 
-        return next.apply(this, arguments)
+        return next.apply(this, args)
       }
   )
 }

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

@@ -107,8 +107,8 @@ function setupResponseInstrumentation (ctx, res) {
       // For 'readable' events, wrap the read() method
       if (eventName === 'readable' && !originalRead && !dataListenerAdded && typeof res.read === 'function') {
         originalRead = res.read
-        res.read = function () {
-          const chunk = originalRead.apply(this, arguments)
+        res.read = function (...args) {
+          const chunk = originalRead.apply(this, args)
           if (!dataListenerAdded) {
             dataReadStarted = true
             collectChunk(chunk)
@@ -189,9 +189,9 @@ function patch (http, methodName) {
         let callback = args.callback
 
         if (callback) {
-          callback = shimmer.wrapFunction(args.callback, cb => function () {
+          callback = shimmer.wrapFunction(args.callback, cb => function (...args) {
             return asyncStartChannel.runStores(ctx, () => {
-              return cb.apply(this, arguments)
+              return cb.apply(this, args)
             })
           })
         }
@@ -214,9 +214,9 @@ function patch (http, methodName) {
 
           // tracked to accurately discern custom request socket timeout
           let customRequestTimeout = false
-          req.setTimeout = function () {
+          req.setTimeout = function (...args) {
             customRequestTimeout = true
-            return setTimeout.apply(this, arguments)
+            return setTimeout.apply(this, args)
           }
 
           req.emit = function (eventName, arg) {

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

@@ -126,9 +126,9 @@ function wrapWriteHead (writeHead) {
 }
 
 function wrapWrite (write) {
-  return function wrappedWrite () {
+  return function wrappedWrite (...args) {
     if (!startWriteHeadCh.hasSubscribers) {
-      return write.apply(this, arguments)
+      return write.apply(this, args)
     }
 
     const abortController = new AbortController()
@@ -147,7 +147,7 @@ function wrapWrite (write) {
       return true
     }
 
-    return write.apply(this, arguments)
+    return write.apply(this, args)
   }
 }
 
@@ -177,9 +177,9 @@ function wrapSetHeader (setHeader) {
 }
 
 function wrapAppendOrRemoveHeader (originalMethod) {
-  return function wrappedAppendOrRemoveHeader () {
+  return function wrappedAppendOrRemoveHeader (...args) {
     if (!startSetHeaderCh.hasSubscribers) {
-      return originalMethod.apply(this, arguments)
+      return originalMethod.apply(this, args)
     }
 
     const abortController = new AbortController()
@@ -189,14 +189,14 @@ function wrapAppendOrRemoveHeader (originalMethod) {
       return this
     }
 
-    return originalMethod.apply(this, arguments)
+    return originalMethod.apply(this, args)
   }
 }
 
 function wrapEnd (end) {
-  return function wrappedEnd () {
+  return function wrappedEnd (...args) {
     if (!startWriteHeadCh.hasSubscribers) {
-      return end.apply(this, arguments)
+      return end.apply(this, args)
     }
 
     const abortController = new AbortController()
@@ -215,6 +215,6 @@ function wrapEnd (end) {
       return this
     }
 
-    return end.apply(this, arguments)
+    return end.apply(this, args)
   }
 }