dd-trace 5.102.0 → 5.104.0

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

@@ -14,11 +14,14 @@ const finishChannel = channel('apm:grpc:client:request:finish')
 const emitChannel = channel('apm:grpc:client:request:emit')
 
 function createWrapMakeRequest (type, hasPeer = false) {
+  const metadataIndex = type === types.client_stream || type === types.bidi ? 3 : 4
+
   return function wrapMakeRequest (makeRequest) {
     return function (path) {
-      const args = ensureMetadata(this, arguments, 4)
+      if (!startChannel.hasSubscribers) return makeRequest.apply(this, arguments)
 
-      return callMethod(this, makeRequest, args, path, args[4], type, hasPeer)
+      const { metadata, args } = resolveMetadata(this, arguments, metadataIndex)
+      return callMethod(this, makeRequest, args, path, metadata, type, hasPeer)
     }
   }
 }
@@ -82,9 +85,13 @@ function wrapMethod (method, path, type, hasPeer) {
     return method
   }
 
+  const metadataIndex = type === types.client_stream || type === types.bidi ? 0 : 1
+
   const wrapped = shimmer.wrapFunction(method, method => function () {
-    const args = ensureMetadata(this, arguments, 1)
-    return callMethod(this, method, args, path, args[1], type, hasPeer)
+    if (!startChannel.hasSubscribers) return method.apply(this, arguments)
+
+    const { metadata, args } = resolveMetadata(this, arguments, metadataIndex)
+    return callMethod(this, method, args, path, metadata, type, hasPeer)
   })
 
   patched.add(wrapped)
