dd-trace 5.53.0 → 5.54.0

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')
       }
     }
 
@@ -160,7 +160,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 +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

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

@@ -49,14 +49,14 @@ class MsgpackEncoder {
     const offset = bytes.length
 
     bytes.reserve(1)
-    bytes.buffer[offset] = 0xc0
+    bytes.buffer[offset] = 0xC0
   }
 
   encodeBoolean (bytes, value) {
     const offset = bytes.length
 
     bytes.reserve(1)
-    bytes.buffer[offset] = value ? 0xc3 : 0xc2
+    bytes.buffer[offset] = value ? 0xC3 : 0xC2
   }
 
   encodeString (bytes, value) {
@@ -75,7 +75,7 @@ class MsgpackEncoder {
     const offset = bytes.length
 
     bytes.reserve(5)
-    bytes.buffer[offset] = 0xdd
+    bytes.buffer[offset] = 0xDD
     bytes.buffer[offset + 1] = length >> 24
     bytes.buffer[offset + 2] = length >> 16
     bytes.buffer[offset + 3] = length >> 8
@@ -105,7 +105,7 @@ class MsgpackEncoder {
     const offset = bytes.length
 
     bytes.reserve(5)
-    bytes.buffer[offset] = 0xdf
+    bytes.buffer[offset] = 0xDF
     bytes.buffer[offset + 1] = keysLength >> 24
     bytes.buffer[offset + 2] = keysLength >> 16
     bytes.buffer[offset + 3] = keysLength >> 8
@@ -122,16 +122,16 @@ class MsgpackEncoder {
 
     if (value.byteLength < 256) {
       bytes.reserve(2)
-      bytes.buffer[offset] = 0xc4
+      bytes.buffer[offset] = 0xC4
       bytes.buffer[offset + 1] = value.byteLength
-    } else if (value.byteLength < 65536) {
+    } else if (value.byteLength < 65_536) {
       bytes.reserve(3)
-      bytes.buffer[offset] = 0xc5
+      bytes.buffer[offset] = 0xC5
       bytes.buffer[offset + 1] = value.byteLength >> 8
       bytes.buffer[offset + 2] = value.byteLength
     } else {
       bytes.reserve(5)
-      bytes.buffer[offset] = 0xc6
+      bytes.buffer[offset] = 0xC6
       bytes.buffer[offset + 1] = value.byteLength >> 24
       bytes.buffer[offset + 2] = value.byteLength >> 16
       bytes.buffer[offset + 3] = value.byteLength >> 8
@@ -145,7 +145,7 @@ class MsgpackEncoder {
     const offset = bytes.length
 
     bytes.reserve(5)
-    bytes.buffer[offset] = 0xce
+    bytes.buffer[offset] = 0xCE
     bytes.buffer[offset + 1] = value >> 24
     bytes.buffer[offset + 2] = value >> 16
     bytes.buffer[offset + 3] = value >> 8
@@ -156,7 +156,7 @@ class MsgpackEncoder {
     const offset = bytes.length
 
     bytes.reserve(3)
-    bytes.buffer[offset] = 0xcd
+    bytes.buffer[offset] = 0xCD
     bytes.buffer[offset + 1] = value >> 8
     bytes.buffer[offset + 2] = value
   }
@@ -167,7 +167,7 @@ class MsgpackEncoder {
     const lo = value >>> 0
 
     bytes.reserve(9)
-    bytes.buffer[offset] = 0xcf
+    bytes.buffer[offset] = 0xCF
     bytes.buffer[offset + 1] = hi >> 24
     bytes.buffer[offset + 2] = hi >> 16
     bytes.buffer[offset + 3] = hi >> 8
@@ -201,16 +201,16 @@ class MsgpackEncoder {
       bytes.buffer[offset] = value
     } else if (value >= -0x80) {
       bytes.reserve(2)
-      bytes.buffer[offset] = 0xd0
+      bytes.buffer[offset] = 0xD0
       bytes.buffer[offset + 1] = value
-    } else if (value >= -0x8000) {
+    } else if (value >= -0x80_00) {
       bytes.reserve(3)
-      bytes.buffer[offset] = 0xd1
+      bytes.buffer[offset] = 0xD1
       bytes.buffer[offset + 1] = value >> 8
       bytes.buffer[offset + 2] = value
-    } else if (value >= -0x80000000) {
+    } else if (value >= -0x80_00_00_00) {
       bytes.reserve(5)
-      bytes.buffer[offset] = 0xd2
+      bytes.buffer[offset] = 0xD2
       bytes.buffer[offset + 1] = value >> 24
       bytes.buffer[offset + 2] = value >> 16
       bytes.buffer[offset + 3] = value >> 8
@@ -220,7 +220,7 @@ class MsgpackEncoder {
       const lo = value >>> 0
 
       bytes.reserve(9)
-      bytes.buffer[offset] = 0xd3
+      bytes.buffer[offset] = 0xD3
       bytes.buffer[offset + 1] = hi >> 24
       bytes.buffer[offset + 2] = hi >> 16
       bytes.buffer[offset + 3] = hi >> 8
@@ -235,21 +235,21 @@ class MsgpackEncoder {
   encodeUnsigned (bytes, value) {
     const offset = bytes.length
 
-    if (value <= 0x7f) {
+    if (value <= 0x7F) {
       bytes.reserve(1)
       bytes.buffer[offset] = value
-    } else if (value <= 0xff) {
+    } else if (value <= 0xFF) {
       bytes.reserve(2)
-      bytes.buffer[offset] = 0xcc
+      bytes.buffer[offset] = 0xCC
       bytes.buffer[offset + 1] = value
-    } else if (value <= 0xffff) {
+    } else if (value <= 0xFF_FF) {
       bytes.reserve(3)
-      bytes.buffer[offset] = 0xcd
+      bytes.buffer[offset] = 0xCD
       bytes.buffer[offset + 1] = value >> 8
       bytes.buffer[offset + 2] = value
-    } else if (value <= 0xffffffff) {
+    } else if (value <= 0xFF_FF_FF_FF) {
       bytes.reserve(5)
-      bytes.buffer[offset] = 0xce
+      bytes.buffer[offset] = 0xCE
       bytes.buffer[offset + 1] = value >> 24
       bytes.buffer[offset + 2] = value >> 16
       bytes.buffer[offset + 3] = value >> 8
@@ -259,7 +259,7 @@ class MsgpackEncoder {
       const lo = value >>> 0
 
       bytes.reserve(9)
-      bytes.buffer[offset] = 0xcf
+      bytes.buffer[offset] = 0xCF
       bytes.buffer[offset + 1] = hi >> 24
       bytes.buffer[offset + 2] = hi >> 16
       bytes.buffer[offset + 3] = hi >> 8
@@ -278,10 +278,10 @@ class MsgpackEncoder {
     bytes.reserve(9)
 
     if (value >= 0n) {
-      bytes.buffer[offset] = 0xcf
+      bytes.buffer[offset] = 0xCF
       bytes.view.setBigUint64(offset + 1, value)
     } else {
-      bytes.buffer[offset] = 0xd3
+      bytes.buffer[offset] = 0xD3
       bytes.view.setBigInt64(offset + 1, value)
     }
   }
@@ -301,7 +301,7 @@ class MsgpackEncoder {
     const offset = bytes.length
 
     bytes.reserve(9)
-    bytes.buffer[offset] = 0xcb
+    bytes.buffer[offset] = 0xCB
     bytes.view.setFloat64(offset + 1, value)
   }
 }

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

@@ -3,15 +3,15 @@
  * @implements {DogStatsD}
  */
 module.exports = class NoopDogStatsDClient {
-  increment () { }
+  increment () {}
 
-  decrement () { }
+  decrement () {}
 
-  gauge () { }
+  gauge () {}
 
-  distribution () { }
+  distribution () {}
 
-  histogram () { }
+  histogram () {}
 
-  flush () { }
+  flush () {}
 }

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

@@ -30,21 +30,19 @@ class NoopSpan {
   _createContext (parent) {
     const spanId = id()
 
-    if (parent) {
-      return new NoopSpanContext({
+    return parent
+      ? new NoopSpanContext({
         noop: this,
         traceId: parent._traceId,
         spanId,
         parentId: parent._spanId,
         baggageItems: Object.assign({}, parent._baggageItems)
       })
-    } else {
-      return new NoopSpanContext({
+      : new NoopSpanContext({
         noop: this,
         traceId: spanId,
         spanId
       })
-    }
   }
 }
 

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

@@ -27,8 +27,7 @@ class NoopTracer {
     return ''
   }
 
-  setUrl () {
-  }
+  setUrl () {}
 
   startSpan (name, options) {
     return this._span