dd-trace 6.2.0 → 6.3.0

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

@@ -35,6 +35,7 @@ const {
   INTEGRATION,
   DECORATOR,
   PROPAGATED_ML_APP_KEY,
+  PROPAGATED_SESSION_ID_KEY,
   DEFAULT_PROMPT_NAME,
   INTERNAL_CONTEXT_VARIABLE_KEYS,
   INTERNAL_QUERY_VARIABLE_KEYS,
@@ -139,7 +140,8 @@ class LLMObsTagger {
     if (modelName) this.tagModelName(span, modelName)
     if (modelProvider) this._setTag(span, MODEL_PROVIDER, modelProvider)
 
-    sessionId = sessionId || registry.get(parent)?.[SESSION_ID]
+    const traceTags = span.context()._trace.tags
+    sessionId = sessionId || registry.get(parent)?.[SESSION_ID] || traceTags[PROPAGATED_SESSION_ID_KEY]
     if (sessionId) this._setTag(span, SESSION_ID, sessionId)
     if (integration) this._setTag(span, INTEGRATION, integration)
     if (_decorator) this._setTag(span, DECORATOR, _decorator)
@@ -752,6 +754,18 @@ class LLMObsTagger {
 
     const tagsCarrier = registry.get(span)
     tagsCarrier[key] = value
+
+    // The first session set in a trace becomes the trace-level default, stored on the trace-shared
+    // propagating tags so later spans (incl. those under a session-less parent) inherit it and it
+    // rides `x-datadog-tags` across service boundaries. Established here, the single choke point for
+    // session writes, so sessions post-populated by integrations after span start also seed it.
+    // First-writer wins, so an explicit session still overrides locally.
+    if (key === SESSION_ID && value) {
+      const traceTags = span.context()._trace.tags
+      if (traceTags[PROPAGATED_SESSION_ID_KEY] === undefined) {
+        traceTags[PROPAGATED_SESSION_ID_KEY] = value
+      }
+    }
   }
 }
 

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

@@ -14,32 +14,34 @@ class NoopSpanProcessor {
 }
 
 class MultiSpanProcessor extends NoopSpanProcessor {
+  #processors
+
   constructor (spanProcessors) {
     super()
-    this._processors = spanProcessors
+    this.#processors = spanProcessors
   }
 
   forceFlush () {
     return Promise.all(
-      this._processors.map(p => p.forceFlush())
+      this.#processors.map(p => p.forceFlush())
     )
   }
 
   onStart (span, context) {
-    for (const processor of this._processors) {
+    for (const processor of this.#processors) {
       processor.onStart(span, context)
     }
   }
 
   onEnd (span) {
-    for (const processor of this._processors) {
+    for (const processor of this.#processors) {
       processor.onEnd(span)
     }
   }
 
   shutdown () {
     return Promise.all(
-      this._processors.map(p => p.shutdown())
+      this.#processors.map(p => p.shutdown())
     )
   }
 }

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

@@ -10,46 +10,62 @@ const { MultiSpanProcessor, NoopSpanProcessor } = require('./span_processor')
 const Tracer = require('./tracer')
 
 class TracerProvider {
+  #activeProcessor = new NoopSpanProcessor()
+  #contextManager = new ContextManager()
+  #processors = []
+  #tracers = new Map()
+
   constructor (config = {}) {
     this.config = config
     this.resource = config.resource
 
-    this._processors = []
-    this._tracers = new Map()
-    this._activeProcessor = new NoopSpanProcessor()
-    this._contextManager = new ContextManager()
+    // @opentelemetry/sdk-trace 2.x (used by @opentelemetry/sdk-node 0.220+)
+    // dropped `addSpanProcessor` and hands the processors to the provider
+    // constructor instead. Wire them the same way the 1.x `addSpanProcessor`
+    // path does, so a NodeSDK configured with a trace exporter or custom
+    // processors still delivers onStart/onEnd to them.
+    if (Array.isArray(config.spanProcessors)) {
+      for (const spanProcessor of config.spanProcessors) {
+        this.addSpanProcessor(spanProcessor)
+      }
+    }
   }
 
   getTracer (name = 'opentelemetry', version = '0.0.0', options) {
     const key = `${name}@${version}`
-    if (!this._tracers.has(key)) {
-      this._tracers.set(key, new Tracer(
+    if (!this.#tracers.has(key)) {
+      this.#tracers.set(key, new Tracer(
         { ...options, name, version },
         this.config,
         this
       ))
     }
-    return this._tracers.get(key)
+    return this.#tracers.get(key)
   }
 
+  /**
+   * @param {NoopSpanProcessor} spanProcessor
+   */
   addSpanProcessor (spanProcessor) {
-    if (!this._processors.length) {
-      this._activeProcessor.shutdown()
+    if (this.#processors.includes(spanProcessor)) return
+
+    if (!this.#processors.length) {
+      this.#activeProcessor.shutdown()
     }
-    this._processors.push(spanProcessor)
-    this._activeProcessor = new MultiSpanProcessor(
-      this._processors
+    this.#processors.push(spanProcessor)
+    this.#activeProcessor = new MultiSpanProcessor(
+      this.#processors
     )
   }
 
   getActiveSpanProcessor () {
-    return this._activeProcessor
+    return this.#activeProcessor
   }
 
   // Not actually required by the SDK spec, but the official Node.js SDK does
   // this and the docs reflect that so we should do this too for familiarity.
   register (config = {}) {
-    context.setGlobalContextManager(this._contextManager)
+    context.setGlobalContextManager(this.#contextManager)
     if (!trace.setGlobalTracerProvider(this)) {
       trace.getTracerProvider().setDelegate(this)
     }
@@ -69,11 +85,11 @@ class TracerProvider {
     }
 
     exporter._writer?.flush()
-    return this._activeProcessor.forceFlush()
+    return this.#activeProcessor.forceFlush()
   }
 
   shutdown () {
-    return this._activeProcessor.shutdown()
+    return this.#activeProcessor.shutdown()
   }
 }
 

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

@@ -7,10 +7,16 @@ const os = require('os')
 const process = require('process')
 const { performance, PerformanceObserver, monitorEventLoopDelay } = require('perf_hooks')
 const log = require('../log')
-const { NODE_MAJOR } = require('../../../../version')
+const { NODE_MAJOR, NODE_MINOR } = require('../../../../version')
 const { createMetricsClient } = require('./client')
 
 const eventLoopDelayResolution = 4
+const EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE = NODE_MAJOR > 26 || (NODE_MAJOR === 26 && NODE_MINOR >= 5)
+
+// @datadog/native-metrics is only needed on Node versions where
+// monitorEventLoopDelay's samplePerIteration option is unavailable.
+// TODO: remove @datadog/native-metrics and this branch once Node < 26.5 is no longer supported.
+const NATIVE_METRICS_REQUIRED = !EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE
 
 let nativeMetrics = null
 let gcObserver = null
@@ -45,7 +51,10 @@ module.exports = {
       startGCObserver()
     }
 
-    const useNative = config.runtimeMetrics.native !== false
+    // When per-iteration sampling is available we prefer it over the native
+    // addon: it provides accurate event loop delay measurements and lets us
+    // collect CPU/GC/heap metrics entirely from JS APIs.
+    const useNative = NATIVE_METRICS_REQUIRED && config.runtimeMetrics.native !== false
 
     if (useNative) {
       // Using no-gc prevents the native gc metrics from being tracked. Not
@@ -74,7 +83,10 @@ module.exports = {
       lastCpuUsage = process.cpuUsage()
 
       if (trackEventLoop) {
-        eventLoopDelayObserver = monitorEventLoopDelay({ resolution: eventLoopDelayResolution })
+        eventLoopDelayObserver = monitorEventLoopDelay({
+          resolution: eventLoopDelayResolution,
+          samplePerIteration: EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE,
+        })
         eventLoopDelayObserver.enable()
       }
 
@@ -83,11 +95,6 @@ module.exports = {
         captureCommonMetrics(trackEventLoop)
         captureHeapSpace()
         if (trackEventLoop) {
-          // Experimental: The Node.js implementation deviates from the native metrics.
-          // We normalize the metrics to the same format but the Node.js values
-          // are that way lower than they should be, while they are still nearer
-          // to the native ones that way.
-          // We use these only as fallback values.
           captureEventLoopDelay()
         }
         client.flush()
@@ -195,12 +202,14 @@ function captureEventLoopDelay () {
   eventLoopDelayObserver.disable()
 
   if (eventLoopDelayObserver.count !== 0) {
-    const minimum = eventLoopDelayResolution * 1e6
+    // Node.js versions without iteration-based metrics use the default sampling method,
+    // which is interval-based and requires normalization because its values are much smaller
+    // than those from the original native implementation and iteration-based metrics.
+    const minimum = EVENT_LOOP_SAMPLE_PER_ITERATION_AVAILABLE ? 0 : eventLoopDelayResolution * 1e6
     const avg = Math.max(eventLoopDelayObserver.mean - minimum, 0)
     const sum = Math.round(avg * eventLoopDelayObserver.count)
 
     if (sum !== 0) {
-      // Normalize the metrics to the same format as the native metrics.
       const stats = {
         min: Math.max(eventLoopDelayObserver.min - minimum, 0),
         max: Math.max(eventLoopDelayObserver.max - minimum, 0),
@@ -214,7 +223,7 @@ function captureEventLoopDelay () {
       histogram('runtime.node.event_loop.delay', stats)
     }
   }
-  eventLoopDelayObserver = monitorEventLoopDelay({ resolution: eventLoopDelayResolution })
+  eventLoopDelayObserver.reset()
   eventLoopDelayObserver.enable()
 }