dd-trace 5.43.0 → 5.45.0

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

@@ -194,7 +194,6 @@ class DogStatsDClient {
   }
 }
 
-// TODO: Handle arrays of tags and tags translation.
 class MetricsAggregationClient {
   constructor (client) {
     this._client = client
@@ -211,98 +210,132 @@ class MetricsAggregationClient {
   }
 
   reset () {
-    this._counters = {}
-    this._gauges = {}
-    this._histograms = {}
+    this._counters = new Map()
+    this._gauges = new Map()
+    this._histograms = new Map()
   }
 
-  distribution (name, value, tag) {
-    this._client.distribution(name, value, tag && [tag])
+  // TODO: Aggerate with a histogram and send the buckets to the client.
+  distribution (name, value, tags) {
+    this._client.distribution(name, value, tags)
   }
 
-  boolean (name, value, tag) {
-    this.gauge(name, value ? 1 : 0, tag)
+  boolean (name, value, tags) {
+    this.gauge(name, value ? 1 : 0, tags)
   }
 
-  histogram (name, value, tag) {
-    this._histograms[name] = this._histograms[name] || new Map()
+  histogram (name, value, tags) {
+    const node = this._ensureTree(this._histograms, name, tags, null)
 
-    if (!this._histograms[name].has(tag)) {
-      this._histograms[name].set(tag, new Histogram())
+    if (!node.value) {
+      node.value = new Histogram()
     }
 
-    this._histograms[name].get(tag).record(value)
+    node.value.record(value)
   }
 
-  count (name, count, tag, monotonic = true) {
-    if (typeof tag === 'boolean') {
-      monotonic = tag
-      tag = undefined
+  count (name, count, tags = [], monotonic = true) {
+    if (typeof tags === 'boolean') {
+      monotonic = tags
+      tags = []
     }
 
-    const map = monotonic ? this._counters : this._gauges
+    const container = monotonic ? this._counters : this._gauges
+    const node = this._ensureTree(container, name, tags, 0)
 
-    map[name] = map[name] || new Map()
-
-    const value = map[name].get(tag) || 0
-
-    map[name].set(tag, value + count)
+    node.value = node.value + count
   }
 
-  gauge (name, value, tag) {
-    this._gauges[name] = this._gauges[name] || new Map()
-    this._gauges[name].set(tag, value)
+  gauge (name, value, tags) {
+    const node = this._ensureTree(this._gauges, name, tags, 0)
+
+    node.value = value
   }
 
-  increment (name, count = 1, tag) {
-    this.count(name, count, tag)
+  increment (name, count = 1, tags) {
+    this.count(name, count, tags)
   }
 
-  decrement (name, count = 1, tag) {
-    this.count(name, -count, tag)
+  decrement (name, count = 1, tags) {
+    this.count(name, -count, tags)
   }
 
   _captureGauges () {
-    Object.keys(this._gauges).forEach(name => {
-      this._gauges[name].forEach((value, tag) => {
-        this._client.gauge(name, value, tag && [tag])
-      })
+    this._captureTree(this._gauges, (node, name, tags) => {
+      this._client.gauge(name, node.value, tags)
     })
   }
 
   _captureCounters () {
-    Object.keys(this._counters).forEach(name => {
-      this._counters[name].forEach((value, tag) => {
-        this._client.increment(name, value, tag && [tag])
-      })
+    this._captureTree(this._counters, (node, name, tags) => {
+      this._client.increment(name, node.value, tags)
     })
 
-    this._counters = {}
+    this._counters.clear()
   }
 
   _captureHistograms () {
-    Object.keys(this._histograms).forEach(name => {
-      this._histograms[name].forEach((stats, tag) => {
-        const tags = tag && [tag]
+    this._captureTree(this._histograms, (node, name, tags) => {
+      let stats = node.value
 
-        // Stats can contain garbage data when a value was never recorded.
-        if (stats.count === 0) {
-          stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0, reset: stats.reset }
-        }
+      // Stats can contain garbage data when a value was never recorded.
+      if (stats.count === 0) {
+        stats = { max: 0, min: 0, sum: 0, avg: 0, median: 0, p95: 0, count: 0 }
+      }
 
-        this._client.gauge(`${name}.min`, stats.min, tags)
-        this._client.gauge(`${name}.max`, stats.max, tags)
-        this._client.increment(`${name}.sum`, stats.sum, tags)
-        this._client.increment(`${name}.total`, stats.sum, tags)
-        this._client.gauge(`${name}.avg`, stats.avg, tags)
-        this._client.increment(`${name}.count`, stats.count, tags)
-        this._client.gauge(`${name}.median`, stats.median, tags)
-        this._client.gauge(`${name}.95percentile`, stats.p95, tags)
+      this._client.gauge(`${name}.min`, stats.min, tags)
+      this._client.gauge(`${name}.max`, stats.max, tags)
+      this._client.increment(`${name}.sum`, stats.sum, tags)
+      this._client.increment(`${name}.total`, stats.sum, tags)
+      this._client.gauge(`${name}.avg`, stats.avg, tags)
+      this._client.increment(`${name}.count`, stats.count, tags)
+      this._client.gauge(`${name}.median`, stats.median, tags)
+      this._client.gauge(`${name}.95percentile`, stats.p95, tags)
 
-        stats.reset()
-      })
+      node.value.reset()
     })
   }
+
+  _captureTree (tree, fn) {
+    for (const [name, root] of tree) {
+      this._captureNode(root, name, [], fn)
+    }
+  }
+
+  _captureNode (node, name, tags, fn) {
+    if (node.touched) {
+      fn(node, name, tags)
+    }
+
+    for (const [tag, next] of node.nodes) {
+      this._captureNode(next, name, tags.concat(tag), fn)
+    }
+  }
+
+  _ensureTree (tree, name, tags, value) {
+    tags = tags ? [].concat(tags) : []
+
+    let node = this._ensureNode(tree, name, value)
+
+    for (const tag of tags) {
+      node = this._ensureNode(node.nodes, tag, value)
+    }
+
+    node.touched = true
+
+    return node
+  }
+
+  _ensureNode (container, key, value) {
+    let node = container.get(key)
+
+    if (!node) {
+      node = { nodes: new Map(), touched: false, value }
+      container.set(key, node)
+    }
+
+    return node
+  }
 }
 
 /**
@@ -324,45 +357,29 @@ class CustomMetrics {
   }
 
   increment (stat, value = 1, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.increment(stat, value, tag)
-    }
+    this._client.increment(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   decrement (stat, value = 1, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.decrement(stat, value, tag)
-    }
+    this._client.decrement(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   gauge (stat, value, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.gauge(stat, value, tag)
-    }
+    this._client.gauge(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   distribution (stat, value, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.distribution(stat, value, tag)
-    }
+    this._client.distribution(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   histogram (stat, value, tags) {
-    for (const tag of this._normalizeTags(tags)) {
-      this._client.histogram(stat, value, tag)
-    }
+    this._client.histogram(stat, value, CustomMetrics.tagTranslator(tags))
   }
 
   flush () {
     return this._client.flush()
   }
 
-  _normalizeTags (tags) {
-    tags = CustomMetrics.tagTranslator(tags)
-
-    return tags.length === 0 ? [undefined] : tags
-  }
-
   /**
    * Exposing { tagName: 'tagValue' } to the end user
    * These are translated into [ 'tagName:tagValue' ] for internal use

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

@@ -7,39 +7,28 @@ class Histogram {
     this.reset()
   }
 
-  get min () { return this._min }
-  get max () { return this._max }
-  get avg () { return this._count === 0 ? 0 : this._sum / this._count }
-  get sum () { return this._sum }
-  get count () { return this._count }
+  get min () { return this._sketch.count === 0 ? 0 : this._sketch.min }
+  get max () { return this._sketch.count === 0 ? 0 : this._sketch.max }
+  get avg () { return this._sketch.count === 0 ? 0 : this._sketch.sum / this._sketch.count }
+  get sum () { return this._sketch.sum }
+  get count () { return this._sketch.count }
   get median () { return this.percentile(50) }
   get p95 () { return this.percentile(95) }
 
   percentile (percentile) {
-    return this._histogram.getValueAtQuantile(percentile / 100) || 0
+    return this._sketch.getValueAtQuantile(percentile / 100) || 0
   }
 
-  record (value) {
-    if (this._count === 0) {
-      this._min = this._max = value
-    } else {
-      this._min = Math.min(this._min, value)
-      this._max = Math.max(this._max, value)
-    }
-
-    this._count++
-    this._sum += value
+  merge (histogram) {
+    return this._sketch.merge(histogram._sketch)
+  }
 
-    this._histogram.accept(value)
+  record (value) {
+    this._sketch.accept(value)
   }
 
   reset () {
-    this._min = 0
-    this._max = 0
-    this._sum = 0
-    this._count = 0
-
-    this._histogram = new DDSketch()
+    this._sketch = new DDSketch()
   }
 }
 

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

@@ -4,6 +4,8 @@ module.exports = {
   SPAN_KINDS: ['llm', 'agent', 'workflow', 'task', 'tool', 'embedding', 'retrieval'],
   SPAN_KIND: '_ml_obs.meta.span.kind',
   SESSION_ID: '_ml_obs.session_id',
+  DECORATOR: '_ml_obs.decorator',
+  INTEGRATION: '_ml_obs.integration',
   METADATA: '_ml_obs.meta.metadata',
   METRICS: '_ml_obs.metrics',
   ML_APP: '_ml_obs.meta.ml_app',

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

@@ -6,6 +6,7 @@ const { storage } = require('./storage')
 
 const LLMObsSpanProcessor = require('./span_processor')
 
+const telemetry = require('./telemetry')
 const { channel } = require('dc-polyfill')
 const spanProcessCh = channel('dd-trace:span:process')
 const evalMetricAppendCh = channel('llmobs:eval-metric:append')
@@ -29,6 +30,7 @@ let spanWriter
 let evalWriter
 
 function enable (config) {
+  const startTime = performance.now()
   // create writers and eval writer append and flush channels
   // span writer append is handled by the span processor
   evalWriter = new LLMObsEvalMetricsWriter(config)
@@ -44,6 +46,7 @@ function enable (config) {
 
   // distributed tracing for llmobs
   injectCh.subscribe(handleLLMObsParentIdInjection)
+  telemetry.recordLLMObsEnabled(startTime, config)
 }
 
 function disable () {

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

@@ -43,14 +43,14 @@ class NoopLLMObs {
         const ctx = ctxOrPropertyKey
         if (ctx.kind !== 'method') return target
 
-        return llmobs.wrap({ name: ctx.name, ...options }, target)
+        return llmobs.wrap({ name: ctx.name, _decorator: true, ...options }, target)
       } else {
         const propertyKey = ctxOrPropertyKey
         if (descriptor) {
           if (typeof descriptor.value !== 'function') return descriptor
 
           const original = descriptor.value
-          descriptor.value = llmobs.wrap({ name: propertyKey, ...options }, original)
+          descriptor.value = llmobs.wrap({ name: propertyKey, _decorator: true, ...options }, original)
 
           return descriptor
         } else {
@@ -59,7 +59,7 @@ class NoopLLMObs {
           const original = target[propertyKey]
           Object.defineProperty(target, propertyKey, {
             ...Object.getOwnPropertyDescriptor(target, propertyKey),
-            value: llmobs.wrap({ name: propertyKey, ...options }, original)
+            value: llmobs.wrap({ name: propertyKey, _decorator: true, ...options }, original)
           })
 
           return target

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

@@ -43,7 +43,7 @@ class LLMObsPlugin extends TracingPlugin {
       llmobsStorage.enterWith({ span })
       ctx.llmobs.parent = parent
 
-      this._tagger.registerLLMObsSpan(span, { parent, ...registerOptions })
+      this._tagger.registerLLMObsSpan(span, { parent, integration: this.constructor.id, ...registerOptions })
     }
   }
 

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

@@ -55,7 +55,8 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       modelName: modelName.toLowerCase(),
       modelProvider: modelProvider.toLowerCase(),
       kind: 'llm',
-      name: 'bedrock-runtime.command'
+      name: 'bedrock-runtime.command',
+      integration: 'bedrock'
     })
 
     const requestParams = extractRequestParams(request.params, modelProvider)

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

@@ -0,0 +1,196 @@
+'use strict'
+
+const LLMObsPlugin = require('./base')
+const {
+  extractModel,
+  extractSystemInstructions
+} = require('../../../../datadog-plugin-google-cloud-vertexai/src/utils')
+
+class VertexAILLMObsPlugin extends LLMObsPlugin {
+  static get id () { return 'vertexai' } // used for llmobs telemetry
+  static get prefix () {
+    return 'tracing:apm:vertexai:request'
+  }
+
+  getLLMObsSpanRegisterOptions (ctx) {
+    const history = ctx.instance?.historyInternal || []
+    ctx.history = history
+
+    return {
+      kind: 'llm',
+      modelName: extractModel(ctx.instance),
+      modelProvider: 'google',
+      name: ctx.resource
+    }
+  }
+
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+
+    const { instance, result, request } = ctx
+    const history = ctx.history || []
+    const systemInstructions = extractSystemInstructions(instance)
+
+    const metadata = getMetadata(instance)
+    const inputMessages = extractInputMessages(request, history, systemInstructions)
+    const outputMessages = extractOutputMessages(result)
+    const metrics = extractMetrics(result)
+
+    this._tagger.tagLLMIO(span, inputMessages, outputMessages)
+    this._tagger.tagMetadata(span, metadata)
+    this._tagger.tagMetrics(span, metrics)
+  }
+}
+
+function getMetadata (instance) {
+  const metadata = {}
+
+  const modelConfig = instance.generationConfig
+  if (!modelConfig) return metadata
+
+  for (const [parameter, parameterKey] of [
+    ['temperature', 'temperature'],
+    ['maxOutputTokens', 'max_output_tokens'],
+    ['candidateCount', 'candidate_count'],
+    ['topP', 'top_p'],
+    ['topK', 'top_k']
+  ]) {
+    if (modelConfig[parameter]) {
+      metadata[parameterKey] = modelConfig[parameter]
+    }
+  }
+
+  return metadata
+}
+
+function extractInputMessages (request, history, systemInstructions) {
+  const contents = typeof request === 'string' || Array.isArray(request) ? request : request.contents
+  const messages = []
+
+  if (systemInstructions) {
+    for (const instruction of systemInstructions) {
+      messages.push({ content: instruction || '', role: 'system' })
+    }
+  }
+
+  for (const content of history) {
+    messages.push(...extractMessagesFromContent(content))
+  }
+
+  if (typeof contents === 'string') {
+    messages.push({ content: contents })
+    return messages
+  }
+
+  if (isPart(contents)) {
+    messages.push(extractMessageFromPart(contents))
+    return messages
+  }
+
+  if (!Array.isArray(contents)) {
+    messages.push({
+      content: '[Non-array content object: ' +
+      `${(typeof contents.toString === 'function' ? contents.toString() : String(contents))}]`
+    })
+    return messages
+  }
+
+  for (const content of contents) {
+    if (typeof content === 'string') {
+      messages.push({ content })
+      continue
+    }
+
+    if (isPart(content)) {
+      messages.push(extractMessageFromPart(content))
+      continue
+    }
+
+    messages.push(...extractMessagesFromContent(content))
+  }
+
+  return messages
+}
+
+function extractOutputMessages (result) {
+  if (!result) return [{ content: '' }]
+  const { response } = result
+
+  if (!response) return [{ content: '' }]
+
+  const outputMessages = []
+  const candidates = response.candidates || []
+  for (const candidate of candidates) {
+    const content = candidate.content || ''
+    outputMessages.push(...extractMessagesFromContent(content))
+  }
+
+  return outputMessages
+}
+
+function extractMessagesFromContent (content) {
+  const messages = []
+
+  const role = content.role || ''
+  const parts = content.parts || []
+  if (parts == null || parts.length === 0 || !Array.isArray(parts)) {
+    const message = {
+      content:
+      `[Non-text content object: ${(typeof content.toString === 'function' ? content.toString() : String(content))}]`
+    }
+    if (role) message.role = role
+    messages.push(message)
+    return messages
+  }
+
+  for (const part of parts) {
+    const message = extractMessageFromPart(part, role)
+    messages.push(message)
+  }
+
+  return messages
+}
+
+function extractMessageFromPart (part, role) {
+  const text = part.text || ''
+  const functionCall = part.functionCall
+  const functionResponse = part.functionResponse
+
+  const message = { content: text }
+  if (role) message.role = role
+  if (functionCall) {
+    message.toolCalls = [{
+      name: functionCall.name,
+      arguments: functionCall.args
+    }]
+  }
+  if (functionResponse) {
+    message.content = `[tool result: ${functionResponse.response}]`
+  }
+
+  return message
+}
+
+function extractMetrics (result) {
+  if (!result) return {}
+  const { response } = result
+
+  if (!response) return {}
+
+  const tokenCounts = response.usageMetadata
+  const metrics = {}
+  if (tokenCounts) {
+    metrics.inputTokens = tokenCounts.promptTokenCount
+    metrics.outputTokens = tokenCounts.candidatesTokenCount
+    metrics.totalTokens = tokenCounts.totalTokenCount
+  }
+
+  return metrics
+}
+
+function isPart (part) {
+  return part.text || part.functionCall || part.functionResponse
+}
+
+module.exports = VertexAILLMObsPlugin

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

@@ -430,6 +430,7 @@ class LLMObs extends NoopLLMObs {
       modelProvider,
       sessionId,
       mlApp,
+      _decorator,
       ...spanOptions
     } = options
 
@@ -438,6 +439,7 @@ class LLMObs extends NoopLLMObs {
       modelName,
       modelProvider,
       sessionId,
+      _decorator,
       spanOptions
     }
   }

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

@@ -7,6 +7,7 @@ const {
   METADATA,
   INPUT_MESSAGES,
   INPUT_VALUE,
+  INTEGRATION,
   OUTPUT_MESSAGES,
   INPUT_DOCUMENTS,
   OUTPUT_DOCUMENTS,
@@ -26,6 +27,8 @@ const {
   ERROR_STACK
 } = require('../constants')
 
+const telemetry = require('./telemetry')
+
 const LLMObsTagger = require('./tagger')
 
 const tracerVersion = require('../../../../package.json').version
@@ -48,6 +51,7 @@ class LLMObsSpanProcessor {
 
     try {
       const formattedEvent = this.format(span)
+      telemetry.incrementLLMObsSpanFinishedCount(span)
       this._writer.append(formattedEvent)
     } catch (e) {
       // this should be a rare case
@@ -186,6 +190,8 @@ class LLMObsSpanProcessor {
     const errType = span.context()._tags[ERROR_TYPE] || error?.name
     if (errType) tags.error_type = errType
     if (sessionId) tags.session_id = sessionId
+    const integration = LLMObsTagger.tagMap.get(span)?.[INTEGRATION]
+    if (integration) tags.integration = integration
     const existingTags = LLMObsTagger.tagMap.get(span)?.[TAGS] || {}
     if (existingTags) tags = { ...tags, ...existingTags }
     return Object.entries(tags).map(([key, value]) => `${key}:${value ?? ''}`)

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

@@ -22,7 +22,9 @@ const {
   ROOT_PARENT_ID,
   INPUT_TOKENS_METRIC_KEY,
   OUTPUT_TOKENS_METRIC_KEY,
-  TOTAL_TOKENS_METRIC_KEY
+  TOTAL_TOKENS_METRIC_KEY,
+  INTEGRATION,
+  DECORATOR
 } = require('./constants/tags')
 
 // global registry of LLMObs spans
@@ -51,7 +53,9 @@ class LLMObsTagger {
     mlApp,
     parent,
     kind,
-    name
+    name,
+    integration,
+    _decorator
   } = {}) {
     if (!this._config.llmobs.enabled) return
     if (!kind) return // do not register it in the map if it doesn't have an llmobs span kind
@@ -66,6 +70,8 @@ class LLMObsTagger {
 
     sessionId = sessionId || registry.get(parent)?.[SESSION_ID]
     if (sessionId) this._setTag(span, SESSION_ID, sessionId)
+    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)