dd-trace 5.132.0 → 5.134.0

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

@@ -9,6 +9,7 @@ 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')
 
@@ -17,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
 
@@ -36,8 +40,13 @@ 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')
     }
@@ -49,7 +58,7 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     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)
@@ -60,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))
@@ -74,6 +83,7 @@ class FlaggingProvider extends DatadogNodeServerProvider {
   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
@@ -82,28 +92,45 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     // TODO: remove once `@datadog/openfeature-node-server` unrefs this timer itself.
     this.initController?.timeoutId?.unref?.()
 
-    // Only observes the outcome for logging; `promise` itself is returned unmodified below.
-    // Guarded so a logger failure can never leave the derived promise unhandled.
-    promise.then(
-      () => {
-        try {
-          log.debug('Feature Flags: provider initialized successfully')
-        } catch { /* logging failure must not crash the process */ }
-      },
-      (error) => {
-        try {
-          // errorWithoutTelemetry avoids inflating telemetry volume for every routine init timeout.
-          log.errorWithoutTelemetry(
-            'Feature Flags: provider failed to initialize: %s',
-            error instanceof Error ? error.message : String(error)
-          )
-        } catch { /* logging failure must not crash the process */ }
-      }
-    )
+    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/index.js

@@ -33,6 +33,12 @@ function _handleFlush () {
  * @param {import('../config')} config - Tracer configuration object
  */
 function enable (config) {
+  if (config.featureFlags?.DD_FEATURE_FLAGS_EXPOSURES_DATADOG_LOGGING_ENABLED === false) {
+    log.debug('Feature Flags: Datadog exposure logging disabled; set %s=true to enable',
+      'DD_FEATURE_FLAGS_EXPOSURES_DATADOG_LOGGING_ENABLED')
+    return
+  }
+
   if (exposuresWriter) {
     log.warn('%s already enabled', exposuresWriter.constructor.name)
     return

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

@@ -31,14 +31,14 @@ const deliveryStrategies = new WeakMap()
 let missingRouteWarningLogged = false
 
 /**
- * Logs the unavailable exposure-delivery warning once.
+ * Logs the unavailable event-delivery warning once.
  *
  */
-function warnExposureDeliveryUnavailable () {
+function warnEventDeliveryUnavailable () {
   if (missingRouteWarningLogged) return
   missingRouteWarningLogged = true
   logger.warn(
-    'Feature Flags exposure delivery is disabled because no compatible local EVP route or direct intake ' +
+    'Feature Flags event delivery is disabled because no compatible local EVP route or direct intake ' +
     'credentials are available.'
   )
 }
@@ -169,7 +169,7 @@ function setAgentlessStrategy (config, setWriterEnabledValue) {
       if (error) {
         logger.debug('FFE Writer disabled - error getting local receiver info: %s', error.message)
       }
-      warnExposureDeliveryUnavailable()
+      warnEventDeliveryUnavailable()
       markUnavailable()
     })
   }

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/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).
@@ -95,6 +95,11 @@ const DD_ERROR_META_KEYS = new Set(['error.message'])
 class OtlpTraceTransformer extends OtlpTransformerBase {
   #otelTraceSemanticsEnabled
 
+  // Span meta entries with the same key and value as a resource attribute are already carried by
+  // the resource (e.g. DD_TAGS), so they are not repeated as span attributes.
+  /** @type {import('@opentelemetry/api').Attributes} */
+  #resourceAttributes
+
   /**
    * Creates a new OtlpTraceTransformer instance.
    *
@@ -104,6 +109,16 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
   constructor (resourceAttributes, otelTraceSemanticsEnabled) {
     super(resourceAttributes, 'http/json', 'traces')
     this.#otelTraceSemanticsEnabled = otelTraceSemanticsEnabled
+    this.#resourceAttributes = resourceAttributes
+  }
+
+  /**
+   * @override
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
+   */
+  updateResourceAttributes (resourceAttributes) {
+    super.updateResourceAttributes(resourceAttributes)
+    this.#resourceAttributes = resourceAttributes
   }
 
   /**
@@ -168,8 +183,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']),
@@ -216,11 +231,13 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
       }
     }
 
-    // Add meta string tags, skipping keys that map to dedicated OTLP fields
+    // Add meta string tags, skipping keys that map to dedicated OTLP fields and tags the
+    // resource already carries with the same value (e.g. global tags from DD_TAGS)
     if (span.meta) {
       for (const [key, value] of Object.entries(span.meta)) {
         if (EXCLUDED_META_KEYS.has(key)) continue
         if (this.#otelTraceSemanticsEnabled && DD_ERROR_META_KEYS.has(key)) continue
+        if (this.#resourceAttributes[key] === value) continue
         attributes.push({ key, value: { stringValue: value } })
       }
     }
@@ -338,26 +355,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

package/packages/dd-trace/src/otel-sampling.js

@@ -11,11 +11,10 @@ const UINT64_MASK = 2n ** 64n - 1n
 /**
  * @param {unknown} value
  * @param {number} minLength
- * @param {number} maxLength
  * @returns {value is string}
  */
-function isLowerHex (value, minLength, maxLength) {
-  if (typeof value !== 'string' || value.length < minLength || value.length > maxLength) return false
+function isLowerHex (value, minLength) {
+  if (typeof value !== 'string' || value.length < minLength || value.length > 14) return false
 
   for (let index = 0; index < value.length; index++) {
     const code = value.charCodeAt(index)
@@ -112,11 +111,11 @@ function sanitizeFields (state) {
   let randomValue = state.get('rv')
   let threshold = state.get('th')
 
-  if (!isLowerHex(randomValue, 14, 14)) {
+  if (!isLowerHex(randomValue, 14)) {
     state.delete('rv')
     randomValue = undefined
   }
-  if (!isLowerHex(threshold, 1, 14)) {
+  if (!isLowerHex(threshold, 1)) {
     state.delete('th')
     threshold = undefined
   }