dd-trace 5.101.0 → 5.102.0

package/packages/dd-trace/src/encode/0.5.js

@@ -1,17 +1,18 @@
 'use strict'
 
 const { normalizeSpan } = require('./tags-processors')
-const { AgentEncoder: BaseEncoder } = require('./0.4')
+const { AgentEncoder: BaseEncoder, stringifySpanEvents } = require('./0.4')
 
 const ARRAY_OF_TWO = 0x92
 const ARRAY_OF_TWELVE = 0x9C
 
 function formatSpan (span) {
   span = normalizeSpan(span)
-  // ensure span events are encoded as tags
+  // v0.5 has no native span_events slot; always serialize as a meta tag.
   if (span.span_events) {
-    span.meta.events = JSON.stringify(span.span_events)
-    delete span.span_events
+    span.meta.events = stringifySpanEvents(span.span_events)
+    // `= undefined` over `delete` to keep the span's hidden class.
+    span.span_events = undefined
   }
   return span
 }
@@ -55,12 +56,17 @@ class AgentEncoder extends BaseEncoder {
   }
 
   _encodeString (bytes, value = '') {
-    this._cacheString(value)
-    this._encodeInteger(bytes, this._stringMap[value])
+    let index = this._stringMap[value]
+    if (index === undefined) {
+      index = this._stringCount++
+      this._stringMap[value] = index
+      this._stringBytes.write(value)
+    }
+    this._encodeInteger(bytes, index)
   }
 
   _cacheString (value) {
-    if (!(value in this._stringMap)) {
+    if (this._stringMap[value] === undefined) {
       this._stringMap[value] = this._stringCount++
       this._stringBytes.write(value)
     }

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

@@ -41,8 +41,7 @@ const VERCEL_AI_GENERATION_METADATA_PREFIX = 'ai.settings.'
  */
 function getSpanTags (ctx) {
   const span = ctx.currentStore?.span
-  const carrier = ctx.attributes ?? span?.context()._tags ?? {}
-  return /** @type {SpanTags} */ (carrier)
+  return /** @type {SpanTags} */ (ctx.attributes ?? span?.context()._tags ?? {})
 }
 
 /**

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/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/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/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_dsm.js

@@ -16,7 +16,7 @@ class DSMTextMapPropagator {
   inject (ctx, carrier) {
     if (!this.config.dsmEnabled) return
 
-    this._injectDatadogDSMContext(ctx, carrier)
+    DsmPathwayCodec.encode(ctx, carrier)
 
     // eslint-disable-next-line eslint-rules/eslint-log-printf-style
     log.debug(() => `Inject into carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
@@ -25,7 +25,7 @@ class DSMTextMapPropagator {
   extract (carrier) {
     if (!this.config.dsmEnabled) return
 
-    const dsmContext = this._extractDatadogDSMContext(carrier)
+    const dsmContext = DsmPathwayCodec.decode(carrier)
 
     if (!dsmContext) return dsmContext
 
@@ -33,15 +33,6 @@ class DSMTextMapPropagator {
     log.debug(() => `Extract from carrier (DSM): ${JSON.stringify(pick(carrier, logKeys))}.`)
     return dsmContext
   }
-
-  _injectDatadogDSMContext (ctx, carrier) {
-    DsmPathwayCodec.encode(ctx, carrier)
-  }
-
-  _extractDatadogDSMContext (carrier) {
-    const ctx = DsmPathwayCodec.decode(carrier)
-    return ctx
-  }
 }
 
 module.exports = DSMTextMapPropagator

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

@@ -650,7 +650,7 @@ module.exports = {
         [GIT_TAG]: BITBUCKET_TAG,
         [GIT_REPOSITORY_URL]: BITBUCKET_GIT_SSH_ORIGIN || BITBUCKET_GIT_HTTP_ORIGIN,
         [CI_WORKSPACE_PATH]: BITBUCKET_CLONE_DIR,
-        [CI_PIPELINE_ID]: BITBUCKET_PIPELINE_UUID && BITBUCKET_PIPELINE_UUID.replaceAll(/{|}/gm, ''),
+        [CI_PIPELINE_ID]: BITBUCKET_PIPELINE_UUID && BITBUCKET_PIPELINE_UUID.replaceAll(/[{}]/gm, ''),
         [GIT_PULL_REQUEST_BASE_BRANCH]: BITBUCKET_PR_DESTINATION_BRANCH,
         [PR_NUMBER]: BITBUCKET_PR_ID,
       }

package/packages/dd-trace/src/plugins/util/git-cache.js

@@ -53,14 +53,12 @@ function getCache (cacheKey) {
   try {
     const cacheFilePath = getCacheFilePath(cacheKey)
     if (!fs.existsSync(cacheFilePath)) {
-      return null
+      return
     }
 
-    const content = fs.readFileSync(cacheFilePath, 'utf8')
-    return content
+    return fs.readFileSync(cacheFilePath, 'utf8')
   } catch (err) {
     log.error('Failed to read git cache', err)
-    return null
   }
 }
 
@@ -87,7 +85,7 @@ function cachedExec (cmd, flags, options) {
   }
   const cacheKey = getCacheKey(cmd, flags)
   const cachedResult = getCache(cacheKey)
-  if (cachedResult !== null) {
+  if (cachedResult !== undefined) {
     if (cachedResult.startsWith('__GIT_COMMAND_FAILED__')) {
       let error
       try {