dd-trace 5.99.1 → 5.101.0

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

@@ -8,11 +8,11 @@ const { threadId } = require('worker_threads')
 const log = require('./log')
 
 async function scheduleSnapshot (config, total) {
-  if (total > config.heapSnapshot.count) return
+  if (total > config.DD_HEAP_SNAPSHOT_COUNT) return
 
-  await setTimeout(config.heapSnapshot.interval * 1000, null, { ref: false })
+  await setTimeout(config.DD_HEAP_SNAPSHOT_INTERVAL * 1000, null, { ref: false })
   await clearMemory()
-  writeHeapSnapshot(getName(config.heapSnapshot.destination))
+  writeHeapSnapshot(getName(config.DD_HEAP_SNAPSHOT_DESTINATION))
   await scheduleSnapshot(config, total + 1)
 }
 
@@ -49,7 +49,7 @@ module.exports = {
    * @param {import('./config/config-base')} config - Tracer configuration
    */
   async start (config) {
-    const destination = config.heapSnapshot.destination
+    const destination = config.DD_HEAP_SNAPSHOT_DESTINATION
 
     try {
       await scheduleSnapshot(config, 1)

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

@@ -7,19 +7,19 @@ const UINT_MAX = 4_294_967_296
 const data = new Uint8Array(8 * 8192)
 const zeroId = new Uint8Array(8)
 
-const map = Array.prototype.map
-const pad = byte => `${byte < 16 ? '0' : ''}${byte.toString(16)}`
-
 let batch = 0
 
 // Internal representation of a trace or span ID.
 class Identifier {
+  /** @type {number[] | Uint8Array} */
+  #buffer
+
   /**
    * @param {string} value
    * @param {number} [radix]
    */
   constructor (value, radix = 16) {
-    this._buffer = radix === 16
+    this.#buffer = radix === 16
       ? createBuffer(value)
       : fromString(value, radix)
   }
@@ -30,32 +30,32 @@ class Identifier {
    */
   toString (radix = 16) {
     return radix === 16
-      ? toHexString(this._buffer)
-      : toNumberString(this._buffer, radix)
+      ? Buffer.from(this.#buffer).toString('hex')
+      : toNumberString(this.#buffer, radix)
   }
 
   /**
    * @returns {bigint}
    */
   toBigInt () {
-    return Buffer.from(this._buffer).readBigUInt64BE(0)
+    return Buffer.from(this.#buffer).readBigUInt64BE(0)
   }
 
   /**
    * @returns {number[] | Uint8Array}
    */
   toBuffer () {
-    return this._buffer
+    return this.#buffer
   }
 
   /**
    * @returns {number[] | Uint8Array}
    */
   toArray () {
-    if (this._buffer.length === 8) {
-      return this._buffer
+    if (this.#buffer.length === 8) {
+      return this.#buffer
     }
-    return this._buffer.slice(-8)
+    return this.#buffer.slice(-8)
   }
 
   /**
@@ -70,12 +70,10 @@ class Identifier {
    * @returns {boolean}
    */
   equals (other) {
-    const length = this._buffer.length
-    const otherLength = other._buffer.length
-
-    // Only compare the bytes available in both IDs.
-    for (let i = length, j = otherLength; i >= 0 && j >= 0; i--, j--) {
-      if (this._buffer[i] !== other._buffer[j]) return false
+    // Big-endian suffix compare: when buffers differ in length, only the
+    // rightmost `min(this.length, other.length)` bytes are checked.
+    for (let i = this.#buffer.length - 1, j = other.#buffer.length - 1; i >= 0 && j >= 0; i--, j--) {
+      if (this.#buffer[i] !== other.#buffer[j]) return false
     }
 
     return true
@@ -174,15 +172,6 @@ function toNumberString (buffer, radix) {
   return str
 }
 
-// Convert a buffer to a hexadecimal string.
-/**
- * @param {number[] | Uint8Array} buffer
- * @returns {string}
- */
-function toHexString (buffer) {
-  return map.call(buffer, pad).join('')
-}
-
 // Simple pseudo-random 64-bit ID generator.
 /**
  * @returns {number[] | Uint8Array}

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -7,7 +7,9 @@ module.exports = {
   DECORATOR: '_ml_obs.decorator',
   INTEGRATION: '_ml_obs.integration',
   METADATA: '_ml_obs.meta.metadata',
+  COST_TAGS: '_ml_obs.meta.metadata._dd.cost_tags',
   METRICS: '_ml_obs.metrics',
+  TOOL_DEFINITIONS: '_ml_obs.meta.tool_definitions',
   ML_APP: '_ml_obs.meta.ml_app',
   PROPAGATED_PARENT_ID_KEY: '_dd.p.llmobs_parent_id',
   PROPAGATED_ML_APP_KEY: '_dd.p.llmobs_ml_app',

package/packages/dd-trace/src/llmobs/plugins/anthropic/index.js

@@ -1,6 +1,7 @@
 'use strict'
 
 const { UNKNOWN_MODEL_PROVIDER } = require('../../constants/tags')
+const { safeJsonParse } = require('../../util')
 const LLMObsPlugin = require('../base')
 const { appendMessage } = require('./util')
 
@@ -47,6 +48,8 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
             const { type } = contentBlock
             if (type === 'text') {
               response.content.push({ type, text: contentBlock.text })
+            } else if (type === 'thinking') {
+              response.content.push({ type, thinking: contentBlock.thinking ?? '' })
             } else if (type === 'tool_use') {
               response.content.push({ type, name: contentBlock.name, input: '', id: contentBlock.id })
             }
@@ -56,20 +59,29 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
             const { delta } = chunk
             if (!delta) continue
 
-            const { text } = delta
-            if (text) response.content[response.content.length - 1].text += text
-
-            const partialJson = delta.partial_json
-            if (partialJson && delta.type === 'input_json_delta') {
-              response.content[response.content.length - 1].input += partialJson
+            const lastBlock = response.content[response.content.length - 1]
+            if (!lastBlock) continue
+
+            if (delta.type === 'thinking_delta') {
+              const { thinking } = delta
+              if (thinking) lastBlock.thinking += thinking
+            } else if (delta.type === 'signature_delta') {
+              // Signature is for internal verification only; skip it.
+            } else if (delta.type === 'input_json_delta') {
+              const partialJson = delta.partial_json
+              if (partialJson) lastBlock.input += partialJson
+            } else {
+              const { text } = delta
+              if (text) lastBlock.text += text
             }
             break
           }
           case 'content_block_stop': {
-            const type = response.content[response.content.length - 1].type
-            if (type === 'tool_use') {
-              const input = response.content[response.content.length - 1].input ?? '{}'
-              response.content[response.content.length - 1].input = JSON.parse(input)
+            const lastBlock = response.content[response.content.length - 1]
+            if (!lastBlock) break
+            if (lastBlock.type === 'tool_use') {
+              const input = lastBlock.input ?? '{}'
+              lastBlock.input = safeJsonParse(input, {})
             }
             break
           }
@@ -167,18 +179,17 @@ class AnthropicLLMObsPlugin extends LLMObsPlugin {
 
     const outputMessages = []
     for (const block of content) {
+      if (block.type === 'thinking') {
+        outputMessages.push({ content: block.thinking ?? '', role: 'reasoning' })
+        continue
+      }
       const { text } = block
       if (typeof text === 'string') {
         outputMessages.push({ content: text, role })
       } else if (block.type === 'tool_use') {
-        let input = block.input
-        if (typeof input === 'string') {
-          input = JSON.parse(input)
-        }
-
         const toolCall = {
           name: block.name,
-          arguments: input,
+          arguments: safeJsonParse(block.input, {}),
           toolId: block.id,
           type: block.type,
         }

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

@@ -3,6 +3,7 @@
 /**
  * @typedef {{type: 'text', text: string}} TextBlock
  * @typedef {{type: 'image'}} ImageBlock
+ * @typedef {{type: 'thinking', thinking: string, signature?: string}} ThinkingBlock
  * @typedef {{
  *  type: 'tool_use', text: string, name: string, id: string, input: string | Record<string, unknown>
  * }} ToolUseBlock
@@ -70,6 +71,8 @@ function appendMessage (messages, { role, content }) {
       messages.push({ content: block.text, role })
     } else if (block.type === 'image') {
       messages.push({ content: '([IMAGE DETECTED])', role })
+    } else if (block.type === 'thinking') {
+      messages.push({ content: block.thinking ?? '', role: 'reasoning' })
     } else if (block.type === 'tool_use') {
       const { text, name, id, type } = block
       let input = block.input

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

@@ -237,15 +237,23 @@ function formatContentObject (content) {
     }
   }
 
-  // Check for function calls
-  const functionCalls = parts.filter(part => part.functionCall)
-  if (functionCalls.length > 0) {
+  // Two filter passes over `parts` collapse to a single walk. Most parts are
+  // text-only so neither bucket is allocated unless a matching part appears.
+  let functionCalls
+  let functionResponses
+  for (const part of parts) {
+    if (part.functionCall) {
+      (functionCalls ??= []).push(part)
+    } else if (part.functionResponse) {
+      (functionResponses ??= []).push(part)
+    }
+  }
+
+  if (functionCalls) {
     return formatFunctionCallMessage(parts, functionCalls, role)
   }
 
-  // Check for function responses
-  const functionResponses = parts.filter(part => part.functionResponse)
-  if (functionResponses.length > 0) {
+  if (functionResponses) {
     return formatFunctionResponseMessage(functionResponses, role)
   }
 
@@ -326,15 +334,26 @@ function formatNonStreamingCandidate (candidate) {
 
   const { parts } = content
 
-  // Check for function calls
-  const functionCalls = parts.filter(part => part.functionCall)
-  if (functionCalls.length > 0) {
+  // One walk replaces three (`filter` + two `find`); priority order is
+  // functionCall > executableCode > codeExecutionResult, same as before.
+  let functionCalls
+  let executableCode
+  let codeExecutionResult
+  for (const part of parts) {
+    if (part.functionCall) {
+      (functionCalls ??= []).push(part)
+    } else if (!executableCode && part.executableCode) {
+      executableCode = part
+    } else if (!codeExecutionResult && part.codeExecutionResult) {
+      codeExecutionResult = part
+    }
+  }
+
+  if (functionCalls) {
     messages.push(formatFunctionCallMessage(parts, functionCalls, ROLES.ASSISTANT))
     return messages
   }
 
-  // Check for executable code
-  const executableCode = parts.find(part => part.executableCode)
   if (executableCode) {
     messages.push({
       role: ROLES.ASSISTANT,
@@ -346,8 +365,6 @@ function formatNonStreamingCandidate (candidate) {
     return messages
   }
 
-  // Check for code execution result
-  const codeExecutionResult = parts.find(part => part.codeExecutionResult)
   if (codeExecutionResult) {
     messages.push({
       role: ROLES.ASSISTANT,

package/packages/dd-trace/src/llmobs/plugins/openai/index.js

@@ -7,6 +7,7 @@ const {
   INSTRUMENTATION_METHOD_AUTO,
   UNKNOWN_MODEL_PROVIDER,
 } = require('../../constants/tags')
+const { safeJsonParse } = require('../../util')
 const {
   extractChatTemplateFromInstructions,
   normalizePromptVariables,
@@ -183,13 +184,12 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
   _tagChatCompletion (span, inputs, response, error) {
     const { messages, model, ...parameters } = inputs
 
-    const metadata = Object.entries(parameters).reduce((obj, [key, value]) => {
-      if (!['tools', 'functions'].includes(key)) {
-        obj[key] = value
+    const metadata = {}
+    for (const key of Object.keys(parameters)) {
+      if (key !== 'tools' && key !== 'functions') {
+        metadata[key] = parameters[key]
       }
-
-      return obj
-    }, {})
+    }
 
     this._tagger.tagMetadata(span, metadata)
 
@@ -213,14 +213,14 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       if (message.function_call) {
         const functionCallInfo = {
           name: message.function_call.name,
-          arguments: JSON.parse(message.function_call.arguments),
+          arguments: safeJsonParse(message.function_call.arguments),
         }
         outputMessages.push({ content, role, toolCalls: [functionCallInfo] })
       } else if (message.tool_calls) {
         const toolCallsInfo = []
         for (const toolCall of message.tool_calls) {
           const toolCallInfo = {
-            arguments: JSON.parse(toolCall.function.arguments),
+            arguments: safeJsonParse(toolCall.function.arguments),
             name: toolCall.function.name,
             toolId: toolCall.id,
             type: toolCall.type,
@@ -277,22 +277,12 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
             inputMessages.push({ role, content })
           }
         } else if (item.type === 'function_call') {
-          // Function call: convert to message with tool_calls
-          // Parse arguments if it's a JSON string
-          let parsedArgs = item.arguments
-          if (typeof parsedArgs === 'string') {
-            try {
-              parsedArgs = JSON.parse(parsedArgs)
-            } catch {
-              parsedArgs = {}
-            }
-          }
           inputMessages.push({
             role: 'assistant',
             toolCalls: [{
               toolId: item.call_id,
               name: item.name,
-              arguments: parsedArgs,
+              arguments: safeJsonParse(item.arguments, {}),
               type: item.type,
             }],
           })
@@ -317,12 +307,12 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       inputMessages.push({ role: 'user', content: input })
     }
 
-    const inputMetadata = Object.entries(parameters).reduce((obj, [key, value]) => {
+    const inputMetadata = {}
+    for (const key of Object.keys(parameters)) {
       if (allowedParamKeys.has(key)) {
-        obj[key] = value
+        inputMetadata[key] = parameters[key]
       }
-      return obj
-    }, {})
+    }
 
     this._tagger.tagMetadata(span, inputMetadata)
 
@@ -354,21 +344,12 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
           })
         } else if (item.type === 'function_call') {
           // Handle function_call type (responses API tool calls)
-          let args = item.arguments
-          // Parse arguments if it's a JSON string
-          if (typeof args === 'string') {
-            try {
-              args = JSON.parse(args)
-            } catch {
-              args = {}
-            }
-          }
           outputMessages.push({
             role: 'assistant',
             toolCalls: [{
               toolId: item.call_id,
               name: item.name,
-              arguments: args,
+              arguments: safeJsonParse(item.arguments, {}),
               type: item.type,
             }],
           })
@@ -390,23 +371,12 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
 
           // Extract tool calls if present in message.tool_calls
           if (Array.isArray(item.tool_calls)) {
-            outputMsg.toolCalls = item.tool_calls.map(tc => {
-              let args = tc.function?.arguments || tc.arguments
-              // Parse arguments if it's a JSON string
-              if (typeof args === 'string') {
-                try {
-                  args = JSON.parse(args)
-                } catch {
-                  args = {}
-                }
-              }
-              return {
-                toolId: tc.id,
-                name: tc.function?.name || tc.name,
-                arguments: args,
-                type: tc.type || 'function_call',
-              }
-            })
+            outputMsg.toolCalls = item.tool_calls.map(tc => ({
+              toolId: tc.id,
+              name: tc.function?.name || tc.name,
+              arguments: safeJsonParse(tc.function?.arguments || tc.arguments, {}),
+              type: tc.type || 'function_call',
+            }))
           }
 
           outputMessages.push(outputMsg)

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

@@ -251,7 +251,7 @@ class LLMObs extends NoopLLMObs {
         throw new Error('LLMObs span must have a span kind specified')
       }
 
-      const { inputData, outputData, metadata, metrics, tags, prompt } = options
+      const { inputData, outputData, metadata, metrics, tags, prompt, costTags } = options
 
       if (inputData || outputData) {
         if (spanKind === 'llm') {
@@ -271,9 +271,13 @@ class LLMObs extends NoopLLMObs {
       if (metrics) {
         this._tagger.tagMetrics(span, metrics)
       }
+      // Apply tags before costTags so costTags can reference tags from the same annotation.
       if (tags) {
         this._tagger.tagSpanTags(span, tags)
       }
+      if (costTags != null) {
+        this._tagger.tagCostTags(span, costTags, 'annotate')
+      }
       if (prompt) {
         this._tagger.tagPrompt(span, prompt)
       }

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

@@ -14,6 +14,8 @@ const {
   MODEL_NAME,
   MODEL_PROVIDER,
   METADATA,
+  COST_TAGS,
+  TOOL_DEFINITIONS,
   INPUT_MESSAGES,
   INPUT_VALUE,
   INTEGRATION,
@@ -130,8 +132,20 @@ class LLMObsSpanProcessor {
       meta.model_provider = (mlObsTags[MODEL_PROVIDER] || 'custom').toLowerCase()
     }
 
-    if (mlObsTags[METADATA]) {
-      this.#addObject(mlObsTags[METADATA], meta.metadata = {})
+    if (mlObsTags[METADATA] || mlObsTags[COST_TAGS]) {
+      const metadata = {}
+      if (mlObsTags[METADATA]) this.#addObject(mlObsTags[METADATA], metadata)
+      // Only seed `metadata._dd` when there's something to put in it (currently cost_tags). Mirrors
+      // dd-trace-py and the cross-language wire format enforced by system-tests — metadata-only
+      // spans must not carry an empty `_dd: {}` block.
+      if (mlObsTags[COST_TAGS]) {
+        this.#getDdMetadata(metadata).cost_tags = mlObsTags[COST_TAGS]
+      }
+      meta.metadata = metadata
+    }
+
+    if (mlObsTags[TOOL_DEFINITIONS]) {
+      this.#addObject(mlObsTags[TOOL_DEFINITIONS], meta.tool_definitions = [])
     }
 
     if (spanKind === 'llm' && mlObsTags[INPUT_MESSAGES]) {
@@ -259,6 +273,18 @@ class LLMObsSpanProcessor {
     add(obj, carrier)
   }
 
+  /**
+   * Returns `metadata._dd`, normalizing it to a fresh object if missing or invalid.
+   * @param {Record<string, unknown>} metadata
+   * @returns {Record<string, unknown>}
+   */
+  #getDdMetadata (metadata) {
+    if (!metadata._dd || typeof metadata._dd !== 'object' || Array.isArray(metadata._dd)) {
+      metadata._dd = {}
+    }
+    return metadata._dd
+  }
+
   #getTags (span, mlApp, sessionId, error) {
     let tags = {
       ...this.#config.parsedDdTags,

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

@@ -12,7 +12,9 @@ const {
   INPUT_DOCUMENTS,
   OUTPUT_VALUE,
   METADATA,
+  COST_TAGS,
   METRICS,
+  TOOL_DEFINITIONS,
   PARENT_ID_KEY,
   INPUT_MESSAGES,
   OUTPUT_MESSAGES,
@@ -41,6 +43,7 @@ const {
   INSTRUMENTATION_METHOD_ANNOTATED,
 } = require('./constants/tags')
 const { storage } = require('./storage')
+const { validateCostTags } = require('./util')
 
 // global registry of LLMObs spans
 // maps LLMObs spans to their annotations
@@ -120,6 +123,11 @@ class LLMObsTagger {
     const tags = annotationContext?.tags
     if (tags) this.tagSpanTags(span, tags)
 
+    // apply after tags so only keys present at span start are accepted.
+    if (annotationContext?.costTags != null) {
+      this.tagCostTags(span, annotationContext.costTags, 'annotation_context')
+    }
+
     // apply annotation context name
     const annotationContextName = annotationContext?.name
     if (annotationContextName) this._setTag(span, NAME, annotationContextName)
@@ -159,6 +167,14 @@ class LLMObsTagger {
     this.#tagText(span, outputData, OUTPUT_VALUE)
   }
 
+  tagToolDefinitions (span, toolDefinitions) {
+    if (Array.isArray(toolDefinitions) && toolDefinitions.length > 0) {
+      this._setTag(span, TOOL_DEFINITIONS, toolDefinitions)
+    } else {
+      this.#handleFailure('Tool definitions must be a non-empty array.', 'invalid_tool_definitions')
+    }
+  }
+
   tagMetadata (span, metadata) {
     const existingMetadata = registry.get(span)?.[METADATA]
     if (existingMetadata) {
@@ -225,6 +241,32 @@ class LLMObsTagger {
     }
   }
 
+  /**
+   * Validates and tags cost tag keys on an LLMObs span. Cost tag references are validated against
+   * the span's already-applied tags, which are read from the registry.
+   * @param {import('../opentracing/span')} span
+   * @param {unknown} costTags Raw user-provided cost tags; validated here.
+   * @param {'annotate' | 'annotation_context'} source
+   */
+  tagCostTags (span, costTags, source) {
+    const spanTags = registry.get(span)?.[TAGS] || {}
+    const validatedCostTags = validateCostTags(span, costTags, source, spanTags)
+    if (!validatedCostTags.length) return
+
+    // Might consider switching to a `Set` if per-span cost tag cardinality grows large enough that
+    // this `.includes`/`.push` merge becomes a hot spot
+    const currentCostTags = registry.get(span)?.[COST_TAGS]
+    if (currentCostTags) {
+      for (const costTag of validatedCostTags) {
+        if (!currentCostTags.includes(costTag)) {
+          currentCostTags.push(costTag)
+        }
+      }
+    } else {
+      this._setTag(span, COST_TAGS, validatedCostTags)
+    }
+  }
+
   /**
    * Tags a prompt on an LLMObs span.
    * @param {import('../opentracing/span')} span

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

@@ -6,6 +6,7 @@ const telemetryMetrics = require('../telemetry/metrics')
 const {
   SPAN_KIND,
   MODEL_PROVIDER,
+  ML_APP,
   PARENT_ID_KEY,
   SESSION_ID,
   ROOT_PARENT_ID,
@@ -123,6 +124,32 @@ function recordLLMObsAnnotate (span, err, value = 1) {
   llmobsMetrics.count('annotations', tags).inc(value)
 }
 
+function recordCostTagsAnnotated (span, source, value = 1) {
+  const mlObsTags = LLMObsTagger.tagMap.get(span) || {}
+  const tags = {
+    span_kind: mlObsTags[SPAN_KIND] || 'N/A',
+    source,
+    ml_app: mlObsTags[ML_APP] || 'N/A',
+    model_provider: mlObsTags[MODEL_PROVIDER] || 'N/A',
+  }
+
+  llmobsMetrics.count('cost_tags.annotated', tags).inc(value)
+}
+
+function recordCostTagsSubmitted (span, count, source, state, reason = 'none') {
+  const mlObsTags = LLMObsTagger.tagMap.get(span) || {}
+  const tags = {
+    span_kind: mlObsTags[SPAN_KIND] || 'N/A',
+    source,
+    ml_app: mlObsTags[ML_APP] || 'N/A',
+    model_provider: mlObsTags[MODEL_PROVIDER] || 'N/A',
+    state,
+    reason,
+  }
+
+  llmobsMetrics.count('cost_tags.submitted', tags).inc(count)
+}
+
 function recordUserFlush (err, value = 1) {
   const tags = { error: Number(!!err) }
   if (err) tags.error_type = err
@@ -167,6 +194,8 @@ module.exports = {
   recordLLMObsSpanSize,
   recordDroppedPayload,
   recordLLMObsAnnotate,
+  recordCostTagsAnnotated,
+  recordCostTagsSubmitted,
   recordUserFlush,
   recordExportSpan,
   recordSubmitEvaluation,