dd-trace 5.99.1 → 5.100.0

package/packages/dd-trace/src/heap_snapshots.js

@@ -8,11 +8,11 @@ const { threadId } = require('worker_threads')
 const log = require('./log')
 
 async function scheduleSnapshot (config, total) {
-  if (total > config.heapSnapshot.count) return
+  if (total > config.DD_HEAP_SNAPSHOT_COUNT) return
 
-  await setTimeout(config.heapSnapshot.interval * 1000, null, { ref: false })
+  await setTimeout(config.DD_HEAP_SNAPSHOT_INTERVAL * 1000, null, { ref: false })
   await clearMemory()
-  writeHeapSnapshot(getName(config.heapSnapshot.destination))
+  writeHeapSnapshot(getName(config.DD_HEAP_SNAPSHOT_DESTINATION))
   await scheduleSnapshot(config, total + 1)
 }
 
@@ -49,7 +49,7 @@ module.exports = {
    * @param {import('./config/config-base')} config - Tracer configuration
    */
   async start (config) {
-    const destination = config.heapSnapshot.destination
+    const destination = config.DD_HEAP_SNAPSHOT_DESTINATION
 
     try {
       await scheduleSnapshot(config, 1)

package/packages/dd-trace/src/openfeature/eval-metrics-hook.js

@@ -30,7 +30,7 @@ const COUNTER_UNIT = '{evaluation}'
  * If counter creation fails (e.g. the OTel API is not yet available), the call
  * is silently skipped and retried on the next `finally()` invocation.
  *
- * When `config.otelMetricsEnabled` is false, `finally()` is always a no-op.
+ * When `config.DD_METRICS_OTEL_ENABLED` is false, `finally()` is always a no-op.
  */
 class EvalMetricsHook {
   #enabled = false
@@ -40,7 +40,7 @@ class EvalMetricsHook {
    * @param {import('../config')} config - Tracer configuration object
    */
   constructor (config) {
-    this.#enabled = config.otelMetricsEnabled === true
+    this.#enabled = config.DD_METRICS_OTEL_ENABLED === true
   }
 
   /**

package/packages/dd-trace/src/opentelemetry/context_manager.js

@@ -2,7 +2,7 @@
 
 const { trace, ROOT_CONTEXT, propagation } = require('@opentelemetry/api')
 const { storage } = require('../../../datadog-core')
-const { getAllBaggageItems, setBaggageItem, removeAllBaggageItems } = require('../baggage')
+const { getAllBaggageItems, setAllBaggageItems, removeAllBaggageItems } = require('../baggage')
 
 const SpanContext = require('./span_context')
 
@@ -64,13 +64,16 @@ class ContextManager {
       return this._store.run(context, cb, ...args)
     }
     const baggages = propagation.getBaggage(context)
-    let baggageItems = []
-    if (baggages) {
-      baggageItems = baggages.getAllEntries()
-    }
-    removeAllBaggageItems()
-    for (const baggage of baggageItems) {
-      setBaggageItem(baggage[0], baggage[1].value)
+    const baggageItems = baggages ? baggages.getAllEntries() : []
+    if (baggageItems.length > 0) {
+      /** @type {Record<string, string>} */
+      const items = {}
+      for (const [key, entry] of baggageItems) {
+        items[key] = entry.value
+      }
+      setAllBaggageItems(items)
+    } else {
+      removeAllBaggageItems()
     }
     if (span && span._ddSpan) {
       const ddSpan = span._ddSpan

package/packages/dd-trace/src/opentelemetry/span-helpers.js

@@ -0,0 +1,170 @@
+'use strict'
+
+const { ERROR_MESSAGE, ERROR_STACK, ERROR_TYPE, IGNORE_OTEL_ERROR } = require('../constants')
+const DatadogSpanContext = require('../opentracing/span_context')
+const TraceState = require('../opentracing/propagation/tracestate')
+
+const id = require('../id')
+
+/**
+ * @typedef {{ toTraceId: (get128?: boolean) => string, toSpanId: (get128?: boolean) => string }} DatadogContextLike
+ * @typedef {{ _ddContext: import('../opentracing/span_context') }} OtelBridgeSpanContextLike
+ * @typedef {{
+ *   traceId: string,
+ *   spanId: string,
+ *   traceFlags?: number,
+ *   traceState?: { serialize: () => string }
+ * }} OtelSpanContextLike
+ * @typedef {DatadogContextLike | OtelBridgeSpanContextLike | OtelSpanContextLike} LinkContextLike
+ * @typedef {{ context: LinkContextLike, attributes?: Record<string, unknown> }} OtelLink
+ * @typedef {{
+ *   name?: string,
+ *   message?: string,
+ *   stack?: string,
+ *   type?: string,
+ *   escaped?: unknown
+ * }} ExceptionLike
+ * @typedef {{
+ *   addEvent: (name: string, attributes: Record<string, unknown>, timeInput?: unknown) => unknown
+ * }} EventTarget
+ */
+
+/**
+ * Normalize any Datadog/OTel span-context shape to a `DatadogSpanContext`.
+ *
+ * @param {LinkContextLike | undefined | null} context
+ * @returns {import('../opentracing/span_context') | undefined}
+ */
+function normalizeLinkContext (context) {
+  if (!context) return
+
+  const bridgeCtx = /** @type {OtelBridgeSpanContextLike} */ (context)
+  if (bridgeCtx._ddContext) return bridgeCtx._ddContext
+
+  const ddCtx = /** @type {DatadogContextLike} */ (context)
+  if (typeof ddCtx.toTraceId === 'function' && typeof ddCtx.toSpanId === 'function') {
+    return /** @type {import('../opentracing/span_context')} */ (/** @type {unknown} */ (context))
+  }
+
+  const otelCtx = /** @type {OtelSpanContextLike} */ (context)
+  if (typeof otelCtx.traceId !== 'string' || typeof otelCtx.spanId !== 'string') return
+
+  let sampling
+  if (typeof otelCtx.traceFlags === 'number') {
+    sampling = { priority: otelCtx.traceFlags & 1 }
+  }
+
+  let tracestate
+  if (otelCtx.traceState?.serialize) {
+    tracestate = TraceState.fromString(otelCtx.traceState.serialize())
+  }
+
+  return new DatadogSpanContext({
+    traceId: id(otelCtx.traceId, 16),
+    spanId: id(otelCtx.spanId, 16),
+    sampling,
+    tracestate,
+  })
+}
+
+/**
+ * @param {import('../opentracing/span')} ddSpan
+ * @param {string} key
+ * @param {unknown} value
+ * @returns {void}
+ */
+function setOtelAttribute (ddSpan, key, value) {
+  if (key === 'http.response.status_code') {
+    ddSpan.setTag('http.status_code', String(value))
+  }
+
+  ddSpan.setTag(key, value)
+}
+
+/**
+ * @param {import('../opentracing/span')} ddSpan
+ * @param {Record<string, unknown>} attributes
+ * @returns {void}
+ */
+function setOtelAttributes (ddSpan, attributes) {
+  if ('http.response.status_code' in attributes) {
+    attributes['http.status_code'] = String(attributes['http.response.status_code'])
+  }
+
+  ddSpan.addTags(attributes)
+}
+
+/**
+ * Accepts both `{ context, attributes }` and the deprecated `(context, attrs)` form.
+ *
+ * @param {import('../opentracing/span')} ddSpan
+ * @param {LinkContextLike | OtelLink} link
+ * @param {Record<string, unknown>} [attrs]
+ * @returns {void}
+ */
+function addOtelLink (ddSpan, link, attrs) {
+  // TODO: Drop the (context, attrs) form in v6.0.0.
+  const linkObj = link && typeof link === 'object' && 'context' in link
+    ? /** @type {OtelLink} */ (link)
+    : { context: /** @type {LinkContextLike} */ (link), attributes: attrs ?? {} }
+
+  const ddSpanContext = normalizeLinkContext(linkObj.context)
+  if (!ddSpanContext) return
+
+  ddSpan.addLink({ context: ddSpanContext, attributes: linkObj.attributes })
+}
+
+/**
+ * @param {import('../opentracing/span')} ddSpan
+ * @param {EventTarget} eventTarget
+ * @param {ExceptionLike} exception
+ * @param {unknown} [timeInput]
+ * @returns {void}
+ */
+function recordException (ddSpan, eventTarget, exception, timeInput) {
+  ddSpan.addTags({
+    [ERROR_TYPE]: exception.name,
+    [ERROR_MESSAGE]: exception.message,
+    [ERROR_STACK]: exception.stack,
+    [IGNORE_OTEL_ERROR]: ddSpan.context()._tags[IGNORE_OTEL_ERROR] ?? true,
+  })
+
+  /** @type {Record<string, unknown>} */
+  const attributes = {}
+  if (exception.message) attributes['exception.message'] = exception.message
+  if (exception.type) attributes['exception.type'] = exception.type
+  if (exception.escaped) attributes['exception.escaped'] = exception.escaped
+  if (exception.stack) attributes['exception.stacktrace'] = exception.stack
+
+  eventTarget.addEvent(exception.name ?? 'Error', attributes, timeInput)
+}
+
+/**
+ * First-call-wins; no-op on ended spans. Only `code === 2` emits Datadog error tags.
+ *
+ * @param {import('../opentracing/span')} ddSpan
+ * @param {{ ended: boolean, _hasStatus: boolean }} bridgeSpan
+ * @param {{ code?: number, message?: string }} [status]
+ * @returns {void}
+ */
+function setStatus (ddSpan, bridgeSpan, { code, message } = {}) {
+  if (bridgeSpan.ended || bridgeSpan._hasStatus || !code) return
+
+  bridgeSpan._hasStatus = true
+
+  if (code === 2) {
+    ddSpan.addTags({
+      [ERROR_MESSAGE]: message,
+      [IGNORE_OTEL_ERROR]: false,
+    })
+  }
+}
+
+module.exports = {
+  addOtelLink,
+  normalizeLinkContext,
+  recordException,
+  setOtelAttribute,
+  setOtelAttributes,
+  setStatus,
+}

package/packages/dd-trace/src/opentelemetry/span.js

@@ -9,12 +9,18 @@ const { timeInputToHrTime } = require('../../../../vendor/dist/@opentelemetry/co
 
 const tracer = require('../../')
 const DatadogSpan = require('../opentracing/span')
-const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK, IGNORE_OTEL_ERROR } = require('../constants')
 const { SERVICE_NAME, RESOURCE_NAME, SPAN_KIND } = require('../../../../ext/tags')
 const kinds = require('../../../../ext/kinds')
 
 const id = require('../id')
 const SpanContext = require('./span_context')
+const {
+  addOtelLink,
+  recordException,
+  setOtelAttribute,
+  setOtelAttributes,
+  setStatus,
+} = require('./span-helpers')
 
 // The one built into OTel rounds so we lose sub-millisecond precision.
 function hrTimeToMilliseconds (time) {
@@ -195,33 +201,17 @@ class Span {
   }
 
   setAttribute (key, value) {
-    if (key === 'http.response.status_code') {
-      this._ddSpan.setTag('http.status_code', value.toString())
-    }
-
-    this._ddSpan.setTag(key, value)
+    setOtelAttribute(this._ddSpan, key, value)
     return this
   }
 
   setAttributes (attributes) {
-    if ('http.response.status_code' in attributes) {
-      attributes['http.status_code'] = attributes['http.response.status_code'].toString()
-    }
-
-    this._ddSpan.addTags(attributes)
+    setOtelAttributes(this._ddSpan, attributes)
     return this
   }
 
   addLink (link, attrs) {
-    // TODO: Remove this once we remove addLink(context, attrs) in v6.0.0
-    if (link instanceof SpanContext) {
-      link = { context: link, attributes: attrs ?? {} }
-    }
-
-    const { context, attributes } = link
-    // Extract dd context
-    const ddSpanContext = context._ddContext
-    this._ddSpan.addLink({ context: ddSpanContext, attributes })
+    addOtelLink(this._ddSpan, link, attrs)
     return this
   }
 
@@ -244,16 +234,8 @@ class Span {
     return this.addLink(zeroContext, attributes)
   }
 
-  setStatus ({ code, message }) {
-    if (!this.ended && !this._hasStatus && code) {
-      this._hasStatus = true
-      if (code === 2) {
-        this._ddSpan.addTags({
-          [ERROR_MESSAGE]: message,
-          [IGNORE_OTEL_ERROR]: false,
-        })
-      }
-    }
+  setStatus (status) {
+    setStatus(this._ddSpan, this, status)
     return this
   }
 
@@ -291,18 +273,8 @@ class Span {
   }
 
   recordException (exception, timeInput) {
-    this._ddSpan.addTags({
-      [ERROR_TYPE]: exception.name,
-      [ERROR_MESSAGE]: exception.message,
-      [ERROR_STACK]: exception.stack,
-      [IGNORE_OTEL_ERROR]: this._ddSpan.context()._tags[IGNORE_OTEL_ERROR] ?? true,
-    })
-    const attributes = {}
-    if (exception.message) attributes['exception.message'] = exception.message
-    if (exception.type) attributes['exception.type'] = exception.type
-    if (exception.escaped) attributes['exception.escaped'] = exception.escaped
-    if (exception.stack) attributes['exception.stacktrace'] = exception.stack
-    this.addEvent(exception.name, attributes, timeInput)
+    // Route through `this.addEvent` so its time-input conversion applies.
+    recordException(this._ddSpan, this, exception, timeInput)
   }
 
   get duration () {

package/packages/dd-trace/src/opentelemetry/tracer.js

@@ -3,49 +3,16 @@
 const api = require('@opentelemetry/api')
 const { sanitizeAttributes } = require('../../../../vendor/dist/@opentelemetry/core')
 
+const tracer = require('../../')
+
 const id = require('../id')
 const log = require('../log')
-const DatadogSpanContext = require('../opentracing/span_context')
 const TextMapPropagator = require('../opentracing/propagation/text_map')
 const TraceState = require('../opentracing/propagation/tracestate')
 const SpanContext = require('./span_context')
 const Span = require('./span')
 const Sampler = require('./sampler')
-
-function normalizeLinkContext (context) {
-  if (!context) return
-
-  // OTel API bridge SpanContext wrapper
-  if (context._ddContext) return context._ddContext
-
-  // Datadog span context
-  if (typeof context.toTraceId === 'function' && typeof context.toSpanId === 'function') {
-    return context
-  }
-
-  // Standard OTel SpanContext (traceId/spanId)
-  if (typeof context.traceId !== 'string' || typeof context.spanId !== 'string') {
-    // Invalid
-    return
-  }
-
-  let sampling
-  if (typeof context.traceFlags === 'number') {
-    sampling = { priority: context.traceFlags & 1 }
-  }
-
-  let tracestate
-  if (context.traceState?.serialize) {
-    tracestate = TraceState.fromString(context.traceState.serialize())
-  }
-
-  return new DatadogSpanContext({
-    traceId: id(context.traceId, 16),
-    spanId: id(context.spanId, 16),
-    sampling,
-    tracestate,
-  })
-}
+const { normalizeLinkContext } = require('./span-helpers')
 
 class Tracer {
   constructor (library, config, tracerProvider) {
@@ -140,6 +107,14 @@ class Tracer {
       spanContext = new SpanContext()
     }
 
+    // init() didn't finish setting up real tracing (e.g. DD_TRACE_ENABLED=false,
+    // or init() was never called), so the inner tracer is still the noop.
+    // DatadogSpan can't construct without a processor + prioritySampler, so fall
+    // through to a non-recording span; the SpanContext still propagates.
+    if (!tracer._tracingInitialized) {
+      return api.trace.wrapSpanContext(spanContext)
+    }
+
     const spanKind = options.kind || api.SpanKind.INTERNAL
     const links = []
     if (options.links?.length) {

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -7,7 +7,7 @@ const DatadogSpanContext = require('../span_context')
 const log = require('../../log')
 const tags = require('../../../../../ext/tags')
 const { getConfiguredEnvName } = require('../../config/helper')
-const { setBaggageItem, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
+const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
 const telemetryMetrics = require('../../telemetry/metrics')
 
 const { AUTO_KEEP, AUTO_REJECT, USER_KEEP } = require('../../../../../ext/priority')
@@ -166,6 +166,7 @@ class TextMapPropagator {
         }
       }
     }
+
     if (this._hasPropagationStyle('inject', 'baggage')) {
       let baggage = ''
       let itemCounter = 0
@@ -408,10 +409,10 @@ class TextMapPropagator {
       }
     }
 
-    if (this._config.tracePropagationBehaviorExtract === 'ignore') {
+    if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'ignore') {
       context._links = []
     } else {
-      if (this._config.tracePropagationBehaviorExtract === 'restart') {
+      if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'restart') {
         context._links = []
         context._links.push({
           context,
@@ -675,11 +676,29 @@ class TextMapPropagator {
   _extractBaggageItems (carrier, spanContext) {
     removeAllBaggageItems()
     if (!this._hasPropagationStyle('extract', 'baggage')) return
-    if (!carrier?.baggage) return
-    const baggages = carrier.baggage.split(',')
+    const baggageHeader = carrier?.baggage
+    const header = Array.isArray(baggageHeader) ? baggageHeader.join(',') : baggageHeader
+    if (!header) return
+
+    const baggages = header.split(',')
     const baggageTagKeys = new Set(this._config.baggageTagKeys)
     const tagAllKeys = baggageTagKeys.has('*')
+    /** @type {Record<string, string> | undefined} */
+    let items
+    let itemCount = 0
+    let byteCount = 0
+
     for (const keyValue of baggages) {
+      if (itemCount >= this._config.baggageMaxItems) {
+        tracerMetrics.count('context_header.truncated', ['truncation_reason:baggage_item_count_exceeded']).inc()
+        break
+      }
+      // Charge the comma slot before the empty-entry skip so a `,,,,,foo=bar` can't iterate for free.
+      byteCount += keyValue.length + 1
+      if (byteCount > this._config.baggageMaxBytes) {
+        tracerMetrics.count('context_header.truncated', ['truncation_reason:baggage_byte_count_exceeded']).inc()
+        break
+      }
       if (!keyValue) continue
 
       // Per W3C baggage, list-members can contain optional properties after `;`.
@@ -692,7 +711,6 @@ class TextMapPropagator {
       const eqIdx = member.indexOf('=')
       if (eqIdx === -1) {
         tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
-        removeAllBaggageItems()
         return
       }
 
@@ -701,7 +719,6 @@ class TextMapPropagator {
 
       if (!baggageTokenExpr.test(key) || !value) {
         tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
-        removeAllBaggageItems()
         return
       }
       try {
@@ -710,15 +727,19 @@ class TextMapPropagator {
         const bytes = value.replaceAll(percentByte, (_, hex) => String.fromCharCode(Number.parseInt(hex, 16)))
         value = Buffer.from(bytes, 'binary').toString('utf8')
       }
+      items ??= {}
+      items[key] = value
+      itemCount++
 
       if (spanContext && (tagAllKeys || baggageTagKeys.has(key))) {
         spanContext._trace.tags['baggage.' + key] = value
       }
-      setBaggageItem(key, value)
     }
 
-    // Successfully extracted baggage
-    tracerMetrics.count('context_header_style.extracted', ['header_style:baggage']).inc()
+    if (items) {
+      setAllBaggageItems(items)
+      tracerMetrics.count('context_header_style.extracted', ['header_style:baggage']).inc()
+    }
   }
 
   _extractSamplingPriority (carrier, spanContext) {

package/packages/dd-trace/src/opentracing/propagation/tracestate.js

@@ -1,19 +1,49 @@
 'use strict'
 
-const traceStateRegex = /[ \t]*([^=]+)=([ \t]*[^, \t]+)[ \t]*(,|$)/gim
-const traceStateDataRegex = /([^:]+):([^;]+)(;|$)/gim
+// W3C Trace Context §3.3.1.2: max 32 list-members.
+// https://www.w3.org/TR/trace-context/#tracestate-header-field-values
+const MAX_LIST_MEMBERS = 32
+const WHITESPACE = /[ \t]/
 
-function fromString (Type, regex, value) {
-  if (typeof value !== 'string' || !value.length) {
-    return new Type()
+/**
+ * Parse a separator-delimited string into key/value entries.
+ *
+ * @param {string} value
+ * @param {string} fieldSeparator Between entries.
+ * @param {string} pairSeparator Between key and value within an entry.
+ * @param {boolean} rejectValueTabs Drop entries whose value contains an internal tab.
+ * @returns {[string, string][]} Entries in reverse of wire order.
+ */
+function parseEntries (value, fieldSeparator, pairSeparator, rejectValueTabs) {
+  const segments = value.split(fieldSeparator)
+  segments.length = Math.min(segments.length, MAX_LIST_MEMBERS)
+
+  // TODO: We should extract dd no matter at what position and move it to the front of the list.
+  // Extract up 31 additional entries.
+  const entries = []
+  for (let index = 0; index < segments.length; index++) {
+    const segment = segments[index]
+    const splitIndex = segment.indexOf(pairSeparator)
+    if (splitIndex === -1) continue
+    const key = segment.slice(0, splitIndex).trim()
+    if (!key || WHITESPACE.test(key)) continue
+    // W3C §3.3.1.3.2: value = 0*255(chr) nblk-chr; chr = %x20 / nblk-chr (no tab).
+    // Leading 0x20 is part of value; trailing whitespace is OWS.
+    const entryValue = segment.slice(splitIndex + 1).trimEnd()
+    if (!entryValue || rejectValueTabs && entryValue.includes('\t')) continue
+    entries.push([key, entryValue])
   }
+  // Reverse so the Map's insertion order is reverse of wire order. `toString`
+  // prepends as it iterates, which yields the original wire order back.
+  entries.reverse()
+  return entries
+}
 
-  const values = []
-  for (const row of value.matchAll(regex)) {
-    values.unshift(row.slice(1, 3))
+function fromString (Type, value, fieldSeparator, pairSeparator, rejectValueTabs) {
+  if (typeof value !== 'string' || !value.length) {
+    return new Type()
   }
-
-  return new Type(values)
+  return new Type(parseEntries(value, fieldSeparator, pairSeparator, rejectValueTabs))
 }
 
 function toString (map, pairSeparator, fieldSeparator) {
@@ -52,7 +82,7 @@ class TraceStateData extends Map {
   }
 
   static fromString (value) {
-    return fromString(TraceStateData, traceStateDataRegex, value)
+    return fromString(TraceStateData, value, ';', ':', false)
   }
 
   toString () {
@@ -92,7 +122,7 @@ class TraceState extends Map {
   }
 
   static fromString (value) {
-    return fromString(TraceState, traceStateRegex, value)
+    return fromString(TraceState, value, ',', '=', true)
   }
 
   toString () {

package/packages/dd-trace/src/opentracing/span.js

@@ -336,7 +336,8 @@ class DatadogSpan {
     let startTime
 
     let baggage = {}
-    if (parent && parent._isRemote && this._parentTracer?._config?.tracePropagationBehaviorExtract !== 'continue') {
+    const propagationBehavior = this._parentTracer?._config?.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT
+    if (parent && parent._isRemote && propagationBehavior !== 'continue') {
       baggage = parent._baggageItems
       parent = null
     }
@@ -375,7 +376,7 @@ class DatadogSpan {
           .padEnd(16, '0')
       }
 
-      if (this._parentTracer?._config?.tracePropagationBehaviorExtract === 'restart') {
+      if (propagationBehavior === 'restart') {
         spanContext._baggageItems = baggage
       }
     }