dd-trace 5.102.0 → 5.104.0

package/packages/dd-trace/src/lambda/index.js

@@ -1,17 +1,65 @@
 'use strict'
 
-const { getValueFromEnvSources } = require('../config/helper')
-const { registerLambdaHook } = require('./runtime/ritm')
-
-/**
- * It is safe to do it this way, since customers will never be expected to disable
- * this specific instrumentation through the init config object.
- */
-const _DD_TRACE_DISABLED_INSTRUMENTATIONS = getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS') || ''
-const _disabledInstrumentations = new Set(
-  _DD_TRACE_DISABLED_INSTRUMENTATIONS ? _DD_TRACE_DISABLED_INSTRUMENTATIONS.split(',') : []
-)
-
-if (!_disabledInstrumentations.has('lambda')) {
-  registerLambdaHook()
+const path = require('path')
+
+const log = require('../log')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('../config/helper')
+const Hook = require('../../../datadog-instrumentations/src/helpers/hook')
+const instrumentations = require('../../../datadog-instrumentations/src/helpers/instrumentations')
+const {
+  filename,
+  pathSepExpr,
+} = require('../../../datadog-instrumentations/src/helpers/register')
+const {
+  extractModuleNameAndHandlerPath,
+  extractModuleRootAndHandler,
+  getLambdaFilePaths,
+} = require('./handler-paths')
+
+if (!getValueFromEnvSources('DD_TRACE_DISABLED_INSTRUMENTATIONS')?.split(',').includes('lambda')) {
+  const lambdaTaskRoot = getEnvironmentVariable('LAMBDA_TASK_ROOT')
+  const originalLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER')
+
+  if (originalLambdaHandler !== undefined && lambdaTaskRoot !== undefined) {
+    const [moduleRoot, moduleAndHandler] = extractModuleRootAndHandler(originalLambdaHandler)
+    const [moduleName] = extractModuleNameAndHandlerPath(moduleAndHandler)
+
+    const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, moduleName)
+    const lambdaFilePaths = getLambdaFilePaths(lambdaStylePath)
+
+    // TODO: Redo this like any other instrumentation.
+    Hook(lambdaFilePaths, (moduleExports, name, _, moduleVersion) => {
+      require('./runtime/patch')
+
+      for (const { hook } of instrumentations[name]) {
+        try {
+          moduleExports = hook(moduleExports, moduleVersion) ?? moduleExports
+        } catch (error) {
+          log.error('Error executing lambda hook', error)
+        }
+      }
+
+      return moduleExports
+    })
+    return
+  }
+
+  const moduleToPatch = 'datadog-lambda-js'
+  Hook([moduleToPatch], (moduleExports, moduleName, _, moduleVersion) => {
+    moduleName = moduleName.replace(pathSepExpr, '/')
+    require('./runtime/patch')
+
+    for (const { file, hook } of instrumentations[moduleToPatch]) {
+      const fullFilename = filename(moduleToPatch, file)
+      if (moduleName === fullFilename) {
+        try {
+          moduleExports = hook(moduleExports, moduleVersion) ?? moduleExports
+        } catch (error) {
+          log.error('Error executing lambda hook for datadog-lambda-js', error)
+        }
+      }
+    }
+
+    return moduleExports
+  })
 }

package/packages/dd-trace/src/lambda/runtime/patch.js

@@ -6,54 +6,32 @@ const { datadog } = require('../handler')
 const { addHook } = require('../../../../datadog-instrumentations/src/helpers/instrument')
 const shimmer = require('../../../../datadog-shimmer')
 const { getEnvironmentVariable, getValueFromEnvSources } = require('../../config/helper')
