dd-trace 5.104.0 → 5.106.0

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const { isMap, isRegExp } = require('node:util').types
+
 const DatabasePlugin = require('../../dd-trace/src/plugins/database')
 
 class MongodbCorePlugin extends DatabasePlugin {
@@ -138,62 +140,301 @@ function truncate (input) {
   return input.length > MAX_QUERY_LENGTH ? input.slice(0, MAX_QUERY_LENGTH) : input
 }
 
-// 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.
+// Depth doubles as the cycle bound: a cycle pushes past MAX_DEPTH and bails,
+// after which the slow path catches it via its ancestor stack.
+/** @param {unknown} input */
+function canStringifyDirect (input) {
+  if (input === null ||
+      typeof input !== 'object' ||
+      ArrayBuffer.isView(input) ||
+      input._bsontype !== undefined ||
+      isRegExp(input) ||
+      isMap(input) ||
+      typeof input.toJSON === 'function') {
+    return false
+  }
+  return canStringifyDirectWalk(input, 1)
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {number} depth
+ */
+function canStringifyDirectWalk (value, depth) {
+  if (depth > MAX_DEPTH) return false
+  const children = Array.isArray(value) ? value : Object.values(value)
+  for (const child of children) {
+    if (child === null ||
+        typeof child === 'string' ||
+        typeof child === 'number' ||
+        typeof child === 'boolean') {
+      continue
+    }
+    if (typeof child !== 'object' ||
+        ArrayBuffer.isView(child) ||
+        child._bsontype !== undefined ||
+        isRegExp(child) ||
+        isMap(child) ||
+        typeof child.toJSON === 'function') {
+      return false
+    }
+    if (!canStringifyDirectWalk(child, depth + 1)) return false
+  }
+  return true
+}
+
 /**
  * @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 (mode === 'none') {
+    if (canStringifyDirect(input)) return JSON.stringify(input)
+    return buildNone(input, [])
+  }
+  if (mode === 'redact') return buildRedact(input, [])
+  return buildTypes(input, [])
+}
 
-    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' : '?'
-      }
+const REDACT_LEAF = '"?"'
+
+/**
+ * @param {RegExp} value
+ * @returns {string}
+ */
+function stringifyRegExp (value) {
+  return `{"$regex":${JSON.stringify(value.source)},"$options":${JSON.stringify(value.flags)}}`
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ * @returns {string | undefined}
+ */
+function buildNone (value, ancestors) {
+  // ArrayBuffer views (Buffer, every TypedArray, DataView) and Binary BSON
+  // wrappers redact at the leaf; the walker neither recurses into the bytes
+  // nor invokes any custom conversion.
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return REDACT_LEAF
+  }
+
+  if (isRegExp(value)) return stringifyRegExp(value)
+
+  // Mirror JSON.stringify's contract: when `toJSON` is present, walk its
+  // result (wrappers like Timestamp / Decimal128 expand to a small object,
+  // ObjectId / Date flatten to a primitive).
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (json === value) return REDACT_LEAF
+    // JSON.stringify keeps a null result as null (an invalid Date's toJSON
+    // returns null); only function / symbol / undefined results drop the key.
+    if (json === null) return 'null'
+    if (typeof json !== 'object') return classifyLeafForNone(json)
+    // A wrapper that exposes binary state through toJSON (Buffer-backed
+    // class with WeakMap state, etc.) returns a TypedArray here. Re-screen
+    // before the per-key walk would expand it element by element.
+    if (ArrayBuffer.isView(json) || json._bsontype === 'Binary') return REDACT_LEAF
+    value = json
+  } else if (bsontype !== undefined) {
+    return REDACT_LEAF
+  }
+
+  // The driver serializes a Map via its entries; mirror that as a document so
+  // the tag matches the wire shape.
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      // JSON.stringify renders unsupported leaves (function, symbol, undefined) as null in arrays.
+      result += sep + (classifyForNone(value[i], ancestors) ?? 'null')
+      sep = ','
     }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      const childResult = classifyForNone(value[key], ancestors)
+      if (childResult === undefined) continue
+      result += sep + JSON.stringify(key) + ':' + childResult
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
+
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ * @returns {string | undefined}
+ */
+function classifyForNone (child, ancestors) {
+  if (typeof child !== 'object') return classifyLeafForNone(child)
+  if (child === null) return 'null'
+  return buildNone(child, ancestors)
+}
+
+/**
+ * @param {unknown} leaf
+ * @returns {string | undefined}
+ */
+function classifyLeafForNone (leaf) {
+  // Implicit `undefined` for function / symbol / undefined matches the
+  // contract callers rely on: JSON.stringify drops those property values
+  // inside objects and writes `null` in arrays.
+  switch (typeof leaf) {
+    case 'string': return JSON.stringify(leaf)
+    case 'number': return Number.isFinite(leaf) ? String(leaf) : 'null'
+    case 'boolean': return leaf ? 'true' : 'false'
+    case 'bigint': return `"${String(leaf)}"`
+  }
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ */
+function buildRedact (value, ancestors) {
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' || isRegExp(value) ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return REDACT_LEAF
+  }
+
+  // Mirror JSON.stringify: when `toJSON` is present, walk its result (which
+  // wrappers like Timestamp / Decimal128 expand to `{$timestamp: "..."}` etc).
+  // A primitive, null, or self-reference collapses to the sentinel — master's
+  // `value === original` short-circuit.
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (typeof json !== 'object' || json === null || json === value) return REDACT_LEAF
+    // Re-screen: toJSON can return a TypedArray or Binary BSON wrapper.
+    if (ArrayBuffer.isView(json) || json._bsontype === 'Binary') return REDACT_LEAF
+    value = json
+  } else if (bsontype !== undefined) {
+    return REDACT_LEAF
+  }
+
+  if (isMap(value)) value = Object.fromEntries(value)
+
+  ancestors.push(value)
 
-    if (value === null || typeof value !== 'object') {
-      if (key === '' || mode === 'none') return value
-      if (mode === 'redact') return '?'
-      return original === null ? 'null' : typeof original
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      result += sep + classifyForRedact(value[i], ancestors)
+      sep = ','
     }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      result += sep + JSON.stringify(key) + ':' + classifyForRedact(value[key], ancestors)
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
+}
 
