dd-trace 5.53.0 → 5.55.0

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

@@ -24,7 +24,8 @@ const {
   OUTPUT_TOKENS_METRIC_KEY,
   TOTAL_TOKENS_METRIC_KEY,
   INTEGRATION,
-  DECORATOR
+  DECORATOR,
+  PROPAGATED_ML_APP_KEY
 } = require('./constants/tags')
 
 // global registry of LLMObs spans
@@ -73,12 +74,24 @@ class LLMObsTagger {
     if (integration) this._setTag(span, INTEGRATION, integration)
     if (_decorator) this._setTag(span, DECORATOR, _decorator)
 
-    if (!mlApp) mlApp = registry.get(parent)?.[ML_APP] || this._config.llmobs.mlApp
-    this._setTag(span, ML_APP, mlApp)
+    const spanMlApp =
+      mlApp ||
+      registry.get(parent)?.[ML_APP] ||
+      span.context()._trace.tags[PROPAGATED_ML_APP_KEY] ||
+      this._config.llmobs.mlApp
+
+    if (!spanMlApp) {
+      throw new Error(
+        '[LLMObs] Cannot start an LLMObs span without an mlApp configured.' +
+        'Ensure this configuration is set before running your application.'
+      )
+    }
+
+    this._setTag(span, ML_APP, spanMlApp)
 
     const parentId =
-      parent?.context().toSpanId() ||
-      span.context()._trace.tags[PROPAGATED_PARENT_ID_KEY] ||
+      parent?.context().toSpanId() ??
+      span.context()._trace.tags[PROPAGATED_PARENT_ID_KEY] ??
       ROOT_PARENT_ID
     this._setTag(span, PARENT_ID_KEY, parentId)
   }
@@ -86,23 +99,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 +148,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')
       }
     }
 
@@ -160,7 +173,7 @@ class LLMObsTagger {
     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 +182,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 +340,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 +355,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,12 +365,12 @@ 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
     }
 
     const tagsCarrier = registry.get(span)
-    Object.assign(tagsCarrier, { [key]: value })
+    tagsCarrier[key] = value
   }
 }
 

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
+    }).replaceAll(String.raw`\\u`, 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

@@ -7,6 +7,7 @@ const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = r
 const logWriter = require('./writer')
 const { Log } = require('./log')
 const { memoize } = require('./utils')
+const { getEnvironmentVariable } = require('../config-helper')
 
 const config = {
   enabled: false,
@@ -95,26 +96,26 @@ const log = {
     return this._deprecate(code, message)
   },
 
-  isEnabled (fleetStableConfigValue = undefined, localStableConfigValue = undefined) {
+  isEnabled (fleetStableConfigValue, localStableConfigValue) {
     return isTrue(coalesce(
       fleetStableConfigValue,
-      process.env?.DD_TRACE_DEBUG,
-      process.env?.OTEL_LOG_LEVEL === 'debug' || undefined,
+      getEnvironmentVariable('DD_TRACE_DEBUG'),
+      getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug' || undefined,
       localStableConfigValue,
       config.enabled
     ))
   },
 
   getLogLevel (
-    optionsValue = undefined,
-    fleetStableConfigValue = undefined,
-    localStableConfigValue = undefined
+    optionsValue,
+    fleetStableConfigValue,
+    localStableConfigValue
   ) {
     return coalesce(
       optionsValue,
       fleetStableConfigValue,
-      process.env?.DD_TRACE_LOG_LEVEL,
-      process.env?.OTEL_LOG_LEVEL,
+      getEnvironmentVariable('DD_TRACE_LOG_LEVEL'),
+      getEnvironmentVariable('OTEL_LOG_LEVEL'),
       localStableConfigValue,
       config.logLevel
     )

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,12 +54,11 @@ 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 {
-    return err
   }
+  return err
 }
 
 function setStackTraceLimitFunction (fn) {

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