dd-trace 5.79.0 → 5.81.0

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

@@ -14,26 +14,43 @@ let batch = 0
 
 // Internal representation of a trace or span ID.
 class Identifier {
+  /**
+   * @param {string} value
+   * @param {number} [radix]
+   */
   constructor (value, radix = 16) {
     this._buffer = radix === 16
       ? createBuffer(value)
       : fromString(value, radix)
   }
 
+  /**
+   * @param {number} [radix]
+   * @returns {string}
+   */
   toString (radix = 16) {
     return radix === 16
       ? toHexString(this._buffer)
       : toNumberString(this._buffer, radix)
   }
 
+  /**
+   * @returns {bigint}
+   */
   toBigInt () {
     return Buffer.from(this._buffer).readBigUInt64BE(0)
   }
 
+  /**
+   * @returns {number[] | Uint8Array}
+   */
   toBuffer () {
     return this._buffer
   }
 
+  /**
+   * @returns {number[] | Uint8Array}
+   */
   toArray () {
     if (this._buffer.length === 8) {
       return this._buffer
@@ -41,10 +58,17 @@ class Identifier {
     return this._buffer.slice(-8)
   }
 
+  /**
+   * @returns {string}
+   */
   toJSON () {
     return this.toString()
   }
 
+  /**
+   * @param {Identifier} other
+   * @returns {boolean}
+   */
   equals (other) {
     const length = this._buffer.length
     const otherLength = other._buffer.length
@@ -59,6 +83,10 @@ class Identifier {
 }
 
 // Create a buffer, using an optional hexadecimal value if provided.
+/**
+ * @param {string} value
+ * @returns {number[] | Uint8Array}
+ */
 function createBuffer (value) {
   if (value === '0') return zeroId
   if (!value) return pseudoRandom()
@@ -77,6 +105,11 @@ function createBuffer (value) {
 }
 
 // Convert a numerical string to a buffer using the specified radix.
+/**
+ * @param {string} str
+ * @param {number} raddix
+ * @returns {number[]}
+ */
 function fromString (str, raddix) {
   const buffer = new Array(8)
   const len = str.length
@@ -116,6 +149,11 @@ function fromString (str, raddix) {
 }
 
 // Convert a buffer to a numerical string.
+/**
+ * @param {number[] | Uint8Array} buffer
+ * @param {number} [radix]
+ * @returns {string}
+ */
 function toNumberString (buffer, radix) {
   let high = readInt32(buffer, buffer.length - 8)
   let low = readInt32(buffer, buffer.length - 4)
@@ -137,11 +175,18 @@ function toNumberString (buffer, radix) {
 }
 
 // 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}
+ */
 function pseudoRandom () {
   if (batch === 0) {
     randomFillSync(data)
@@ -164,6 +209,11 @@ function pseudoRandom () {
 }
 
 // Read a buffer to unsigned integer bytes.
+/**
+ * @param {number[] | Uint8Array} buffer
+ * @param {number} offset
+ * @returns {number}
+ */
 function readInt32 (buffer, offset) {
   return (buffer[offset + 0] * 16_777_216) +
     (buffer[offset + 1] << 16) +
@@ -172,6 +222,11 @@ function readInt32 (buffer, offset) {
 }
 
 // Write unsigned integer bytes to a buffer.
+/**
+ * @param {number[] | Uint8Array} buffer
+ * @param {number} value
+ * @param {number} offset
+ */
 function writeUInt32BE (buffer, value, offset) {
   buffer[3 + offset] = value & 255
   value >>= 8
@@ -182,6 +237,11 @@ function writeUInt32BE (buffer, value, offset) {
   buffer[0 + offset] = value & 255
 }
 
+/**
+ * @param {string} value
+ * @param {number} [radix]
+ * @returns {Identifier}
+ */
 module.exports = function createIdentifier (value, radix) {
   return new Identifier(value, radix)
 }

package/packages/dd-trace/src/lambda/runtime/ritm.js

@@ -3,7 +3,7 @@
  * Modifications copyright 2022 Datadog, Inc.
  *
  * Some functions are part of aws-lambda-nodejs-runtime-interface-client
- * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/main/src/utils/UserFunction.ts
+ * https://github.com/aws/aws-lambda-nodejs-runtime-interface-client/blob/v2.1.0/src/utils/UserFunction.ts
  */
 'use strict'
 
@@ -53,8 +53,7 @@ function _extractModuleNameAndHandlerPath (handler) {
   const FUNCTION_EXPR = /^([^.]*)\.(.*)$/
   const match = handler.match(FUNCTION_EXPR)
   if (!match || match.length !== 3) {
-    // Malformed Handler Name
-    return // TODO: throw error
+    throw new Error(`Malformed handler name: ${handler}`)
   }
   return [match[1], match[2]] // [module, handler-path]
 }

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

@@ -34,6 +34,7 @@ module.exports = {
   TOTAL_TOKENS_METRIC_KEY: 'total_tokens',
   CACHE_READ_INPUT_TOKENS_METRIC_KEY: 'cache_read_input_tokens',
   CACHE_WRITE_INPUT_TOKENS_METRIC_KEY: 'cache_write_input_tokens',
+  REASONING_OUTPUT_TOKENS_METRIC_KEY: 'reasoning_output_tokens',
 
   DROPPED_IO_COLLECTION_ERROR: 'dropped_io'
 }

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

@@ -12,7 +12,7 @@ const telemetry = require('./telemetry')
 const LLMObsSpanProcessor = require('./span_processor')
 
 const { channel } = require('dc-polyfill')
-const spanProcessCh = channel('dd-trace:span:process')
+const spanFinishCh = channel('dd-trace:span:finish')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
 const flushCh = channel('llmobs:writers:flush')
 const injectCh = channel('dd-trace:span:inject')
@@ -62,7 +62,7 @@ function enable (config) {
   // span processing
   spanProcessor = new LLMObsSpanProcessor(config)
   spanProcessor.setWriter(spanWriter)
-  spanProcessCh.subscribe(handleSpanProcess)
+  spanFinishCh.subscribe(handleSpanProcess)
 
   // distributed tracing for llmobs
   injectCh.subscribe(handleLLMObsParentIdInjection)
@@ -86,7 +86,7 @@ function enable (config) {
 function disable () {
   if (evalMetricAppendCh.hasSubscribers) evalMetricAppendCh.unsubscribe(handleEvalMetricAppend)
   if (flushCh.hasSubscribers) flushCh.unsubscribe(handleFlush)
-  if (spanProcessCh.hasSubscribers) spanProcessCh.unsubscribe(handleSpanProcess)
+  if (spanFinishCh.hasSubscribers) spanFinishCh.unsubscribe(handleSpanProcess)
   if (injectCh.hasSubscribers) injectCh.unsubscribe(handleLLMObsParentIdInjection)
   if (registerUserSpanProcessorCh.hasSubscribers) registerUserSpanProcessorCh.unsubscribe(handleRegisterProcessor)
 
@@ -133,8 +133,8 @@ function handleRegisterProcessor (userSpanProcessor) {
   spanProcessor.setUserSpanProcessor(userSpanProcessor)
 }
 
-function handleSpanProcess (data) {
-  spanProcessor.process(data)
+function handleSpanProcess (span) {
+  spanProcessor.process(span)
 }
 
 function handleEvalMetricAppend (payload) {

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

@@ -75,6 +75,12 @@ class NoopLLMObs {
   submitEvaluation (llmobsSpanContext, options) {}
 
   flush () {}
+
+  registerProcessor (processor) {}
+
+  deregisterProcessor () {}
+
+  annotationContext (options, fn) { return fn() }
 }
 
 module.exports = NoopLLMObs

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

@@ -79,6 +79,7 @@ class VercelAILLMObsPlugin extends BaseLLMObsPlugin {
    *
    * We use the tool description as the next best identifier for a tool.
    *
+   * @param {string} toolName
    * @param {string} toolDescription
    * @returns {string | undefined}
    */

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

@@ -0,0 +1,104 @@
+'use strict'
+
+const LLMObsPlugin = require('../base')
+const {
+  getOperation,
+  extractMetrics,
+  extractMetadata,
+  aggregateStreamingChunks,
+  formatInputMessages,
+  formatEmbeddingInput,
+  formatOutputMessages,
+  formatEmbeddingOutput
+} = require('./util')
+
+class GenAiLLMObsPlugin extends LLMObsPlugin {
+  static id = 'google-genai'
+  static integration = 'google_genai'
+  static prefix = 'tracing:apm:google:genai:request'
+
+  constructor () {
+    super(...arguments)
+
+    // Subscribe to streaming chunk events
+    this.addSub('apm:google:genai:request:chunk', ({ ctx, chunk, done }) => {
+      ctx.isStreaming = true
+      ctx.chunks = ctx.chunks || []
+
+      if (chunk) ctx.chunks.push(chunk)
+      if (!done) return
+
+      // Aggregate streaming chunks into a single response
+      ctx.result = aggregateStreamingChunks(ctx.chunks)
+    })
+  }
+
+  getLLMObsSpanRegisterOptions (ctx) {
+    const { args, methodName } = ctx
+    if (!methodName) return
+
+    const inputs = args[0]
+    const operation = getOperation(methodName)
+
+    return {
+      modelProvider: 'google',
+      modelName: inputs.model,
+      kind: operation,
+      name: 'google_genai.request'
+    }
+  }
+
+  setLLMObsTags (ctx) {
+    const { args, methodName } = ctx
+    const span = ctx.currentStore?.span
+    if (!methodName) return
+
+    const inputs = args[0]
+    const response = ctx.result
+    const error = !!span.context()._tags.error
+
+    const operation = getOperation(methodName)
+
+    if (operation === 'llm') {
+      this.#tagGenerateContent(span, inputs, response, error, ctx.isStreaming)
+    } else if (operation === 'embedding') {
+      this.#tagEmbedding(span, inputs, response, error)
+    }
+
+    if (!error && response) {
+      const metrics = extractMetrics(response)
+      this._tagger.tagMetrics(span, metrics)
+    }
+  }
+
+  #tagGenerateContent (span, inputs, response, error, isStreaming = false) {
+    const { config = {} } = inputs
+
+    const inputMessages = formatInputMessages(inputs.contents)
+
+    const metadata = extractMetadata(config)
+    this._tagger.tagMetadata(span, metadata)
+
+    if (error) {
+      this._tagger.tagLLMIO(span, inputMessages, [{ content: '' }])
+      return
+    }
+
+    const outputMessages = formatOutputMessages(response, isStreaming)
+    this._tagger.tagLLMIO(span, inputMessages, outputMessages)
+  }
+
+  #tagEmbedding (span, inputs, response, error) {
+    const embeddingInput = formatEmbeddingInput(inputs.contents)
+
+    if (error) {
+      this._tagger.tagEmbeddingIO(span, embeddingInput)
+      return
+    }
+
+    const embeddingOutput = formatEmbeddingOutput(response)
+    this._tagger.tagEmbeddingIO(span, embeddingInput, embeddingOutput)
+  }
+}
+
+module.exports = GenAiLLMObsPlugin