dd-trace 5.52.0 → 5.54.0

package/packages/dd-trace/src/llmobs/plugins/bedrockruntime.js

@@ -9,7 +9,7 @@ const {
   parseModelId
 } = require('../../../../datadog-plugin-aws-sdk/src/services/bedrockruntime/utils')
 
-const ENABLED_OPERATIONS = ['invokeModel']
+const ENABLED_OPERATIONS = new Set(['invokeModel'])
 
 const requestIdsToTokens = {}
 
@@ -21,7 +21,7 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       const request = response.request
       const operation = request.operation
       // avoids instrumenting other non supported runtime operations
-      if (!ENABLED_OPERATIONS.includes(operation)) {
+      if (!ENABLED_OPERATIONS.has(operation)) {
         return
       }
       const { modelProvider, modelName } = parseModelId(request.params.modelId)
@@ -40,8 +40,8 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       const outputTokenCount = headers['x-amzn-bedrock-output-token-count']
 
       requestIdsToTokens[requestId] = {
-        inputTokensFromHeaders: inputTokenCount && parseInt(inputTokenCount),
-        outputTokensFromHeaders: outputTokenCount && parseInt(outputTokenCount)
+        inputTokensFromHeaders: inputTokenCount && Number.parseInt(inputTokenCount),
+        outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount)
       }
     })
   }
@@ -64,8 +64,8 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
 
     // add metadata tags
     this._tagger.tagMetadata(span, {
-      temperature: parseFloat(requestParams.temperature) || 0.0,
-      max_tokens: parseInt(requestParams.maxTokens) || 0
+      temperature: Number.parseFloat(requestParams.temperature) || 0,
+      max_tokens: Number.parseInt(requestParams.maxTokens) || 0
     })
 
     // add I/O tags

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/chain.js

