dd-trace 5.42.0 → 5.44.0

package/packages/dd-trace/src/encode/0.4.js

@@ -5,11 +5,22 @@ const { Chunk, MsgpackEncoder } = require('../msgpack')
 const log = require('../log')
 const { isTrue } = require('../util')
 const coalesce = require('koalas')
+const { memoize } = require('../log/utils')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
 
-function formatSpan (span) {
-  return normalizeSpan(truncateSpan(span, false))
+function formatSpan (span, config) {
+  span = normalizeSpan(truncateSpan(span, false))
+  if (span.span_events) {
+    // ensure span events are encoded as tags if agent doesn't support native top level span events
+    if (!config?.trace?.nativeSpanEvents) {
+      span.meta.events = JSON.stringify(span.span_events)
+      delete span.span_events
+    } else {
+      formatSpanEvents(span)
+    }
+  }
+  return span
 }
 
 class AgentEncoder {
@@ -24,6 +35,7 @@ class AgentEncoder {
       process.env.DD_TRACE_ENCODING_DEBUG,
       false
     ))
+    this._config = this._writer?._config
   }
 
   count () {
@@ -74,16 +86,18 @@ class AgentEncoder {
     this._encodeArrayPrefix(bytes, trace)
 
     for (let span of trace) {
-      span = formatSpan(span)
+      span = formatSpan(span, this._config)
       bytes.reserve(1)
 
-      if (span.type && span.meta_struct) {
-        bytes.buffer[bytes.length - 1] = 0x8d
-      } else if (span.type || span.meta_struct) {
-        bytes.buffer[bytes.length - 1] = 0x8c
-      } else {
-        bytes.buffer[bytes.length - 1] = 0x8b
-      }
+      // this is the original size of the fixed map for span attributes that always exist
+      let mapSize = 11
+
+      // increment the payload map size depending on if some optional fields exist
+      if (span.type) mapSize += 1
+      if (span.meta_struct) mapSize += 1
+      if (span.span_events) mapSize += 1
+
+      bytes.buffer[bytes.length - 1] = 0x80 + mapSize
 
       if (span.type) {
         this._encodeString(bytes, 'type')
@@ -112,6 +126,10 @@ class AgentEncoder {
       this._encodeMap(bytes, span.meta)
       this._encodeString(bytes, 'metrics')
       this._encodeMap(bytes, span.metrics)
+      if (span.span_events) {
+        this._encodeString(bytes, 'span_events')
+        this._encodeObjectAsArray(bytes, span.span_events, new Set())
+      }
       if (span.meta_struct) {
         this._encodeString(bytes, 'meta_struct')
         this._encodeMetaStruct(bytes, span.meta_struct)
@@ -200,6 +218,9 @@ class AgentEncoder {
       case 'number':
         this._encodeFloat(bytes, value)
         break
+      case 'boolean':
+        this._encodeBool(bytes, value)
+        break
       default:
         // should not happen
     }
@@ -258,7 +279,7 @@ class AgentEncoder {
       this._encodeObjectAsArray(bytes, value, circularReferencesDetector)
     } else if (value !== null && typeof value === 'object') {
       this._encodeObjectAsMap(bytes, value, circularReferencesDetector)
-    } else if (typeof value === 'string' || typeof value === 'number') {
+    } else if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
       this._encodeValue(bytes, value)
     }
   }
@@ -268,7 +289,7 @@ class AgentEncoder {
     const validKeys = keys.filter(key => {
       const v = value[key]
       return typeof v === 'string' ||
-        typeof v === 'number' ||
+        typeof v === 'number' || typeof v === 'boolean' ||
         (v !== null && typeof v === 'object' && !circularReferencesDetector.has(v))
     })
 
@@ -319,4 +340,79 @@ class AgentEncoder {
   }
 }
 
+const memoizedLogDebug = memoize((key, message) => {
+  log.debug(message)
+  // return something to store in memoize cache
+  return true
+})
+
+function formatSpanEvents (span) {
+  for (const spanEvent of span.span_events) {
+    if (spanEvent.attributes) {
+      for (const [key, value] of Object.entries(spanEvent.attributes)) {
+        const newValue = convertSpanEventAttributeValues(key, value)
+        if (newValue !== undefined) {
+          spanEvent.attributes[key] = newValue
+        } else {
+          delete spanEvent.attributes[key] // delete from attributes if undefined
+        }
+      }
+      if (Object.entries(spanEvent.attributes).length === 0) {
+        delete spanEvent.attributes
+      }
+    }
+  }
+}
+
+function convertSpanEventAttributeValues (key, value, depth = 0) {
+  if (typeof value === 'string') {
+    return {
+      type: 0,
+      string_value: value
+    }
+  } else if (typeof value === 'boolean') {
+    return {
+      type: 1,
+      bool_value: value
+    }
+  } else if (Number.isInteger(value)) {
+    return {
+      type: 2,
+      int_value: value
+    }
+  } else if (typeof value === 'number') {
+    return {
+      type: 3,
+      double_value: value
+    }
+  } else if (Array.isArray(value)) {
+    if (depth === 0) {
+      const convertedArray = value
+        .map((val) => convertSpanEventAttributeValues(key, val, 1))
+        .filter((convertedVal) => convertedVal !== undefined)
+
+      // Only include array_value if there are valid elements
+      if (convertedArray.length > 0) {
+        return {
+          type: 4,
+          array_value: convertedArray
+        }
+      } else {
+        // If all elements were unsupported, return undefined
+        return undefined
+      }
+    } else {
+      memoizedLogDebug(key, 'Encountered nested array data type for span event v0.4 encoding. ' +
+        `Skipping encoding key: ${key}: with value: ${typeof value}.`
+      )
+      return undefined
+    }
+  } else {
+    memoizedLogDebug(key, 'Encountered unsupported data type for span event v0.4 encoding, key: ' +
+       `${key}: with value: ${typeof value}. Skipping encoding of pair.`
+    )
+    return undefined
+  }
+}
+
 module.exports = { AgentEncoder }

package/packages/dd-trace/src/encode/0.5.js

@@ -7,7 +7,13 @@ const ARRAY_OF_TWO = 0x92
 const ARRAY_OF_TWELVE = 0x9c
 
 function formatSpan (span) {
-  return normalizeSpan(truncateSpan(span, false))
+  span = normalizeSpan(truncateSpan(span, false))
+  // ensure span events are encoded as tags
+  if (span.span_events) {
+    span.meta.events = JSON.stringify(span.span_events)
+    delete span.span_events
+  }
+  return span
 }
 
 class AgentEncoder extends BaseEncoder {

package/packages/dd-trace/src/exporters/agent/index.js

@@ -24,7 +24,8 @@ class AgentExporter {
       prioritySampler,
       lookup,
       protocolVersion,
-      headers
+      headers,
+      config
     })
 
     this._timer = undefined

package/packages/dd-trace/src/exporters/agent/writer.js

@@ -10,15 +10,16 @@ const BaseWriter = require('../common/writer')
 const METRIC_PREFIX = 'datadog.tracer.node.exporter.agent'
 
 class Writer extends BaseWriter {
-  constructor ({ prioritySampler, lookup, protocolVersion, headers }) {
+  constructor ({ prioritySampler, lookup, protocolVersion, headers, config = {} }) {
     super(...arguments)
     const AgentEncoder = getEncoder(protocolVersion)
 
     this._prioritySampler = prioritySampler
     this._lookup = lookup
     this._protocolVersion = protocolVersion
-    this._encoder = new AgentEncoder(this)
     this._headers = headers
+    this._config = config
+    this._encoder = new AgentEncoder(this)
   }
 
   _sendPayload (data, count, done) {

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

@@ -68,7 +68,7 @@ function setSingleSpanIngestionTags (span, options) {
   addTag({}, span.metrics, SPAN_SAMPLING_MAX_PER_SECOND, options.maxPerSecond)
 }
 
-function extractSpanLinks (trace, span) {
+function extractSpanLinks (formattedSpan, span) {
   const links = []
   if (span._links) {
     for (const link of span._links) {
@@ -87,10 +87,10 @@ function extractSpanLinks (trace, span) {
       links.push(formattedLink)
     }
   }
-  if (links.length > 0) { trace.meta['_dd.span_links'] = JSON.stringify(links) }
+  if (links.length > 0) { formattedSpan.meta['_dd.span_links'] = JSON.stringify(links) }
 }
 
-function extractSpanEvents (trace, span) {
+function extractSpanEvents (formattedSpan, span) {
   const events = []
   if (span._events) {
     for (const event of span._events) {
@@ -103,10 +103,12 @@ function extractSpanEvents (trace, span) {
       events.push(formattedEvent)
     }
   }
-  if (events.length > 0) { trace.meta.events = JSON.stringify(events) }
+  if (events.length > 0) {
+    formattedSpan.span_events = events
+  }
 }
 
-function extractTags (trace, span) {
+function extractTags (formattedSpan, span) {
   const context = span.context()
   const origin = context._trace.origin
   const tags = context._tags
@@ -114,7 +116,7 @@ function extractTags (trace, span) {
   const priority = context._sampling.priority
 
   if (tags['span.kind'] && tags['span.kind'] !== 'internal') {
-    addTag({}, trace.metrics, MEASURED, 1)
+    addTag({}, formattedSpan.metrics, MEASURED, 1)
   }
 
   const tracerService = span.tracer()._service.toLowerCase()
@@ -129,22 +131,22 @@ function extractTags (trace, span) {
       case 'service.name':
       case 'span.type':
       case 'resource.name':
-        addTag(trace, {}, map[tag], tags[tag])
+        addTag(formattedSpan, {}, map[tag], tags[tag])
         break
       // HACK: remove when Datadog supports numeric status code
       case 'http.status_code':
-        addTag(trace.meta, {}, tag, tags[tag] && String(tags[tag]))
+        addTag(formattedSpan.meta, {}, tag, tags[tag] && String(tags[tag]))
         break
       case 'analytics.event':
-        addTag({}, trace.metrics, ANALYTICS, tags[tag] === undefined || tags[tag] ? 1 : 0)
+        addTag({}, formattedSpan.metrics, ANALYTICS, tags[tag] === undefined || tags[tag] ? 1 : 0)
         break
       case HOSTNAME_KEY:
       case MEASURED:
-        addTag({}, trace.metrics, tag, tags[tag] === undefined || tags[tag] ? 1 : 0)
+        addTag({}, formattedSpan.metrics, tag, tags[tag] === undefined || tags[tag] ? 1 : 0)
         break
       case 'error':
         if (context._name !== 'fs.operation') {
-          extractError(trace, tags[tag])
+          extractError(formattedSpan, tags[tag])
         }
         break
       case ERROR_TYPE:
@@ -152,60 +154,60 @@ function extractTags (trace, span) {
       case ERROR_STACK:
         // HACK: remove when implemented in the backend
         if (context._name !== 'fs.operation') {
-          // HACK: to ensure otel.recordException does not influence trace.error
+          // HACK: to ensure otel.recordException does not influence formattedSpan.error
           if (tags.setTraceError) {
-            trace.error = 1
+            formattedSpan.error = 1
           }
         } else {
           break
         }
       default: // eslint-disable-line no-fallthrough
-        addTag(trace.meta, trace.metrics, tag, tags[tag])
+        addTag(formattedSpan.meta, formattedSpan.metrics, tag, tags[tag])
     }
   }
-  setSingleSpanIngestionTags(trace, context._spanSampling)
+  setSingleSpanIngestionTags(formattedSpan, context._spanSampling)
 
-  addTag(trace.meta, trace.metrics, 'language', 'javascript')
-  addTag(trace.meta, trace.metrics, PROCESS_ID, process.pid)
-  addTag(trace.meta, trace.metrics, SAMPLING_PRIORITY_KEY, priority)
-  addTag(trace.meta, trace.metrics, ORIGIN_KEY, origin)
-  addTag(trace.meta, trace.metrics, HOSTNAME_KEY, hostname)
+  addTag(formattedSpan.meta, formattedSpan.metrics, 'language', 'javascript')
+  addTag(formattedSpan.meta, formattedSpan.metrics, PROCESS_ID, process.pid)
+  addTag(formattedSpan.meta, formattedSpan.metrics, SAMPLING_PRIORITY_KEY, priority)
+  addTag(formattedSpan.meta, formattedSpan.metrics, ORIGIN_KEY, origin)
+  addTag(formattedSpan.meta, formattedSpan.metrics, HOSTNAME_KEY, hostname)
 }
 
-function extractRootTags (trace, span) {
+function extractRootTags (formattedSpan, span) {
   const context = span.context()
   const isLocalRoot = span === context._trace.started[0]
   const parentId = context._parentId
 
   if (!isLocalRoot || (parentId && parentId.toString(10) !== '0')) return
 
-  addTag({}, trace.metrics, SAMPLING_RULE_DECISION, context._trace[SAMPLING_RULE_DECISION])
-  addTag({}, trace.metrics, SAMPLING_LIMIT_DECISION, context._trace[SAMPLING_LIMIT_DECISION])
-  addTag({}, trace.metrics, SAMPLING_AGENT_DECISION, context._trace[SAMPLING_AGENT_DECISION])
-  addTag({}, trace.metrics, TOP_LEVEL_KEY, 1)
+  addTag({}, formattedSpan.metrics, SAMPLING_RULE_DECISION, context._trace[SAMPLING_RULE_DECISION])
+  addTag({}, formattedSpan.metrics, SAMPLING_LIMIT_DECISION, context._trace[SAMPLING_LIMIT_DECISION])
+  addTag({}, formattedSpan.metrics, SAMPLING_AGENT_DECISION, context._trace[SAMPLING_AGENT_DECISION])
+  addTag({}, formattedSpan.metrics, TOP_LEVEL_KEY, 1)
 }
 
-function extractChunkTags (trace, span) {
+function extractChunkTags (formattedSpan, span) {
   const context = span.context()
   const isLocalRoot = span === context._trace.started[0]
 
   if (!isLocalRoot) return
 
   for (const key in context._trace.tags) {
-    addTag(trace.meta, trace.metrics, key, context._trace.tags[key])
+    addTag(formattedSpan.meta, formattedSpan.metrics, key, context._trace.tags[key])
   }
 }
 
-function extractError (trace, error) {
+function extractError (formattedSpan, error) {
   if (!error) return
 
-  trace.error = 1
+  formattedSpan.error = 1
 
   if (isError(error)) {
     // AggregateError only has a code and no message.
-    addTag(trace.meta, trace.metrics, ERROR_MESSAGE, error.message || error.code)
-    addTag(trace.meta, trace.metrics, ERROR_TYPE, error.name)
-    addTag(trace.meta, trace.metrics, ERROR_STACK, error.stack)
+    addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_MESSAGE, error.message || error.code)
+    addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_TYPE, error.name)
+    addTag(formattedSpan.meta, formattedSpan.metrics, ERROR_STACK, error.stack)
   }
 }
 

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/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

@@ -105,12 +105,12 @@ class LLMObs extends NoopLLMObs {
 
     if (fn.length > 1) {
       return this._tracer.trace(name, spanOptions, (span, cb) =>
-        this._activate(span, { kind, options: llmobsOptions }, () => fn(span, cb))
+        this._activate(span, { kind, ...llmobsOptions }, () => fn(span, cb))
       )
     }
 
     return this._tracer.trace(name, spanOptions, span =>
-      this._activate(span, { kind, options: llmobsOptions }, () => fn(span))
+      this._activate(span, { kind, ...llmobsOptions }, () => fn(span))
     )
   }
 
@@ -166,7 +166,7 @@ class LLMObs extends NoopLLMObs {
       }
 
       try {
-        const result = llmobs._activate(span, { kind, options: llmobsOptions }, () => fn.apply(this, fnArgs))
+        const result = llmobs._activate(span, { kind, ...llmobsOptions }, () => fn.apply(this, fnArgs))
 
         if (result && typeof result.then === 'function') {
           return result.then(
@@ -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
     }
   }