dd-trace 6.20.1 → 6.22.0

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

@@ -24,7 +24,9 @@ function setAgentStrategy (config, setWritersAgentlessValue) {
     }
 
     const endpoints = agentInfo.endpoints
-    const hasEndpoint = Array.isArray(endpoints) && endpoints.includes(EVP_PROXY_AGENT_BASE_PATH)
+    // The Lambda extension lists full proxy paths (e.g. /evp_proxy/v2/api/v2/llmobs), not the bare prefix.
+    const hasEndpoint = Array.isArray(endpoints) &&
+      endpoints.some(endpoint => typeof endpoint === 'string' && endpoint.startsWith(EVP_PROXY_AGENT_BASE_PATH))
     setWritersAgentlessValue(!hasEndpoint)
   })
 }

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

@@ -17,11 +17,7 @@ class Log {
   get formatted () {
     const { message, args } = this
 
-    let formatted = message
-    if (message && args && args.length) {
-      formatted = format(message, ...args)
-    }
-    return formatted
+    return message && args && args.length ? format(message, ...args) : message
   }
 
   static parse (...args) {

package/packages/dd-trace/src/openfeature/agentless_configuration_source.js

@@ -21,6 +21,7 @@ const RETRY_JITTER = 0.2
  * @property {number} pollIntervalMs
  * @property {number} requestTimeoutMs
  * @property {string | undefined} apiKey
+ * @property {string | undefined} env
  */
 
 /**
@@ -106,9 +107,23 @@ class AgentlessConfigurationSource {
    */
   async #pollOnce (abortController) {
     for (let attempt = 1; attempt <= MAX_ATTEMPTS; attempt++) {
+      log.debug('Feature Flags: agentless configuration poll attempt %d/%d', attempt, MAX_ATTEMPTS)
       const response = await this.#request(abortController.signal)
       if (this.#abortController !== abortController) return
 
+      if (response.statusCode === 304) {
+        // 304 means the cached configuration is still valid, not a failure.
+        log.debug('Feature Flags: agentless configuration poll attempt %d/%d returned HTTP 304 (unchanged)',
+          attempt, MAX_ATTEMPTS)
+      } else if (response.statusCode === undefined) {
+        log.debug('Feature Flags: agentless configuration poll attempt %d/%d failed: %s',
+          attempt, MAX_ATTEMPTS, errorMessage(response.error))
+      } else {
+        // Avoids errorMessage(response.error), which embeds the full request URL.
+        log.debug('Feature Flags: agentless configuration poll attempt %d/%d returned HTTP %d',
+          attempt, MAX_ATTEMPTS, response.statusCode)
+      }
+
       const retryable = response.statusCode === undefined || isRetryableStatus(response.statusCode)
       if (!retryable) {
         this.#apply(response)
@@ -205,6 +220,13 @@ class AgentlessConfigurationSource {
     const etag = response.headers?.etag
     const value = Array.isArray(etag) ? etag[0] : etag
     this.#etag = value?.trim() || undefined
+
+    // eslint-disable-next-line eslint-rules/eslint-log-printf-style
+    log.debug(() => {
+      const flagCount = Object.keys(configuration.flags ?? {}).length
+      return 'Feature Flags: agentless configuration applied successfully ' +
+        `(${flagCount} flag(s), env=${this.#config.env ?? 'unset'})`
+    })
   }
 
   /**
@@ -270,10 +292,17 @@ function parseConfiguration (body) {
 }
 
 /**
+ * Formats a request error, including the underlying network error code
+ * (e.g. ENOTFOUND, ECONNREFUSED, ETIMEDOUT) when available, since "request
+ * failed" alone does not tell a customer whether the problem is DNS, a
+ * refused connection, a timeout, or something else.
+ *
  * @param {unknown} error
  */
 function errorMessage (error) {
-  return error instanceof Error ? error.message : String(error ?? 'request was not sent')
+  if (!(error instanceof Error)) return String(error ?? 'request was not sent')
+  const code = /** @type {{ code?: string }} */ (error).code
+  return code ? `${error.message} (${code})` : error.message
 }
 
 /**

package/packages/dd-trace/src/openfeature/configuration_source.js

@@ -23,7 +23,10 @@ function create (config, applyConfiguration) {
     DD_FEATURE_FLAGS_ENABLED: enabled,
   } = config.featureFlags
 
-  if (!enabled || source !== 'agentless') {
+  if (!enabled) return
+
+  if (source !== 'agentless') {
+    log.debug('Feature Flags: configuration source is %s, not agentless; skipping agentless setup', source)
     return
   }
 
@@ -35,11 +38,14 @@ function create (config, applyConfiguration) {
     }
 
     const AgentlessConfigurationSource = require('./agentless_configuration_source')
+    const resolvedEndpoint = endpoint(config, baseUrl)
+    log.debug('Feature Flags: starting agentless configuration source at %s', redactedUrl(resolvedEndpoint))
     return new AgentlessConfigurationSource({
-      endpoint: endpoint(config, baseUrl),
+      endpoint: resolvedEndpoint,
       pollIntervalMs: Math.min(pollIntervalSeconds, MAX_POLL_INTERVAL_SECONDS) * 1000,
       requestTimeoutMs: requestTimeoutSeconds * 1000,
       apiKey: hasCustomEndpoint ? undefined : config.DD_API_KEY,
+      env: config.env,
     }, applyConfiguration)
   } catch (error) {
     log.error('Unable to configure Feature Flagging configuration source', error)
@@ -85,6 +91,15 @@ function endpoint (config, configuredBaseUrl) {
   return url
 }
 
+/**
+ * Drops everything but the origin; a custom base URL may embed a signed token in its path.
+ *
+ * @param {URL} url
+ */
+function redactedUrl (url) {
+  return `${url.protocol}//${url.host}`
+}
+
 module.exports = {
   create,
 }

package/packages/dd-trace/src/openfeature/debug-logging-hook.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const log = require('../log')
+
+/**
+ * Logs full evaluation details under DD_TRACE_DEBUG, matching EvalMetricsHook's use of `finally`.
+ */
+class DebugLoggingHook {
+  /**
+   * @param {{ flagKey: string }} hookContext - Hook context containing the flag key
+   * @param {object} evaluationDetails - Full evaluation details
+   */
+  finally (hookContext, evaluationDetails) {
+    try {
+      log.debug('Feature Flags: evaluated %s: %o', hookContext?.flagKey, evaluationDetails)
+    } catch (error) {
+      try {
+        // Defense in depth; the OpenFeature SDK already guards finally hooks.
+        log.warn('DebugLoggingHook: error in finally hook: %s', error.message)
+      } catch { /* logging failure must not crash evaluation */ }
+    }
+  }
+}
+
+module.exports = DebugLoggingHook

package/packages/dd-trace/src/openfeature/evaluation-telemetry-opt-out-hook.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const PARAMETER = 'dd_evaluation_telemetry_opt_out'
+
+/** Gates an owned finally-only telemetry hook without changing evaluation or exposure handling. */
+class EvaluationTelemetryOptOutHook {
+  #delegate
+  #decisions = new WeakMap()
+
+  /** @param {import('@openfeature/server-sdk').Hook} delegate */
+  constructor (delegate) {
+    this.#delegate = delegate
+  }
+
+  /** @param {import('@openfeature/core').HookContext} hookContext */
+  before (hookContext) {
+    // Hook context identity is stable across stages, including each MultiProvider branch.
+    this.#decisions.set(hookContext, isOptedOut(hookContext.context))
+  }
+
+  /** @param {import('@openfeature/core').HookContext} hookContext */
+  error (hookContext) {
+    // A customer before hook can fail before this hook runs. Capture opt-out before customer error hooks change it.
+    if (!this.#decisions.has(hookContext)) {
+      this.#decisions.set(hookContext, isOptedOut(hookContext.context))
+    }
+  }
+
+  /**
+   * @param {import('@openfeature/core').HookContext} hookContext
+   * @param {import('@openfeature/core').EvaluationDetails<import('@openfeature/core').FlagValue>} evaluationDetails
+   * @param {import('@openfeature/core').HookHints} [hints]
+   */
+  finally (hookContext, evaluationDetails, hints) {
+    const optedOut = this.#decisions.get(hookContext) === true || isOptedOut(hookContext.context)
+    this.#decisions.delete(hookContext)
+    if (!optedOut) return this.#delegate.finally?.(hookContext, evaluationDetails, hints)
+  }
+}
+
+/** @param {import('@openfeature/core').EvaluationContext} context */
+function isOptedOut (context) {
+  try {
+    return context?.[PARAMETER] === true
+  } catch {
+    // An unreadable attribute is not boolean true and must not change the evaluation result.
+    return false
+  }
+}
+
+module.exports = EvaluationTelemetryOptOutHook

package/packages/dd-trace/src/openfeature/flagging_provider.js

@@ -4,9 +4,12 @@ const { channel } = require('dc-polyfill')
 
 const { DatadogNodeServerProvider } = require('../../../../vendor/dist/@datadog/openfeature-node-server')
 const log = require('../log')
+const { debugChannel } = require('../log/channels')
 const configurationSource = require('./configuration_source')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
+const DebugLoggingHook = require('./debug-logging-hook')
 const EvalMetricsHook = require('./eval-metrics-hook')
+const EvaluationTelemetryOptOutHook = require('./evaluation-telemetry-opt-out-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 const FlagEvalEVPHook = require('./writers/flag-eval-evp-hook')
 
@@ -15,6 +18,9 @@ const FlagEvalEVPHook = require('./writers/flag-eval-evp-hook')
  * Extends DatadogNodeServerProvider to add tracer integration and configuration management.
  */
 class FlaggingProvider extends DatadogNodeServerProvider {
+  // Track this wrapper's logging lifecycle without reading the upstream provider's private state.
+  #waitingForConfiguration = false
+
   /** @type {SpanEnrichmentHook | undefined} */
   #spanEnrichmentHook
 
@@ -34,14 +40,25 @@ class FlaggingProvider extends DatadogNodeServerProvider {
       initializationTimeoutMs: config.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS,
     })
 
+    const enableOptOut =
+      config.featureFlags.DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED === true
+    /** @param {import('@openfeature/server-sdk').Hook} hook */
+    const telemetryHook = hook => enableOptOut ? new EvaluationTelemetryOptOutHook(hook) : hook
+
     if (config.DD_METRICS_OTEL_ENABLED === true) {
-      this.hooks.push(new EvalMetricsHook(config))
+      this.hooks.push(telemetryHook(new EvalMetricsHook(config)))
+    } else {
+      log.debug('Feature Flags: evaluation metrics disabled; set %s=true to enable', 'DD_METRICS_OTEL_ENABLED')
+    }
+
+    if (config.debug && debugChannel.hasSubscribers) {
+      this.hooks.push(new DebugLoggingHook())
     }
 
     if (config.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_SPAN_ENRICHMENT_ENABLED) {
       this.#spanEnrichmentHook = new SpanEnrichmentHook(tracer)
       // @ts-expect-error The upstream constructor always initializes its optional hooks property.
-      this.hooks.push(this.#spanEnrichmentHook)
+      this.hooks.push(telemetryHook(this.#spanEnrichmentHook))
       log.info('%s span enrichment enabled', this.constructor.name)
     } else {
       log.info('%s span enrichment disabled', this.constructor.name)
@@ -52,7 +69,7 @@ class FlaggingProvider extends DatadogNodeServerProvider {
 
     if (config.featureFlags?.DD_FLAGGING_EVALUATION_COUNTS_ENABLED !== false) {
       this.#flagEvalEVPHook = new FlagEvalEVPHook(config)
-      this.hooks.push(this.#flagEvalEVPHook)
+      this.hooks.push(telemetryHook(this.#flagEvalEVPHook))
     }
 
     this.#configurationSource = configurationSource.create(config, this.setConfiguration.bind(this))
@@ -64,6 +81,9 @@ class FlaggingProvider extends DatadogNodeServerProvider {
    * @returns {Promise<void>}
    */
   initialize (context) {
+    log.debug('Feature Flags: waiting for provider initialization...')
+
+    this.#waitingForConfiguration = !this.getConfiguration()
     const promise = super.initialize(context)
 
     // `DatadogNodeServerProvider#initialize` starts a timer that is never unref'd, which would
@@ -72,9 +92,45 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     // TODO: remove once `@datadog/openfeature-node-server` unrefs this timer itself.
     this.initController?.timeoutId?.unref?.()
 
+    if (this.getConfiguration()) this.#logInitialConfiguration()
+
     return promise
   }
 
+  /**
+   * @param {Parameters<DatadogNodeServerProvider['setConfiguration']>[0]} configuration
+   */
+  setConfiguration (configuration) {
+    const wasWaiting = this.#waitingForConfiguration
+    super.setConfiguration(configuration)
+    this.#waitingForConfiguration = false
+    if (wasWaiting && configuration != null) this.#logInitialConfiguration()
+  }
+
+  /**
+   * @param {unknown} error
+   */
+  setError (error) {
+    const wasWaiting = this.#waitingForConfiguration
+    super.setError(error)
+    this.#waitingForConfiguration = false
+    if (!wasWaiting) return
+
+    try {
+      // Avoid inflating telemetry volume for routine initialization timeouts.
+      log.errorWithoutTelemetry(
+        'Feature Flags: provider failed to initialize: %s',
+        error instanceof Error ? error.message : String(error)
+      )
+    } catch { /* logging failure must not affect initialization */ }
+  }
+
+  #logInitialConfiguration () {
+    try {
+      log.debug('Feature Flags: initial configuration available')
+    } catch { /* logging failure must not affect initialization */ }
+  }
+
   /**
    * Called when the provider is shut down.
    * Cleans up resources including channel subscriptions.

package/packages/dd-trace/src/openfeature/remote_config.js

@@ -1,5 +1,6 @@
 'use strict'
 
+const log = require('../log')
 const RemoteConfigCapabilities = require('../remote_config/capabilities')
 
 /**
@@ -12,6 +13,8 @@ const RemoteConfigCapabilities = require('../remote_config/capabilities')
 function enable (rc, getOpenfeatureProxy, subscribe) {
   if (!subscribe) return
 
+  log.debug('Feature Flags: starting remote_config configuration source (Agent Remote Configuration)')
+
   rc.updateCapabilities(RemoteConfigCapabilities.FFE_FLAG_CONFIGURATION_RULES, true)
 
   /**
@@ -21,7 +24,13 @@ function enable (rc, getOpenfeatureProxy, subscribe) {
   const updateConfiguration = (action, conf) => {
     if (action === 'apply' || action === 'modify') {
       getOpenfeatureProxy().setConfiguration(conf)
+      // eslint-disable-next-line eslint-rules/eslint-log-printf-style
+      log.debug(() => {
+        const flagCount = Object.keys(conf?.flags ?? {}).length
+        return `Feature Flags: remote_config configuration ${action} applied successfully (${flagCount} flag(s))`
+      })
     } else if (action === 'unapply') {
+      log.debug('Feature Flags: remote_config configuration removed')
       getOpenfeatureProxy().setConfiguration(undefined)
     }
   }

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

@@ -16,6 +16,18 @@ const ROUTE_DISCOVERY_COOLDOWN_MS = 60_000
 const REQUIRED_LOCAL_HEADERS = [EVP_ORIGIN_HEADER_NAME, EVP_ORIGIN_VERSION_HEADER_NAME]
 const STOP_NOOP = () => {}
 
+/**
+ * @typedef {(enabled: boolean, route?: import('./flag-evaluations').FlagEvaluationRoute) => void} DeliverySubscriber
+ */
+/**
+ * @typedef {object} DeliveryStrategy
+ * @property {Set<{notify: DeliverySubscriber}>} subscribers
+ * @property {() => void} stop
+ * @property {[boolean, import('./flag-evaluations').FlagEvaluationRoute?]} [result]
+ */
+/** @type {WeakMap<import('../../config/config-base'), DeliveryStrategy>} */
+const deliveryStrategies = new WeakMap()
+
 let missingRouteWarningLogged = false
 
 /**
@@ -167,18 +179,45 @@ function setAgentlessStrategy (config, setWriterEnabledValue) {
 }
 
 /**
- * Applies one event-delivery strategy that can be shared by all Feature Flags writers.
+ * Subscribes to the delivery strategy owned by this tracer configuration.
+ * The provider and exposure module receive the same configuration object from
+ * the tracer. Share their route transitions, but never share credentials across
+ * distinct configurations. The last subscriber owns discovery cleanup.
  *
  * @param {import('../../config/config-base')} config - Tracer configuration object
  * @param {(enabled: boolean, route?: import('./flag-evaluations').FlagEvaluationRoute) => void} setWriterEnabledValue
  *   Callback to set the writer enabled state
  */
 function setEventDeliveryStrategy (config, setWriterEnabledValue) {
-  if (config.featureFlags?.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'agentless') {
-    return setAgentlessStrategy(config, setWriterEnabledValue)
+  let strategy = deliveryStrategies.get(config)
+  const subscriber = { notify: setWriterEnabledValue }
+
+  if (strategy) {
+    strategy.subscribers.add(subscriber)
+    if (strategy.result) setWriterEnabledValue(...strategy.result)
+  } else {
+    strategy = { subscribers: new Set([subscriber]), stop: STOP_NOOP }
+    deliveryStrategies.set(config, strategy)
+    /** @type {DeliverySubscriber} */
+    const notify = (enabled, route) => {
+      // A Remote Config discovery already in flight cannot be canceled. Ignore
+      // its result after shutdown, including when the same config is reused.
+      if (deliveryStrategies.get(config) !== strategy) return
+      strategy.result = route === undefined ? [enabled] : [enabled, route]
+      for (const subscriber of strategy.subscribers) {
+        subscriber.notify(...strategy.result)
+      }
+    }
+    strategy.stop = config.featureFlags?.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'agentless'
+      ? setAgentlessStrategy(config, notify)
+      : setAgentStrategy(config, notify)
   }
 
-  return setAgentStrategy(config, setWriterEnabledValue)
+  return () => {
+    if (!strategy.subscribers.delete(subscriber) || strategy.subscribers.size !== 0) return
+    deliveryStrategies.delete(config)
+    strategy.stop()
+  }
 }
 
 module.exports = {

package/packages/dd-trace/src/opentelemetry/logs/otlp_transformer.js

@@ -52,7 +52,7 @@ function encodeHrTime (hrTime) {
  * OtlpTransformer transforms log records to OTLP format.
  *
  * This implementation follows the OTLP Logs v1.7.0 Data Model specification:
- * https://opentelemetry.io/docs/specs/otlp/#log-data-model
+ * https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/logs/v1/logs.proto
  *
  * @class OtlpTransformer
  * @augments OtlpTransformerBase

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

@@ -18,7 +18,7 @@ const AGGREGATION_TEMPORALITY_CUMULATIVE = protoAggregationTemporality.values.AG
  * OtlpTransformer transforms metrics to OTLP format.
  *
  * This implementation follows the OTLP Metrics v1.7.0 Data Model specification:
- * https://opentelemetry.io/docs/specs/otlp/#metrics-data-model
+ * https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/metrics/v1/metrics.proto
  *
  * @class OtlpTransformer
  * @augments OtlpTransformerBase

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

@@ -162,8 +162,7 @@ class PeriodicMetricReader {
   addBatchObservableCallback (callback, observables) {
     if (typeof callback !== 'function') return
     const instruments = new Set(observables?.filter(isObservableInstrument))
-    if (instruments.size === 0) return
-    if (this.#findBatchCallback(callback, instruments) !== -1) return
+    if (instruments.size === 0 || this.#findBatchCallback(callback, instruments) !== -1) return
     this.#batchCallbacks.push({ callback, instruments })
   }
 

package/packages/dd-trace/src/opentelemetry/otlp/common.proto

@@ -1,4 +1,4 @@
-// Vendored from: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/logs/v1/common.proto
+// Vendored from: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/common/v1/common.proto
 // Copyright 2019, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");

package/packages/dd-trace/src/opentelemetry/resource-attributes.js

@@ -30,7 +30,7 @@ function buildResourceAttributes (config) {
   const resourceAttributes = {
     'service.name': config.service,
     'service.version': config.version,
-    'deployment.environment': config.env,
+    'deployment.environment.name': config.env,
     ...tags,
   }
 

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

@@ -84,7 +84,7 @@ const DD_ERROR_META_KEYS = new Set(['error.message'])
  * OtlpTraceTransformer transforms DD-formatted spans to OTLP trace JSON format.
  *
  * This implementation follows the OTLP trace data model:
- * https://opentelemetry.io/docs/specs/otlp/#trace-data-model
+ * https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/trace/v1/trace.proto
  *
  * It receives DD-formatted spans (from span_format.js) and produces
  * an ExportTraceServiceRequest serialized as JSON (http/json protocol only).
@@ -168,8 +168,8 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
 
     return {
       traceId: span.trace_id.toTraceIdHex(traceIdHigh).padStart(32, '0'),
-      spanId: this.#idToBytes(span.span_id, 8),
-      parentSpanId: (parentId && !parentId.equals(ZERO_ID)) ? this.#idToBytes(parentId, 8) : undefined,
+      spanId: this.#spanIdToHex(span.span_id),
+      parentSpanId: parentId && !parentId.equals(ZERO_ID) ? this.#spanIdToHex(parentId) : undefined,
       traceState: span.trace_state,
       name: span.resource,
       kind: this.#mapSpanKind(span.meta?.['span.kind']),
@@ -338,26 +338,9 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
     }
   }
 
-  /**
-   * Converts a DD Identifier object to a hex-encoded string of the specified byte length.
-   * Pads with leading zeros if the identifier buffer is shorter than the target.
-   * Per the OTLP http/json spec, trace-ids and span-ids must be hex-encoded strings.
-   *
-   * @param {Identifier} identifier - DD Identifier
-   * @param {number} targetLength - Target byte length (16 for trace ID, 8 for span ID)
-   */
-  #idToBytes (identifier, targetLength) {
-    const buffer = identifier.toBuffer()
-    if (buffer.length === targetLength) {
-      return Buffer.from(buffer).toString('hex')
-    }
-    if (buffer.length > targetLength) {
-      return Buffer.from(buffer.slice(buffer.length - targetLength)).toString('hex')
-    }
-    // Pad with leading zeros to reach target length.
-    const result = Buffer.alloc(targetLength)
-    Buffer.from(buffer).copy(result, targetLength - buffer.length)
-    return result.toString('hex')
+  /** @param {Identifier} identifier */
+  #spanIdToHex (identifier) {
+    return identifier.toString(16).slice(-16)
   }
 
   /**

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

@@ -38,7 +38,7 @@ const id = require('../../id')
 const DatadogSpanContext = require('../span_context')
 const log = require('../../log')
 const tags = require('../../../../../ext/tags')
-const { getConfiguredEnvName } = require('../../config/helper')
+const { getValidatedConfiguredEnvName } = require('../../config/helper')
 const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
 const { hasTraceSourcePropagationTag } = require('../../standalone/tracesource')
 const telemetryMetrics = require('../../telemetry/metrics')
@@ -134,8 +134,7 @@ function isOptionalDatadogTraceStateField (key, injection) {
  * @returns {DatadogSpanContext | undefined}
  */
 function extractGenericContext (traceId, spanId, radix) {
-  if (!traceId || invalidSegment.test(traceId)) return
-  if (!spanId) return
+  if (!traceId || invalidSegment.test(traceId) || !spanId) return
 
   return new DatadogSpanContext({
     traceId: id(traceId, radix),
@@ -305,13 +304,25 @@ class TextMapPropagator {
   /** @type {string[] | undefined} Source array that `#baggageTagKeysSet` was built from. */
   #baggageTagKeysSetSource
 
-  /** @type {import('../../config')} */
+  /** @type {ReturnType<import('../../config')>} */
   #config
 
   /** @type {typeof extractB3SingleContext | typeof extractB3MultiContext} */
   #extractB3Context
 
-  /** @param {import('../../config')} config */
+  /** Whether the `b3` injection style resolves to single-header propagation. */
+  #b3InjectIsSingleHeader
+
+  /** Cached origin used to resolve the v5 `b3` injection style. */
+  #b3InjectOrigin
+
+  /** Cached state of the v5 experimental B3 setting. */
+  #b3ExperimentalEnabled
+
+  /** Cached origin of the shared v5 propagation style. */
+  #b3SharedOrigin
+
+  /** @param {ReturnType<import('../../config')>} config */
   constructor (config) {
     this.#config = config
 
@@ -319,16 +330,44 @@ class TextMapPropagator {
     // expect single, legacy `DD_TRACE_PROPAGATION_STYLE` callers expect multi.
     /* istanbul ignore else: v5 fallback */
     if (DD_MAJOR >= 6) {
+      this.#b3InjectIsSingleHeader = true
       this.#extractB3Context = extractB3SingleContext
     } else {
-      const envName = getConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
+      const envName = getValidatedConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
       // eslint-disable-next-line eslint-rules/eslint-env-aliases
       this.#extractB3Context = envName === 'OTEL_PROPAGATORS'
         ? extractB3SingleContext
         : extractB3MultiContext
+
+      this.#refreshB3InjectionStyle()
     }
   }
 
+  #refreshB3InjectionStyle () {
+    const origin = this.#config.getOrigin?.('tracePropagationStyle.inject') ?? 'default'
+    const experimentalEnabled = this.#config.experimental?.b3 === true
+    const sharedOrigin = origin === 'calculated'
+      ? this.#config.getOrigin?.('DD_TRACE_PROPAGATION_STYLE') ?? 'default'
+      : undefined
+    if (origin === this.#b3InjectOrigin &&
+      experimentalEnabled === this.#b3ExperimentalEnabled &&
+      sharedOrigin === this.#b3SharedOrigin) return
+
+    let envName
+    if (origin === 'calculated' && !experimentalEnabled && sharedOrigin !== 'remote_config') {
+      envName = getValidatedConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE')
+    } else if (origin === 'env_var' ||
+      origin === 'local_stable_config' ||
+      origin === 'fleet_stable_config') {
+      envName = getValidatedConfiguredEnvName('DD_TRACE_PROPAGATION_STYLE_INJECT')
+    }
+    // eslint-disable-next-line eslint-rules/eslint-env-aliases
+    this.#b3InjectIsSingleHeader = envName === 'OTEL_PROPAGATORS'
+    this.#b3InjectOrigin = origin
+    this.#b3ExperimentalEnabled = experimentalEnabled
+    this.#b3SharedOrigin = sharedOrigin
+  }
+
   /**
    * Returns a `Set` view of `#config.baggageTagKeys` that is rebuilt only
    * when the source array reference changes. Avoids an `O(n)` `Set` alloc
@@ -574,9 +613,8 @@ class TextMapPropagator {
    * @returns {Record<string, string> | undefined}
    */
   #injectB3MultipleHeaders (spanContext, carrier) {
-    // 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'))
+      (this.#hasPropagationStyle('inject', 'b3') && !this.#usesB3SingleHeaderInjection())
     if (!hasB3multi) return
 
     carrier ??= {}
@@ -603,7 +641,7 @@ class TextMapPropagator {
   #injectB3SingleHeader (spanContext, carrier) {
     // 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'))
+      (this.#hasPropagationStyle('inject', 'b3') && this.#usesB3SingleHeaderInjection())
     if (!hasB3SingleHeader) return
 
     carrier ??= {}
@@ -620,6 +658,11 @@ class TextMapPropagator {
     return carrier
   }
 
+  #usesB3SingleHeaderInjection () {
+    if (DD_MAJOR < 6) this.#refreshB3InjectionStyle()
+    return this.#b3InjectIsSingleHeader
+  }
+
   /**
    * @param {DatadogSpanContext} spanContext
    * @param {Record<string, string> | undefined} carrier
@@ -982,11 +1025,8 @@ class TextMapPropagator {
       const traceparent = { version }
       // W3C Trace Context §3.3.1.1: multiple tracestate fields MUST be combined per RFC 7230 §3.2.2.
       const tracestate = TraceState.fromString(readTracestate(carrier))
-      if (invalidSegment.test(traceId)) return
-      if (invalidSegment.test(spanId)) return
-
       // Version ff is considered invalid
-      if (version === 'ff') return
+      if (invalidSegment.test(traceId) || invalidSegment.test(spanId) || version === 'ff') return
 
       // Version 00 should have no tail, but future versions may
       if (tail && version === '00') return