@@ -140,24 +147,25 @@ function createWrapEmit (ctx, hasPeer = false) {
 }
 
 function callMethod (client, method, args, path, metadata, type, hasPeer = false) {
-  if (!startChannel.hasSubscribers) return method.apply(client, args)
-
-  const length = args.length
-  const callback = args[length - 1]
-
   const ctx = { metadata, path, type }
 
   return startChannel.runStores(ctx, () => {
     try {
+      let callArgs = args
+
       if (type === types.unary || type === types.client_stream) {
+        if (!Array.isArray(callArgs)) callArgs = [...callArgs]
+
+        const length = callArgs.length
+        const callback = callArgs[length - 1]
         if (typeof callback === 'function') {
-          args[length - 1] = wrapCallback(ctx, callback)
+          callArgs[length - 1] = wrapCallback(ctx, callback)
         } else {
-          args[length] = wrapCallback(ctx)
+          callArgs[length] = wrapCallback(ctx)
         }
       }
 
-      const call = method.apply(client, args)
+      const call = method.apply(client, callArgs)
 
       if (call && typeof call.emit === 'function') {
         shimmer.wrap(call, 'emit', createWrapEmit(ctx, hasPeer))
@@ -167,36 +175,44 @@ function callMethod (client, method, args, path, metadata, type, hasPeer = false
     } catch (e) {
       ctx.error = e
       errorChannel.publish(ctx)
+      throw e
     }
     // No end channel needed
   })
 }
 
-function ensureMetadata (client, args, index) {
-  const grpc = getGrpc(client)
-
-  if (!client || !grpc) return args
-
-  const meta = args[index]
-  const normalized = []
-
-  for (let i = 0; i < index; i++) {
-    normalized.push(args[i])
+/**
+ * Returns the `Metadata` for a gRPC client invocation, splicing or replacing
+ * one at `index` when the user did not pass their own.
+ *
+ * @param {object} client
+ * @param {ArrayLike<unknown>} args
+ * @param {number} index
+ * @returns {{ metadata: object | undefined, args: ArrayLike<unknown> }}
+ */
+function resolveMetadata (client, args, index) {
+  const grpc = client && getGrpc(client)
+  if (!grpc) return { metadata: undefined, args }
+
+  const slot = args[index]
+
+  if (slot instanceof grpc.Metadata || slot?.constructor?.name === 'Metadata') {
+    return { metadata: slot, args }
   }
 
-  if (!meta || !meta.constructor || meta.constructor.name !== 'Metadata') {
-    normalized.push(new grpc.Metadata())
-  }
-
-  if (meta) {
-    normalized.push(meta)
-  }
+  const metadata = new grpc.Metadata()
 
-  for (let i = index + 1; i < args.length; i++) {
-    normalized.push(args[i])
+  if (slot == null) {
+    const out = [...args]
+    out[index] = metadata
+    return { metadata, args: out }
   }
 
-  return normalized
+  const out = new Array(args.length + 1)
+  for (let i = 0; i < index; i++) out[i] = args[i]
+  out[index] = metadata
+  for (let i = index; i < args.length; i++) out[i + 1] = args[i]
+  return { metadata, args: out }
 }
 
 function getType (definition) {

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) =>
@@ -45,7 +45,7 @@ function createCallbackInstrumentor (prefix, { captureResult = false } = {}) {
         }
 
         return startCh.runStores(ctx, () => {
-          args[lastIndex] = shimmer.wrapFunction(cb, cb => function (error, ...rest) {
+          args[lastIndex] = shimmer.wrapCallback(cb, cb => function (error, ...rest) {
             if (error) {
               ctx.error = error
               errorCh.publish(ctx)

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,58 @@
+'use strict'
+
+// Produce API key 0; v0–v2 use the legacy MessageSet format with no header
+// field, so trace headers can only be carried on v3+ (Kafka >=0.11).
+const PRODUCE_API_KEY = 0
+const PRODUCE_VERSION_WITH_HEADERS = 3
+
+// 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
+}
+
+/**
+ * @param {{ versions?: Record<number, { minVersion: number, maxVersion: number }> } | undefined} brokerPool
+ *   kafkajs's `cluster.brokerPool`. `versions` is populated once the seed
+ *   broker handshakes; before that, the answer is unknown and we return
+ *   `true` so the caller defaults to injection.
+ */
+function brokerSupportsMessageHeaders (brokerPool) {
+  const produce = brokerPool?.versions?.[PRODUCE_API_KEY]
+  return !produce || produce.maxVersion >= PRODUCE_VERSION_WITH_HEADERS
+}
+
+module.exports = {
+  brokerSupportsMessageHeaders,
+  clientToCluster,
+  cloneMessages,
+}

package/packages/datadog-instrumentations/src/helpers/rewriter/compiler.js

@@ -19,9 +19,10 @@ const compiler = {
       // TODO: Figure out ESBuild `createRequire` issue and remove this hack.
       const oxc = runtimeRequire(['oxc', 'parser'].join('-'))
 
-      compiler.parse = (sourceText, options) => {
+      compiler.parse = (sourceText, { range, isModule } = {}) => {
         const { program, errors } = oxc.parseSync('index.js', sourceText, {
-          ...options,
+          range,
+          sourceType: isModule ? 'module' : 'script',
           preserveParens: false,
         })
 

package/packages/datadog-instrumentations/src/helpers/rewriter/index.js

@@ -2,15 +2,25 @@
 
 const { readFileSync } = require('fs')
 const { join } = require('path')
+const { pathToFileURL } = require('url')
 const log = require('../../../../dd-trace/src/log')
 const { create } = require('../../../../../vendor/dist/@apm-js-collab/code-transformer')
 const { traceAsyncIterator, traceIterator } = require('./transforms')
 const instrumentations = require('./instrumentations')
 
-let dcPolyfill
+// `dc-polyfill` is referenced from injected `require()` (CJS) and `import`
+// (ESM) statements that the transformer splices into the rewritten module.
+// `require()` accepts an absolute filesystem path; the ESM resolver rejects it
+// with `ERR_INVALID_MODULE_SPECIFIER` and needs a `file://` URL instead. We
+// pre-compute both forms here so each matcher hands the transformer a
+// specifier that is valid for the module type it is rewriting.
+let dcPolyfillCjs
+let dcPolyfillEsm
 
 try {
-  dcPolyfill = require.resolve('dc-polyfill').replaceAll('\\', '/')
+  const resolved = require.resolve('dc-polyfill')
+  dcPolyfillCjs = resolved.replaceAll('\\', '/')
+  dcPolyfillEsm = pathToFileURL(resolved).href
 } catch {
   // The `dc-polyfill` module is unavailable for some reason (like bundling).
   // Let's just keep the default of using `diagnostics-channel` as a fallback
@@ -20,10 +30,13 @@ try {
 /** @type {Record<string, string>} map of module base name to version */
 const moduleVersions = {}
 const disabled = new Set()
-const matcher = create(instrumentations, dcPolyfill)
+const matcherCjs = create(instrumentations, dcPolyfillCjs)
+const matcherEsm = create(instrumentations, dcPolyfillEsm)
 
-matcher.addTransform('traceIterator', traceIterator)
-matcher.addTransform('traceAsyncIterator', traceAsyncIterator)
+for (const matcher of [matcherCjs, matcherEsm]) {
+  matcher.addTransform('traceIterator', traceIterator)
+  matcher.addTransform('traceAsyncIterator', traceAsyncIterator)
+}
 
 function rewrite (content, filename, format) {
   if (!content) return content
@@ -41,6 +54,7 @@ function rewrite (content, filename, format) {
 
   if (disabled.has(moduleName)) return content
 
+  const matcher = moduleType === 'esm' ? matcherEsm : matcherCjs
   const transformer = matcher.getTransformer(moduleName, version, filePath)
 
   if (!transformer) return content

package/packages/datadog-instrumentations/src/helpers/rewriter/transforms.js

@@ -10,17 +10,25 @@ const tracingChannelPredicate = (node) => (
 )
 
 const transforms = module.exports = {
-  tracingChannelImport ({ dcModule, sourceType }, node) {
+  /**
+   * @param {{ dcModule: string, moduleType: 'esm' | 'cjs' }} state
+   * @param {import('estree').Program} node
+   */
+  tracingChannelImport ({ dcModule, moduleType }, node) {
     if (node.body.some(tracingChannelPredicate)) return
 
+    // The vendored matcher state exposes `moduleType` (`esm` / `cjs`), so we
+    // read that field directly. Naming it `sourceType` here used to silently
+    // pick the CJS branch for every ESM file, leaving `require()` baked into
+    // pure ESM modules like `@langchain/langgraph/dist/pregel/index.js`.
+    const isModule = moduleType === 'esm'
+
     const index = node.body.findIndex(child => child.directive === 'use strict')
-    const code = isModuleSourceType(sourceType)
-      ? `import { tracingChannel as tr_ch_apm_tracingChannel } from "${dcModule}"`
+    const code = isModule
+      ? `import tr_ch_apm_dc from "${dcModule}"; const {tracingChannel: tr_ch_apm_tracingChannel} = tr_ch_apm_dc`
       : `const {tracingChannel: tr_ch_apm_tracingChannel} = require("${dcModule}")`
 
-    node.body.splice(index + 1, 0, parse(code, {
-      isModule: isModuleSourceType(sourceType),
-    }).body[0])
+    node.body.splice(index + 1, 0, ...parse(code, { isModule }).body)
   },
 
   tracingChannelDeclaration (state, node) {
@@ -53,13 +61,6 @@ function traceAny (state, node, _parent, ancestry) {
   }
 }
 
-/**
- * @param {string} sourceType
- */
-function isModuleSourceType (sourceType) {
-  return sourceType === 'module' || sourceType === 'esm'
-}
-
 function traceFunction (state, node, program) {
   transforms.tracingChannelDeclaration(state, program)
 

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

@@ -188,8 +188,8 @@ function patch (http, methodName) {
         let finished = false
         let callback = args.callback
 
-        if (callback) {
-          callback = shimmer.wrapFunction(args.callback, cb => function (...args) {
+        if (typeof callback === 'function') {
+          callback = shimmer.wrapCallback(args.callback, cb => function (...args) {
             return asyncStartChannel.runStores(ctx, () => {
               return cb.apply(this, args)
             })

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

@@ -10,28 +10,32 @@ 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)
+    if (!startCh.hasSubscribers) return sendCommand.call(this, command, stream)
 
-    if (!command || !command.promise) return sendCommand.apply(this, arguments)
+    if (!command?.promise) return sendCommand.call(this, command, stream)
 
     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.call(this, command, stream)
     })
   })
   return Redis