@@ -5,16 +5,12 @@ const { spanHasError } = require('../../../util')
 
 class LangChainLLMObsChainHandler extends LangChainLLMObsHandler {
   setMetaTags ({ span, inputs, results }) {
-    let input, output
+    let input
     if (inputs) {
       input = this.formatIO(inputs)
     }
 
-    if (!results || spanHasError(span)) {
-      output = ''
-    } else {
-      output = this.formatIO(results)
-    }
+    const output = !results || spanHasError(span) ? '' : this.formatIO(results)
 
     // chain spans will always be workflows
     this._tagger.tagTextIO(span, input, output)

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/chat_model.js

@@ -61,12 +61,12 @@ class LangChainLLMObsChatModelHandler extends LangChainLLMObsHandler {
 
         if (!isWorkflow && !tokensSetTopLevel) {
           const { tokens, runId } = this.checkTokenUsageFromAIMessage(chatCompletionMessage)
-          if (!tokensPerRunId[runId]) {
-            tokensPerRunId[runId] = tokens
-          } else {
+          if (tokensPerRunId[runId]) {
             tokensPerRunId[runId].inputTokens += tokens.inputTokens
             tokensPerRunId[runId].outputTokens += tokens.outputTokens
             tokensPerRunId[runId].totalTokens += tokens.totalTokens
+          } else {
+            tokensPerRunId[runId] = tokens
           }
         }
       }

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

@@ -9,8 +9,8 @@ const ANTHROPIC_PROVIDER_NAME = 'anthropic'
 const BEDROCK_PROVIDER_NAME = 'amazon_bedrock'
 const OPENAI_PROVIDER_NAME = 'openai'
 
-const SUPPORTED_INTEGRATIONS = ['openai']
-const LLM_SPAN_TYPES = ['llm', 'chat_model', 'embedding']
+const SUPPORTED_INTEGRATIONS = new Set(['openai'])
+const LLM_SPAN_TYPES = new Set(['llm', 'chat_model', 'embedding'])
 const LLM = 'llm'
 const WORKFLOW = 'workflow'
 const EMBEDDING = 'embedding'
@@ -94,18 +94,18 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
       span?.context()._tags[`langchain.request.${provider}.parameters.model_kwargs.max_tokens`]
 
     if (temperature) {
-      metadata.temperature = parseFloat(temperature)
+      metadata.temperature = Number.parseFloat(temperature)
     }
 
     if (maxTokens) {
-      metadata.maxTokens = parseInt(maxTokens)
+      metadata.maxTokens = Number.parseInt(maxTokens)
     }
 
     this._tagger.tagMetadata(span, metadata)
   }
 
   getKind (type, provider) {
-    if (LLM_SPAN_TYPES.includes(type)) {
+    if (LLM_SPAN_TYPES.has(type)) {
       const llmobsIntegration = this.getIntegrationName(type, provider)
 
       if (!this.isLLMIntegrationEnabled(llmobsIntegration)) {
@@ -129,7 +129,7 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
   }
 
   isLLMIntegrationEnabled (integration) {
-    return SUPPORTED_INTEGRATIONS.includes(integration) && pluginManager?._pluginsByName[integration]?.llmobs?._enabled
+    return SUPPORTED_INTEGRATIONS.has(integration) && pluginManager?._pluginsByName[integration]?.llmobs?._enabled
   }
 }
 

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

@@ -105,7 +105,7 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
     const embeddingInput = embeddingInputs.map(input => ({ text: input }))
 
     if (error) {
-      this._tagger.tagEmbeddingIO(span, embeddingInput, undefined)
+      this._tagger.tagEmbeddingIO(span, embeddingInput)
       return
     }
 

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

@@ -121,7 +121,7 @@ class LLMObs extends NoopLLMObs {
     }
 
     const kind = validateKind(options.kind) // will throw if kind is undefined or not an expected kind
-    let name = options.name || (fn?.name ? fn.name : undefined) || kind
+    let name = options.name || fn?.name || kind
 
     if (!name) {
       logger.warn('No span name provided for `wrap`. Defaulting to "unnamed-anonymous-function".')
@@ -285,7 +285,7 @@ class LLMObs extends NoopLLMObs {
       }
       if (!(span instanceof Span)) {
         err = 'invalid_span'
-        throw new Error('Span must be a valid Span object.')
+        throw new TypeError('Span must be a valid Span object.')
       }
       if (!LLMObsTagger.tagMap.has(span)) {
         err = 'invalid_span'

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

@@ -86,23 +86,23 @@ class LLMObsTagger {
   // TODO: similarly for the following `tag` methods,
   // how can we transition from a span weakmap to core API functionality
   tagLLMIO (span, inputData, outputData) {
-    this._tagMessages(span, inputData, INPUT_MESSAGES)
-    this._tagMessages(span, outputData, OUTPUT_MESSAGES)
+    this.#tagMessages(span, inputData, INPUT_MESSAGES)
+    this.#tagMessages(span, outputData, OUTPUT_MESSAGES)
   }
 
   tagEmbeddingIO (span, inputData, outputData) {
-    this._tagDocuments(span, inputData, INPUT_DOCUMENTS)
-    this._tagText(span, outputData, OUTPUT_VALUE)
+    this.#tagDocuments(span, inputData, INPUT_DOCUMENTS)
+    this.#tagText(span, outputData, OUTPUT_VALUE)
   }
 
   tagRetrievalIO (span, inputData, outputData) {
-    this._tagText(span, inputData, INPUT_VALUE)
-    this._tagDocuments(span, outputData, OUTPUT_DOCUMENTS)
+    this.#tagText(span, inputData, INPUT_VALUE)
+    this.#tagDocuments(span, outputData, OUTPUT_DOCUMENTS)
   }
 
   tagTextIO (span, inputData, outputData) {
-    this._tagText(span, inputData, INPUT_VALUE)
-    this._tagText(span, outputData, OUTPUT_VALUE)
+    this.#tagText(span, inputData, INPUT_VALUE)
+    this.#tagText(span, outputData, OUTPUT_VALUE)
   }
 
   tagMetadata (span, metadata) {
@@ -135,7 +135,7 @@ class LLMObsTagger {
       if (typeof value === 'number') {
         filterdMetrics[processedKey] = value
       } else {
-        this._handleFailure(`Value for metric '${key}' must be a number, instead got ${value}`, 'invalid_metrics')
+        this.#handleFailure(`Value for metric '${key}' must be a number, instead got ${value}`, 'invalid_metrics')
       }
     }
 
@@ -148,19 +148,19 @@ class LLMObsTagger {
   }
 
   tagSpanTags (span, tags) {
-    // new tags will be merged with existing tags
     const currentTags = registry.get(span)?.[TAGS]
     if (currentTags) {
-      Object.assign(tags, currentTags)
+      Object.assign(currentTags, tags)
+    } else {
+      this._setTag(span, TAGS, tags)
     }
-    this._setTag(span, TAGS, tags)
   }
 
   changeKind (span, newKind) {
     this._setTag(span, SPAN_KIND, newKind)
   }
 
-  _tagText (span, data, key) {
+  #tagText (span, data, key) {
     if (data) {
       if (typeof data === 'string') {
         this._setTag(span, key, data)
@@ -169,142 +169,156 @@ class LLMObsTagger {
           this._setTag(span, key, JSON.stringify(data))
         } catch {
           const type = key === INPUT_VALUE ? 'input' : 'output'
-          this._handleFailure(`Failed to parse ${type} value, must be JSON serializable.`, 'invalid_io_text')
+          this.#handleFailure(`Failed to parse ${type} value, must be JSON serializable.`, 'invalid_io_text')
         }
       }
     }
   }
 
-  _tagDocuments (span, data, key) {
-    if (data) {
-      if (!Array.isArray(data)) {
-        data = [data]
-      }
+  #tagDocuments (span, data, key) {
+    if (!data) {
+      return
+    }
 
-      const documents = data.map(document => {
-        if (typeof document === 'string') {
-          return { text: document }
-        }
+    if (!Array.isArray(data)) {
+      data = [data]
+    }
 
-        if (document == null || typeof document !== 'object') {
-          this._handleFailure('Documents must be a string, object, or list of objects.', 'invalid_embedding_io')
-          return undefined
-        }
+    const documents = []
+    for (const document of data) {
+      if (typeof document === 'string') {
+        documents.push({ text: document })
+        continue
+      }
 
-        const { text, name, id, score } = document
-        let validDocument = true
+      if (document == null || typeof document !== 'object') {
+        this.#handleFailure('Documents must be a string, object, or list of objects.', 'invalid_embedding_io')
+        continue
+      }
 
-        if (typeof text !== 'string') {
-          this._handleFailure('Document text must be a string.', 'invalid_embedding_io')
-          validDocument = false
-        }
+      const { text, name, id, score } = document
 
-        const documentObj = { text }
+      const valid = typeof text === 'string'
+      if (!valid) {
+        this.#handleFailure('Document text must be a string.', 'invalid_embedding_io')
+      }
 
-        validDocument = this._tagConditionalString(name, 'Document name', documentObj, 'name') && validDocument
-        validDocument = this._tagConditionalString(id, 'Document ID', documentObj, 'id') && validDocument
-        validDocument = this._tagConditionalNumber(score, 'Document score', documentObj, 'score') && validDocument
+      const documentObj = { text }
 
-        return validDocument ? documentObj : undefined
-      }).filter(doc => !!doc)
+      const condition1 = this.#tagConditionalString(name, 'Document name', documentObj, 'name')
+      const condition2 = this.#tagConditionalString(id, 'Document ID', documentObj, 'id')
+      const condition3 = this.#tagConditionalNumber(score, 'Document score', documentObj, 'score')
 
-      if (documents.length) {
-        this._setTag(span, key, documents)
+      if (valid && condition1 && condition2 && condition3) {
+        documents.push(documentObj)
       }
     }
-  }
 
-  _tagMessages (span, data, key) {
-    if (data) {
-      if (!Array.isArray(data)) {
-        data = [data]
-      }
+    if (documents.length) {
+      this._setTag(span, key, documents)
+    }
+  }
 
-      const messages = data.map(message => {
-        if (typeof message === 'string') {
-          return { content: message }
-        }
+  #filterToolCalls (toolCalls) {
+    if (!Array.isArray(toolCalls)) {
+      toolCalls = [toolCalls]
+    }
 
-        if (message == null || typeof message !== 'object') {
-          this._handleFailure('Messages must be a string, object, or list of objects', 'invalid_io_messages')
-          return undefined
-        }
+    const filteredToolCalls = []
+    for (const toolCall of toolCalls) {
+      if (typeof toolCall !== 'object') {
+        this.#handleFailure('Tool call must be an object.', 'invalid_io_messages')
+        continue
+      }
 
-        let validMessage = true
+      const { name, arguments: args, toolId, type } = toolCall
+      const toolCallObj = {}
 
-        const { content = '', role } = message
-        let toolCalls = message.toolCalls
-        const messageObj = { content }
+      const condition1 = this.#tagConditionalString(name, 'Tool name', toolCallObj, 'name')
+      const condition2 = this.#tagConditionalObject(args, 'Tool arguments', toolCallObj, 'arguments')
+      const condition3 = this.#tagConditionalString(toolId, 'Tool ID', toolCallObj, 'tool_id')
+      const condition4 = this.#tagConditionalString(type, 'Tool type', toolCallObj, 'type')
 
-        if (typeof content !== 'string') {
-          this._handleFailure('Message content must be a string.', 'invalid_io_messages')
-          validMessage = false
-        }
+      if (condition1 && condition2 && condition3 && condition4) {
+        filteredToolCalls.push(toolCallObj)
+      }
+    }
+    return filteredToolCalls
+  }
 
-        validMessage = this._tagConditionalString(role, 'Message role', messageObj, 'role') && validMessage
+  #tagMessages (span, data, key) {
+    if (!data) {
+      return
+    }
+    if (!Array.isArray(data)) {
+      data = [data]
+    }
 
-        if (toolCalls) {
-          if (!Array.isArray(toolCalls)) {
-            toolCalls = [toolCalls]
-          }
+    const messages = []
 
-          const filteredToolCalls = toolCalls.map(toolCall => {
-            if (typeof toolCall !== 'object') {
-              this._handleFailure('Tool call must be an object.', 'invalid_io_messages')
-              return undefined
-            }
+    for (const message of data) {
+      if (typeof message === 'string') {
+        messages.push({ content: message })
+        continue
+      }
+      if (message == null || typeof message !== 'object') {
+        this.#handleFailure('Messages must be a string, object, or list of objects', 'invalid_io_messages')
+        continue
+      }
 
-            let validTool = true
+      const { content = '', role } = message
+      const toolCalls = message.toolCalls
+      const messageObj = { content }
 
-            const { name, arguments: args, toolId, type } = toolCall
-            const toolCallObj = {}
+      const valid = typeof content === 'string'
+      if (!valid) {
+        this.#handleFailure('Message content must be a string.', 'invalid_io_messages')
+      }
 
-            validTool = this._tagConditionalString(name, 'Tool name', toolCallObj, 'name') && validTool
-            validTool = this._tagConditionalObject(args, 'Tool arguments', toolCallObj, 'arguments') && validTool
-            validTool = this._tagConditionalString(toolId, 'Tool ID', toolCallObj, 'tool_id') && validTool
-            validTool = this._tagConditionalString(type, 'Tool type', toolCallObj, 'type') && validTool
+      const condition = this.#tagConditionalString(role, 'Message role', messageObj, 'role')
 
-            return validTool ? toolCallObj : undefined
-          }).filter(toolCall => !!toolCall)
+      if (toolCalls) {
+        const filteredToolCalls = this.#filterToolCalls(toolCalls)
 
-          if (filteredToolCalls.length) {
-            messageObj.tool_calls = filteredToolCalls
-          }
+        if (filteredToolCalls.length) {
+          messageObj.tool_calls = filteredToolCalls
         }
+      }
 
-        return validMessage ? messageObj : undefined
-      }).filter(msg => !!msg)
-
-      if (messages.length) {
-        this._setTag(span, key, messages)
+      if (valid && condition) {
+        messages.push(messageObj)
       }
     }
+
+    if (messages.length) {
+      this._setTag(span, key, messages)
+    }
   }
 
-  _tagConditionalString (data, type, carrier, key) {
+  #tagConditionalString (data, type, carrier, key) {
     if (!data) return true
     if (typeof data !== 'string') {
-      this._handleFailure(`"${type}" must be a string.`)
+      this.#handleFailure(`"${type}" must be a string.`)
       return false
     }
     carrier[key] = data
     return true
   }
 
-  _tagConditionalNumber (data, type, carrier, key) {
+  #tagConditionalNumber (data, type, carrier, key) {
     if (!data) return true
     if (typeof data !== 'number') {
-      this._handleFailure(`"${type}" must be a number.`)
+      this.#handleFailure(`"${type}" must be a number.`)
       return false
     }
     carrier[key] = data
     return true
   }
 
-  _tagConditionalObject (data, type, carrier, key) {
+  #tagConditionalObject (data, type, carrier, key) {
     if (!data) return true
     if (typeof data !== 'object') {
-      this._handleFailure(`"${type}" must be an object.`)
+      this.#handleFailure(`"${type}" must be an object.`)
       return false
     }
     carrier[key] = data
@@ -313,7 +327,7 @@ class LLMObsTagger {
 
   // any public-facing LLMObs APIs using this tagger should not soft fail
   // auto-instrumentation should soft fail
-  _handleFailure (msg, errorTag) {
+  #handleFailure (msg, errorTag) {
     if (this.softFail) {
       log.warn(msg)
     } else {
@@ -328,7 +342,7 @@ class LLMObsTagger {
   _register (span) {
     if (!this._config.llmobs.enabled) return
     if (registry.has(span)) {
-      this._handleFailure(`LLMObs Span "${span._name}" already registered.`)
+      this.#handleFailure(`LLMObs Span "${span._name}" already registered.`)
       return
     }
 
@@ -338,7 +352,7 @@ class LLMObsTagger {
   _setTag (span, key, value) {
     if (!this._config.llmobs.enabled) return
     if (!registry.has(span)) {
-      this._handleFailure(`Span "${span._name}" must be an LLMObs generated span.`)
+      this.#handleFailure(`Span "${span._name}" must be an LLMObs generated span.`)
       return
     }
 

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

@@ -2,15 +2,13 @@
 
 const { SPAN_KINDS } = require('./constants/tags')
 
-function encodeUnicode (str) {
-  if (!str) return str
-  return str.split('').map(char => {
-    const code = char.charCodeAt(0)
-    if (code > 127) {
-      return `\\u${code.toString(16).padStart(4, '0')}`
-    }
-    return char
-  }).join('')
+function encodeUnicode (str = '') {
+  let result = ''
+  for (let i = 0; i < str.length; i++) {
+    const code = str.charCodeAt(i)
+    result += code > 127 ? `\\u${code.toString(16).padStart(4, '0')}` : str[i]
+  }
+  return result
 }
 
 function validateKind (kind) {
@@ -107,6 +105,8 @@ function findArgumentsBounds (str) {
   let end = -1
   let closerCount = 0
 
+  // TODO(BridgeAR): This "breaks" up codePoints.
+  // Investigate if this is a problem.
   for (let i = 0; i < str.length; i++) {
     const char = str[i]
 

package/packages/dd-trace/src/llmobs/writers/base.js

@@ -157,7 +157,7 @@ class BaseLLMObsWriter {
         return encodeUnicode(value) // serialize unicode characters
       }
       return value
-    }).replace(/\\\\u/g, '\\u') // remove double escaping
+    }).replace(/\\\\u/g, String.raw`\u`) // remove double escaping
   }
 }
 

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

@@ -27,7 +27,7 @@ function setAgentStrategy (config, setWritersAgentlessValue) {
     }
 
     const endpoints = agentInfo.endpoints
-    const hasEndpoint = Array.isArray(endpoints) && endpoints.some(endpoint => endpoint === EVP_PROXY_AGENT_BASE_PATH)
+    const hasEndpoint = Array.isArray(endpoints) && endpoints.includes(EVP_PROXY_AGENT_BASE_PATH)
     setWritersAgentlessValue(!hasEndpoint)
   })
 }

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

@@ -95,7 +95,7 @@ const log = {
     return this._deprecate(code, message)
   },
 
-  isEnabled (fleetStableConfigValue = undefined, localStableConfigValue = undefined) {
+  isEnabled (fleetStableConfigValue, localStableConfigValue) {
     return isTrue(coalesce(
       fleetStableConfigValue,
       process.env?.DD_TRACE_DEBUG,
@@ -106,9 +106,9 @@ const log = {
   },
 
   getLogLevel (
-    optionsValue = undefined,
-    fleetStableConfigValue = undefined,
-    localStableConfigValue = undefined
+    optionsValue,
+    fleetStableConfigValue,
+    localStableConfigValue
   ) {
     return coalesce(
       optionsValue,

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

@@ -23,7 +23,7 @@ class Log {
   static parse (...args) {
     let message, cause, delegate
 
-    const lastArg = args[args.length - 1]
+    const lastArg = args.at(-1)
     if (lastArg && typeof lastArg === 'object' && lastArg.stack) { // lastArg instanceof Error?
       cause = args.pop()
     }

package/packages/dd-trace/src/log/writer.js

@@ -42,7 +42,7 @@ function toggle (enable, level) {
 }
 
 function use (newLogger) {
-  if (newLogger && newLogger.debug instanceof Function && newLogger.error instanceof Function) {
+  if (typeof newLogger?.debug === 'function' && typeof newLogger.error === 'function') {
     logger = newLogger
   }
 }
@@ -54,7 +54,7 @@ function reset () {
 }
 
 function getErrorLog (err) {
-  if (err && typeof err.delegate === 'function') {
+  if (typeof err?.delegate === 'function') {
     const result = err.delegate()
     return Array.isArray(result) ? Log.parse(...result) : Log.parse(result)
   } else {

package/packages/dd-trace/src/msgpack/chunk.js

@@ -21,10 +21,10 @@ class Chunk {
 
     if (length < 0x20) { // fixstr
       this.reserve(length + 1)
-      this.buffer[offset] = length | 0xa0
-    } else if (length < 0x100000000) { // str 32
+      this.buffer[offset] = length | 0xA0
+    } else if (length < 0x1_00_00_00_00) { // str 32
       this.reserve(length + 5)
-      this.buffer[offset] = 0xdb
+      this.buffer[offset] = 0xDB
       this.buffer[offset + 1] = length >> 24
       this.buffer[offset + 2] = length >> 16
       this.buffer[offset + 3] = length >> 8