dd-trace 5.101.0 → 5.103.0

package/packages/dd-trace/src/llmobs/plugins/genai/util.js

@@ -243,9 +243,11 @@ function formatContentObject (content) {
   let functionResponses
   for (const part of parts) {
     if (part.functionCall) {
-      (functionCalls ??= []).push(part)
+      functionCalls ??= []
+      functionCalls.push(part)
     } else if (part.functionResponse) {
-      (functionResponses ??= []).push(part)
+      functionResponses ??= []
+      functionResponses.push(part)
     }
   }
 
@@ -341,7 +343,8 @@ function formatNonStreamingCandidate (candidate) {
   let codeExecutionResult
   for (const part of parts) {
     if (part.functionCall) {
-      (functionCalls ??= []).push(part)
+      functionCalls ??= []
+      functionCalls.push(part)
     } else if (!executableCode && part.executableCode) {
       executableCode = part
     } else if (!codeExecutionResult && part.codeExecutionResult) {

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

@@ -112,16 +112,16 @@ class LLMObs extends NoopLLMObs {
     const {
       spanOptions,
       ...llmobsOptions
-    } = this._extractOptions(options)
+    } = this.#extractOptions(options)
 
     if (fn.length > 1) {
       return this._tracer.trace(name, spanOptions, (span, cb) =>
-        this._activate(span, { kind, ...llmobsOptions }, () => fn(span, cb))
+        this.#activate(span, { kind, ...llmobsOptions }, () => fn(span, cb))
       )
     }
 
     return this._tracer.trace(name, spanOptions, span =>
-      this._activate(span, { kind, ...llmobsOptions }, () => fn(span))
+      this.#activate(span, { kind, ...llmobsOptions }, () => fn(span))
     )
   }
 
@@ -142,53 +142,53 @@ class LLMObs extends NoopLLMObs {
     const {
       spanOptions,
       ...llmobsOptions
-    } = this._extractOptions(options)
+    } = this.#extractOptions(options)
 
     const llmobs = this
 
-    function wrapped () {
+    function wrapped (...args) {
       telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: false, kind })
 
       const span = llmobs._tracer.scope().active()
-      const fnArgs = arguments
+      const fnArgs = args
 
       const lastArgId = fnArgs.length - 1
       const cb = fnArgs[lastArgId]
       const hasCallback = typeof cb === 'function'
 
       if (hasCallback) {
-        const scopeBoundCb = llmobs._bind(cb)
-        fnArgs[lastArgId] = function () {
+        const scopeBoundCb = llmobs.#bind(cb)
+        fnArgs[lastArgId] = function (...args) {
           // it is standard practice to follow the callback signature (err, result)
           // however, we try to parse the arguments to determine if the first argument is an error
           // if it is not, and is not undefined, we will use that for the output value
-          const maybeError = arguments[0]
-          const maybeResult = arguments[1]
+          const maybeError = args[0]
+          const maybeResult = args[1]
 
-          llmobs._autoAnnotate(
+          llmobs.#autoAnnotate(
             span,
             kind,
             getFunctionArguments(fn, fnArgs),
             isError(maybeError) || maybeError == null ? maybeResult : maybeError
           )
 
-          return scopeBoundCb.apply(this, arguments)
+          return scopeBoundCb.apply(this, args)
         }
       }
 
       try {
-        const result = llmobs._activate(span, { kind, ...llmobsOptions }, () => fn.apply(this, fnArgs))
+        const result = llmobs.#activate(span, { kind, ...llmobsOptions }, () => fn.apply(this, fnArgs))
 
         if (result && typeof result.then === 'function') {
           return result.then(
             value => {
               if (!hasCallback) {
-                llmobs._autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs), value)
+                llmobs.#autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs), value)
               }
               return value
             },
             err => {
-              llmobs._autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs))
+              llmobs.#autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs))
               throw err
             }
           )
@@ -199,12 +199,12 @@ class LLMObs extends NoopLLMObs {
         // the callback is called before the function returns (although unlikely)
         // we do not want to throw for "annotating a finished span" in this case
         if (!hasCallback) {
-          llmobs._autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs), result)
+          llmobs.#autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs), result)
         }
 
         return result
       } catch (e) {
-        llmobs._autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs))
+        llmobs.#autoAnnotate(span, kind, getFunctionArguments(fn, fnArgs))
         throw e
       }
     }
