dd-trace 5.102.0 → 5.103.0

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

@@ -0,0 +1,240 @@
+'use strict'
+
+const { join } = require('path')
+const { wrap } = require('../../datadog-shimmer')
+const { addHook, channel, tracingChannel } = require('./helpers/instrument')
+
+const requestCh = tracingChannel('apm:electron:net:request')
+const mainReceiveCh = tracingChannel('apm:electron:ipc:main:receive')
+const mainHandleCh = tracingChannel('apm:electron:ipc:main:handle')
+const mainSendCh = tracingChannel('apm:electron:ipc:main:send')
+const rendererPatchedCh = channel('apm:electron:ipc:renderer:patched')
+const rendererReceiveCh = tracingChannel('apm:electron:ipc:renderer:receive')
+const rendererSendCh = tracingChannel('apm:electron:ipc:renderer:send')
+
+const listeners = {}
+const handlers = {}
+
+function createWrapRequest (ch) {
+  return function wrapRequest (request) {
+    return function (...args) {
+      if (!ch.start.hasSubscribers) return request.apply(this, arguments)
+
+      const ctx = { args }
+
+      return ch.start.runStores(ctx, () => {
+        try {
+          const req = request.apply(this, ctx.args)
+          const emit = req.emit
+
+          ctx.req = req
+
+          req.emit = function (eventName, arg) {
+            /* eslint-disable no-fallthrough */
+            switch (eventName) {
+              case 'response':
+                ctx.res = arg
+                ctx.res.on('error', error => {
+                  ctx.error = error
+                  ch.error.publish(ctx)
+                  ch.asyncStart.publish(ctx)
+                })
+                ctx.res.on('end', () => ch.asyncStart.publish(ctx))
+                break
+              case 'error':
+                ctx.error = arg
+                ch.error.publish(ctx)
+              case 'abort':
+                ch.asyncStart.publish(ctx)
+            }
+
+            return emit.apply(this, arguments)
+          }
+
+          return req
+        } catch (e) {
+          ctx.error = e
+          ch.error.publish(ctx)
+          throw e
+        } finally {
+          ch.end.publish(ctx)
+        }
+      })
+    }
+  }
+}
+
+function createWrapAddListener (ch, mappings) {
+  return function wrapAddListener (addListener) {
+    return function (channel, listener) {
+      const wrappedListener = (event, ...args) => {
+        const ctx = { args, channel, event }
+
+        return ch.tracePromise(() => listener.call(this, event, ...args), ctx)
+      }
+
+      const mapping = mappings[channel] || new WeakMap()
+      const wrapper = mapping.get(listener) || wrappedListener
+
+      mapping.set(listener, wrapper)
+
+      return addListener.call(this, channel, wrappedListener)
+    }
+  }
+}
+
+function createWrapRemoveListener (mappings) {
+  return function wrapRemoveListener (removeListener) {
+    return function (channel, listener) {
+      const mapping = mappings[channel]
+
+      if (mapping) {
+        const wrapper = mapping.get(listener)
+
+        if (wrapper) {
+          return removeListener.call(this, channel, wrapper)
+        }
+      }
+
+      return removeListener.call(this, channel, listener)
+    }
+  }
+}
+
+function createWrapRemoveAllListeners (mappings) {
+  return function wrapRemoveAllListeners (removeAllListeners) {
+    return function (channel) {
+      if (channel) {
+        delete mappings[channel]
+      } else {
+        for (const key of Object.keys(mappings)) delete mappings[key]
+      }
+
+      return removeAllListeners.call(this, channel)
+    }
+  }
+}
+
+function createWrapSend (ch, promise = false) {
+  const trace = (promise ? ch.tracePromise : ch.traceSync).bind(ch)
+
+  return function wrapSend (send) {
+    return function (channel, ...args) {
+      const ctx = { args, channel, self: this }
+
+      return trace(() => send.call(this, channel, ...args), ctx)
+    }
+  }
+}
+
+function wrapSendToFrame (send) {
+  return function (frameId, channel, ...args) {
+    const ctx = { args, channel, frameId, self: this }
+
+    return mainSendCh.traceSync(() => send.call(this, frameId, channel, ...args), ctx)
+  }
+}
+
+function wrapBrowserWindow (electron) {
+  const moduleExports = {}
+
+  class DatadogBrowserWindow extends electron.BrowserWindow {
+    constructor (options = {}) {
+      const win = super(options)
+
+      win.webContents.session.registerPreloadScript({
+        type: 'frame', // TODO: service-worker
+        filePath: join(__dirname, 'electron', 'preload.js'),
+      })
+
+      // BrowserWindow doesn't support subclassing because it's all native code
+      // so we return an instance of it instead of the subclass.
+      return win
+    }
+  }
+
+  Object.defineProperty(moduleExports, 'BrowserWindow', {
+    enumerable: true,
+    get: () => DatadogBrowserWindow,
+    configurable: false,
+  })
+
+  for (const key of Reflect.ownKeys(electron)) {
+    const descriptor = Reflect.getOwnPropertyDescriptor(electron, key)
+
+    if (key === 'BrowserWindow') continue
+
+    Object.defineProperty(moduleExports, key, descriptor)
+  }
+
+  return moduleExports
+}
+
+function wrapWebContents (proto) {
+  const descriptor = Object.getOwnPropertyDescriptor(proto, 'webContents')
+  const wrapped = new WeakSet()
+  const wrapSend = createWrapSend(mainSendCh)
+
+  Object.defineProperty(proto, 'webContents', {
+    get () {
+      const webContents = descriptor.get.apply(this)
+
+      if (!wrapped.has(webContents)) {
+        // wrap(webContents, 'postMessage', wrapSend)
+        wrap(webContents, 'send', wrapSend)
+        wrap(webContents, 'sendToFrame', wrapSendToFrame)
+
+        wrapped.add(webContents)
+      }
+
+      return webContents
+    },
+  })
+}
+
+addHook({ name: 'electron', versions: ['>=37.0.0'] }, electron => {
+  // Electron exports a string in Node and an object in Electron.
+  if (typeof electron === 'string') return electron
+
+  const { BrowserWindow, ipcMain, ipcRenderer, net } = electron
+
+  if (net) {
+    // This also covers `fetch` as it uses `request` under the hood.
+    wrap(net, 'request', createWrapRequest(requestCh))
+  }
+
+  if (ipcRenderer) {
+    wrap(ipcRenderer, 'invoke', createWrapSend(rendererSendCh, true))
+    // wrap(ipcRenderer, 'postMessage', createWrapSend(rendererSendCh))
+    wrap(ipcRenderer, 'send', createWrapSend(rendererSendCh))
+    wrap(ipcRenderer, 'sendSync', createWrapSend(rendererSendCh))
+    wrap(ipcRenderer, 'sendToHost', createWrapSend(rendererSendCh))
+
+    wrap(ipcRenderer, 'addListener', createWrapAddListener(rendererReceiveCh, listeners))
+    wrap(ipcRenderer, 'off', createWrapRemoveListener(listeners))
+    wrap(ipcRenderer, 'on', createWrapAddListener(rendererReceiveCh, listeners))
+    wrap(ipcRenderer, 'once', createWrapAddListener(rendererReceiveCh, listeners))
+    wrap(ipcRenderer, 'removeListener', createWrapRemoveListener(listeners))
+    wrap(ipcRenderer, 'removeAllListeners', createWrapRemoveAllListeners(listeners))
+
+    ipcRenderer.send('datadog:apm:renderer:patched')
+  } else {
+    wrap(ipcMain, 'addListener', createWrapAddListener(mainReceiveCh, listeners))
+    wrap(ipcMain, 'handle', createWrapAddListener(mainHandleCh, handlers))
+    wrap(ipcMain, 'handleOnce', createWrapAddListener(mainHandleCh, handlers))
+    wrap(ipcMain, 'off', createWrapRemoveListener(listeners))
+    wrap(ipcMain, 'on', createWrapAddListener(mainReceiveCh, listeners))
+    wrap(ipcMain, 'once', createWrapAddListener(mainReceiveCh, listeners))
+    wrap(ipcMain, 'removeAllListeners', createWrapRemoveAllListeners(listeners))
+    wrap(ipcMain, 'removeHandler', createWrapRemoveAllListeners(handlers))
+    wrap(ipcMain, 'removeListener', createWrapRemoveListener(listeners))
+
+    ipcMain.once('datadog:apm:renderer:patched', event => rendererPatchedCh.publish(event))
+
+    wrapWebContents(BrowserWindow.prototype)
+
+    electron = wrapBrowserWindow(electron)
+  }
+
+  return electron
+})

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/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/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) =>

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/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