dd-trace 5.104.0 → 5.105.0

package/packages/dd-trace/src/openfeature/span-enrichment-hook.js

@@ -0,0 +1,143 @@
+'use strict'
+
+const { channel } = require('dc-polyfill')
+const log = require('../log')
+const { SpanEnrichmentState } = require('./span-enrichment')
+
+const finishCh = channel('dd-trace:span:finish')
+
+/**
+ * OpenFeature hook that enriches APM spans with feature flag evaluation data.
+ *
+ * Implements the OpenFeature `finally` hook interface to capture flag evaluations
+ * and add span tags for observability. Tags are accumulated during the span's
+ * lifetime and applied when the root span finishes.
+ *
+ * Span tags added:
+ * - `ffe_flags_enc`: Base64 delta-varint encoded serial IDs
+ * - `ffe_subjects_enc`: JSON dict of SHA256(targeting_key) → encoded serial IDs
+ * - `ffe_runtime_defaults`: JSON dict of flag_key → default value string
+ */
+class SpanEnrichmentHook {
+  #tracer
+  /** @type {WeakMap<object, SpanEnrichmentState>} */
+  #spanStates = new WeakMap()
+
+  /**
+   * Handler for span finish channel. Applies accumulated tags to the span.
+   * Arrow function to preserve `this` binding for channel subscription.
+   *
+   * @param {object} span - The span that is finishing
+   */
+  #onSpanFinish = (span) => {
+    const state = this.#spanStates.get(span)
+    if (!state || !state.hasData()) return
+
+    try {
+      const tags = state.toSpanTags()
+
+      for (const [key, value] of Object.entries(tags)) {
+        if (value) {
+          span.setTag(key, value)
+        }
+      }
+    } catch (err) {
+      log.warn('SpanEnrichmentHook: error applying span tags: %s', err.message)
+    } finally {
+      this.#spanStates.delete(span)
+    }
+  }
+
+  /**
+   * @param {import('../tracer')} tracer - Datadog tracer instance
+   */
+  constructor (tracer) {
+    this.#tracer = tracer
+    finishCh.subscribe(this.#onSpanFinish)
+  }
+
+  /**
+   * Called by the OpenFeature SDK after every flag evaluation (success or error).
+   *
+   * @param {object} hookContext - Hook context containing the flag key and evaluation context
+   * @param {string} hookContext.flagKey - The flag key being evaluated
+   * @param {object} [hookContext.context] - Evaluation context
+   * @param {string} [hookContext.context.targetingKey] - Targeting key
+   * @param {object} evaluationDetails - Full evaluation details including flag metadata
+   * @param {object} [evaluationDetails.flagMetadata] - Metadata from the provider
+   * @param {number} [evaluationDetails.flagMetadata.__dd_split_serial_id] - Serial ID from UFC split
+   * @param {boolean} [evaluationDetails.flagMetadata.__dd_do_log] - Whether to log subject
+   * @param {string} [evaluationDetails.variant] - Variant key if flag was found in UFC
+   * @param {boolean|string|number|object} [evaluationDetails.value] - Evaluated value
+   * @returns {void}
+   */
+  finally (hookContext, evaluationDetails) {
+    try {
+      const rootSpan = this._getRootSpan()
+      if (!rootSpan) return
+
+      const state = this._getOrCreateState(rootSpan)
+      const { flagKey, context } = hookContext || {}
+      const { flagMetadata, variant, value } = evaluationDetails || {}
+
+      const serialId = flagMetadata?.__dd_split_serial_id
+      const doLog = flagMetadata?.__dd_do_log ?? false
+      const targetingKey = context?.targetingKey
+
+      if (serialId != null) {
+        state.addSerialId(serialId)
+
+        if (doLog && targetingKey) {
+          state.addSubject(targetingKey, serialId)
+        }
+      } else if (variant === undefined) {
+        state.addDefault(flagKey, value)
+      }
+    } catch (err) {
+      log.warn('SpanEnrichmentHook: error in finally hook: %s', err.message)
+    }
+  }
+
+  /**
+   * Get the root span for the current trace context.
+   * The root span is always the first span in trace.started since spans
+   * are added in creation order and the root is created first.
+   *
+   * @returns {object|null} The root span, or null if no active span
+   * @private
+   */
+  _getRootSpan () {
+    const span = this.#tracer.scope().active()
+    if (!span) return null
+
+    const trace = span.context()._trace
+
+    return trace?.started?.[0] ?? span
+  }
+
+  /**
+   * Get or create enrichment state for a span.
+   *
+   * @param {object} span - The span to get state for
+   * @returns {SpanEnrichmentState} The enrichment state
+   * @private
+   */
+  _getOrCreateState (span) {
+    let state = this.#spanStates.get(span)
+    if (!state) {
+      state = new SpanEnrichmentState()
+      this.#spanStates.set(span, state)
+    }
+    return state
+  }
+
+  /**
+   * Cleanup method to unsubscribe from channels.
+   * Should be called when the provider is shut down.
+   */
+  destroy () {
+    finishCh.unsubscribe(this.#onSpanFinish)
+  }
+}
+
+module.exports = SpanEnrichmentHook

package/packages/dd-trace/src/openfeature/span-enrichment.js

@@ -0,0 +1,149 @@
+'use strict'
+
+const log = require('../log')
+
+const { encodeDeltaVarint, hashTargetingKey } = require('./encoding')
+
+const MAX_SERIAL_IDS = 200
+const MAX_SUBJECTS = 10
+const MAX_EXPERIMENTS_PER_SUBJECT = 20
+const MAX_DEFAULTS = 5
+const MAX_DEFAULT_VALUE_LENGTH = 64
+
+/**
+ * Manages feature flag enrichment state for a single root span.
+ * Accumulates serial IDs, subjects, and defaults throughout the span's lifetime.
+ */
+class SpanEnrichmentState {
+  constructor () {
+    /** @type {Set<number>} */
+    this._serialIds = new Set()
+
+    /** @type {Map<string, Set<number>>} hashed targeting key -> serial IDs */
+    this._subjects = new Map()
+
+    /** @type {Map<string, string>} flag key -> runtime default value */
+    this._defaults = new Map()
+  }
+
+  /**
+   * Add a serial ID from a flag evaluation.
+   *
+   * @param {number} serialId - The serial ID to add
+   * @returns {boolean} True if added, false if limit reached
+   */
+  addSerialId (serialId) {
+    if (this._serialIds.size >= MAX_SERIAL_IDS) {
+      log.debug('SpanEnrichment: MAX_SERIAL_IDS limit (%d) reached, dropping serialId %d', MAX_SERIAL_IDS, serialId)
+      return false
+    }
+    this._serialIds.add(serialId)
+    return true
+  }
+
+  /**
+   * Add a subject (targeting key) with its associated serial ID.
+   * Only called when doLog=true.
+   *
+   * @param {string} targetingKey - The targeting key (will be hashed)
+   * @param {number} serialId - The serial ID associated with this evaluation
+   * @returns {boolean} True if added, false if limit reached
+   */
+  addSubject (targetingKey, serialId) {
+    const hashedKey = hashTargetingKey(targetingKey)
+
+    if (this._subjects.has(hashedKey)) {
+      const subjectIds = this._subjects.get(hashedKey)
+      if (subjectIds.size >= MAX_EXPERIMENTS_PER_SUBJECT) {
+        log.debug('SpanEnrichment: MAX_EXPERIMENTS_PER_SUBJECT limit (%d) reached for subject',
+          MAX_EXPERIMENTS_PER_SUBJECT)
+        return false
+      }
+      subjectIds.add(serialId)
+      return true
+    }
+
+    if (this._subjects.size >= MAX_SUBJECTS) {
+      log.debug('SpanEnrichment: MAX_SUBJECTS limit (%d) reached, dropping subject', MAX_SUBJECTS)
+      return false
+    }
+
+    this._subjects.set(hashedKey, new Set([serialId]))
+    return true
+  }
+
+  /**
+   * Add a default fallback for a flag not found in UFC.
+   *
+   * @param {string} flagKey - The flag key
+   * @param {boolean|string|number|object} defaultValue - The default value used
+   * @returns {boolean} True if added, false if limit reached
+   */
+  addDefault (flagKey, defaultValue) {
+    if (this._defaults.has(flagKey)) {
+      return true
+    }
+
+    if (this._defaults.size >= MAX_DEFAULTS) {
+      log.debug('SpanEnrichment: MAX_DEFAULTS limit (%d) reached, dropping flag %s', MAX_DEFAULTS, flagKey)
+      return false
+    }
+
+    let valueStr = typeof defaultValue === 'object' && defaultValue !== null
+      ? JSON.stringify(defaultValue)
+      : String(defaultValue)
+
+    if (valueStr.length > MAX_DEFAULT_VALUE_LENGTH) {
+      valueStr = valueStr.slice(0, MAX_DEFAULT_VALUE_LENGTH)
+    }
+
+    this._defaults.set(flagKey, valueStr)
+    return true
+  }
+
+  /**
+   * Check if there is any enrichment data to add to the span.
+   * Note: _subjects is not checked because addSubject() is never called without first
+   * calling addSerialId(), so _subjects having data necessitates _serialIds having data.
+   *
+   * @returns {boolean} True if there is data to add
+   */
+  hasData () {
+    return this._serialIds.size > 0 || this._defaults.size > 0
+  }
+
+  /**
+   * Convert accumulated state to span tags.
+   *
+   * @returns {object} Object with ffe_flags_enc, ffe_subjects_enc, and ffe_runtime_defaults tags
+   */
+  toSpanTags () {
+    const tags = {}
+
+    if (this._serialIds.size > 0) {
+      tags.ffe_flags_enc = encodeDeltaVarint(this._serialIds)
+    }
+
+    if (this._subjects.size > 0) {
+      const subjectsObj = Object.fromEntries(
+        [...this._subjects].map(([key, ids]) => [key, encodeDeltaVarint(ids)])
+      )
+      tags.ffe_subjects_enc = JSON.stringify(subjectsObj)
+    }
+
+    if (this._defaults.size > 0) {
+      tags.ffe_runtime_defaults = JSON.stringify(Object.fromEntries(this._defaults))
+    }
+
+    return tags
+  }
+}
+
+module.exports = {
+  SpanEnrichmentState,
+  MAX_SERIAL_IDS,
+  MAX_SUBJECTS,
+  MAX_EXPERIMENTS_PER_SUBJECT,
+  MAX_DEFAULTS,
+  MAX_DEFAULT_VALUE_LENGTH,
+}

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

@@ -7,6 +7,7 @@ const { timeInputToHrTime } = require('../../../../vendor/dist/@opentelemetry/co
 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 { DD_MAJOR } = require('../../../../version')
 
 const id = require('../id')
 
@@ -176,8 +177,8 @@ function setOtelAttributes (ddSpan, attributes) {
 function addOtelLink (ddSpan, link, attrs) {
   if (!isWritable(ddSpan) || !link) return
 
-  // TODO: Drop the (context, attrs) form in v6.0.0.
-  const { context, attributes } = isOtelLink(link)
+  // v5 still accepts the legacy `addLink(context, attrs)` shape; v6 only takes `addLink(otel.Link)`.
+  const { context, attributes } = isOtelLink(link) || DD_MAJOR >= 6
     ? link
     : { context: link, attributes: attrs ?? {} }
 
@@ -230,7 +231,7 @@ function recordException (ddSpan, exception, timeInput) {
     [ERROR_TYPE]: exception.name,
     [ERROR_MESSAGE]: exception.message,
     [ERROR_STACK]: exception.stack,
-    [IGNORE_OTEL_ERROR]: ddSpan.context()._tags[IGNORE_OTEL_ERROR] ?? true,
+    [IGNORE_OTEL_ERROR]: ddSpan.context().getTag(IGNORE_OTEL_ERROR) ?? true,
   })
 
   const attributes = {}

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

@@ -216,7 +216,7 @@ class Span extends BridgeSpanBase {
       'ptr.hash': ptrHash,
       'link.kind': 'span-pointer',
     }
-    return this.addLink(zeroContext, attributes)
+    return this.addLink({ context: zeroContext, attributes })
   }
 
   /**

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

@@ -11,20 +11,31 @@ class LogPropagator {
   inject (spanContext, carrier) {
     if (!carrier) return
 
-    carrier.dd = {}
+    const dd = {}
+    let hasField = false
 
     if (spanContext) {
-      carrier.dd.trace_id = this._config.traceId128BitGenerationEnabled &&
+      dd.trace_id = this._config.traceId128BitGenerationEnabled &&
         this._config.traceId128BitLoggingEnabled && spanContext._trace.tags['_dd.p.tid']
         ? spanContext.toTraceId(true)
         : spanContext.toTraceId()
-
-      carrier.dd.span_id = spanContext.toSpanId()
+      dd.span_id = spanContext.toSpanId()
+      hasField = true
+    }
+    if (this._config.service) {
+      dd.service = this._config.service
+      hasField = true
+    }
+    if (this._config.version) {
+      dd.version = this._config.version
+      hasField = true
+    }
+    if (this._config.env) {
+      dd.env = this._config.env
+      hasField = true
     }
 
-    if (this._config.service) carrier.dd.service = this._config.service
-    if (this._config.version) carrier.dd.version = this._config.version
-    if (this._config.env) carrier.dd.env = this._config.env
+    if (hasField) carrier.dd = dd
   }
 
   extract (carrier) {

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

@@ -35,7 +35,6 @@ const b3FlagsKey = 'x-b3-flags'
 const b3HeaderKey = 'b3'
 const sqsdHeaderHey = 'x-aws-sqsd-attr-_datadog'
 const b3HeaderExpr = /^(([0-9a-f]{16}){1,2}-[0-9a-f]{16}(-[01d](-[0-9a-f]{16})?)?|[01d])$/i
-const baggageExpr = new RegExp(`^${baggagePrefix}(.+)$`)
 // W3C Baggage key grammar: key = token (RFC 7230).
 // Spec (up-to-date): "Propagation format for distributed context: Baggage" §3.3.1
 // https://www.w3.org/TR/baggage/#header-content
@@ -56,6 +55,15 @@ const ddKeys = [traceKey, spanKey, samplingKey, originKey]
 const b3Keys = [b3TraceKey, b3SpanKey, b3ParentKey, b3SampledKey, b3FlagsKey, b3HeaderKey]
 const w3cKeys = [traceparentKey, tracestateKey]
 const logKeys = [...ddKeys, ...b3Keys, ...w3cKeys]
+// Dispatch table for `_extractSpanContext`. `'b3'` resolves to the matching
+// single/multi extractor per instance — see `#b3MethodName` — so it is not in
+// this table. `'baggage'` is consumed by `_extractBaggageItems`, not the loop.
+const EXTRACT_STYLE_METHODS = new Map([
+  ['datadog', '_extractDatadogContext'],
+  ['tracecontext', '_extractTraceparentContext'],
+  ['b3 single header', '_extractB3SingleContext'],
+  ['b3multi', '_extractB3MultiContext'],
+])
 // Origin value in tracestate replaces '~', ',' and ';' with '_"
 const tracestateOriginFilter = /[^\x20-\x2B\x2D-\x3A\x3C-\x7D]/g
 // Tag keys in tracestate replace ' ', ',' and '=' with '_'
@@ -68,27 +76,29 @@ const hex16 = /^[0-9A-Fa-f]{16}$/
 const percentByte = /%([0-9A-Fa-f]{2})/g
 
 class TextMapPropagator {
-  #extractB3Context
-
   /** @type {Set<string> | undefined} Cached `Set` view of `_config.baggageTagKeys`. */
   #baggageTagKeysSet
 
   /** @type {string[] | undefined} Source array that `#baggageTagKeysSet` was built from. */
   #baggageTagKeysSetSource
 
+  /** @type {'_extractB3SingleContext' | '_extractB3MultiContext'} */
+  #b3MethodName
+
   constructor (config) {
     this._config = config
 
-    // v6: `'b3'` is always single-header. v5: env-name decides — OTEL_PROPAGATORS callers expect
-    // single, the legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
+    // v6: `'b3'` is always single-header. v5: `OTEL_PROPAGATORS` callers
+    // expect single, legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
+    /* istanbul ignore else: v5 fallback, master ships 6.0.0-pre */
     if (DD_MAJOR >= 6) {
-      this.#extractB3Context = this._extractB3SingleContext
+      this.#b3MethodName = '_extractB3SingleContext'
     } else {
       const envName = getConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
       // eslint-disable-next-line eslint-rules/eslint-env-aliases
-      this.#extractB3Context = envName === 'OTEL_PROPAGATORS'
-        ? this._extractB3SingleContext
-        : this._extractB3MultiContext
+      this.#b3MethodName = envName === 'OTEL_PROPAGATORS'
+        ? '_extractB3SingleContext'
+        : '_extractB3MultiContext'
     }
   }
 
@@ -129,8 +139,7 @@ class TextMapPropagator {
 
   extract (carrier) {
     const spanContext = this._extractSpanContext(carrier)
-
-    if (!spanContext) return spanContext
+    if (spanContext === undefined) return null
 
     if (extractCh.hasSubscribers) {
       extractCh.publish({ spanContext, carrier })
@@ -292,7 +301,7 @@ class TextMapPropagator {
     // v6 keeps `'b3 single header'` as a back-compat alias for callers that bypass parser normalisation.
     const hasB3SingleHeader = this._hasPropagationStyle('inject', 'b3 single header') ||
       (DD_MAJOR >= 6 && this._hasPropagationStyle('inject', 'b3'))
-    if (!hasB3SingleHeader) return null
+    if (!hasB3SingleHeader) return
 
     const traceId = this._getB3TraceId(spanContext)
     const spanId = spanContext._spanId.toString(16)
@@ -361,7 +370,7 @@ class TextMapPropagator {
   }
 
   _hasTraceIdConflict (w3cSpanContext, firstSpanContext) {
-    return w3cSpanContext !== null &&
+    return w3cSpanContext !== undefined &&
            firstSpanContext.toTraceId(true) === w3cSpanContext.toTraceId(true) &&
            firstSpanContext.toSpanId() !== w3cSpanContext.toSpanId()
   }
@@ -372,7 +381,7 @@ class TextMapPropagator {
 
   _updateParentIdFromDdHeaders (carrier, firstSpanContext) {
     const ddCtx = this._extractDatadogContext(carrier)
-    if (ddCtx !== null) {
+    if (ddCtx !== undefined) {
       firstSpanContext._trace.tags[tags.DD_PARENT_ID] = ddCtx._spanId.toString().padStart(16, '0')
     }
   }
@@ -394,35 +403,20 @@ class TextMapPropagator {
   }
 
   _extractSpanContext (carrier) {
-    let context = null
+    let context
     let style = ''
     for (const extractor of this._config.tracePropagationStyle.extract) {
-      let extractedContext = null
-      switch (extractor) {
-        case 'datadog':
-          extractedContext = this._extractDatadogContext(carrier)
-          break
-        case 'tracecontext':
-          extractedContext = this._extractTraceparentContext(carrier)
-          break
-        case 'b3 single header':
-          extractedContext = this._extractB3SingleContext(carrier)
-          break
-        case 'b3':
-          extractedContext = this.#extractB3Context(carrier)
-          break
-        case 'b3multi':
-          extractedContext = this._extractB3MultiContext(carrier)
-          break
-        default:
-          if (extractor !== 'baggage') log.warn('Unknown propagation style:', extractor)
+      const method = extractor === 'b3' ? this.#b3MethodName : EXTRACT_STYLE_METHODS.get(extractor)
+      if (method === undefined) {
+        if (extractor !== 'baggage') log.warn('Unknown propagation style:', extractor)
+        continue
       }
-
-      if (extractedContext === null) { // If the current extractor was invalid, continue to the next extractor
+      const extractedContext = this[method](carrier)
+      if (extractedContext === undefined) {
         continue
       }
 
-      if (context === null) {
+      if (context === undefined) {
         context = extractedContext
         style = extractor
         if (this._config.DD_TRACE_PROPAGATION_EXTRACT_FIRST) {
@@ -446,9 +440,7 @@ class TextMapPropagator {
     }
 
     if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'ignore') {
-      // `context` is null when no extractor matched; the fallback below picks up
-      // the SQSD context if present, otherwise the request runs untraced.
-      if (context) context._links = []
+      if (context !== undefined) context._links = []
     } else {
       if (this._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT === 'restart' && context) {
         context._links = []
@@ -490,14 +482,17 @@ class TextMapPropagator {
 
   _extractB3MultiContext (carrier) {
     const b3 = this._extractB3MultipleHeaders(carrier)
-    if (!b3) return null
+    if (b3 === undefined) return
     return this._extractB3Context(b3)
   }
 
   _extractB3SingleContext (carrier) {
-    if (!b3HeaderExpr.test(carrier[b3HeaderKey])) return null
+    // `typeof === 'string'` first; otherwise the regex coerces `undefined` to
+    // `'undefined'` and runs on every header-less request.
+    const header = carrier[b3HeaderKey]
+    if (typeof header !== 'string' || !b3HeaderExpr.test(header)) return
     const b3 = this._extractB3SingleHeader(carrier)
-    if (!b3) return null
+    if (b3 === undefined) return
     return this._extractB3Context(b3)
   }
 
@@ -527,23 +522,19 @@ class TextMapPropagator {
 
   _extractSqsdContext (carrier) {
     const headerValue = carrier[sqsdHeaderHey]
-    if (!headerValue) {
-      return null
-    }
+    if (!headerValue) return
     let parsed
     try {
       parsed = JSON.parse(headerValue)
     } catch {
-      return null
+      return
     }
     return this._extractDatadogContext(parsed)
   }
 
   _extractTraceparentContext (carrier) {
     const headerValue = carrier[traceparentKey]
-    if (typeof headerValue !== 'string') {
-      return null
-    }
+    if (typeof headerValue !== 'string') return
     const matches = headerValue.trim().match(traceparentExpr)
     if (matches !== null) {
       const [, version, traceId, spanId, flags, tail] = matches
@@ -554,14 +545,14 @@ class TextMapPropagator {
         ? carrier.tracestate.filter(item => typeof item === 'string').join(',')
         : carrier.tracestate
       const tracestate = TraceState.fromString(rawTracestate)
-      if (invalidSegment.test(traceId)) return null
-      if (invalidSegment.test(spanId)) return null
+      if (invalidSegment.test(traceId)) return
+      if (invalidSegment.test(spanId)) return
 
       // Version ff is considered invalid
-      if (version === 'ff') return null
+      if (version === 'ff') return
 
       // Version 00 should have no tail, but future versions may
-      if (tail && version === '00') return null
+      if (tail && version === '00') return
 
       const spanContext = new DatadogSpanContext({
         traceId: id(traceId, 16),
@@ -624,12 +615,11 @@ class TextMapPropagator {
       this._extractLegacyBaggageItems(carrier, spanContext)
       return spanContext
     }
-    return null
   }
 
   _extractGenericContext (carrier, traceKey, spanKey, radix) {
     if (carrier && carrier[traceKey] && carrier[spanKey]) {
-      if (invalidSegment.test(carrier[traceKey])) return null
+      if (invalidSegment.test(carrier[traceKey])) return
 
       return new DatadogSpanContext({
         traceId: id(carrier[traceKey], radix),
@@ -637,11 +627,17 @@ class TextMapPropagator {
         isRemote: true,
       })
     }
-
-    return null
   }
 
   _extractB3MultipleHeaders (carrier) {
+    // `b3ParentKey` is intentionally absent: this method never consults it,
+    // so a parent-id-only carrier should bail with the rest.
+    if (carrier[b3TraceKey] === undefined &&
+      carrier[b3SampledKey] === undefined &&
+      carrier[b3FlagsKey] === undefined) {
+      return
+    }
+
     let empty = true
     const b3 = {}
 
@@ -661,12 +657,12 @@ class TextMapPropagator {
       empty = false
     }
 
-    return empty ? null : b3
+    return empty ? undefined : b3
   }
 
   _extractB3SingleHeader (carrier) {
     const header = carrier[b3HeaderKey]
-    if (!header) return null
+    if (!header) return
 
     const parts = header.split('-')
 
@@ -705,13 +701,12 @@ class TextMapPropagator {
   }
 
   _extractLegacyBaggageItems (carrier, spanContext) {
-    if (this._config.legacyBaggageEnabled) {
-      for (const key of Object.keys(carrier)) {
-        const match = key.match(baggageExpr)
-
-        if (match) {
-          spanContext._baggageItems[match[1]] = carrier[key]
-        }
+    if (!this._config.legacyBaggageEnabled) return
+    for (const key of Object.keys(carrier)) {
+      if (!key.startsWith(baggagePrefix)) continue
+      const baggageKey = key.slice(baggagePrefix.length)
+      if (baggageKey) {
+        spanContext._baggageItems[baggageKey] = carrier[key]
       }
     }
   }