@@ -516,7 +516,7 @@ class LLMObs extends NoopLLMObs {
     flushCh.publish()
   }
 
-  _autoAnnotate (span, kind, input, output) {
+  #autoAnnotate (span, kind, input, output) {
     const annotations = {}
     if (input && !['llm', 'embedding'].includes(kind) && !LLMObsTagger.tagMap.get(span)?.[INPUT_VALUE]) {
       annotations.inputData = input
@@ -534,7 +534,7 @@ class LLMObs extends NoopLLMObs {
     return store?.span
   }
 
-  _activate (span, options, fn) {
+  #activate (span, options, fn) {
     const parentStore = storage.getStore()
     if (this.enabled) storage.enterWith({ ...parentStore, span })
 
@@ -567,22 +567,20 @@ class LLMObs extends NoopLLMObs {
   }
 
   // bind function to active LLMObs span
-  _bind (fn) {
+  #bind (fn) {
     if (typeof fn !== 'function') return fn
 
     const llmobs = this
     const activeSpan = llmobs._active()
 
-    const bound = function () {
-      return llmobs._activate(activeSpan, null, () => {
-        return fn.apply(this, arguments)
+    return function (...args) {
+      return llmobs.#activate(activeSpan, null, () => {
+        return fn.apply(this, args)
       })
     }
-
-    return bound
   }
 
-  _extractOptions (options) {
+  #extractOptions (options) {
     const {
       modelName,
       modelProvider,

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

@@ -39,10 +39,16 @@ const telemetry = require('./telemetry')
 const LLMObsTagger = require('./tagger')
 
 class LLMObservabilitySpan {
-  constructor () {
+  /**
+   * @param {string} kind span kind
+   */
+  constructor (kind) {
     this.input = []
     this.output = []
 
+    /** @type {string} */
+    this.kind = kind
+
     this._tags = {}
   }
 
@@ -115,7 +121,6 @@ class LLMObsSpanProcessor {
   }
 
   format (span) {
-    const llmObsSpan = new LLMObservabilitySpan()
     let inputType, outputType
 
     const spanTags = span.context()._tags
@@ -145,14 +150,18 @@ class LLMObsSpanProcessor {
     }
 
     if (mlObsTags[TOOL_DEFINITIONS]) {
-      this.#addObject(mlObsTags[TOOL_DEFINITIONS], meta.tool_definitions = [])
+      meta.tool_definitions = []
+      this.#addObject(mlObsTags[TOOL_DEFINITIONS], meta.tool_definitions)
     }
 
+    const llmObsSpan = new LLMObservabilitySpan(spanKind)
+
     if (spanKind === 'llm' && mlObsTags[INPUT_MESSAGES]) {
       llmObsSpan.input = mlObsTags[INPUT_MESSAGES]
       inputType = 'messages'
     } else if (spanKind === 'embedding' && mlObsTags[INPUT_DOCUMENTS]) {
-      input.documents = mlObsTags[INPUT_DOCUMENTS]
+      llmObsSpan.input = mlObsTags[INPUT_DOCUMENTS].map(doc => ({ content: doc.text, role: '' }))
+      inputType = 'documents'
     } else if (mlObsTags[INPUT_VALUE]) {
       llmObsSpan.input = [{ role: '', content: mlObsTags[INPUT_VALUE] }]
       inputType = 'value'
@@ -162,7 +171,8 @@ class LLMObsSpanProcessor {
       llmObsSpan.output = mlObsTags[OUTPUT_MESSAGES]
       outputType = 'messages'
     } else if (spanKind === 'retrieval' && mlObsTags[OUTPUT_DOCUMENTS]) {
-      output.documents = mlObsTags[OUTPUT_DOCUMENTS]
+      llmObsSpan.output = mlObsTags[OUTPUT_DOCUMENTS].map(doc => ({ content: doc.text, role: '' }))
+      outputType = 'documents'
     } else if (mlObsTags[OUTPUT_VALUE]) {
       llmObsSpan.output = [{ role: '', content: mlObsTags[OUTPUT_VALUE] }]
       outputType = 'value'
@@ -194,6 +204,11 @@ class LLMObsSpanProcessor {
         input.messages = processedSpan.input
       } else if (inputType === 'value') {
         input.value = processedSpan.input[0].content
+      } else if (inputType === 'documents') {
+        input.documents = processedSpan.input.map((processedDocument, processedDocumentIdx) => ({
+          ...mlObsTags[INPUT_DOCUMENTS][processedDocumentIdx],
+          text: processedDocument.content,
+        }))
       }
     }
 
@@ -202,6 +217,11 @@ class LLMObsSpanProcessor {
         output.messages = processedSpan.output
       } else if (outputType === 'value') {
         output.value = processedSpan.output[0].content
+      } else if (outputType === 'documents') {
+        output.documents = processedSpan.output.map((processedDocument, processedDocumentIdx) => ({
+          ...mlObsTags[OUTPUT_DOCUMENTS][processedDocumentIdx],
+          text: processedDocument.content,
+        }))
       }
     }
 

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

@@ -12,6 +12,7 @@ function encodeUnicode (str = '') {
   for (let index = 0; index < str.length; index++) {
     if (str.charCodeAt(index) > 127) {
       let result = str.slice(0, index)
+      // eslint-disable-next-line sonarjs/updated-loop-counter -- inner loop continues from outer position
       for (; index < str.length; index++) {
         const code = str.charCodeAt(index)
         result += code > 127 ? String.raw`\u${code.toString(16).padStart(4, '0')}` : str[index]

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/msgpack/chunk.js

@@ -8,11 +8,13 @@ const DEFAULT_MIN_SIZE = 2 * 1024 * 1024 // 2MB
  * either.
  */
 class MsgpackChunk {
+  #minSize
+
   constructor (minSize = DEFAULT_MIN_SIZE) {
     this.buffer = Buffer.allocUnsafe(minSize)
     this.view = new DataView(this.buffer.buffer)
     this.length = 0
-    this._minSize = minSize
+    this.#minSize = minSize
   }
 
   write (value) {
@@ -50,13 +52,14 @@ class MsgpackChunk {
 
   reserve (size) {
     if (this.length + size > this.buffer.length) {
-      this._resize(this._minSize * Math.ceil((this.length + size) / this._minSize))
+      const minSize = this.#minSize
+      this.#resize(minSize * Math.ceil((this.length + size) / minSize))
     }
 
     this.length += size
   }
 
-  _resize (size) {
+  #resize (size) {
     const oldBuffer = this.buffer
 
     this.buffer = Buffer.allocUnsafe(size)

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

@@ -2,6 +2,18 @@
 
 const { NOOP_REASON } = require('./constants/constants')
 
+/**
+ * @template T
+ * @param {T} defaultValue
+ * @returns {Promise<{value: T, reason: string}>}
+ */
+function resolveDefault (defaultValue) {
+  return Promise.resolve({
+    value: defaultValue,
+    reason: NOOP_REASON,
+  })
+}
+
 /**
  * No-op implementation of OpenFeature provider that always returns default values.
  * Used when the OpenFeature provider is not initialized or disabled.
@@ -20,59 +32,51 @@ class NoopFlaggingProvider {
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {boolean} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: boolean, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveBooleanEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {string} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: string, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveStringEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {number} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: number, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveNumberEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**
-   * @param {string} flagKey - Flag key
-   * @param {object} defaultValue - Default value to return
-   * @param {object} context - Evaluation context
-   * @param {object} logger - Logger instance
-   * @returns {Promise<{value: object, reason: string}>} Resolution details
+   * @template T
+   * @param {string} flagKey
+   * @param {T} defaultValue
+   * @param {object} context
+   * @param {object} logger
+   * @returns {Promise<{value: T, reason: string}>}
    */
   resolveObjectEvaluation (flagKey, defaultValue, context, logger) {
-    return Promise.resolve({
-      value: defaultValue,
-      reason: NOOP_REASON,
-    })
+    return resolveDefault(defaultValue)
   }
 
   /**

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

@@ -43,7 +43,7 @@ const BaseFFEWriter = require('./base')
  */
 class ExposuresWriter extends BaseFFEWriter {
   /**
-   * @param {import('../../config')} config - Tracer configuration object
+   * @param {import('../../config/config-base')} config - Tracer configuration object
    */
   constructor (config) {
     // Build full EVP endpoint path
@@ -62,7 +62,19 @@ class ExposuresWriter extends BaseFFEWriter {
     })
     this._enabled = false // Start disabled until agent strategy is set
     this._pendingEvents = [] // Buffer events until enabled
-    this._context = this._buildContext()
+
+    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
   }
 
   /**
@@ -112,62 +124,31 @@ class ExposuresWriter extends BaseFFEWriter {
    * @returns {ExposureEventPayload} Formatted payload with service context
    */
   makePayload (events) {
-    const formattedEvents = events.map(event => this._formatExposureEvent(event))
+    const formattedEvents = events.map(event => {
+      return {
+        timestamp: event.timestamp || Date.now(),
+        allocation: {
+          key: event.allocation?.key || event['allocation.key'],
+        },
+        flag: {
+          key: event.flag?.key || event['flag.key'],
+        },
+        variant: {
+          key: event.variant?.key || event['variant.key'],
+        },
+        subject: {
+          id: event.subject?.id || event['subject.id'],
+          type: event.subject?.type,
+          attributes: event.subject?.attributes,
+        },
+      }
+    })
 
     return {
       context: this._context,
       exposures: formattedEvents,
     }
   }
-
-  /**
-   * Builds service context metadata
-   * @private
-   * @returns {ExposureContext} Service context
-   */
-  _buildContext () {
-    const context = {
-      service: this._config.service || 'unknown',
-    }
-
-    // Only include version and env if they are defined
-    if (this._config.version !== undefined) {
-      context.version = this._config.version
-    }
-
-    if (this._config.env !== undefined) {
-      context.env = this._config.env
-    }
-
-    return context
-  }
-
-  /**
-   * @private
-   * @param {ExposureEvent} event - Raw exposure event
-   * @returns {ExposureEvent} Formatted exposure event
-   */
-  _formatExposureEvent (event) {
-    // Ensure the event matches the expected schema
-    const formattedEvent = {
-      timestamp: event.timestamp || Date.now(),
-      allocation: {
-        key: event.allocation?.key || event['allocation.key'],
-      },
-      flag: {
-        key: event.flag?.key || event['flag.key'],
-      },
-      variant: {
-        key: event.variant?.key || event['variant.key'],
-      },
-      subject: {
-        id: event.subject?.id || event['subject.id'],
-        type: event.subject?.type,
-        attributes: event.subject?.attributes,
-      },
-    }
-    return formattedEvent
-  }
 }
 
 module.exports = ExposuresWriter

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?.()
   }
 
   /**

package/packages/dd-trace/src/opentelemetry/otlp/otlp_transformer_base.js

@@ -141,8 +141,7 @@ class OtlpTransformerBase {
    */
   serializeToProtobuf (protoType, data) {
     const message = protoType.create(data)
-    const buffer = protoType.encode(message).finish()
-    return buffer
+    return protoType.encode(message).finish()
   }
 
   /**

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

@@ -130,28 +130,6 @@ class Tracer {
     }
     const attributes = sanitizeAttributes(options.attributes)
 
-    // TODO: sampling API is not yet supported
-    // // make sampling decision
-    // const samplingResult = this._sampler.shouldSample(
-    //   context,
-    //   spanContext.traceId,
-    //   name,
-    //   spanKind,
-    //   attributes,
-    //   links
-    // )
-
-    // // Should use new span context
-    // spanContext._ddContext._sampling.priority =
-    //   samplingResult.decision === api.SamplingDecision.RECORD_AND_SAMPLED
-    //     ? AUTO_KEEP
-    //     : AUTO_REJECT
-
-    // if (samplingResult.decision === api.SamplingDecision.NOT_RECORD) {
-    //   api.diag.debug('Recording is off, propagating context in a non-recording span')
-    //   return api.trace.wrapSpanContext(spanContext)
-    // }
-
     return new Span(
       this,
       context,

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':