dd-trace 5.102.0 → 5.103.0

package/ext/exporters.js

@@ -10,4 +10,5 @@ module.exports = {
   MOCHA_WORKER: 'mocha_worker',
   PLAYWRIGHT_WORKER: 'playwright_worker',
   VITEST_WORKER: 'vitest_worker',
+  ELECTRON: 'electron',
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dd-trace",
-  "version": "5.102.0",
+  "version": "5.103.0",
   "description": "Datadog APM tracing client for JavaScript",
   "main": "index.js",
   "typings": "index.d.ts",
@@ -79,6 +79,7 @@
     "test:integration:cypress:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/cypress/${SPEC:-cypress-*}.spec.js\"",
     "test:integration:debugger": "mocha --timeout 60000 \"integration-tests/debugger/*.spec.js\"",
     "test:integration:debugger:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/debugger/*.spec.js\"",
+    "test:integration:electron": "mocha \"integration-tests/electron/*.spec.js\"",
     "test:integration:esbuild": "mocha --timeout 60000 \"integration-tests/esbuild/*.spec.js\"",
     "test:integration:esbuild:coverage": "node ./integration-tests/coverage/run-suite.js --timeout 60000 \"integration-tests/esbuild/*.spec.js\"",
     "test:integration:webpack": "mocha --timeout 60000 \"integration-tests/webpack/*.spec.js\"",
@@ -159,20 +160,20 @@
     "version.js"
   ],
   "dependencies": {
-    "dc-polyfill": "^0.1.10",
+    "dc-polyfill": "^0.1.11",
     "import-in-the-middle": "^3.0.1"
   },
   "optionalDependencies": {
     "@datadog/libdatadog": "0.9.3",
     "@datadog/native-appsec": "11.0.1",
     "@datadog/native-iast-taint-tracking": "4.1.0",
-    "@datadog/native-metrics": "3.1.1",
-    "@datadog/openfeature-node-server": "^1.1.2",
+    "@datadog/native-metrics": "3.1.2",
+    "@datadog/openfeature-node-server": "1.1.2",
     "@datadog/pprof": "5.14.1",
     "@datadog/wasm-js-rewriter": "5.0.1",
     "@opentelemetry/api": ">=1.0.0 <1.10.0",
     "@opentelemetry/api-logs": "<1.0.0",
-    "oxc-parser": "^0.128.0"
+    "oxc-parser": "^0.129.0"
   },
   "devDependencies": {
     "@actions/core": "^3.0.1",
@@ -187,17 +188,17 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^18.19.106",
     "@types/sinon": "^21.0.1",
-    "axios": "^1.15.2",
+    "axios": "^1.16.0",
     "benchmark": "^2.1.4",
     "body-parser": "^2.2.2",
     "bun": "1.3.13",
     "codeowners-audit": "^2.9.0",
     "eslint": "^9.39.2",
-    "eslint-plugin-cypress": "^6.4.0",
+    "eslint-plugin-cypress": "^6.4.1",
     "eslint-plugin-import": "^2.32.0",
     "eslint-plugin-jsdoc": "^62.9.0",
     "eslint-plugin-mocha": "^11.2.0",
-    "eslint-plugin-n": "^17.23.2",
+    "eslint-plugin-n": "^18.0.1",
     "eslint-plugin-promise": "^7.3.0",
     "eslint-plugin-sonarjs": "^4.0.3",
     "eslint-plugin-unicorn": "^64.0.0",
@@ -213,7 +214,7 @@
     "mocha-junit-reporter": "^2.2.1",
     "mocha-multi-reporters": "^1.5.1",
     "multer": "^2.1.1",
-    "nock": "^13.5.6",
+    "nock": "^14.0.15",
     "node-preload": "^0.2.1",
     "nyc": "^18.0.0",
     "octokit": "^5.0.3",
@@ -223,11 +224,11 @@
     "retry": "^0.13.1",
     "semifies": "^1.0.0",
     "semver": "^7.7.2",
-    "sinon": "^21.1.2",
+    "sinon": "^22.0.0",
     "tiktoken": "^1.0.21",
     "typescript": "^6.0.3",
     "workerpool": "^10.0.2",
-    "yaml": "^2.8.3",
+    "yaml": "^2.8.4",
     "yarn-deduplicate": "^6.0.2"
   }
 }

package/packages/datadog-esbuild/src/utils.js