-const { _extractModuleNameAndHandlerPath, _extractModuleRootAndHandler, _getLambdaFilePaths } = require('./ritm')
-
-/**
- * Patches a Datadog Lambda module by calling `patchDatadogLambdaHandler`
- * with the handler name `datadog`.
- *
- * @param {object} datadogLambdaModule node module to be patched.
- * @returns a Datadog Lambda module with the `datadog` function from
- * `datadog-lambda-js` patched.
- */
-const patchDatadogLambdaModule = (datadogLambdaModule) => {
+const {
+  extractModuleNameAndHandlerPath,
+  extractModuleRootAndHandler,
+  getLambdaFilePaths,
+} = require('../handler-paths')
+
+/** @param {object} datadogLambdaModule */
+function patchDatadogLambdaModule (datadogLambdaModule) {
   shimmer.wrap(datadogLambdaModule, 'datadog', patchDatadogLambdaHandler)
-
   return datadogLambdaModule
 }
 
-/**
- * Patches a Datadog Lambda handler in order to do
- * Datadog instrumentation by getting the Lambda handler from its
- * arguments.
- *
- * @param {Function} datadogHandler the Datadog Lambda handler to destructure.
- * @returns the datadogHandler with its arguments patched.
- */
+/** @param {Function} datadogHandler */
 function patchDatadogLambdaHandler (datadogHandler) {
-  return (userHandler) => {
-    return datadogHandler(datadog(userHandler))
-  }
+  return userHandler => datadogHandler(datadog(userHandler))
 }
 
-/**
- * Patches a Lambda module on the given handler path.
- *
- * @param {string} handlerPath path of the handler to be patched.
- * @returns a module with the given handler path patched.
- */
-const patchLambdaModule = (handlerPath) => (lambdaModule) => {
-  shimmer.wrap(lambdaModule, handlerPath, patchLambdaHandler)
-
-  return lambdaModule
+/** @param {string} handlerPath */
+function patchLambdaModule (handlerPath) {
+  return lambdaModule => {
+    shimmer.wrap(lambdaModule, handlerPath, patchLambdaHandler)
+    return lambdaModule
+  }
 }
 
-/**
- * Patches a Lambda handler in order to do Datadog instrumentation.
- *
- * @param {Function} lambdaHandler the Lambda handler to be patched.
- * @returns a function which patches the given Lambda handler.
- */
+/** @param {Function} lambdaHandler */
 function patchLambdaHandler (lambdaHandler) {
   return datadog(lambdaHandler)
 }
@@ -62,16 +40,13 @@ const lambdaTaskRoot = getEnvironmentVariable('LAMBDA_TASK_ROOT')
 const originalLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER')
 
 if (originalLambdaHandler === undefined) {
-  // Instrumentation is done manually.
   addHook({ name: 'datadog-lambda-js' }, patchDatadogLambdaModule)
 } else {
-  const [moduleRoot, moduleAndHandler] = _extractModuleRootAndHandler(originalLambdaHandler)
-  const [_module, handlerPath] = _extractModuleNameAndHandlerPath(moduleAndHandler)
-
-  const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, _module)
-  const lambdaFilePaths = _getLambdaFilePaths(lambdaStylePath)
+  const [moduleRoot, moduleAndHandler] = extractModuleRootAndHandler(originalLambdaHandler)
+  const [moduleName, handlerPath] = extractModuleNameAndHandlerPath(moduleAndHandler)
 
-  for (const lambdaFilePath of lambdaFilePaths) {
+  const lambdaStylePath = path.resolve(lambdaTaskRoot, moduleRoot, moduleName)
+  for (const lambdaFilePath of getLambdaFilePaths(lambdaStylePath)) {
     addHook({ name: lambdaFilePath }, patchLambdaModule(handlerPath))
   }
 }

package/packages/dd-trace/src/llmobs/index.js

@@ -108,6 +108,10 @@ function disable () {
 // since LLMObs traces can extend between services and be the same trace,
 // we need to propagate the parent id and mlApp.
 function handleLLMObsParentIdInjection ({ carrier }) {
+  // Respect the standard propagator's gate: when trace tag propagation is
+  // disabled, don't write `x-datadog-tags` for LLMObs either.
+  if (globalTracerConfig.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) return
+
   const parent = storage.getStore()?.span
   const mlObsSpanTags = LLMObsTagger.tagMap.get(parent)
 
@@ -118,8 +122,15 @@ function handleLLMObsParentIdInjection ({ carrier }) {
     parentContext?._trace?.tags?.[PROPAGATED_ML_APP_KEY] ||
     globalTracerConfig.llmobs.mlApp
 
-  if (parentId) carrier['x-datadog-tags'] += `,${PROPAGATED_PARENT_ID_KEY}=${parentId}`
-  if (mlApp) carrier['x-datadog-tags'] += `,${PROPAGATED_ML_APP_KEY}=${mlApp}`
+  if (!parentId && !mlApp) return
+
+  // `_injectTags` only writes `x-datadog-tags` when the trace has `_dd.p.*`
+  // tags, so it may be undefined here — coalesce before appending.
+  const existing = carrier['x-datadog-tags']
+  let tags = existing || ''
+  if (parentId) tags += `${tags ? ',' : ''}${PROPAGATED_PARENT_ID_KEY}=${parentId}`
+  if (mlApp) tags += `${tags ? ',' : ''}${PROPAGATED_ML_APP_KEY}=${mlApp}`
+  if (tags !== existing) carrier['x-datadog-tags'] = tags
 }
 
 function handleFlush () {

package/packages/dd-trace/src/llmobs/plugins/bedrockruntime.js

@@ -14,7 +14,17 @@ const llmobsStore = storage('llmobs')
 
 const ENABLED_OPERATIONS = new Set(['invokeModel', 'invokeModelWithResponseStream'])
 
-const requestIdsToTokens = {}
+/**
+ * @typedef {{
+ *   inputTokensFromHeaders?: number,
+ *   outputTokensFromHeaders?: number,
+ *   cacheReadTokensFromHeaders?: number,
+ *   cacheWriteTokensFromHeaders?: number,
+ * }} HeaderTokens
+ */
+
+/** @type {Map<string, HeaderTokens>} */
+const pendingTokenHeaders = new Map()
 
 class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   constructor () {
@@ -24,33 +34,39 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       const { response } = ctx
       const request = response.request
       const operation = request.operation
+
+      // Release the cached headers even for operations the plugin does not tag,
+      // so non-LLM Bedrock calls do not leak entries into pendingTokenHeaders.
+      const tokensFromHeaders = consumeTokenHeaders(response.$metadata?.requestId)
+
       // avoids instrumenting other non supported runtime operations
-      if (!ENABLED_OPERATIONS.has(operation)) {
-        return
-      }
+      if (!ENABLED_OPERATIONS.has(operation)) return
+
       const { modelProvider, modelName } = parseModelId(request.params.modelId)
 
       // avoids instrumenting non llm type
-      if (modelName.includes('embed')) {
-        return
-      }
+      if (modelName.includes('embed')) return
+
       const span = ctx.currentStore?.span
-      this.setLLMObsTags({ ctx, request, span, response, modelProvider, modelName })
+      this.setLLMObsTags({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders })
     })
 
     this.addSub('apm:aws:response:deserialize:bedrockruntime', ({ headers }) => {
       const requestId = headers['x-amzn-requestid']
+      // No request id means no way to correlate with the :complete: event.
+      if (!requestId) return
+
       const inputTokenCount = headers['x-amzn-bedrock-input-token-count']
       const outputTokenCount = headers['x-amzn-bedrock-output-token-count']
       const cacheReadTokenCount = headers['x-amzn-bedrock-cache-read-input-token-count']
       const cacheWriteTokenCount = headers['x-amzn-bedrock-cache-write-input-token-count']
 
-      requestIdsToTokens[requestId] = {
+      pendingTokenHeaders.set(requestId, {
         inputTokensFromHeaders: inputTokenCount && Number.parseInt(inputTokenCount),
         outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount),
         cacheReadTokensFromHeaders: cacheReadTokenCount && Number.parseInt(cacheReadTokenCount),
         cacheWriteTokensFromHeaders: cacheWriteTokenCount && Number.parseInt(cacheWriteTokenCount),
-      }
+      })
     })
 
     this.addSub('apm:aws:response:streamed-chunk:bedrockruntime', ({ ctx, chunk }) => {
@@ -60,7 +76,7 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
     })
   }
 
-  setLLMObsTags ({ ctx, request, span, response, modelProvider, modelName }) {
+  setLLMObsTags ({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders }) {
     const isStream = request?.operation?.toLowerCase().includes('stream')
     telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: 'bedrock' })
 
@@ -97,7 +113,7 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
 
     // add token metrics
     const { inputTokens, outputTokens, totalTokens, cacheReadTokens, cacheWriteTokens } = extractTokens({
-      requestId: response.$metadata.requestId,
+      tokensFromHeaders,
       usage: textAndResponseReason.usage,
     })
     this._tagger.tagMetrics(span, {
@@ -110,14 +126,28 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   }
 }
 
-function extractTokens ({ requestId, usage }) {
+/**
+ * @param {string | undefined} requestId
+ * @returns {HeaderTokens | undefined}
+ */
+function consumeTokenHeaders (requestId) {
+  const tokens = pendingTokenHeaders.get(requestId)
+  pendingTokenHeaders.delete(requestId)
+  return tokens
+}
+
+/**
+ * Combine response-body usage with header-derived counts, preferring the body.
+ *
+ * @param {{ tokensFromHeaders: HeaderTokens | undefined, usage: Record<string, number | undefined> }} options
+ */
+function extractTokens ({ tokensFromHeaders, usage }) {
   const {
     inputTokensFromHeaders,
     outputTokensFromHeaders,
     cacheReadTokensFromHeaders,
     cacheWriteTokensFromHeaders,
-  } = requestIdsToTokens[requestId] || {}
-  delete requestIdsToTokens[requestId]
+  } = tokensFromHeaders ?? {}
 
   const inputTokens = usage.inputTokens || inputTokensFromHeaders || 0
   const outputTokens = usage.outputTokens || outputTokensFromHeaders || 0

package/packages/dd-trace/src/llmobs/sdk.js

@@ -55,6 +55,11 @@ class LLMObs extends NoopLLMObs {
   }
 
   enable (options = {}) {
+    logger.warn(
+      'Enabling LLM Observability via `llmobs.enable()` is deprecated and will be removed in dd-trace@7.0.0. ' +
+      'Please instantiate LLM Observability via DD_LLMOBS_ENABLED or `tracer.init({ llmobs: ...options })`.'
+    )
+
     if (this.enabled) {
       logger.debug('LLMObs is already enabled.')
       return
@@ -79,6 +84,11 @@ class LLMObs extends NoopLLMObs {
   }
 
   disable () {
+    logger.warn(
+      'Disabling LLM Observability via `llmobs.disable()` is deprecated and will be removed in dd-trace@7.0.0. ' +
+      'Set DD_LLMOBS_ENABLED=false to disable LLM Observability.'
+    )
+
     if (!this.enabled) {
       logger.debug('LLMObs is already disabled.')
       return

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -54,7 +54,8 @@ class BaseLLMObsWriter {
 
     this._periodic = setInterval(() => {
       this.flush()
-    }, this._interval).unref()
+    }, this._interval)
+    this._periodic.unref?.()
 
     const destroyer = this.destroy.bind(this)
     globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(destroyer)

package/packages/dd-trace/src/log/writer.js

@@ -3,6 +3,8 @@
 const { storage } = require('../../../datadog-core')
 const { LogChannel } = require('./channels')
 
+const legacyStorage = storage('legacy')
+
 const defaultLogger = {
   debug: msg => console.debug(msg), /* eslint-disable-line no-console */
   info: msg => console.info(msg), /* eslint-disable-line no-console */
@@ -15,7 +17,7 @@ let logger = defaultLogger
 let logChannel = new LogChannel()
 
 function withNoop (fn) {
-  storage('legacy').run({ noop: true }, fn)
+  legacyStorage.run({ noop: true }, fn)
 }
 
 function toggleSubscription (enable, level) {

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

@@ -4,9 +4,11 @@ const id = require('../id')
 const { storage } = require('../../../datadog-core') // TODO: noop storage?
 const NoopSpanContext = require('./span_context')
 
+const legacyStorage = storage('legacy')
+
 class NoopSpan {
   constructor (tracer, parent) {
-    this._store = storage('legacy').getHandle()
+    this._store = legacyStorage.getHandle()
     this._noopTracer = tracer
     this._noopContext = this._createContext(parent)
   }

package/packages/dd-trace/src/openfeature/writers/base.js

@@ -55,7 +55,8 @@ class BaseFFEWriter {
 
     this._periodic = setInterval(() => {
       this.flush()
-    }, this._interval).unref()
+    }, this._interval)
+    this._periodic.unref?.()
 
     const destroyer = this.destroy.bind(this)
     globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(destroyer)

package/packages/dd-trace/src/openfeature/writers/exposures.js

@@ -8,8 +8,14 @@ const {
   EVP_PAYLOAD_SIZE_LIMIT,
   EVP_EVENT_SIZE_LIMIT,
 } = require('../constants/constants')
+const log = require('../../log')
 const BaseFFEWriter = require('./base')
 
+// Disabled-state cap. Drops invalidate experiment results because the provider's
+// exposure dedupe cache keeps masking dropped events after recovery. The first
+// drop emits a warning and `droppedEventCount` accumulates the cumulative loss.
+const PENDING_MAX_EVENTS = 1000
+
 /**
  * @typedef {object} ExposureEvent
  * @property {number} timestamp - Unix timestamp in milliseconds
@@ -42,11 +48,21 @@ const BaseFFEWriter = require('./base')
  * ExposuresWriter is responsible for sending exposure events to the Datadog Agent.
  */
 class ExposuresWriter extends BaseFFEWriter {
+  // Disabled until the agent strategy probe resolves.
+  #enabled = false
+
+  /** @type {ExposureEvent[]} */
+  #pendingEvents = []
+
+  /** @type {ExposureContext} */
+  #context
+
+  #dropWarned = false
+
   /**
    * @param {import('../../config/config-base')} config - Tracer configuration object
    */
   constructor (config) {
-    // Build full EVP endpoint path
     const basePath = EVP_PROXY_AGENT_BASE_PATH.replace(/\/+$/, '')
     const endpoint = EXPOSURES_ENDPOINT.replace(/^\/+/, '')
     const fullEndpoint = `${basePath}/${endpoint}`
@@ -60,33 +76,33 @@ class ExposuresWriter extends BaseFFEWriter {
         [EVP_SUBDOMAIN_HEADER_NAME]: EVP_SUBDOMAIN_VALUE,
       },
     })
-    this._enabled = false // Start disabled until agent strategy is set
-    this._pendingEvents = [] // Buffer events until enabled
 
+    /** @type {ExposureContext} */
     const context = {
       service: config.service,
     }
-    // Only include version and env if they are defined
+
     if (config.version !== undefined) {
       context.version = config.version
     }
+
     if (config.env !== undefined) {
       context.env = config.env
     }
 
-    this._context = context
+    this.#context = context
   }
 
   /**
    * @param {boolean} enabled - Whether to enable the writer
    */
   setEnabled (enabled) {
-    this._enabled = enabled
+    this.#enabled = enabled
 
-    if (enabled && this._pendingEvents.length > 0) {
+    if (enabled && this.#pendingEvents.length > 0) {
       // Flush all pending events as a batch
-      super.append(this._pendingEvents)
-      this._pendingEvents = []
+      super.append(this.#pendingEvents)
+      this.#pendingEvents = []
     }
   }
 
@@ -95,24 +111,38 @@ class ExposuresWriter extends BaseFFEWriter {
    * @param {ExposureEvent|ExposureEvent[]} events - Exposure event(s) to append
    */
   append (events) {
-    if (!this._enabled) {
-      // Buffer events until writer is ready
-      if (Array.isArray(events)) {
-        this._pendingEvents.push(...events)
-      } else {
-        this._pendingEvents.push(events)
-      }
+    if (this.#enabled) {
+      super.append(events)
       return
     }
-    super.append(events)
+
+    const eventArray = Array.isArray(events) ? events : [events]
+    this.#pendingEvents.push(...eventArray)
+    if (this.#pendingEvents.length > PENDING_MAX_EVENTS) {
+      const dropped = this.#pendingEvents.length - PENDING_MAX_EVENTS
+      this.#pendingEvents.splice(0, dropped)
+      this._droppedEvents += dropped
+      if (!this.#dropWarned) {
+        this.#dropWarned = true
+        log.warn(
+          '%s dropped exposure event(s) at cap %d. This may invalidate experiment results.',
+          this.constructor.name, PENDING_MAX_EVENTS)
+      }
+    }
+  }
+
+  /**
+   * @returns {number} Cumulative number of exposure events dropped due to buffer overflow.
+   */
+  get droppedEventCount () {
+    return this._droppedEvents
   }
 
   /**
    * Flushes buffered exposure events to the agent
    */
   flush () {
-    if (!this._enabled) {
-      // Don't flush when disabled
+    if (!this.#enabled) {
       return
     }
     super.flush()
@@ -125,6 +155,7 @@ class ExposuresWriter extends BaseFFEWriter {
    */
   makePayload (events) {
     const formattedEvents = events.map(event => {
+      /** @type {ExposureEvent} */
       return {
         timestamp: event.timestamp || Date.now(),
         allocation: {
@@ -145,7 +176,7 @@ class ExposuresWriter extends BaseFFEWriter {
     })
 
     return {
-      context: this._context,
+      context: this.#context,
       exposures: formattedEvents,
     }
   }

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

@@ -167,7 +167,8 @@ class PeriodicMetricReader {
 
     this.#timer = setInterval(() => {
       this.#collectAndExport()
-    }, this.#exportInterval).unref()
+    }, this.#exportInterval)
+    this.#timer.unref?.()
   }
 
   /**
@@ -335,7 +336,7 @@ class MetricAggregator {
       }
     }
 
-    this.#applyDeltaTemporality(metricsMap, lastExportedState)
+    this.#applyDeltaTemporality(metricsMap.values(), lastExportedState)
     return metricsMap
   }
 

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

@@ -9,6 +9,7 @@ const tags = require('../../../../../ext/tags')
 const { getConfiguredEnvName } = require('../../config/helper')
 const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
 const telemetryMetrics = require('../../telemetry/metrics')
+const { DD_MAJOR } = require('../../../../../version')
 
 const { AUTO_KEEP, AUTO_REJECT, USER_KEEP } = require('../../../../../ext/priority')
 const TraceState = require('./tracestate')
@@ -78,10 +79,17 @@ class TextMapPropagator {
   constructor (config) {
     this._config = config
 
-    // TODO: should match "b3 single header" in next major
-    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
+    // v6: `'b3'` is always single-header. v5: env-name decides — OTEL_PROPAGATORS callers expect
+    // single, the legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
+    if (DD_MAJOR >= 6) {
+      this.#extractB3Context = this._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
+    }
   }
 
   /**
@@ -262,9 +270,10 @@ class TextMapPropagator {
   }
 
   _injectB3MultipleHeaders (spanContext, carrier) {
-    const hasB3 = this._hasPropagationStyle('inject', 'b3')
-    const hasB3multi = this._hasPropagationStyle('inject', 'b3multi')
-    if (!(hasB3 || hasB3multi)) return
+    // v5 also accepts the legacy `'b3'` spelling for multi; v6 routes `'b3'` to single-header.
+    const hasB3multi = this._hasPropagationStyle('inject', 'b3multi') ||
+      (DD_MAJOR < 6 && this._hasPropagationStyle('inject', 'b3'))
+    if (!hasB3multi) return
 
     carrier[b3TraceKey] = this._getB3TraceId(spanContext)
     carrier[b3SpanKey] = spanContext._spanId.toString(16)
@@ -280,7 +289,9 @@ class TextMapPropagator {
   }
 
   _injectB3SingleHeader (spanContext, carrier) {
-    const hasB3SingleHeader = this._hasPropagationStyle('inject', 'b3 single header')
+    // 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
 
     const traceId = this._getB3TraceId(spanContext)
@@ -394,7 +405,7 @@ class TextMapPropagator {
         case 'tracecontext':
           extractedContext = this._extractTraceparentContext(carrier)
           break
-        case 'b3 single header': // TODO: delete in major after singular "b3"
+        case 'b3 single header':
           extractedContext = this._extractB3SingleContext(carrier)
           break
         case 'b3':

package/packages/dd-trace/src/payload-tagging/config/index.js

@@ -30,8 +30,8 @@ function getSDKRules (sdk, requestInput, responseInput) {
  * Appends input rules to all supported SDKs and returns a structure mapping SDK
  * names to per-service rules.
  *
- * @param {string[]} [requestInput=[]]
- * @param {string[]} [responseInput=[]]
+ * @param {string[]} [requestInput]
+ * @param {string[]} [responseInput]
  * @returns {Record<string, SDKRules>}
  */
 function appendRules (requestInput = [], responseInput = []) {

package/packages/dd-trace/src/plugins/apollo.js

@@ -3,13 +3,15 @@
 const { storage } = require('../../../datadog-core')
 const TracingPlugin = require('./tracing')
 
+const legacyStorage = storage('legacy')
+
 class ApolloBasePlugin extends TracingPlugin {
   static id = 'apollo.gateway'
   static type = 'web'
   static kind = 'server'
 
   bindStart (ctx) {
-    const store = storage('legacy').getStore()
+    const store = legacyStorage.getStore()
     const childOf = store ? /** @type {import('../opentracing/span') | undefined} */ (store.span) : null
 
     const span = this.startSpan(this.getOperationName(), {