dd-trace 5.102.0 → 5.104.0

package/packages/datadog-plugin-kafkajs/src/producer.js

@@ -91,6 +91,38 @@ class KafkajsProducerPlugin extends ProducerPlugin {
     }
   }
 
+  finish (ctx) {
+    const span = ctx?.currentStore?.span
+    const result = ctx?.result
+    if (span && Array.isArray(result) && result.length > 0) {
+      // The broker response is one entry per (topic, partition). Each entry
+      // carries a `baseOffset` — the offset assigned to the first record sent
+      // to that partition. We don't know per-partition record counts from the
+      // response, only the starting offset.
+      const offsets = []
+      for (const entry of result) {
+        const offsetAsLong = entry.offset ?? entry.baseOffset
+        if (entry.partition === undefined || offsetAsLong === undefined) continue
+        // Kafka offsets are 64-bit; coercing to Number loses precision past
+        // 2^53. Keep them as strings so the tag matches the exact offset on
+        // long-lived/high-throughput topics.
+        offsets.push({ partition: entry.partition, start_offset: String(offsetAsLong) })
+      }
+      if (offsets.length > 0) {
+        offsets.sort((a, b) => a.partition - b.partition)
+        span.setTag('kafka.messages.offsets', JSON.stringify(offsets))
+      }
+      // Single-message send: the one entry's partition/offset describes the
+      // exact record. Also expose them as flat tags for easy filtering.
+      if (offsets.length === 1 && ctx.messages?.length === 1) {
+        span.setTag('kafka.partition', offsets[0].partition)
+        // Set as a string meta tag (not a metric) to preserve full 64-bit precision.
+        span.setTag('kafka.message.offset', offsets[0].start_offset)
+      }
+    }
+    super.finish(ctx)
+  }
+
   bindStart (ctx) {
     const { topic, messages, bootstrapServers, clusterId, disableHeaderInjection } = ctx
     const span = this.startSpan({

package/packages/datadog-plugin-mocha/src/index.js

@@ -105,6 +105,7 @@ class MochaPlugin extends CiPlugin {
           'mocha'
         ),
         ...this.getSessionRequestErrorTags(),
+        ...this.getSessionItrSkippingEnabledTags(),
       }
       if (isUnskippable) {
         testSuiteMetadata[TEST_ITR_UNSKIPPABLE] = 'true'

package/packages/datadog-plugin-mongodb-core/src/index.js

@@ -20,6 +20,9 @@ class MongodbCorePlugin extends DatabasePlugin {
 
     this.config.heartbeatEnabled = config.heartbeatEnabled ??
       this._tracerConfig.DD_TRACE_MONGODB_HEARTBEAT_ENABLED
+    this.config.obfuscateQuery = normaliseObfuscateQuery(
+      config.obfuscateQuery ?? this._tracerConfig.DD_TRACE_MONGODB_OBFUSCATE_QUERY
+    )
   }
 
   bindStart (ctx) {
@@ -28,7 +31,7 @@ class MongodbCorePlugin extends DatabasePlugin {
     if (!this.config.heartbeatEnabled && isHeartbeat(ops, this.config)) {
       return
     }
-    const query = getQuery(ops)
+    const query = getQuery(ops, this.config.obfuscateQuery)
     const resource = truncate(getResource(this, ns, query, name))
     const serviceResult = this.serviceName({ pluginConfig: this.config })
     const span = this.startSpan(this.operationName(), {
@@ -90,9 +93,8 @@ class MongodbCorePlugin extends DatabasePlugin {
   }
 }
 
-function sanitizeBigInt (data) {
-  return JSON.stringify(data, (_key, value) => typeof value === 'bigint' ? value.toString() : value)
-}
+const MAX_DEPTH = 10
+const MAX_QUERY_LENGTH = 10_000
 
 function extractQuery (statements) {
   if (statements.length === 1 && statements[0].q) return statements[0].q
@@ -100,22 +102,26 @@ function extractQuery (statements) {
   const extractedQueries = []
   for (let i = 0; i < statements.length; i++) {
     if (statements[i].q) {
-      extractedQueries.push(limitDepth(statements[i].q))
+      extractedQueries.push(statements[i].q)
     }
   }
 
   return extractedQueries
 }
 
-function getQuery (cmd) {
+/**
+ * @param {Record<string, unknown> | unknown[] | undefined} cmd
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function getQuery (cmd, mode) {
   if (!cmd || (typeof cmd !== 'object' && !Array.isArray(cmd))) return
 
-  if (Array.isArray(cmd)) return sanitizeBigInt(extractQuery(cmd))
-  if (cmd.query) return sanitizeBigInt(limitDepth(cmd.query))
-  if (cmd.filter) return sanitizeBigInt(limitDepth(cmd.filter))
-  if (cmd.pipeline) return sanitizeBigInt(limitDepth(cmd.pipeline))
-  if (cmd.deletes) return sanitizeBigInt(extractQuery(cmd.deletes))
-  if (cmd.updates) return sanitizeBigInt(extractQuery(cmd.updates))
+  if (Array.isArray(cmd)) return sanitiseAndStringify(extractQuery(cmd), mode)
+  if (cmd.query) return sanitiseAndStringify(cmd.query, mode)
+  if (cmd.filter) return sanitiseAndStringify(cmd.filter, mode)
+  if (cmd.pipeline) return sanitiseAndStringify(cmd.pipeline, mode)
+  if (cmd.deletes) return sanitiseAndStringify(extractQuery(cmd.deletes), mode)
+  if (cmd.updates) return sanitiseAndStringify(extractQuery(cmd.updates), mode)
 }
 
 function getResource (plugin, ns, query, operationName) {
@@ -129,73 +135,68 @@ function getResource (plugin, ns, query, operationName) {
 }
 
 function truncate (input) {
-  return input.slice(0, Math.min(input.length, 10_000))
-}
-
-function shouldSimplify (input) {
-  return !isObject(input) || typeof input.toJSON === 'function'
+  return input.length > MAX_QUERY_LENGTH ? input.slice(0, MAX_QUERY_LENGTH) : input
 }
 
-function shouldHide (input) {
-  return Buffer.isBuffer(input) || typeof input === 'function' || isBinary(input)
-}
-
-function limitDepth (input) {
-  if (isBSON(input)) {
-    input = input.toJSON()
-  }
-
-  if (shouldHide(input)) return '?'
-  if (shouldSimplify(input)) return input
-
-  const output = {}
-  const queue = [{
-    input,
-    output,
-    depth: 0,
-  }]
-
-  while (queue.length) {
-    const {
-      input, output, depth,
-    } = queue.pop()
-    const nextDepth = depth + 1
-    for (const key of Object.keys(input)) {
-      let child = input[key]
-      if (typeof child === 'function') continue
-
-      if (isBSON(child)) {
-        child = typeof child.toJSON === 'function' ? child.toJSON() : '?'
-      }
+// Single-pass sanitisation. The replacer:
+// - skips functions and coerces bigint to its decimal string,
+// - collapses Buffer / BSON Binary / BSON types without toJSON (MinKey, MaxKey) to a sentinel,
+// - lets JSON.stringify call toJSON on other BSON types (ObjectId, Long, Decimal128, Date, Timestamp, ...)
+//   so the result lands here as a primitive or plain object,
+// - tracks depth via an ancestor stack so cycles and depth >= MAX_DEPTH collapse to the sentinel,
+// - in `redact` mode, replaces every primitive leaf (including null) with '?',
+// - in `types` mode, replaces every primitive leaf with the typeof of the *original* value (so a
+//   BSON Date that flattens to a string still reports as 'object'), and 'null' for null.
+// Keys, operator names, and array / pipeline shape are preserved in both modes so the resulting
+// JSON is still a usable query signature.
+/**
+ * @param {Record<string, unknown> | unknown[]} input
+ * @param {'none' | 'types' | 'redact'} mode
+ */
+function sanitiseAndStringify (input, mode) {
+  const ancestors = []
+  return JSON.stringify(input, function (key, value) {
+    if (typeof value === 'function') return
+    if (typeof value === 'bigint') {
+      if (mode === 'redact') return '?'
+      if (mode === 'types') return 'bigint'
+      return value.toString()
+    }
 
-      if (depth >= 10 || shouldHide(child)) {
-        output[key] = '?'
-      } else if (shouldSimplify(child)) {
-        output[key] = child
-      } else {
-        output[key] = {}
-        queue.push({
-          input: child,
-          output: output[key],
-          depth: nextDepth,
-        })
+    const original = key === '' ? value : this[key]
+    if (typeof original === 'object' && original !== null) {
+      const bsontype = original._bsontype
+      if (Buffer.isBuffer(original) || (bsontype !== undefined && (bsontype === 'Binary' || value === original))) {
+        return mode === 'types' ? 'object' : '?'
       }
     }
-  }
 
-  return output
-}
+    if (value === null || typeof value !== 'object') {
+      if (key === '' || mode === 'none') return value
+      if (mode === 'redact') return '?'
+      return original === null ? 'null' : typeof original
+    }
 
-function isObject (val) {
-  return val !== null && typeof val === 'object' && !Array.isArray(val)
-}
+    while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop()
+    if (ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+      return mode === 'types' ? 'object' : '?'
+    }
+    ancestors.push(value)
 
-function isBSON (val) {
-  return val && val._bsontype && !isBinary(val)
+    return value
+  })
 }
 
-function isBinary (val) {
-  return val && val._bsontype === 'Binary'
+/**
+ * Coerce the plugin-config and env values for `obfuscateQuery` to one of the three canonical modes.
+ * Anything outside the enum — including `undefined` — falls back to `'none'`.
+ *
+ * @param {unknown} value
+ * @returns {'none' | 'types' | 'redact'}
+ */
+function normaliseObfuscateQuery (value) {
+  if (value === 'types' || value === 'redact') return value
+  return 'none'
 }
 
 function isHeartbeat (ops, config) {

package/packages/datadog-plugin-mysql/src/index.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { storage } = require('../../datadog-core')
-const CLIENT_PORT_KEY = require('../../dd-trace/src/constants')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 
 class MySQLPlugin extends DatabasePlugin {

package/packages/datadog-plugin-openai/src/services.js

@@ -36,7 +36,8 @@ module.exports.init = function (tracerConfig) {
 
   interval = setInterval(() => {
     metrics.flush()
-  }, FLUSH_INTERVAL).unref()
+  }, FLUSH_INTERVAL)
+  interval.unref?.()
 
   return { metrics, logger }
 }

package/packages/datadog-plugin-pg/src/index.js

@@ -9,9 +9,9 @@ class PGPlugin extends DatabasePlugin {
   static system = 'postgres'
 
   bindStart (ctx) {
-    const { params = {}, query, processId, stream } = ctx
+    const { params = {}, query, originalText, processId, stream } = ctx
     const service = this.serviceName({ pluginConfig: this.config, params })
-    const originalStatement = this.maybeTruncate(query.text)
+    const originalStatement = this.maybeTruncate(originalText)
 
     const span = this.startSpan(this.operationName(), {
       service,
@@ -32,7 +32,7 @@ class PGPlugin extends DatabasePlugin {
       span.setTag('db.stream', 1)
     }
 
-    query.__ddInjectableQuery = this.injectDbmQuery(span, query.text, service.name, !!query.name)
+    ctx.injected = this.injectDbmQuery(span, originalText, service.name, !!query.name)
 
     return ctx.currentStore
   }

package/packages/datadog-plugin-playwright/src/index.js

@@ -321,6 +321,7 @@ class PlaywrightPlugin extends CiPlugin {
       isAtrRetry,
       isModified,
       finalStatus,
+      earlyFlakeAbortReason,
       onDone,
     }) => {
       if (!span) return
@@ -384,6 +385,9 @@ class PlaywrightPlugin extends CiPlugin {
       if (finalStatus) {
         span.setTag(TEST_FINAL_STATUS, finalStatus)
       }
+      if (earlyFlakeAbortReason) {
+        span.setTag(TEST_EARLY_FLAKE_ABORT_REASON, earlyFlakeAbortReason)
+      }
       for (const step of steps) {
         const stepStartTime = step.startTime.getTime()
         const stepSpan = this.tracer.startSpan('playwright.step', {

package/packages/datadog-plugin-redis/src/index.js

@@ -4,17 +4,31 @@ const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
 const CachePlugin = require('../../dd-trace/src/plugins/cache')
 const urlFilter = require('../../dd-trace/src/plugins/util/urlfilter')
 
+const MAX_ARG_LENGTH = 100
+const MAX_COMMAND_LENGTH = 1000
+
 class RedisPlugin extends CachePlugin {
   static id = 'redis'
   static system = 'redis'
 
+  /** @type {string} */
+  #rawCommandKey
+  /** @type {Map<string | undefined, { name: string, source: string | undefined }>} */
+  #serviceByConnection = new Map()
+  // `nomenclature.config` identity at last cache fill. `withNamingSchema` swaps it without
+  // running this plugin's `configure`, so identity drives invalidation in `bindStart`.
+  /** @type {object | undefined} */
+  #lastNomenclatureConfig
+  /** @type {string | undefined} */
+  #cachedOperationName
+
   constructor (...args) {
     super(...args)
     this._spanType = 'redis'
   }
 
   bindStart (ctx) {
-    const { db, command, args, connectionOptions, connectionName } = ctx
+    const { db, command, args, argsStartIndex, connectionOptions, connectionName } = ctx
 
     const resource = command
     const normalizedCommand = command.toUpperCase()
@@ -22,14 +36,27 @@ class RedisPlugin extends CachePlugin {
       return { noop: true }
     }
 
+    const nomConfig = this._tracer._nomenclature.config
+    if (this.#lastNomenclatureConfig !== nomConfig) {
+      this.#lastNomenclatureConfig = nomConfig
+      this.#cachedOperationName = undefined
+      this.#serviceByConnection.clear()
+    }
+
+    let service = this.#serviceByConnection.get(connectionName)
+    if (service === undefined) {
+      service = this.serviceName({ pluginConfig: this.config, system: this.system, connectionName })
+      this.#serviceByConnection.set(connectionName, service)
+    }
+
     this.startSpan({
       resource,
-      service: this.serviceName({ pluginConfig: this.config, system: this.system, connectionName }),
+      service,
       type: this._spanType,
       meta: {
         'db.type': this._spanType,
         'db.name': db || '0',
-        [`${this._spanType}.raw_command`]: formatCommand(normalizedCommand, args),
+        [this.#rawCommandKey]: formatCommand(normalizedCommand, args, argsStartIndex),
         'out.host': connectionOptions.host,
         [CLIENT_PORT_KEY]: connectionOptions.port,
       },
@@ -38,41 +65,44 @@ class RedisPlugin extends CachePlugin {
     return ctx.currentStore
   }
 
+  operationName () {
+    this.#cachedOperationName ??= super.operationName()
+    return this.#cachedOperationName
+  }
+
   configure (config) {
     super.configure(normalizeConfig(config))
+    // Subclasses (iovalkey) overwrite `_spanType` in their constructor, before any `configure`,
+    // so reading it here is stable.
+    this.#rawCommandKey = `${this._spanType}.raw_command`
+    this.#lastNomenclatureConfig = undefined
+    this.#cachedOperationName = undefined
+    this.#serviceByConnection.clear()
   }
 }
 
-function formatCommand (command, args) {
+function formatCommand (command, args, argsStartIndex = 0) {
   if (!args || command === 'AUTH') return command
 
-  for (let i = 0, l = args.length; i < l; i++) {
-    if (typeof args[i] === 'function') continue
-
-    command = `${command} ${formatArg(args[i])}`
+  let result = command
+  for (let i = argsStartIndex, l = args.length; i < l; i++) {
+    const arg = args[i]
+    if (typeof arg === 'function') continue
 
-    if (command.length > 1000) return trim(command, 1000)
+    result = `${result} ${formatArg(arg)}`
+    if (result.length > MAX_COMMAND_LENGTH) return result.slice(0, MAX_COMMAND_LENGTH - 3) + '...'
   }
 
-  return command
+  return result
 }
 
 function formatArg (arg) {
-  switch (typeof arg) {
-    case 'string':
-    case 'number':
-      return trim(String(arg), 100)
-    default:
-      return '?'
-  }
-}
-
-function trim (str, maxlen) {
-  if (str.length > maxlen) {
-    str = str.slice(0, maxlen - 3) + '...'
+  if (typeof arg === 'string') {
+    return arg.length > MAX_ARG_LENGTH ? arg.slice(0, MAX_ARG_LENGTH - 3) + '...' : arg
   }
-
-  return str
+  // Number stringification is bounded (~23 chars max), so it never hits MAX_ARG_LENGTH.
+  if (typeof arg === 'number') return String(arg)
+  return '?'
 }
 
 function normalizeConfig (config) {

package/packages/datadog-plugin-undici/src/index.js

@@ -27,6 +27,7 @@ class UndiciPlugin extends HttpClientPlugin {
     // Subscribe to native undici diagnostic channels for undici >= 4.7.0
     // These channels fire for ALL undici requests (fetch, request, stream, etc.)
     this.addSub('undici:request:create', this.#onNativeRequestCreate.bind(this))
+    this.addSub('undici:request:bodySent', this.#onNativeRequestBodySent.bind(this))
     this.addSub('undici:request:headers', this.#onNativeRequestHeaders.bind(this))
     this.addSub('undici:request:trailers', this.#onNativeRequestTrailers.bind(this))
     this.addSub('undici:request:error', this.#onNativeRequestError.bind(this))
@@ -109,12 +110,30 @@ class UndiciPlugin extends HttpClientPlugin {
       span,
       store,
       uri,
+      method,
     })
 
     // Enter the span context
     storage('legacy').enterWith({ ...store, span })
   }
 
+  #onNativeRequestBodySent ({ request }) {
+    const ctx = requestContexts.get(request)
+    if (!ctx || ctx.method !== 'CONNECT') return
+
+    const { span, store } = ctx
+
+    this.config.hooks.request(span, null, null)
+
+    span.finish()
+
+    requestContexts.delete(request)
+
+    if (store) {
+      storage('legacy').enterWith(store)
+    }
+  }
+
   #onNativeRequestHeaders ({ request, response }) {
     const ctx = requestContexts.get(request)
     if (!ctx) return

package/packages/datadog-plugin-vitest/src/index.js

@@ -56,6 +56,16 @@ class VitestPlugin extends CiPlugin {
 
     this.taskToFinishTime = new WeakMap()
 
+    this.addSub('ci:vitest:session:configuration', ({ onDone }) => {
+      const testSessionSpanContext = this.testSessionSpan?.context()
+      const testModuleSpanContext = this.testModuleSpan?.context()
+      onDone({
+        testSessionId: testSessionSpanContext?.toTraceId(),
+        testModuleId: testModuleSpanContext?.toSpanId(),
+        testCommand: this.command,
+      })
+    })
+
     this.addSub('ci:vitest:test:is-new', ({ knownTests, testSuiteAbsolutePath, testName, onDone }) => {
       // if for whatever reason the worker does not receive valid known tests, we don't consider it as new
       if (!knownTests.vitest) {
@@ -299,14 +309,16 @@ class VitestPlugin extends CiPlugin {
     this.addBind('ci:vitest:test-suite:start', (ctx) => {
       const { testSuiteAbsolutePath, frameworkVersion } = ctx
 
-      // TODO: Handle case where the command is not set
-      this.command = this._tracerConfig.DD_CIVISIBILITY_TEST_COMMAND
+      const testCommand = ctx.testCommand || 'vitest run'
+      const { testSessionId, testModuleId } = ctx
+      this.command = testCommand
       this.frameworkVersion = frameworkVersion
-      const testSessionSpanContext = this.tracer.extract('text_map', {
-        // TODO: Handle case where the session ID or module ID is not set
-        'x-datadog-trace-id': this._tracerConfig.DD_CIVISIBILITY_TEST_SESSION_ID,
-        'x-datadog-parent-id': this._tracerConfig.DD_CIVISIBILITY_TEST_MODULE_ID,
-      })
+      const testSessionSpanContext = testSessionId && testModuleId
+        ? this.tracer.extract('text_map', {
+          'x-datadog-trace-id': testSessionId,
+          'x-datadog-parent-id': testModuleId,
+        })
+        : undefined
 
       const trimmedCommand = DD_MAJOR < 6 ? this.command : 'vitest run'
       // test suites run in a different process, so they also need to init the metadata dictionary

package/packages/datadog-shimmer/src/shimmer.js

@@ -82,6 +82,40 @@ function wrapFunction (original, wrapper) {
   return wrapped
 }
 
+/**
+ * Lean variant of `wrapFunction` for the case where the wrapped value is a
+ * user-supplied callback that the user cannot reasonably introspect beyond
+ * `name` and `length`, and the wrapper closure is fully controlled by us.
+ *
+ * Compared to `wrapFunction`, this skips the prototype copy, the
+ * `assertNotClass` guard, and the `Reflect.ownKeys` descriptor-copy loop.
+ * Only `name` and `length` are preserved, and only when the wrapper's
+ * autogenerated values differ -- a wrapper whose closure already has the
+ * right arity / name pays no overhead.
+ *
+ * Use `wrapFunction` instead when any of the following is true: the wrapped
+ * function needs to keep its prototype, has custom own properties the caller
+ * may read, or is `new`-ed.
+ *
+ * @param {Function} original - User-supplied callback being wrapped.
+ * @param {(original: Function) => Function} wrapper - Factory that receives
+ * `original` and returns the wrapper closure.
+ * @returns {Function} The wrapper closure with `name` and `length` preserved.
+ */
+function wrapCallback (original, wrapper) {
+  if (typeof original !== 'function') {
+    return original
+  }
+  const wrapped = wrapper(original)
+  if (wrapped.name !== original.name) {
+    Object.defineProperty(wrapped, 'name', { value: original.name, configurable: true })
+  }
+  if (wrapped.length !== original.length) {
+    Object.defineProperty(wrapped, 'length', { value: original.length, configurable: true })
+  }
+  return wrapped
+}
+
 /**
  * Wraps a method of an object with a wrapper function.
  *
@@ -280,6 +314,7 @@ function assertNotClass (target) {
 
 module.exports = {
   wrap,
+  wrapCallback,
   wrapFunction,
   massWrap,
 }

package/packages/dd-trace/src/aiguard/index.js

@@ -3,6 +3,7 @@
 const log = require('../log')
 const { incomingHttpRequestStart, aiguardChannel } = require('./channels')
 const AIGuard = require('./sdk')
+const { SOURCE_AUTO, INTEGRATION_NONE } = require('./tags')
 
 let isEnabled = false
 let aiguard
@@ -51,7 +52,8 @@ function onEvaluate (ctx) {
     return
   }
 
-  aiguard.evaluate(ctx.messages, { block })
+  const opts = { block, source: SOURCE_AUTO, integration: ctx.integration || INTEGRATION_NONE }
+  aiguard.evaluate(ctx.messages, opts)
     .then(() => {
       ctx.resolve()
     })