@@ -83,9 +83,9 @@ function getSource (url, { format }) {
  *
  * @param {object} moduleData
  * @param {string} moduleData.path
- * @param {boolean} [moduleData.internal = false]
+ * @param {boolean} [moduleData.internal]
  * @param {object} moduleData.context
- * @param {boolean} [moduleData.excludeDefault = false]
+ * @param {boolean} [moduleData.excludeDefault]
  * @returns {Promise<Map>}
  */
 async function processModule ({ path, internal = false, context, excludeDefault = false }) {

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

@@ -20,7 +20,7 @@ const wrappedModels = new WeakSet()
  */
 function publishToAIGuard (messages) {
   return new Promise((resolve, reject) => {
-    aiguardChannel.publish({ messages, resolve, reject })
+    aiguardChannel.publish({ messages, integration: 'ai', resolve, reject })
   })
 }
 

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

@@ -7,6 +7,7 @@ const {
   addHook,
   channel,
 } = require('./helpers/instrument')
+const { cloneMessages } = require('./helpers/kafka')
 
 // Create channels for Confluent Kafka JavaScript
 const channels = {
@@ -211,46 +212,62 @@ function instrumentKafkaJS (kafkaJS) {
                       return send.apply(this, arguments)
                     }
 
+                    const disableHeaderInjection = disabledHeaderWeakSet.has(producer)
+
+                    // Hand the underlying client a shallow clone so neither
+                    // injection nor the client's auto-fields (it sets
+                    // `headers: null` on messages without headers) ever
+                    // touch caller-owned objects. With injection disabled the
+                    // clone must not seed `headers: {}` either: brokers that
+                    // reject any header field cannot recover otherwise.
+                    let outgoingPayload = payload
+                    if (payload && Array.isArray(payload.messages)) {
+                      outgoingPayload = {
+                        ...payload,
+                        messages: cloneMessages(payload.messages, !disableHeaderInjection),
+                      }
+                    }
+
                     const ctx = {
-                      topic: payload?.topic,
-                      messages: payload?.messages || [],
+                      topic: outgoingPayload?.topic,
+                      messages: outgoingPayload?.messages || [],
                       bootstrapServers: kafka._ddBrokers,
-                      disableHeaderInjection: disabledHeaderWeakSet.has(producer),
+                      disableHeaderInjection,
                     }
 
                     return channels.producerStart.runStores(ctx, () => {
                       try {
-                        const result = send.apply(this, arguments)
+                        const result = send.call(this, outgoingPayload)
 
                         result.then((res) => {
                           ctx.result = res
                           channels.producerCommit.publish(ctx)
                           channels.producerFinish.publish(ctx)
-                        }, (err) => {
-                          if (err) {
-                            // Fixes bug where we would inject message headers for kafka brokers
-                            // that don't support headers (version <0.11). On the error, we disable
-                            // header injection. Tnfortunately the error name / type is not more specific.
-                            // This approach is implemented by other tracers as well.
-                            if (err.name === 'KafkaJSError' && err.type === 'ERR_UNKNOWN') {
+                        }, (error) => {
+                          if (error) {
+                            // KafkaJS-compat reports `ERR_UNKNOWN` for brokers
+                            // <0.11 that cannot parse headers. Stop injecting
+                            // for this producer; subsequent sends to the same
+                            // broker succeed.
+                            if (error.name === 'KafkaJSError' && error.type === 'ERR_UNKNOWN') {
                               disabledHeaderWeakSet.add(producer)
                               log.error(
                                 // eslint-disable-next-line @stylistic/max-len
                                 'Kafka Broker responded with UNKNOWN_SERVER_ERROR (-1). Please look at broker logs for more information. Tracer message header injection for Kafka is disabled.'
                               )
                             }
-                            ctx.error = err
+                            ctx.error = error
                             channels.producerError.publish(ctx)
                           }
                           channels.producerFinish.publish(ctx)
                         })
 
                         return result
-                      } catch (e) {
-                        ctx.error = e
+                      } catch (error) {
+                        ctx.error = error
                         channels.producerError.publish(ctx)
                         channels.producerFinish.publish(ctx)
-                        throw e
+                        throw error
                       }
                     })
                   }

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

@@ -1,12 +1,27 @@
 'use strict'
 
-const { errorMonitor } = require('events')
+const { tracingChannel } = require('dc-polyfill')
+
 const shimmer = require('../../datadog-shimmer')
 const {
-  channel,
   addHook,
 } = require('./helpers/instrument')
 
+// One TracingChannel per traced operation, looked up at module init so the
+// hot path only does property reads on a stable handle.
+const queryCh = tracingChannel('apm:couchbase:query')
+const upsertCh = tracingChannel('apm:couchbase:upsert')
+const insertCh = tracingChannel('apm:couchbase:insert')
+const replaceCh = tracingChannel('apm:couchbase:replace')
+
+/** @type {Map<string, ReturnType<typeof tracingChannel>>} */
+const opChannelByName = new Map([
+  ['query', queryCh],
+  ['upsert', upsertCh],
+  ['insert', insertCh],
+  ['replace', replaceCh],
+])
+
 function findCallbackIndex (args, lowerbound = 2) {
   for (let i = args.length - 1; i >= lowerbound; i--) {
     if (typeof args[i] === 'function') return i
@@ -19,244 +34,78 @@ function getQueryResource (q) {
   return q && (typeof q === 'string' ? q : q.statement)
 }
 
-function wrapAllNames (names, action) {
-  for (const name of names) {
-    action(name)
+// Hand-rolled instead of `tracingChannel.tracePromise`: synchronous
+// `res.then(...)` dodges the `Promise.resolve(thenable)` microtask race on
+// SDK v3.2.x / v4.0-v4.4 (lazy listener attachment), and external `.on()`
+// is forbidden on v4.5.0+ (JSCBC-1301 depromisify). See commit body.
+/**
+ * @param {import('node:diagnostics_channel').TracingChannel} ch
+ *   Pinned per-op channel.
+ * @param {(...callArgs: unknown[]) => unknown} fn The SDK method being traced.
+ * @param {object} ctx Mutated to record `result` / `error`.
+ * @param {object} thisArg
+ * @param {unknown[]} args Forwarded to `fn` verbatim.
+ */
+function traceV3 (ch, fn, ctx, thisArg, args) {
+  if (!ch.start.hasSubscribers) return fn.apply(thisArg, args)
+  const cbIndex = findCallbackIndex(args, 1)
+  if (cbIndex >= 0) {
+    return ch.traceCallback(fn, cbIndex, ctx, thisArg, ...args)
   }
-}
-
-function wrapCallback (callback, ctx, channelPrefix) {
-  const callbackStartCh = channel(`${channelPrefix}:callback:start`)
-  const callbackFinishCh = channel(`${channelPrefix}:callback:finish`)
-
-  const wrapped = callbackStartCh.runStores(ctx, () => {
-    return function (...args) {
-      return callbackFinishCh.runStores(ctx, () => {
-        return callback.apply(this, args)
-      })
-    }
-  })
-  Object.defineProperty(wrapped, '_dd_wrapped', { value: true })
-  return wrapped
-}
-
-function wrapQuery (query) {
-  return function (q, params, callback) {
-    const cb = arguments[arguments.length - 1]
-    if (typeof cb === 'function') {
-      const ctx = {}
-      arguments[arguments.length - 1] = wrapCallback(cb, ctx, 'apm:couchbase:query')
-    }
-
-    return query.apply(this, arguments)
-  }
-}
-
-function wrapCallbackFinish (callback, thisArg, _args, errorCh, finishCh, ctx, channelPrefix) {
-  const callbackStartCh = channel(`${channelPrefix}:callback:start`)
-  const callbackFinishCh = channel(`${channelPrefix}:callback:finish`)
-
-  const wrapped = callbackStartCh.runStores(ctx, () => {
-    return function finish (error, result) {
-      return callbackFinishCh.runStores(ctx, () => {
-        if (error) {
-          ctx.error = error
-          errorCh.publish(ctx)
-        }
-        finishCh.publish(ctx)
-        return callback.apply(thisArg, [error, result])
-      })
-    }
-  })
-  Object.defineProperty(wrapped, '_dd_wrapped', { value: true })
-  return wrapped
-}
-
-function wrap (prefix, fn) {
-  const startCh = channel(prefix + ':start')
-  const finishCh = channel(prefix + ':finish')
-  const errorCh = channel(prefix + ':error')
-
-  return function (...args) {
-    if (!startCh.hasSubscribers) {
-      return fn.apply(this, args)
-    }
-
-    const callbackIndex = findCallbackIndex(args, 1)
-
-    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 = args[callbackIndex]
-
-      args[callbackIndex] = shimmer.wrapFunction(cb, (cb) => {
-        return wrapCallbackFinish(cb, this, args, errorCh, finishCh, ctx, prefix)
-      })
-
-      try {
-        return fn.apply(this, args)
-      } catch (error) {
-        ctx.error = error
-        void error.stack // trigger getting the stack at the original throwing point
-        errorCh.publish(ctx)
-
-        throw error
-      }
-    })
-  }
-}
-
-// semver >=2 <3
-function wrapMaybeInvoke (_maybeInvoke, channelPrefix) {
-  return function (fn, args) {
-    if (!Array.isArray(args)) return _maybeInvoke.apply(this, arguments)
-
-    const callbackIndex = findCallbackIndex(args, 0)
-
-    if (callbackIndex === -1) return _maybeInvoke.apply(this, arguments)
-
-    const callback = args[callbackIndex]
-
-    if (typeof callback === 'function' && !callback._dd_wrapped) {
-      const ctx = {}
-      args[callbackIndex] = wrapCallback(callback, ctx, channelPrefix)
-    }
-
-    return _maybeInvoke.apply(this, arguments)
-  }
-}
-
-// semver >=3
-
-function wrapCBandPromise (fn, name, startData, thisArg, args) {
-  const startCh = channel(`apm:couchbase:${name}:start`)
-  const finishCh = channel(`apm:couchbase:${name}:finish`)
-  const errorCh = channel(`apm:couchbase:${name}:error`)
-
-  if (!startCh.hasSubscribers) return fn.apply(thisArg, args)
-
-  const ctx = startData
-  return startCh.runStores(ctx, () => {
+  return ch.start.runStores(ctx, () => {
     try {
-      const cbIndex = findCallbackIndex(args, 1)
-      if (cbIndex >= 0) {
-        // v3 offers callback or promises event handling
-        // NOTE: this does not work with v3.2.0-3.2.1 cluster.query, as there is a bug in the couchbase source code
-        args[cbIndex] = shimmer.wrapFunction(args[cbIndex], (cb) => {
-          return wrapCallbackFinish(cb, thisArg, args, errorCh, finishCh, ctx, `apm:couchbase:${name}`)
-        })
-      }
       const res = fn.apply(thisArg, args)
-
-      // semver >=3 will always return promise by default
       res.then(
         (result) => {
           ctx.result = result
-          finishCh.publish(ctx)
+          ch.asyncStart.publish(ctx)
+          ch.asyncEnd.publish(ctx)
         },
-        (err) => {
-          ctx.error = err
-          errorCh.publish(ctx)
-          finishCh.publish(ctx)
+        (error) => {
+          ctx.error = error
+          ch.error.publish(ctx)
+          ch.asyncStart.publish(ctx)
+          ch.asyncEnd.publish(ctx)
         }
       )
       return res
-    } catch (e) {
-      void e.stack
-      ctx.error = e
-      errorCh.publish(ctx)
-      throw e
+    } catch (error) {
+      ctx.error = error
+      ch.error.publish(ctx)
+      throw error
+    } finally {
+      ch.end.publish(ctx)
     }
   })
 }
 
-function wrapWithName (name) {
+/**
+ * @param {string} name Operation name (`upsert`, `insert`, `replace`).
+ */
+function wrapV3WithName (name) {
+  const ch = opChannelByName.get(name)
   return function (operation) {
-    return function (...args) { // no arguments used by us
-      return wrapCBandPromise(operation, name, {
+    return function (...args) {
+      const ctx = {
         collection: { name: this._name || '_default' },
         bucket: { name: this._scope._bucket._name },
         seedNodes: this._dd_connStr,
-      }, this, args)
+      }
+      return traceV3(ch, operation, ctx, this, args)
     }
   }
 }
 
+/**
+ * @param {(...args: unknown[]) => unknown} query Original `Cluster.prototype.query`.
+ */
 function wrapV3Query (query) {
-  return function (q) {
-    const resource = getQueryResource(q)
-    return wrapCBandPromise(query, 'query', { resource, seedNodes: this._connStr }, this, arguments)
+  return function (...args) {
+    const ctx = { resource: getQueryResource(args[0]), seedNodes: this._connStr }
+    return traceV3(queryCh, query, ctx, this, args)
   }
 }
 
-// semver >=2 <3
-addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^2.6.12'] }, Bucket => {
-  shimmer.wrap(Bucket.prototype, '_maybeInvoke', maybeInvoke => {
-    return wrapMaybeInvoke(maybeInvoke, 'apm:couchbase:bucket:maybeInvoke')
-  })
-
-  const startCh = channel('apm:couchbase:query:start')
-  const finishCh = channel('apm:couchbase:query:finish')
-  const errorCh = channel('apm:couchbase:query:error')
-
-  shimmer.wrap(Bucket.prototype, 'query', query => wrapQuery(query))
-
-  shimmer.wrap(Bucket.prototype, '_n1qlReq', _n1qlReq => function (host, q, adhoc, emitter) {
-    if (!startCh.hasSubscribers) {
-      return _n1qlReq.apply(this, arguments)
-    }
-
-    if (!emitter || !emitter.once) return _n1qlReq.apply(this, arguments)
-
-    const n1qlQuery = getQueryResource(q)
-
-    const ctx = { resource: n1qlQuery, bucket: { name: this.name || this._name }, seedNodes: this._dd_hosts }
-    return startCh.runStores(ctx, () => {
-      emitter.once('rows', () => {
-        finishCh.publish(ctx)
-      })
-
-      emitter.once(errorMonitor, (error) => {
-        if (!error) return
-        ctx.error = error
-        errorCh.publish(ctx)
-        finishCh.publish(ctx)
-      })
-
-      try {
-        return _n1qlReq.apply(this, arguments)
-      } catch (err) {
-        void err.stack // trigger getting the stack at the original throwing point
-        ctx.error = err
-        errorCh.publish(ctx)
-
-        throw err
-      }
-    })
-  })
-
-  wrapAllNames(['upsert', 'insert', 'replace', 'append', 'prepend'], name => {
-    shimmer.wrap(Bucket.prototype, name, fn => wrap(`apm:couchbase:${name}`, fn))
-  })
-})
-
-addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^2.6.12'] }, Cluster => {
-  shimmer.wrap(Cluster.prototype, '_maybeInvoke', maybeInvoke => {
-    return wrapMaybeInvoke(maybeInvoke, 'apm:couchbase:cluster:maybeInvoke')
-  })
-
-  shimmer.wrap(Cluster.prototype, 'query', query => wrapQuery(query))
-  shimmer.wrap(Cluster.prototype, 'openBucket', openBucket => {
-    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
-    }
-  })
-})
-
 // semver >=3 <3.2.0
 
 addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^3.0.7', '^3.1.3'] }, Bucket => {
@@ -271,9 +120,9 @@ addHook({ name: 'couchbase', file: 'lib/bucket.js', versions: ['^3.0.7', '^3.1.3
 })
 
 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))
-  })
+  for (const name of ['upsert', 'insert', 'replace']) {
+    shimmer.wrap(Collection.prototype, name, wrapV3WithName(name))
+  }
 })
 
 addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.3'] }, Cluster => {
@@ -286,9 +135,9 @@ addHook({ name: 'couchbase', file: 'lib/cluster.js', versions: ['^3.0.7', '^3.1.
 addHook({ name: 'couchbase', file: 'dist/collection.js', versions: ['>=3.2.2'] }, collection => {
   const Collection = collection.Collection
 
-  wrapAllNames(['upsert', 'insert', 'replace'], name => {
-    shimmer.wrap(Collection.prototype, name, wrapWithName(name))
-  })
+  for (const name of ['upsert', 'insert', 'replace']) {
+    shimmer.wrap(Collection.prototype, name, wrapV3WithName(name))
+  }
 })
 
 addHook({ name: 'couchbase', file: 'dist/bucket.js', versions: ['>=3.2.2'] }, bucket => {

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

@@ -653,7 +653,7 @@ function getWrappedStart (start, frameworkVersion, isParallel = false, isCoordin
       const skippableResponse = await getChannelPromise(skippableSuitesCh)
 
       errorSkippableRequest = skippableResponse.err
-      skippableSuites = skippableResponse.skippableSuites
+      skippableSuites = skippableResponse.skippableSuites ?? []
 
       if (!errorSkippableRequest) {
         const filteredPickles = isCoordinator

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

@@ -0,0 +1,42 @@
+'use strict'
+
+// eslint-disable-next-line n/no-missing-require
+const { contextBridge, ipcRenderer } = require('electron')
+
+const BRIDGE_CHANNEL = 'datadog:bridge-send'
+const CONFIG_CHANNEL = 'datadog:bridge-config'
+
+// Privacy levels matching @datadog/browser-core DefaultPrivacyLevel
+const MASK = 'mask'
+
+const config = ipcRenderer.sendSync(CONFIG_CHANNEL)
+
+const defaultPrivacyLevel = config?.defaultPrivacyLevel ?? MASK
+const configuredHosts = config?.allowedWebViewHosts ?? []
+// eslint-disable-next-line no-undef
+const allowedHosts = [...new Set([location.hostname, ...configuredHosts])]
+
+const bridge = {
+  getCapabilities () {
+    return '[]'
+  },
+  getPrivacyLevel () {
+    return defaultPrivacyLevel
+  },
+  getAllowedWebViewHosts () {
+    return JSON.stringify(allowedHosts)
+  },
+  send (msg) {
+    ipcRenderer.send(BRIDGE_CHANNEL, msg)
+  },
+}
+
+// Support both contextIsolation enabled (default) and disabled
+
+window.DatadogEventBridge = bridge
+
+try {
+  contextBridge.exposeInMainWorld('DatadogEventBridge', bridge)
+} catch {
+  // exposeInMainWorld throws when contextIsolation is disabled
+}