dd-trace 5.99.0 → 5.100.0

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/logs/index.js

@@ -60,18 +60,18 @@ function initializeOpenTelemetryLogs (config) {
 
   // Create OTLP exporter using resolved config values
   const exporter = new OtlpHttpLogExporter(
-    config.otelLogsUrl,
+    config.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
     config.OTEL_EXPORTER_OTLP_LOGS_HEADERS,
-    config.otelLogsTimeout,
-    config.otelLogsProtocol,
+    config.OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
+    config.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
     resourceAttributes
   )
 
   // Create batch processor for exporting logs to Datadog Agent
   const processor = new BatchLogRecordProcessor(
     exporter,
-    config.otelBatchTimeout,
-    config.otelMaxExportBatchSize
+    config.OTEL_BSP_SCHEDULE_DELAY,
+    config.OTEL_BSP_MAX_EXPORT_BATCH_SIZE
   )
 
   // Create logger provider with processor for Datadog Agent export

package/packages/dd-trace/src/opentelemetry/metrics/index.js

@@ -57,18 +57,18 @@ function initializeOpenTelemetryMetrics (config) {
   }
 
   const exporter = new OtlpHttpMetricExporter(
-    config.otelMetricsUrl,
+    config.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
     config.OTEL_EXPORTER_OTLP_METRICS_HEADERS,
-    config.otelMetricsTimeout,
-    config.otelMetricsProtocol,
+    config.OTEL_EXPORTER_OTLP_METRICS_TIMEOUT,
+    config.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL,
     resourceAttributes
   )
 
   const reader = new PeriodicMetricReader(
     exporter,
-    config.otelMetricsExportInterval,
-    config.otelMetricsTemporalityPreference,
-    config.otelMaxQueueSize
+    config.OTEL_METRIC_EXPORT_INTERVAL,
+    config.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE,
+    config.OTEL_BSP_MAX_QUEUE_SIZE
   )
 
   const meterProvider = new MeterProvider({ reader })

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/trace/otlp_http_trace_exporter.js

@@ -19,7 +19,7 @@ const OtlpTraceTransformer = require('./otlp_transformer')
  * (https://opentelemetry.io/docs/specs/otel/trace/sdk/#batching-processor).
  * Currently each finished trace is sent as its own HTTP request, which is
  * unsuitable for high-traffic production environments. The config values
- * `otelBatchTimeout`, `otelMaxExportBatchSize`, and `otelMaxQueueSize`
+ * `OTEL_BSP_SCHEDULE_DELAY`, `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`, and `OTEL_BSP_MAX_QUEUE_SIZE`
  * (OTEL_BSP_*) are already defined and should drive that implementation.
  *
  * @class OtlpHttpTraceExporter

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')
@@ -64,6 +64,7 @@ const tracestateTagValueFilter = /[^\x20-\x2B\x2D-\x3A\x3C-\x7D]/g
 const invalidSegment = /^0+$/
 const zeroTraceId = '0000000000000000'
 const hex16 = /^[0-9A-Fa-f]{16}$/
+const percentByte = /%([0-9A-Fa-f]{2})/g
 
 class TextMapPropagator {
   #extractB3Context
@@ -165,6 +166,7 @@ class TextMapPropagator {
         }
       }
     }
+
     if (this._hasPropagationStyle('inject', 'baggage')) {
       let baggage = ''
       let itemCounter = 0
@@ -173,15 +175,15 @@ class TextMapPropagator {
       const baggageItems = getAllBaggageItems()
       if (!baggageItems) return
       for (const [key, value] of Object.entries(baggageItems)) {
-        const baggageKey = String(key).trim()
-        if (!baggageKey || !baggageTokenExpr.test(baggageKey)) continue
+        const baggageKey = key.trim()
+        if (!baggageTokenExpr.test(baggageKey)) continue
 
         // Do not trim values. If callers include leading/trailing whitespace, it must be percent-encoded.
         // W3C list-member allows optional properties after ';'.
         // https://www.w3.org/TR/baggage/#header-content
-        const item = `${baggageKey}=${encodeURIComponent(String(value))},`
+        const item = `${baggageKey}=${encodeURIComponent(value)},`
         itemCounter += 1
-        byteCounter += Buffer.byteLength(item)
+        byteCounter += item.length
 
         // Check for item count limit exceeded
         if (itemCounter > this._config.baggageMaxItems) {
@@ -209,7 +211,7 @@ class TextMapPropagator {
   _injectTags (spanContext, carrier) {
     const trace = spanContext._trace
 
-    if (this._config.tagsHeaderMaxLength === 0) {
+    if (this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) {
       log.debug('Trace tag propagation is disabled, skipping injection.')
       return
     }
@@ -228,7 +230,7 @@ class TextMapPropagator {
 
     const header = tags.join(',')
 
-    if (header.length > this._config.tagsHeaderMaxLength) {
+    if (header.length > this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH) {
       log.error('Trace tags from span are too large, skipping injection.')
     } else if (header) {
       carrier[tagsKey] = header
@@ -387,7 +389,7 @@ class TextMapPropagator {
       if (context === null) {
         context = extractedContext
         style = extractor
-        if (this._config.tracePropagationExtractFirst) {
+        if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) {
           break
         }
       } else {
@@ -407,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,
@@ -436,7 +438,7 @@ class TextMapPropagator {
     this._extractSamplingPriority(carrier, spanContext)
     this._extractTags(carrier, spanContext)
 
-    if (this._config.tracePropagationExtractFirst) return spanContext
+    if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) return spanContext
 
     const tc = this._extractTraceparentContext(carrier)
 
@@ -674,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 `;`.
@@ -691,7 +711,6 @@ class TextMapPropagator {
       const eqIdx = member.indexOf('=')
       if (eqIdx === -1) {
         tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
-        removeAllBaggageItems()
         return
       }
 
@@ -700,25 +719,27 @@ class TextMapPropagator {
 
       if (!baggageTokenExpr.test(key) || !value) {
         tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
-        removeAllBaggageItems()
         return
       }
       try {
         value = decodeURIComponent(value)
       } catch {
-        tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
-        removeAllBaggageItems()
-        return
+        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) {
@@ -734,9 +755,9 @@ class TextMapPropagator {
 
     const trace = spanContext._trace
 
-    if (this._config.tagsHeaderMaxLength === 0) {
+    if (this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) {
       log.debug('Trace tag propagation is disabled, skipping extraction.')
-    } else if (carrier[tagsKey].length > this._config.tagsHeaderMaxLength) {
+    } else if (carrier[tagsKey].length > this._config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH) {
       log.error('Trace tags from carrier are too large, skipping extraction.')
     } else {
       const pairs = carrier[tagsKey].split(',')