-    while (ancestors.length > 0 && ancestors.at(-1) !== this) ancestors.pop()
-    if (ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
-      return mode === 'types' ? 'object' : '?'
+/**
+ * @param {unknown} child
+ * @param {object[]} ancestors
+ */
+function classifyForRedact (child, ancestors) {
+  if (typeof child !== 'object' || child === null) return REDACT_LEAF
+  return buildRedact(child, ancestors)
+}
+
+const TYPE_OBJECT = '"object"'
+const TYPE_NULL = '"null"'
+const TYPE_BY_TYPEOF = {
+  string: '"string"',
+  number: '"number"',
+  boolean: '"boolean"',
+  bigint: '"bigint"',
+  undefined: '"undefined"',
+}
+
+/**
+ * @param {Record<string, unknown> | unknown[]} value
+ * @param {object[]} ancestors
+ */
+function buildTypes (value, ancestors) {
+  const bsontype = value._bsontype
+  if (ArrayBuffer.isView(value) || bsontype === 'Binary' || isRegExp(value) ||
+      ancestors.length >= MAX_DEPTH || ancestors.includes(value)) {
+    return TYPE_OBJECT
+  }
+
+  if (typeof value.toJSON === 'function') {
+    const json = value.toJSON()
+    if (typeof json !== 'object' ||
+        json === null ||
+        json === value ||
+        ArrayBuffer.isView(json) ||
+        json._bsontype === 'Binary') {
+      return TYPE_OBJECT
     }
-    ancestors.push(value)
+    value = json
+  } else if (bsontype !== undefined) {
+    return TYPE_OBJECT
+  }
+
+  if (isMap(value)) value = Object.fromEntries(value)
 
-    return value
-  })
+  ancestors.push(value)
+
+  let result
+  if (Array.isArray(value)) {
+    result = '['
+    let sep = ''
+    for (let i = 0; i < value.length; i++) {
+      // JSON.stringify renders unsupported leaves (function, symbol) as null in arrays.
+      result += sep + (classifyForTypes(value[i], ancestors) ?? 'null')
+      sep = ','
+    }
+    result += ']'
+  } else {
+    result = '{'
+    let sep = ''
+    for (const key of Object.keys(value)) {
+      const childResult = classifyForTypes(value[key], ancestors)
+      if (childResult === undefined) continue
+      result += sep + JSON.stringify(key) + ':' + childResult
+      sep = ','
+    }
+    result += '}'
+  }
+  ancestors.pop()
+  return result
 }
 
 /**
- * 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'}
+ * @param {unknown} child
+ * @param {object[]} ancestors
  */
