dd-trace 6.19.0 → 6.20.0

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

@@ -77,6 +77,8 @@ const zeroTraceId = '0000000000000000'
 const hex16 = /^[0-9A-Fa-f]{16}$/
 const percentByte = /%([0-9A-Fa-f]{2})/g
 
+let otelSampling
+
 /**
  * @typedef {object} B3Context
  * @property {string} [flags]
@@ -85,6 +87,13 @@ const percentByte = /%([0-9A-Fa-f]{2})/g
  * @property {string} [traceId]
  */
 
+/**
+ * @typedef {object} TraceTagInjection
+ * @property {DatadogSpanContext} spanContext
+ * @property {Array<string | undefined>} [traceTagReplacements]
+ * @property {number} [optionalTraceTagCount]
+ */
+
 /**
  * @param {Array<string | undefined>} traceTagReplacements
  * @param {string} key
@@ -96,6 +105,28 @@ function hasTraceTagReplacement (traceTagReplacements, key) {
   return false
 }
 
+/** @param {string} key */
+function toTraceStateTagKey (key) {
+  return 't.' + key.slice(6).replaceAll(tracestateTagKeyFilter, '_')
+}
+
+/**
+ * @param {string} key
+ * @param {TraceTagInjection | undefined} injection
+ */
+function isOptionalDatadogTraceStateField (key, injection) {
+  if (!key.startsWith('t.') || key === 't.dm' || key === 't.ts') return false
+
+  const traceTagReplacements = injection?.traceTagReplacements
+  if (!traceTagReplacements) return true
+  const firstOptionalTraceTagIndex = traceTagReplacements.length - (injection.optionalTraceTagCount ?? 0) * 2
+  for (let index = 0; index < firstOptionalTraceTagIndex; index += 2) {
+    const traceTagKey = traceTagReplacements[index]
+    if (traceTagKey.startsWith('_dd.p.') && toTraceStateTagKey(traceTagKey) === key) return false
+  }
+  return true
+}
+
 /**
  * @param {string | undefined} traceId
  * @param {string | undefined} spanId
@@ -149,12 +180,15 @@ function getB3Priority (sampled, debug) {
  * @returns {DatadogSpanContext | undefined}
  */
 function extractB3Context (b3) {
-  const priority = getB3Priority(b3.sampled, b3.flags === '1')
-  const spanContext = extractGenericContext(b3.traceId, b3.spanId, 16)
+  const debug = b3.flags === '1'
+  const priority = getB3Priority(b3.sampled, debug)
+  let spanContext = extractGenericContext(b3.traceId, b3.spanId, 16)
 
   if (priority !== undefined) {
-    if (!spanContext) {
-      return new DatadogSpanContext({
+    if (spanContext) {
+      spanContext._sampling.priority = priority
+    } else {
+      spanContext = new DatadogSpanContext({
         traceId: id(),
         spanId: null,
         sampling: { priority },
@@ -162,7 +196,7 @@ function extractB3Context (b3) {
       })
     }
 
-    spanContext._sampling.priority = priority
+    if (debug) spanContext._sampling.isProbabilityDecision = false
   }
 
   if (spanContext && b3.traceId) extract128BitTraceId(b3.traceId, spanContext)
@@ -326,13 +360,15 @@ class TextMapPropagator {
       hasTraceSourcePropagationTag(spanContext._trace.tags)
     let traceTagReplacements
     let optionalTraceTagCount = 0
+    /** @type {TraceTagInjection | undefined} */
+    let traceTagInjection
     if (injectTraceContext && injectCh.hasSubscribers && (
       this.#hasPropagationStyle('inject', 'datadog') || this.#hasPropagationStyle('inject', 'tracecontext')
     )) {
-      const injection = { spanContext }
-      injectCh.publish(injection)
-      traceTagReplacements = injection.traceTagReplacements
-      optionalTraceTagCount = injection.optionalTraceTagCount ?? 0
+      traceTagInjection = { spanContext }
+      injectCh.publish(traceTagInjection)
+      traceTagReplacements = traceTagInjection.traceTagReplacements
+      optionalTraceTagCount = traceTagInjection.optionalTraceTagCount ?? 0
     }
     if (injectTraceContext) {
       injectedCarrier = this.#injectDatadog(
@@ -343,7 +379,7 @@ class TextMapPropagator {
     }
     injectedCarrier = this
       .#injectTraceparent(
-        spanContext, injectedCarrier ?? carrier, injectTraceContext, traceTagReplacements
+        spanContext, injectedCarrier ?? carrier, injectTraceContext, traceTagReplacements, traceTagInjection
       ) ?? injectedCarrier
 
     if (injectedCarrier === undefined) return
@@ -509,7 +545,7 @@ class TextMapPropagator {
     }
 
     if (traceTagReplacements) {
-      const requiredEntryCount = traceTagReplacements.length - optionalTraceTagCount * 2
+      const firstOptionalTraceTagIndex = traceTagReplacements.length - optionalTraceTagCount * 2
       for (let index = 0; index < traceTagReplacements.length; index += 2) {
         const key = traceTagReplacements[index]
         const value = traceTagReplacements[index + 1]
@@ -520,7 +556,7 @@ class TextMapPropagator {
         }
 
         const entry = `${header ? ',' : ''}${key}=${value}`
-        if (index >= requiredEntryCount && header.length + entry.length > maxLength) break
+        if (index >= firstOptionalTraceTagIndex && header.length + entry.length > maxLength) break
         header += entry
       }
     }
@@ -589,13 +625,14 @@ class TextMapPropagator {
    * @param {Record<string, string> | undefined} carrier
    * @param {boolean} injectTraceContext
    * @param {Array<string | undefined>} [traceTagReplacements]
+   * @param {TraceTagInjection} [traceTagInjection]
    * @returns {Record<string, string> | undefined}
    */
-  #injectTraceparent (spanContext, carrier, injectTraceContext, traceTagReplacements) {
+  #injectTraceparent (spanContext, carrier, injectTraceContext, traceTagReplacements, traceTagInjection) {
     if (!this.#hasPropagationStyle('inject', 'tracecontext')) return
 
     if (!injectTraceContext) {
-      const tracestate = TraceState.fromString(spanContext._tracestate?.toString())
+      const tracestate = spanContext._tracestate?.clone() ?? new TraceState()
       tracestate.delete('dd')
       const header = tracestate.toString()
       if (!header) return
@@ -611,11 +648,14 @@ class TextMapPropagator {
       _trace: { origin },
     } = spanContext
     const ts = traceTagReplacements
-      ? TraceState.fromString(_tracestate?.toString())
+      ? _tracestate?.clone() ?? new TraceState()
       : _tracestate ?? new TraceState()
 
     writeTraceparent(carrier, spanContext.toTraceparent())
 
+    otelSampling ??= require('../../otel-sampling')
+    otelSampling.updateOtelTraceState(spanContext, ts)
+
     ts.forVendor('dd', state => {
       if (!spanContext._isRemote) {
         // SpanContext was created by a ddtrace span.
@@ -643,8 +683,7 @@ class TextMapPropagator {
         const tagValueRaw = spanContext._trace.tags[key]
         if (!tagValueRaw || !key.startsWith('_dd.p.')) continue
 
-        const tagKey = 't.' + key.slice(6)
-          .replaceAll(tracestateTagKeyFilter, '_')
+        const tagKey = toTraceStateTagKey(key)
 
         const tagValue = tagValueRaw
           .toString()
@@ -659,8 +698,7 @@ class TextMapPropagator {
           const key = traceTagReplacements[index]
           if (!key.startsWith('_dd.p.')) continue
 
-          const tagKey = 't.' + key.slice(6)
-            .replaceAll(tracestateTagKeyFilter, '_')
+          const tagKey = toTraceStateTagKey(key)
           const tagValueRaw = traceTagReplacements[index + 1]
           if (!tagValueRaw) {
             state.delete(tagKey)
@@ -675,7 +713,7 @@ class TextMapPropagator {
           state.set(tagKey, tagValue)
         }
       }
-    })
+    }, isOptionalDatadogTraceStateField, traceTagInjection)
 
     writeTracestate(carrier, ts.toString())
 
@@ -690,6 +728,32 @@ class TextMapPropagator {
     return this.#config.tracePropagationStyle[mode].includes(name)
   }
 
+  /**
+   * Merges W3C sampling state into the context selected by propagation-style precedence.
+   *
+   * @param {DatadogSpanContext} w3cSpanContext
+   * @param {DatadogSpanContext} selectedSpanContext
+   */
+  #mergeTraceContextState (w3cSpanContext, selectedSpanContext) {
+    const selectedPriority = selectedSpanContext._sampling.priority
+    if (selectedPriority === undefined) {
+      selectedSpanContext._sampling.priority = w3cSpanContext._sampling.priority
+      selectedSpanContext._sampling.mechanism = w3cSpanContext._sampling.mechanism
+      selectedSpanContext._trace.tags['_dd.p.dm'] = w3cSpanContext._trace.tags['_dd.p.dm']
+    } else if (
+      selectedSpanContext._sampling.isProbabilityDecision === false ||
+      (selectedPriority >= AUTO_KEEP) !== (w3cSpanContext._sampling.priority >= AUTO_KEEP)
+    ) {
+      // Copied sampling metadata must not describe a conflicting or non-probabilistic selected decision.
+      selectedSpanContext._sampling.isProbabilityDecision = false
+      w3cSpanContext._tracestate.forVendor('dd', state => {
+        if (state.get('t.dm') !== undefined) state.delete('t.dm')
+      })
+    }
+
+    selectedSpanContext._tracestate = w3cSpanContext._tracestate
+  }
+
   /**
    * @param {DatadogSpanContext | undefined} w3cSpanContext
    * @param {DatadogSpanContext} firstSpanContext
@@ -699,10 +763,13 @@ class TextMapPropagator {
    */
   #resolveTraceContextConflicts (w3cSpanContext, firstSpanContext, carrier, datadogContext) {
     if (w3cSpanContext === undefined ||
-        firstSpanContext.toTraceId(true) !== w3cSpanContext.toTraceId(true) ||
-        firstSpanContext.toSpanId() === w3cSpanContext.toSpanId()) {
+        firstSpanContext.toTraceId(true) !== w3cSpanContext.toTraceId(true)) {
       return firstSpanContext
     }
+
+    this.#mergeTraceContextState(w3cSpanContext, firstSpanContext)
+    if (firstSpanContext.toSpanId() === w3cSpanContext.toSpanId()) return firstSpanContext
+
     if (tags.DD_PARENT_ID in w3cSpanContext._trace.tags) {
       // tracecontext headers contain a p value, ensure this value is sent to backend
       firstSpanContext._trace.tags[tags.DD_PARENT_ID] = w3cSpanContext._trace.tags[tags.DD_PARENT_ID]
@@ -740,7 +807,8 @@ class TextMapPropagator {
               traceContext = this.#extractTraceparentContext(carrier)
               traceContextExtracted = true
             }
-            this.#addTraceContextState(extractedContext, traceContext)
+            const selectedContext = context && context !== traceContext ? context : extractedContext
+            this.#addTraceContextState(selectedContext, traceContext)
           }
           break
         case 'tracecontext':
@@ -842,7 +910,25 @@ class TextMapPropagator {
     }
 
     const traceTags = this.#extractTags(carrier)
-    if (traceTags) spanContext._trace.tags = traceTags
+    if (traceTags) {
+      spanContext._trace.tags = traceTags
+      const decisionMaker = traceTags['_dd.p.dm']
+      if (decisionMaker !== undefined) {
+        // Avoid general integer parsing for the common single-digit mechanisms.
+        const digit = decisionMaker.length === 2 && decisionMaker[0] === '-'
+          ? decisionMaker.charCodeAt(1) - 48
+          : -1
+        if (digit >= 0 && digit <= 9) {
+          spanContext._sampling.mechanism = digit
+        } else {
+          // Preserve integer-prefix parsing; Number() also turns empty values into zero.
+          const mechanism = Math.abs(Number.parseInt(decisionMaker, 10))
+          if (Number.isInteger(mechanism) && mechanism >= 0) {
+            spanContext._sampling.mechanism = mechanism
+          }
+        }
+      }
+    }
 
     return spanContext
   }
@@ -879,7 +965,7 @@ class TextMapPropagator {
   #addTraceContextState (datadogContext, traceContext) {
     if (traceContext && datadogContext._traceId.equals(traceContext._traceId)) {
       datadogContext._traceparent = traceContext._traceparent
-      datadogContext._tracestate = traceContext._tracestate
+      this.#mergeTraceContextState(traceContext, datadogContext)
     }
   }
 
@@ -905,6 +991,11 @@ class TextMapPropagator {
       // Version 00 should have no tail, but future versions may
       if (tail && version === '00') return
 
+      if (tracestate.get('ot') !== undefined) {
+        otelSampling ??= require('../../otel-sampling')
+        otelSampling.normalizeOtelTraceState(tracestate)
+      }
+
       const spanContext = new DatadogSpanContext({
         traceId: id(traceId, 16),
         spanId: id(spanId, 16),

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

@@ -3,6 +3,7 @@
 // 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 MAX_VALUE_LENGTH = 256
 const WHITESPACE = /[ \t]/
 
 /**
@@ -12,10 +13,12 @@ const WHITESPACE = /[ \t]/
  * @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.
+ * @param {number} [maxEntries] Maximum number of entries to parse.
+ * @param {number} [maxValueLength] Maximum length of an entry value.
  * @returns {[string, string][]} Entries in reverse of wire order.
  */
-function parseEntries (value, fieldSeparator, pairSeparator, rejectValueTabs) {
-  const segments = value.split(fieldSeparator, MAX_LIST_MEMBERS)
+function parseEntries (value, fieldSeparator, pairSeparator, rejectValueTabs, maxEntries, maxValueLength) {
+  const segments = value.split(fieldSeparator, maxEntries)
 
   // TODO: We should extract dd no matter at what position and move it to the front of the list.
   // Extract up 31 additional entries.
@@ -29,7 +32,9 @@ function parseEntries (value, fieldSeparator, pairSeparator, rejectValueTabs) {
     // 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
+    if (!entryValue ||
+      maxValueLength !== undefined && entryValue.length > maxValueLength ||
+      rejectValueTabs && entryValue.includes('\t')) continue
     entries.push([key, entryValue])
   }
   // Reverse so the Map's insertion order is reverse of wire order. `toString`
@@ -38,11 +43,21 @@ function parseEntries (value, fieldSeparator, pairSeparator, rejectValueTabs) {
   return entries
 }
 
-function fromString (Type, value, fieldSeparator, pairSeparator, rejectValueTabs) {
+/**
+ * @param {typeof TraceState | typeof TraceStateData} Type
+ * @param {string | undefined} value
+ * @param {string} fieldSeparator
+ * @param {string} pairSeparator
+ * @param {boolean} rejectValueTabs
+ * @param {number} [maxEntries]
+ * @param {number} [maxValueLength]
+ * @returns {TraceState | TraceStateData}
+ */
+function fromString (Type, value, fieldSeparator, pairSeparator, rejectValueTabs, maxEntries, maxValueLength) {
   if (typeof value !== 'string' || !value.length) {
     return new Type()
   }
-  return new Type(parseEntries(value, fieldSeparator, pairSeparator, rejectValueTabs))
+  return new Type(parseEntries(value, fieldSeparator, pairSeparator, rejectValueTabs, maxEntries, maxValueLength))
 }
 
 function toString (map, pairSeparator, fieldSeparator) {
@@ -76,8 +91,9 @@ class TraceStateData {
   }
 
   delete (key) {
+    if (!this.#map.delete(key)) return false
     this.changed = true
-    return this.#map.delete(key)
+    return true
   }
 
   clear () {
@@ -97,6 +113,24 @@ class TraceStateData {
     return this.#map.size
   }
 
+  /**
+   * @template Context
+   * @param {number} valueLength
+   * @param {(key: string, context: Context) => boolean} isOptional
+   * @param {Context} context
+   */
+  trimOptionalFields (valueLength, isOptional, context) {
+    const fields = [...this.#map]
+    for (let index = fields.length - 1; index >= 0 && valueLength > MAX_VALUE_LENGTH; index--) {
+      const [key, value] = fields[index]
+      if (!isOptional(key, context)) continue
+
+      valueLength -= key.length + String(value).length + (this.#map.size > 1 ? 2 : 1)
+      this.delete(key)
+    }
+  }
+
+  /** @param {string | undefined} value */
   static fromString (value) {
     return fromString(TraceStateData, value, ';', ':', false)
   }
@@ -115,11 +149,22 @@ class TraceState {
 
   constructor (entries) {
     this.#map = entries ? new Map(entries) : new Map()
+    while (this.#map.size > MAX_LIST_MEMBERS) {
+      this.#map.delete(this.#map.keys().next().value)
+    }
   }
 
   // Delete entries on update to ensure they're moved to the end of the list
+  /**
+   * @param {string} key
+   * @param {string} value
+   */
   set (key, value) {
-    if (this.#map.has(key)) this.#map.delete(key)
+    if (value.length > MAX_VALUE_LENGTH) return this
+    const updated = this.#map.delete(key)
+    if (!updated && this.#map.size === MAX_LIST_MEMBERS) {
+      this.#map.delete(this.#map.keys().next().value)
+    }
     this.#map.set(key, value)
     return this
   }
@@ -140,25 +185,44 @@ class TraceState {
     return this.#map.size
   }
 
-  forVendor (vendor, handle) {
+  /** @returns {TraceState} A shallow copy with independent member storage. */
+  clone () {
+    return new TraceState(this.#map)
+  }
+
+  /**
+   * @template Context
+   * @param {string} vendor
+   * @param {(state: TraceStateData) => unknown} handle
+   * @param {(key: string, context: Context) => boolean} [isOptional]
+   * @param {Context} [context]
+   * @returns {unknown}
+   */
+  forVendor (vendor, handle, isOptional, context) {
     const data = this.#map.get(vendor)
     const state = TraceStateData.fromString(data)
     const result = handle(state)
 
-    if (state.changed) {
-      const value = state.toString()
-      if (value) {
-        this.set(vendor, value)
-      } else {
-        this.delete(vendor)
-      }
+    if (!state.changed) return result
+
+    let value = state.toString()
+    if (value.length > MAX_VALUE_LENGTH && isOptional) {
+      state.trimOptionalFields(value.length, isOptional, context)
+      value = state.toString()
+    }
+    if (value.length > MAX_VALUE_LENGTH) {
+      if (isOptional) this.delete(vendor)
+      return result
     }
+    if (value === data) return result
+    if (value) this.set(vendor, value)
+    else this.delete(vendor)
 
     return result
   }
 
   static fromString (value) {
-    return fromString(TraceState, value, ',', '=', true)
+    return fromString(TraceState, value, ',', '=', true, MAX_LIST_MEMBERS, MAX_VALUE_LENGTH)
   }
 
   toString () {

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

@@ -213,8 +213,8 @@ class DatadogSpan {
   setTag (key, value) {
     this._spanContext.setTag(key, value)
 
-    if (isSamplingPriorityTag(key) && this._spanContext._sampling.priority === undefined) {
-      this._prioritySampler.sample(this, false)
+    if (isSamplingPriorityTag(key)) {
+      this._prioritySampler.setPriorityFromTags(this, this._spanContext.getTags())
     }
 
     if (tagsUpdateCh.hasSubscribers) {
@@ -236,21 +236,26 @@ class DatadogSpan {
     if (keyValueMap !== null && typeof keyValueMap === 'object' && !Array.isArray(keyValueMap)) {
       Object.assign(tags, keyValueMap)
       mayChangeSamplingPriority =
-        MANUAL_KEEP in keyValueMap ||
-        MANUAL_DROP in keyValueMap ||
-        SAMPLING_PRIORITY in keyValueMap
+        keyValueMap[MANUAL_KEEP] !== undefined ||
+        keyValueMap[MANUAL_DROP] !== undefined ||
+        keyValueMap[SAMPLING_PRIORITY] !== undefined
     } else {
       /* istanbul ignore if: v5 fallback, master ships 6.0.0-pre */
       if (DD_MAJOR < 6 && (typeof keyValueMap === 'string' || Array.isArray(keyValueMap))) {
-        tagger.add(tags, keyValueMap)
-        mayChangeSamplingPriority = true
+        const samplingTags = {}
+        tagger.add(samplingTags, keyValueMap)
+        Object.assign(tags, samplingTags)
+        mayChangeSamplingPriority =
+          samplingTags[MANUAL_KEEP] !== undefined ||
+          samplingTags[MANUAL_DROP] !== undefined ||
+          samplingTags[SAMPLING_PRIORITY] !== undefined
       } else {
         return this
       }
     }
 
-    if (mayChangeSamplingPriority && this._spanContext._sampling.priority === undefined) {
-      this._prioritySampler.sample(this, false)
+    if (mayChangeSamplingPriority) {
+      this._prioritySampler.setPriorityFromTags(this, tags)
     }
 
     if (tagsUpdateCh.hasSubscribers) {

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

@@ -39,8 +39,9 @@ class DatadogTracer {
     // silently lose all test spans. The same applies to the Electron exporter:
     // spans must reach the Electron SDK's IPC bridge, not an OTLP endpoint,
     // even when OTEL_* vars are set for unrelated telemetry.
-    if (config.OTEL_TRACES_EXPORTER === 'otlp' && !config.isCiVisibility &&
-      config.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER !== 'electron') {
+    const exportOtlpTraces = config.OTEL_TRACES_EXPORTER === 'otlp' && !config.isCiVisibility &&
+      config.tracing.DD_TRACE_EXPERIMENTAL_EXPORTER !== 'electron'
+    if (exportOtlpTraces) {
       const { createOtlpTraceExporter } = require('../opentelemetry/trace')
       this._exporter = createOtlpTraceExporter(config)
     } else {
@@ -53,7 +54,13 @@ class DatadogTracer {
       const { createOtlpSpanStatsExporter } = require('../opentelemetry/metrics')
       otlpStatsExporter = createOtlpSpanStatsExporter(config)
     }
-    this._processor = new SpanProcessor(this._exporter, this._prioritySampler, config, otlpStatsExporter)
+    this._processor = new SpanProcessor(
+      this._exporter,
+      this._prioritySampler,
+      config,
+      otlpStatsExporter,
+      exportOtlpTraces
+    )
     this._url = this._exporter._url
     this._enableGetRumData = config.rum.DD_TRACE_EXPERIMENTAL_GET_RUM_DATA_ENABLED
     this._traceId128BitGenerationEnabled = config.traceId128BitGenerationEnabled