dd-trace 6.3.0 → 6.4.0

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

@@ -8,6 +8,7 @@ const log = require('../../log')
 const tags = require('../../../../../ext/tags')
 const { getConfiguredEnvName } = require('../../config/helper')
 const { setAllBaggageItems, getAllBaggageItems, removeAllBaggageItems } = require('../../baggage')
+const { hasTraceSourcePropagationTag } = require('../../standalone/tracesource')
 const telemetryMetrics = require('../../telemetry/metrics')
 const { DD_MAJOR } = require('../../../../../version')
 
@@ -119,22 +120,35 @@ class TextMapPropagator {
     return this.#baggageTagKeysSet
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   inject (spanContext, carrier) {
-    if (!carrier) return
-    this._injectBaggageItems(spanContext, carrier)
-    if (!spanContext) return
+    if (carrier === null) return
+    let injectedCarrier = this._injectBaggageItems(spanContext, carrier)
+    if (!spanContext) return injectedCarrier
 
-    this._injectDatadog(spanContext, carrier)
-    this._injectB3MultipleHeaders(spanContext, carrier)
-    this._injectB3SingleHeader(spanContext, carrier)
-    this._injectTraceparent(spanContext, carrier)
-
-    if (injectCh.hasSubscribers) {
-      injectCh.publish({ spanContext, carrier })
+    const injectTraceContext = this._config.apmTracingEnabled !== false ||
+      hasTraceSourcePropagationTag(spanContext._trace.tags)
+    if (injectTraceContext) {
+      injectedCarrier = this._injectDatadog(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
+      injectedCarrier = this._injectB3MultipleHeaders(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
+      injectedCarrier = this._injectB3SingleHeader(spanContext, injectedCarrier ?? carrier) ?? injectedCarrier
     }
+    injectedCarrier = this
+      ._injectTraceparent(spanContext, injectedCarrier ?? carrier, injectTraceContext) ?? injectedCarrier
+
+    if (injectedCarrier === undefined) return
+
+    carrier = injectedCarrier
+    if (injectCh.hasSubscribers) injectCh.publish({ spanContext, carrier })
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier: ${JSON.stringify(pick(carrier, logKeys))}.`)
+
+    return carrier
   }
 
   extract (carrier) {
@@ -156,15 +170,23 @@ class TextMapPropagator {
     return spanContext
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectDatadog (spanContext, carrier) {
     if (!this._hasPropagationStyle('inject', 'datadog')) return
 
+    carrier ??= {}
     carrier[traceKey] = spanContext.toTraceId()
     carrier[spanKey] = spanContext.toSpanId()
 
     this._injectOrigin(spanContext, carrier)
     this._injectSamplingPriority(spanContext, carrier)
     this._injectTags(spanContext, carrier)
+
+    return carrier
   }
 
   _injectOrigin (spanContext, carrier) {
@@ -183,7 +205,13 @@ class TextMapPropagator {
     }
   }
 
+  /**
+   * @param {DatadogSpanContext | null | undefined} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _injectBaggageItems (spanContext, carrier) {
+    let injectedCarrier
     if (this._config.legacyBaggageEnabled) {
       const baggageItems = spanContext?._baggageItems
       if (baggageItems) {
@@ -202,7 +230,8 @@ class TextMapPropagator {
           if (invalidHeaderValueCharExpr.test(headerValue)) {
             headerValue = encodeURIComponent(headerValue)
           }
-          carrier[headerName] = headerValue
+          injectedCarrier ??= carrier ?? {}
+          injectedCarrier[headerName] = headerValue
         }
       }
     }
@@ -213,7 +242,6 @@ class TextMapPropagator {
       let byteCounter = 0
 
       const baggageItems = getAllBaggageItems()
-      if (!baggageItems) return
       for (const key of Object.keys(baggageItems)) {
         const baggageKey = key.trim()
         if (!baggageTokenExpr.test(baggageKey)) continue
@@ -242,10 +270,13 @@ class TextMapPropagator {
 
       baggage = baggage.slice(0, -1)
       if (baggage) {
-        carrier.baggage = baggage
+        injectedCarrier ??= carrier ?? {}
+        injectedCarrier.baggage = baggage
         tracerMetrics.count('context_header_style.injected', ['header_style:baggage']).inc()
       }
     }
+
+    return injectedCarrier
   }
 
   _injectTags (spanContext, carrier) {
@@ -278,12 +309,18 @@ class TextMapPropagator {
     }
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @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'))
     if (!hasB3multi) return
 
+    carrier ??= {}
     carrier[b3TraceKey] = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     carrier[b3SpanKey] = spanContext._spanId.toString(16)
     carrier[b3SampledKey] = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
@@ -295,14 +332,22 @@ class TextMapPropagator {
     if (spanContext._parentId) {
       carrier[b3ParentKey] = spanContext._parentId.toString(16)
     }
+
+    return carrier
   }
 
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   _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'))
     if (!hasB3SingleHeader) return
 
+    carrier ??= {}
     const traceId = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     const spanId = spanContext._spanId.toString(16)
     const sampled = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
@@ -311,11 +356,30 @@ class TextMapPropagator {
     if (spanContext._parentId) {
       carrier[b3HeaderKey] += '-' + spanContext._parentId.toString(16)
     }
+
+    return carrier
   }
 
-  _injectTraceparent (spanContext, carrier) {
+  /**
+   * @param {DatadogSpanContext} spanContext
+   * @param {Record<string, string> | undefined} carrier
+   * @param {boolean} injectTraceContext
+   * @returns {Record<string, string> | undefined}
+   */
+  _injectTraceparent (spanContext, carrier, injectTraceContext) {
     if (!this._hasPropagationStyle('inject', 'tracecontext')) return
 
+    if (!injectTraceContext) {
+      const tracestate = TraceState.fromString(spanContext._tracestate?.toString())
+      tracestate.delete('dd')
+      const header = tracestate.toString()
+      if (!header) return
+      carrier ??= {}
+      carrier.tracestate = header
+      return carrier
+    }
+
+    carrier ??= {}
     const {
       _sampling: { priority, mechanism },
       _tracestate: ts = new TraceState(),
@@ -363,6 +427,8 @@ class TextMapPropagator {
     })
 
     carrier.tracestate = ts.toString()
+
+    return carrier
   }
 
   _hasPropagationStyle (mode, name) {

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

@@ -13,13 +13,22 @@ class DSMTextMapPropagator {
     this.config = config
   }
 
+  /**
+   * @param {object} ctx DSM pathway context.
+   * @param {Record<string, string>} [carrier]
+   * @returns {Record<string, string> | undefined}
+   */
   inject (ctx, carrier) {
     if (!this.config.dsmEnabled) return
 
-    DsmPathwayCodec.encode(ctx, carrier)
+    const injectedCarrier = DsmPathwayCodec.encode(ctx, carrier)
+    if (injectedCarrier === undefined) return
 
+    carrier = injectedCarrier
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
+
+    return carrier
   }
 
   extract (carrier) {

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

@@ -101,6 +101,12 @@ class DatadogTracer {
     return span
   }
 
+  /**
+   * @param {Span|SpanContext} context
+   * @param {string} format
+   * @param {object} [carrier]
+   * @returns {object | undefined}
+   */
   inject (context, format, carrier) {
     if (context instanceof Span) {
       context = context.context()
@@ -110,7 +116,7 @@ class DatadogTracer {
       if (format !== 'text_map_dsm' && format !== formats.LOG) {
         this._prioritySampler.sample(context)
       }
-      this._propagators[format].inject(context, carrier)
+      return this._propagators[format].inject(context, carrier)
     } catch (e) {
       log.error('Error injecting trace', e)
       runtimeMetrics.increment('datadog.tracer.node.inject.errors', true)

package/packages/dd-trace/src/plugins/util/test.js

@@ -1454,7 +1454,7 @@ function parseAnnotations (annotations) {
  * Returns 0 when the test is too slow to retry (≥ 5 min).
  *
  * @param {number} durationMs
- * @param {Record<string, number>} slowTestRetries  e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
+ * @param {Record<string, number>} slowTestRetries e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
  * @returns {number}
  */
 function getEfdRetryCount (durationMs, slowTestRetries) {
@@ -1469,12 +1469,17 @@ function getEfdRetryCount (durationMs, slowTestRetries) {
 /**
  * Returns the maximum retry count configured by the backend for EFD.
  *
- * @param {Record<string, number>} slowTestRetries e.g. { '5s': 10, '10s': 5, '30s': 3, '5m': 2 }
- * @returns {number}
+ * @param {Record<string, number> | undefined} slowTestRetries
+ * @returns {number | undefined}
  */
 function getMaxEfdRetryCount (slowTestRetries) {
+  if (slowTestRetries === undefined) return
+
+  const retryCounts = Object.values(slowTestRetries)
+  if (retryCounts.length === 0) return
+
   let maxRetries = 0
-  for (const retryCount of Object.values(slowTestRetries || {})) {
+  for (const retryCount of retryCounts) {
     if (retryCount > maxRetries) {
       maxRetries = retryCount
     }

package/packages/dd-trace/src/plugins/util/web.js

@@ -185,6 +185,18 @@ const web = {
     return context
   },
 
+  // Key an existing context on the underlying `Http2Stream` so a second request
+  // backed by the same stream resolves to it via the `req.stream` lookup in
+  // `patch`. Only a mixed HTTP/2 server (raw-stream + 'request' listeners) needs
+  // this: it creates the span from a throwaway stream adapter, then the
+  // compatibility layer synthesizes the real `Http2ServerRequest` off the same
+  // stream and must reuse the adapter's span rather than open an orphan context.
+  // Confined to that path so the common single-listener request pays no extra
+  // per-request map write.
+  linkContextToStream (stream, context) {
+    contexts.set(stream, context)
+  },
+
   // Return the request root span.
   root (req) {
     const context = contexts.get(req)

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const NoopProxy = require('./noop/proxy')
+const { features } = require('./feature-registry')
 const DatadogTracer = require('./tracer')
 const getConfig = require('./config')
 const runtimeMetrics = require('./runtime_metrics')
@@ -91,7 +92,10 @@ class Tracer extends NoopProxy {
       iast: new LazyModule(() => require('./appsec/iast')),
       llmobs: new LazyModule(() => require('./llmobs')),
       rewriter: new LazyModule(() => require('./appsec/iast/taint-tracking/rewriter')),
-      openfeature: new LazyModule(() => require('./openfeature')),
+    }
+
+    for (const feature of Object.values(features)) {
+      this._modules[feature.name] = new LazyModule(feature.factory)
     }
   }
 
@@ -114,7 +118,11 @@ class Tracer extends NoopProxy {
       propagationHash.configure(config)
 
       if (config.DD_CRASHTRACKING_ENABLED) {
-        require('./crashtracking').start(config)
+        try {
+          require('./crashtracking').start(config)
+        } catch (e) {
+          log.warn('Crashtracking is not available in this environment', e)
+        }
       }
 
       if (config.DD_HEAP_SNAPSHOT_COUNT > 0) {
@@ -176,8 +184,9 @@ class Tracer extends NoopProxy {
           DynamicInstrumentation.start(config, rc)
         }
 
-        const openfeatureRemoteConfig = require('./openfeature/remote_config')
-        openfeatureRemoteConfig.enable(rc, config, () => this.openfeature)
+        for (const feature of Object.values(features)) {
+          feature.remoteConfig?.(rc, config, this)
+        }
       }
 
       if (config.profiling.DD_PROFILING_ENABLED === 'true') {
@@ -287,14 +296,15 @@ class Tracer extends NoopProxy {
         lazyProxy(this, 'llmobs', () => require('./llmobs/sdk'), this._tracer, this._modules.llmobs, config)
 
         if (config.experimental?.aiguard?.enabled) {
-          this._modules.aiguard.enable(this._tracer, config)
           lazyProxy(this, 'aiguard', () => require('./aiguard/sdk'), this._tracer, config)
         }
         this._tracingInitialized = true
       }
-      if (config.experimental.flaggingProvider.enabled) {
-        this._modules.openfeature.enable(config)
-        lazyProxy(this, 'openfeature', () => require('./openfeature/flagging_provider'), this._tracer, config)
+      for (const feature of Object.values(features)) {
+        feature.enable?.(config, this._tracer, this, lazyProxy)
+      }
+      if (config.experimental?.aiguard?.enabled) {
+        this._modules.aiguard.enable(this._tracer, config)
       }
       if (config.iast.enabled) {
         this._modules.iast.enable(config, this._tracer)
@@ -305,7 +315,9 @@ class Tracer extends NoopProxy {
       this._modules.aiguard.disable()
       this._modules.iast.disable()
       this._modules.llmobs.disable()
-      this._modules.openfeature.disable()
+      for (const feature of Object.values(features)) {
+        this._modules[feature.name].disable()
+      }
     }
 
     if (this._tracingInitialized) {

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

@@ -2,13 +2,11 @@
 
 const { channel } = require('dc-polyfill')
 const { USER_KEEP } = require('../../../../ext/priority')
-const TraceState = require('../opentracing/propagation/tracestate')
 const { APM_TRACING_ENABLED_KEY } = require('../constants')
 const TraceSourcePrioritySampler = require('./tracesource_priority_sampler')
 const { hasTraceSourcePropagationTag } = require('./tracesource')
 
 const startCh = channel('dd-trace:span:start')
-const injectCh = channel('dd-trace:span:inject')
 const extractCh = channel('dd-trace:span:extract')
 
 /**
@@ -16,13 +14,11 @@ const extractCh = channel('dd-trace:span:extract')
  */
 function configure (config) {
   if (startCh.hasSubscribers) startCh.unsubscribe(onSpanStart)
-  if (injectCh.hasSubscribers) injectCh.unsubscribe(onSpanInject)
   if (extractCh.hasSubscribers) extractCh.unsubscribe(onSpanExtract)
 
   if (config.apmTracingEnabled !== false) return
 
   startCh.subscribe(onSpanStart)
-  injectCh.subscribe(onSpanInject)
   extractCh.subscribe(onSpanExtract)
 
   return new TraceSourcePrioritySampler(config.env)
@@ -38,24 +34,6 @@ function onSpanStart ({ span, fields }) {
   }
 }
 
-function onSpanInject ({ spanContext, carrier }) {
-  if (!spanContext?._trace?.tags || !carrier) return
-
-  // do not inject trace and sampling if there is no _dd.p.ts
-  if (!hasTraceSourcePropagationTag(spanContext._trace.tags)) {
-    for (const key in carrier) {
-      const lKey = key.toLowerCase()
-      if (lKey.startsWith('x-datadog') || lKey.startsWith('x-b3') || lKey === 'traceparent') {
-        delete carrier[key]
-      } else if (lKey === 'tracestate') {
-        const tracestate = TraceState.fromString(carrier[key])
-        tracestate.forVendor('dd', state => state.clear())
-        carrier[key] = tracestate.toString()
-      }
-    }
-  }
-}
-
 function onSpanExtract ({ spanContext = {} }) {
   if (!spanContext._trace?.tags || !spanContext._sampling) return