+function classifyForTypes (child, ancestors) {
+  if (typeof child !== 'object') return TYPE_BY_TYPEOF[typeof child]
+  if (child === null) return TYPE_NULL
+  return buildTypes(child, ancestors)
+}
+
+/** @param {unknown} value */
 function normaliseObfuscateQuery (value) {
   if (value === 'types' || value === 'redact') return value
   return 'none'

package/packages/datadog-plugin-nats/src/consumer.js

@@ -0,0 +1,43 @@
+'use strict'
+
+const { TEXT_MAP } = require('../../../ext/formats')
+const ConsumerPlugin = require('../../dd-trace/src/plugins/consumer')
+const { headersToTextMap } = require('./util')
+
+const MESSAGING_DESTINATION_KEY = 'messaging.destination.name'
+
+class NatsConsumerPlugin extends ConsumerPlugin {
+  static id = 'nats'
+  static operation = 'consume'
+
+  bindStart (ctx) {
+    const { subject: filter, message } = ctx
+    // For wildcard subscriptions (e.g. `orders.*`), `filter` is the subscription
+    // pattern but `message.subject` is the actual delivered subject. Prefer the
+    // delivered one for resource/destination so spans aren't all collapsed under
+    // the wildcard pattern. Fall back to the filter if the message is missing it.
+    const subject = typeof message?.subject === 'string' ? message.subject : filter
+    const carrier = headersToTextMap(message?.headers)
+    const childOf = carrier ? this.tracer.extract(TEXT_MAP, carrier) : null
+
+    const meta = {
+      component: 'nats',
+      'nats.subject': subject,
+      [MESSAGING_DESTINATION_KEY]: subject,
+    }
+    if (filter && filter !== subject) {
+      meta['nats.subscription.subject'] = filter
+    }
+
+    this.startSpan({
+      childOf,
+      resource: subject,
+      type: 'worker',
+      meta,
+    }, ctx)
+
+    return ctx.currentStore
+  }
+}
+
+module.exports = NatsConsumerPlugin

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

@@ -0,0 +1,20 @@
+'use strict'
+
+const CompositePlugin = require('../../dd-trace/src/plugins/composite')
+const ProducerPlugin = require('./producer')
+const ConsumerPlugin = require('./consumer')
+
+class NatsPlugin extends CompositePlugin {
+  static id = 'nats'
+  // Disabled by default — users must opt in via DD_TRACE_NATS_ENABLED=true
+  // or `tracer.use('nats')`. Matches the feature parity dashboard policy.
+  static experimental = true
+  static get plugins () {
+    return {
+      producer: ProducerPlugin,
+      consumer: ConsumerPlugin,
+    }
+  }
+}
+
+module.exports = NatsPlugin

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

@@ -0,0 +1,62 @@
+'use strict'
+
+const { TEXT_MAP } = require('../../../ext/formats')
+const { CLIENT_PORT_KEY } = require('../../dd-trace/src/constants')
+const ProducerPlugin = require('../../dd-trace/src/plugins/producer')
+const { getOperationName } = require('./util')
+
+const MESSAGING_DESTINATION_KEY = 'messaging.destination.name'
+
+class NatsProducerPlugin extends ProducerPlugin {
+  static id = 'nats'
+  static operation = 'publish'
+  static peerServicePrecursors = [MESSAGING_DESTINATION_KEY]
+
+  bindStart (ctx) {
+    const { subject, options, connection, type, createHeaders } = ctx
+    const server = connection?.protocol?.servers?.getCurrent?.() ??
+      connection?.protocol?.servers?.getCurrentServer?.()
+    const operation = getOperationName(type)
+
+    const span = this.startSpan({
+      resource: subject,
+      meta: {
+        component: 'nats',
+        'nats.subject': subject,
+        'nats.operation': operation,
+        [MESSAGING_DESTINATION_KEY]: subject,
+        'out.host': server?.hostname,
+      },
+    }, ctx)
+
+    if (server?.port) {
+      span.setTag(CLIENT_PORT_KEY, server.port)
+    }
+
+    if (this.serverSupportsHeaders(connection)) {
+      let headers = options.headers
+      if (!headers && typeof createHeaders === 'function') {
+        headers = createHeaders()
+        options.headers = headers
+      }
+      if (headers && typeof headers.set === 'function') {
+        const carrier = {}
+        this.tracer.inject(span, TEXT_MAP, carrier)
+        for (const key of Object.keys(carrier)) {
+          headers.set(key, carrier[key])
+        }
+      }
+    }
+
+    return ctx.currentStore
+  }
+
+  serverSupportsHeaders (connection) {
+    const info = connection?.protocol?.info
+    // If info isn't available yet (e.g. publish before INFO), assume supported — modern NATS does.
+    if (!info) return true
+    return info.headers !== false
+  }
+}
+
+module.exports = NatsProducerPlugin

package/packages/datadog-plugin-nats/src/util.js

@@ -0,0 +1,33 @@
+'use strict'
+
+function headersToTextMap (msgHdrs) {
+  if (!msgHdrs || typeof msgHdrs[Symbol.iterator] !== 'function') return null
+  const textMap = {}
+  for (const [key, values] of msgHdrs) {
+    if (!Array.isArray(values) || values.length === 0) continue
+    // Trace headers are single-valued (injected via `set`, not `append`), so
+    // the first element is always the authoritative value.
+    textMap[key] = values[0]
+  }
+  return textMap
+}
+
+function getOperationName (type) {
+  switch (type) {
+    case 'publish':
+      return 'publish'
+    case 'request':
+    case 'requestMany':
+      return 'request'
+    default:
+      // Surface unrecognized operations explicitly rather than silently
+      // collapsing them into 'publish' — if NATS adds a new outbound API,
+      // this lets us see it in traces and fix the mapping deliberately.
+      return 'unknown'
+  }
+}
+
+module.exports = {
+  headersToTextMap,
+  getOperationName,
+}

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

@@ -33,11 +33,13 @@ class NextPlugin extends ServerPlugin {
         'span.type': 'web',
         'span.kind': 'server',
         'http.method': req.method,
-        ...(serviceSource === undefined ? {} : { [SVC_SRC_KEY]: serviceSource }),
+        ...(serviceSource === undefined ? undefined : { [SVC_SRC_KEY]: serviceSource }),
       },
       integrationName: this.constructor.id,
     })
 
