dd-trace 5.101.0 → 5.103.0

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/fetch.js

@@ -5,10 +5,10 @@ const { IS_SERVERLESS } = require('../../dd-trace/src/serverless')
 if (globalThis.fetch) {
   const globalFetch = globalThis.fetch
 
-  let fetch = (input, init) => {
+  let wrappedFetch = (input, init) => {
     wrapRealFetch()
 
-    return fetch(input, init)
+    return wrappedFetch(input, init)
   }
 
   function wrapRealFetch () {
@@ -20,14 +20,14 @@ if (globalThis.fetch) {
       channel('dd-trace:instrumentation:load').publish({ name: 'global:fetch' })
     })
 
-    fetch = wrapFetch(globalFetch)
+    wrappedFetch = wrapFetch(globalFetch)
   }
 
   if (!IS_SERVERLESS) {
     wrapRealFetch()
   }
 
-  globalThis.fetch = function value (input, init) {
-    return fetch(input, init)
+  globalThis.fetch = function fetch (input, init) {
+    return wrappedFetch(input, init)
   }
 }

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/graphql.js

@@ -169,7 +169,7 @@ function wrapExecute (execute) {
       const ctx = {
         operation,
         args,
-        docSource: documentSources.get(document),
+        docSource: source,
         source,
         fields: Object.create(null),
         abortController: new AbortController(),
@@ -257,13 +257,17 @@ function callInAsyncScope (fn, thisArg, args, abortController, cb) {
 }
 
 function pathToArray (path) {
-  const flattened = []
-  let curr = path
-  while (curr) {
-    flattened.push(curr.key)
-    curr = curr.prev
+  let length = 0
+  for (let curr = path; curr; curr = curr.prev) {
+    length += 1
   }
-  return flattened.reverse()
+
+  const flattened = new Array(length)
+  let index = length
+  for (let curr = path; curr; curr = curr.prev) {
+    flattened[--index] = curr.key
+  }
+  return flattened
 }
 
 function assertField (rootCtx, info, args) {
@@ -295,9 +299,7 @@ function wrapFields (type) {
 
   patchedTypes.add(type)
 
-  for (const key of Object.keys(type._fields)) {
-    const field = type._fields[key]
-
+  for (const field of Object.values(type._fields)) {
     wrapFieldResolve(field)
     wrapFieldType(field)
   }
@@ -321,8 +323,7 @@ function wrapFieldType (field) {
 }
 
 function finishResolvers ({ fields }) {
-  for (const key of Object.keys(fields).reverse()) {
-    const field = fields[key]
+  for (const field of Object.values(fields)) {
     field.ctx.finishTime = field.finishTime
     field.ctx.field = field
     if (field.error) {

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

@@ -19,7 +19,7 @@ const { channel } = require('./instrument')
  *
  * @param {string} prefix
  * @param {object} [options]
- * @param {boolean} [options.captureResult=false] set `ctx.result` to the callback's first
+ * @param {boolean} [options.captureResult] set `ctx.result` to the callback's first
  *   non-error argument before publishing `:finish`. Plugins that tag spans from the call's
  *   return value (e.g. the DNS lookup plugin) rely on this.
  * @returns {(buildContext: (thisArg: unknown, args: IArguments) => object | undefined) =>
@@ -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/hook.js

@@ -16,7 +16,10 @@ function getVersion (moduleBaseDir) {
     return requirePackageJson(moduleBaseDir, /** @type {import('module').Module} */ (module)).version
   }
 
-  return process.version
+  // In a packaged Electron binary, built-in modules (like 'electron', 'electron/main') have no
+  // moduleBaseDir. Use the Electron version for version checks when available, otherwise fall back
+  // to the Node.js version.
+  return process.versions?.electron ?? process.version
 }
 
 /**

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

@@ -68,6 +68,7 @@ module.exports = {
   cypress: () => require('../cypress'),
   'dd-trace-api': () => require('../dd-trace-api'),
   elasticsearch: () => require('../elasticsearch'),
+  electron: () => require('../electron'),
   express: () => require('../express'),
   'express-mongo-sanitize': () => require('../express-mongo-sanitize'),
   'express-session': () => require('../express-session'),

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

@@ -55,9 +55,9 @@ exports.getHooks = function getHooks (names) {
  * @param {object} args
  * @param {string} args.name module name
  * @param {string[]} [args.versions] array of semver range strings
- * @param {string} [args.file='index.js'] path to file within package to instrument
+ * @param {string} [args.file] path to file within package to instrument. Defaults to 'index.js'.
  * @param {string} [args.filePattern] pattern to match files within package to instrument
- * @param {boolean} [args.patchDefault=true] whether to patch the default export
+ * @param {boolean} [args.patchDefault] whether to patch the default export. Defaults to true.
  * @param {(moduleExports: unknown, version: string, isIitm?: boolean) => unknown} [hook] Patches module exports
  */
 exports.addHook = function addHook ({ name, versions, file, filePattern, patchDefault }, hook) {

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

@@ -0,0 +1,41 @@
+'use strict'
+
+// Side-table mapping a kafkajs producer/consumer to the cluster captured at
+// creation time. The boundary uses it to read `cluster.brokerPool` lazily on
+// first send/consume instead of opening a parallel admin connection. A
+// WeakMap keeps the kafkajs object itself untouched: no Symbol-keyed
+// property to leak through `Reflect.ownKeys`, no string-keyed underscore for
+// user serializers to pick up, and the entry drops as soon as the producer
+// is GC'd.
+const clientToCluster = new WeakMap()
+
+/**
+ * Shallow-clone each message and its headers so the boundary, kafkajs, and
+ * the user never share the same nested objects. With `ensureHeaders` true
+ * (header injection enabled) messages without `headers` get an empty object
+ * the producer plugin can inject into; with it false (broker rejected
+ * headers) the absence of `headers` is preserved so brokers that fail on any
+ * header field can recover.
+ *
+ * @param {Array<unknown>} messages
+ * @param {boolean} ensureHeaders
+ */
+function cloneMessages (messages, ensureHeaders) {
+  const result = new Array(messages.length)
+  for (let i = 0; i < messages.length; i++) {
+    const message = messages[i]
+    if (message === null || typeof message !== 'object') {
+      result[i] = message
+    } else if (message.headers) {
+      result[i] = { ...message, headers: { ...message.headers } }
+    } else {
+      result[i] = ensureHeaders ? { ...message, headers: {} } : { ...message }
+    }
+  }
+  return result
+}
+
+module.exports = {
+  clientToCluster,
+  cloneMessages,
+}

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

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

@@ -10,6 +10,8 @@ const startCh = channel('apm:ioredis:command:start')
 const finishCh = channel('apm:ioredis:command:finish')
 const errorCh = channel('apm:ioredis:command:error')
 
+const connectionOptionsCache = new WeakMap()
+
 function wrapRedis (Redis) {
   shimmer.wrap(Redis.prototype, 'sendCommand', sendCommand => function (command, stream) {
     if (!startCh.hasSubscribers) return sendCommand.apply(this, arguments)
@@ -17,21 +19,23 @@ function wrapRedis (Redis) {
     if (!command || !command.promise) return sendCommand.apply(this, arguments)
 
     const options = this.options || {}
-    const connectionName = options.connectionName
-    const db = options.db
-    const connectionOptions = { host: options.host, port: options.port }
-
-    const ctx = { db, command: command.name, args: command.args, connectionOptions, connectionName }
+    let connectionOptions = connectionOptionsCache.get(this)
+    if (connectionOptions === undefined) {
+      connectionOptions = { host: options.host, port: options.port }
+      connectionOptionsCache.set(this, connectionOptions)
+    }
+
+    const ctx = {
+      db: options.db,
+      command: command.name,
+      args: command.args,
+      connectionOptions,
+      connectionName: options.connectionName,
+    }
     return startCh.runStores(ctx, () => {
       command.promise.then(() => finish(finishCh, errorCh, ctx), err => finish(finishCh, errorCh, ctx, err))
 
-      try {
-        return sendCommand.apply(this, arguments)
-      } catch (err) {
-        errorCh.publish(err)
-
-        throw err
-      }
+      return sendCommand.apply(this, arguments)
     })
   })
   return Redis