+    this.stampIntegrationService(span, serviceName)
+
     analyticsSampler.sample(span, this.config.measured, true)
 
     return { ...store, span, req }
@@ -60,7 +62,7 @@ class NextPlugin extends ServerPlugin {
     if (!store) return
 
     const span = store.span
-    const error = span.context()._tags.error
+    const error = span.context().getTag('error')
     const requestError = req.error || nextRequest.error
 
     if (requestError) {
@@ -97,7 +99,7 @@ class NextPlugin extends ServerPlugin {
     if (!req) return
 
     // Only use error page names if there's not already a name
-    const current = span.context()._tags['next.page']
+    const current = span.context().getTag('next.page')
     const isErrorPage = errorPages.has(page)
 
     if (current && isErrorPage) {

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

@@ -8,6 +8,7 @@ const Sampler = require('../../dd-trace/src/sampler')
 const { MEASURED } = require('../../../ext/tags')
 
 const { DD_MAJOR } = require('../../../version')
+const { ERROR_TYPE } = require('../../dd-trace/src/constants')
 const {
   convertBuffersToObjects,
   constructCompletionResponseFromStreamedChunks,
@@ -157,7 +158,7 @@ class OpenAiTracingPlugin extends TracingPlugin {
     const span = store?.span
     if (!span) return
 
-    const error = !!span.context()._tags.error
+    const error = !!span.context().getTag('error')
 
     let headers, body, method, path
     if (!error) {
@@ -171,7 +172,7 @@ class OpenAiTracingPlugin extends TracingPlugin {
       headers = Object.fromEntries(headers)
     }
 
-    const resource = span._spanContext._tags['resource.name']
+    const resource = span.context().getTag('resource.name')
     const normalizedMethodName = store.normalizedMethodName
 
     body = coerceResponseBody(body, normalizedMethodName)
@@ -211,6 +212,18 @@ class OpenAiTracingPlugin extends TracingPlugin {
     this.sendMetrics(headers, body, endpoint, span._duration, error, tags)
   }
 
+  error (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    super.error(ctx) // add normal error tag
+
+    const errorType = ctx.error?.type
+    if (errorType) {
+      span.setTag(ERROR_TYPE, errorType)
+    }
+  }
+
   sendMetrics (headers, body, endpoint, duration, error, spanTags) {
     const tags = [`error:${Number(!!error)}`]
     if (error) {

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

@@ -24,19 +24,30 @@ class OracledbPlugin extends DatabasePlugin {
       dbInstance ??= dbInfo.dbInstance
     }
 
-    this.startSpan(this.operationName(), {
+    // oracledb >= 6.4 accepts `execute({ statement, values })` (sql-template-tag form)
+    // in addition to a plain SQL string. Extract the SQL text either way so we can tag
+    // the resource and inject DBM into the statement, then re-wrap if needed to keep
+    // the caller's binds.
+    const sql = query?.statement ?? query
+
+    const span = this.startSpan(this.operationName(), {
       service,
-      resource: query,
+      resource: sql,
       type: 'sql',
       kind: 'client',
       meta: {
         'db.user': this.config.user,
         'db.instance': dbInstance,
+        'db.name': dbInstance,
         'db.hostname': hostname,
+        'out.host': hostname,
         [CLIENT_PORT_KEY]: port,
       },
     }, ctx)
 
+    const injected = this.injectDbmQuery(span, sql, service.name)
+    ctx.injected = query?.statement ? { ...query, statement: injected } : injected
+
     return ctx.currentStore
   }
 }

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

@@ -1,9 +1,51 @@
 'use strict'
 
+const { buildLogHolder, messageProxy } = require('../../dd-trace/src/plugins/log_injection')
 const LogPlugin = require('../../dd-trace/src/plugins/log_plugin')
 
 class PinoPlugin extends LogPlugin {
   static id = 'pino'
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('apm:pino:log:json', (payload) => this.handleJsonLine(payload))
+    this.addSub('apm:pino:log', (arg) => this.handlePrettyMessage(arg))
+  }
+
+  /**
+   * Splice `,"dd":<json>` into the JSON line pino has already produced.
+   * The caller-owned message object is never observed -- user Proxies and
+   * custom serialisers see nothing because there is no mutation to see.
+   *
+   * @param {{ line: string }} payload
+   */
+  handleJsonLine (payload) {
+    const logHolder = buildLogHolder(this.tracer)
+    if (!logHolder) return
+
+    const line = payload.line
+    const lastClose = line.lastIndexOf('}')
+    if (lastClose < 1) return
+
+    const ddJson = JSON.stringify(logHolder.dd)
+    const sep = line.charCodeAt(lastClose - 1) === 0x7B ? '' : ','
+    payload.line = line.slice(0, lastClose) + sep + '"dd":' + ddJson + line.slice(lastClose)
+  }
+
+  /**
+   * `pino-pretty` (bundled with pino 5/7, separate package on >=8) reads
+   * the original message object rather than the JSON line, so the splice
+   * above is invisible to it. Wrap the message in a Proxy that exposes a
+   * virtual `dd` field for the prettifier to pick up.
+   *
+   * @param {{ message: object }} arg
+   */
+  handlePrettyMessage (arg) {
+    const logHolder = buildLogHolder(this.tracer)
+    if (!logHolder) return
+
+    arg.message = messageProxy(arg.message, logHolder)
+  }
 }
 
 module.exports = PinoPlugin