dd-trace 5.132.0 → 5.134.0

package/packages/dd-trace/src/llmobs/plugins/nova-sonic.js

@@ -0,0 +1,92 @@
+'use strict'
+
+const { pcm16ToWav } = require('../audio-codec')
+const { fitsInlineAudioBudget, formatAudioPartWithGuard } = require('../audio-utils')
+const { AUDIO_FALLBACK, LLMOBS_AUDIO_INLINE_MAX_BYTES } = require('../constants/audio')
+const { storage } = require('../storage')
+const LLMObsPlugin = require('./base')
+
+class SonicLLMObsPlugin extends LLMObsPlugin {
+  static id = 'bedrockruntime_sonic_llmobs'
+  static integration = 'bedrock'
+  static system = 'aws.bedrock'
+  static prefix = 'tracing:apm:aws:bedrockruntime:sonic:span'
+  static emitsGenAiApmTags = false
+
+  constructor (...args) {
+    super(...args)
+    this.addSub('dd-trace:aws:bedrockruntime:sonic:capture-context', context => {
+      if (!this._llmobsEnabled) return
+      context.enabled = true
+      // Capture once at invocation, even when absent or already finished. Scoped replay restores
+      // the consumer's context on every exit, including exceptions, without repairing IDs later.
+      const store = storage.getStore()
+      const previous = context.runInContext ?? (fn => fn())
+      context.runInContext = fn => previous(() => storage.run(store, fn))
+    })
+  }
+
+  /** @param {object} ctx */
+  getLLMObsSpanRegisterOptions (ctx) {
+    const options = {
+      kind: ctx.kind,
+      name: ctx.name,
+      sessionId: ctx.descriptor.sessionId,
+    }
+    if (ctx.kind === 'llm') {
+      options.modelName = ctx.model
+      options.modelProvider = 'amazon'
+    }
+    return options
+  }
+
+  /** @param {object} ctx */
+  start (ctx) {
+    super.start(ctx)
+    // Replay already has the complete descriptor. Annotate before any end subscriber can finish
+    // the span, including when disabling/re-enabling LLMObs changes subscriber registration order.
+    if (this._llmobsEnabledFor(ctx)) this.setLLMObsTags(ctx)
+  }
+
+  /** @param {object} ctx */
+  setLLMObsTags (ctx) {
+    const span = ctx.currentStore?.span
+    if (!span) return
+    const { turn, history, metadata } = ctx.descriptor
+    const text = turn.finalText || turn.speculativeText
+    if (ctx.kind !== 'llm') {
+      if (ctx.name === 'nova sonic audio turn') this._tagger.tagTextIO(span, turn.userText, text)
+      return
+    }
+
+    const input = { role: 'user', content: turn.userText || (turn.inputAudioObserved ? AUDIO_FALLBACK : '') }
+    const output = { role: 'assistant', content: text || (turn.outputAudioObserved ? AUDIO_FALLBACK : '') }
+    if (turn.tools.length) output.toolCalls = turn.tools
+    const inputs = [...history, input, ...turn.toolResults]
+    const outputs = [output]
+    // Reserve the serialized text/tools and metadata before spending one budget across both WAVs.
+    let budget = Math.max(0, LLMOBS_AUDIO_INLINE_MAX_BYTES -
+      Buffer.byteLength(JSON.stringify([inputs, outputs, metadata])) - 256)
+    for (const [message, pcm, rate] of [
+      [input, turn.inputPcm, turn.inputRate],
+      [output, turn.output.pcm(), turn.output.rate],
+    ]) {
+      if (!pcm?.length || !rate) continue
+      const part = fitsInlineAudioBudget(pcm.length + 44, budget)
+        ? formatAudioPartWithGuard(pcm16ToWav(pcm, rate), 'audio/wav', budget)
+        : undefined
+      if (part) {
+        message.audioParts = [part]
+        budget -= part.content.length
+      } else if (message === output) {
+        metadata.output_audio_omitted_reason = 'payload_limit'
+      }
+    }
+    if (turn.output.omittedReason) metadata.output_audio_omitted_reason = turn.output.omittedReason
+    this._tagger.tagLLMIO(span, inputs, outputs)
+    this._tagger.tagMetadata(span, metadata)
+    this._tagger.tagMetrics(span, turn.metrics)
+  }
+}
+
+module.exports = SonicLLMObsPlugin

package/packages/dd-trace/src/llmobs/plugins/openai/constants.js

@@ -12,6 +12,9 @@ const AUDIO_MIME_TYPES = {
   mp3: 'audio/mpeg',
 }
 
+const DECISION_PROVIDER_TAG = 'decision_provider'
+const DECISION_PROVIDER = 'openai'
+
 module.exports = {
   INPUT_TYPE_IMAGE,
   INPUT_TYPE_FILE,
@@ -19,4 +22,6 @@ module.exports = {
   IMAGE_FALLBACK,
   FILE_FALLBACK,
   AUDIO_MIME_TYPES,
+  DECISION_PROVIDER_TAG,
+  DECISION_PROVIDER,
 }

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

@@ -8,7 +8,13 @@ const {
 } = require('../../constants/tags')
 const { audioMimeTypeFromFormat, formatAudioPart } = require('../../audio-utils')
 const { safeJsonParse } = require('../../util')
-const { AUDIO_MIME_TYPES } = require('./constants')
+const {
+  AUDIO_MIME_TYPES,
+  DECISION_PROVIDER,
+  DECISION_PROVIDER_TAG,
+  IMAGE_FALLBACK,
+  INPUT_TYPE_IMAGE,
+} = require('./constants')
 const {
   extractChatTemplateFromInstructions,
   normalizePromptVariables,
@@ -16,6 +22,7 @@ const {
   extractContentParts,
   hasMultimodalInputs,
   getModelProviderAndClient,
+  getServerToolUsageMetrics,
 } = require('./utils')
 
 const allowedParamKeys = new Set([
@@ -107,6 +114,8 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       this._tagEmbedding(span, inputs, response, error)
     } else if (operation === 'response') {
       this.#tagResponse(span, inputs, response, error)
+    } else if (operation === 'decision') {
+      this.#tagDecision(span, inputs, response, error)
     }
 
     if (!error) {
@@ -148,12 +157,20 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
         // Responses API - always include
         const cacheReadTokens = tokenUsage.input_tokens_details.cached_tokens
         if (cacheReadTokens !== undefined) metrics.cacheReadTokens = cacheReadTokens
+        const cacheWriteTokens = tokenUsage.input_tokens_details.cache_write_tokens
+        if (cacheWriteTokens != null) metrics.cacheWriteTokens = cacheWriteTokens
+        // Cache writes are billed at a different rate per TTL
+        const cacheWriteDetails = tokenUsage.input_tokens_details.cache_write_tokens_details
+        if (cacheWriteDetails?.ttl_30m_tokens != null) metrics.cacheWrite30mTokens = cacheWriteDetails.ttl_30m_tokens
+        if (cacheWriteDetails?.ttl_12h_tokens != null) metrics.cacheWrite12hTokens = cacheWriteDetails.ttl_12h_tokens
       } else if (tokenUsage.prompt_tokens_details) {
         // Chat/Completions API - only include if > 0
         const cacheReadTokens = tokenUsage.prompt_tokens_details.cached_tokens
         if (cacheReadTokens != null) {
           metrics.cacheReadTokens = cacheReadTokens
         }
+        const cacheWriteTokens = tokenUsage.prompt_tokens_details.cache_write_tokens
+        if (cacheWriteTokens != null) metrics.cacheWriteTokens = cacheWriteTokens
       }
       // Reasoning tokens - Responses API returns `output_tokens_details`, `completion_tokens_details`
       const reasoningOutputObject = tokenUsage.output_tokens_details ?? tokenUsage.completion_tokens_details
@@ -161,6 +178,8 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       if (reasoningOutputTokens !== undefined) metrics.reasoningOutputTokens = reasoningOutputTokens
     }
 
+    Object.assign(metrics, getServerToolUsageMetrics(response))
+
     return metrics
   }
 
@@ -464,6 +483,32 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
 
     this._tagger.tagMetadata(span, outputMetadata) // update the metadata with the output metadata
   }
+
+  #tagDecision (span, inputs, response, error) {
+    this._tagger.tagSpanTags(span, { [DECISION_PROVIDER_TAG]: DECISION_PROVIDER })
+
+    const { input, questions } = inputs
+
+    const inputMessages = typeof input === 'string'
+      ? [{ role: 'user', content: input }]
+      : (Array.isArray(input) ? input : []).map(message => ({
+          role: message.role ?? 'user',
+          content: decisionMessageContent(message.content),
+        }))
+
+    if (Array.isArray(questions)) {
+      this._tagger.tagMetadata(span, { questions })
+    }
+
+    if (error) {
+      this._tagger.tagLLMIO(span, inputMessages, [{ content: '' }])
+      return
+    }
+
+    this._tagger.tagLLMIO(span, inputMessages, [
+      { role: 'assistant', content: JSON.stringify(response.answers ?? []) },
+    ])
+  }
 }
 
 // TODO: this will be moved to the APM integration
@@ -485,13 +530,28 @@ function normalizeOpenAIResourceName (resource) {
     case 'responses.create':
       return 'createResponse'
 
+    // decisions
+    case 'decisions.create':
+      return 'createDecision'
+
     default:
       return resource
   }
 }
 
+// Decision images must be inline data URLs, so they are replaced with a marker instead of copied onto the span
+function decisionMessageContent (content) {
+  if (!Array.isArray(content)) return content ?? ''
+
+  return content
+    .map(part => (part?.type === INPUT_TYPE_IMAGE ? IMAGE_FALLBACK : part?.text ?? ''))
+    .filter(Boolean)
+    .join('\n')
+}
+
 function gateResource (resource) {
-  return ['createCompletion', 'createChatCompletion', 'createEmbedding', 'createResponse'].includes(resource)
+  return ['createCompletion', 'createChatCompletion', 'createEmbedding', 'createResponse', 'createDecision']
+    .includes(resource)
     ? resource
     : undefined
 }
@@ -506,6 +566,8 @@ function getOperation (resource) {
       return 'embedding'
     case 'createResponse':
       return 'response'
+    case 'createDecision':
+      return 'decision'
     default:
       // should never happen
       return 'unknown'

package/packages/dd-trace/src/llmobs/plugins/openai/utils.js

@@ -198,6 +198,43 @@ function getModelProviderAndClient (baseUrl = '') {
   return { modelProvider, client: 'OpenAI' }
 }
 
+/**
+ * Count the billable server-side tool calls in an OpenAI Responses response.
+ *
+ * Web searches are read from the undocumented `tool_usage.web_search.num_requests` when present, otherwise
+ * counted from completed `web_search_call` items whose action is `search` (`open_page` / `find_in_page` steps are
+ * not billed). File searches have no usage counter, so each completed `file_search_call` item counts once.
+ * Zero counts are omitted.
+ *
+ * @param {Record<string, unknown>} [response] - Any OpenAI response; only Responses API fields are read
+ * @returns {{ webSearchCount?: number, storageSearchCount?: number }}
+ */
+function getServerToolUsageMetrics (response) {
+  const metrics = {}
+  const reportedWebSearches = response?.tool_usage?.web_search?.num_requests
+  const hasReportedWebSearches = typeof reportedWebSearches === 'number'
+  if (hasReportedWebSearches && reportedWebSearches > 0) metrics.webSearchCount = reportedWebSearches
+
+  const output = response?.output
+  if (!Array.isArray(output)) return metrics
+
+  for (const item of output) {
+    if (item?.status !== 'completed') continue
+
+    if (item.type === 'web_search_call') {
+      if (hasReportedWebSearches) continue
+      // Items without an action (older payloads) are assumed to be searches.
+      const actionType = item.action?.type
+      if (actionType !== undefined && actionType !== 'search') continue
+      metrics.webSearchCount = (metrics.webSearchCount ?? 0) + 1
+    } else if (item.type === 'file_search_call') {
+      metrics.storageSearchCount = (metrics.storageSearchCount ?? 0) + 1
+    }
+  }
+
+  return metrics
+}
+
 module.exports = {
   extractChatTemplateFromInstructions,
   normalizePromptVariables,
@@ -206,4 +243,5 @@ module.exports = {
   hasMultimodalInputs,
   getModelProviderAndClient,
   getOpenAIModelProvider,
+  getServerToolUsageMetrics,
 }

package/packages/dd-trace/src/llmobs/prompts/manager.js

@@ -84,13 +84,11 @@ function promptFromData (data, source) {
 }
 
 /**
- * Copy a prompt with a different source.
  * @param {ManagedPrompt} prompt
- * @param {'registry'|'cache'|'fallback'|'ff'|'resolve'} source
  */
-function withSource (prompt, source) {
-  if (source === prompt.source) return prompt
-  return new ManagedPrompt({ ...prompt, source })
+function withCacheSource (prompt) {
+  if (SOURCE_CACHE === prompt.source) return prompt
+  return new ManagedPrompt({ ...prompt, source: /** @type {ManagedPrompt['source']} */ (SOURCE_CACHE) })
 }
 
 function detailFromBody (body) {
@@ -310,7 +308,7 @@ class PromptManager {
     const cacheable = generationAtStart === this.cacheGeneration && latest
     if (result.prompt) {
       if (cacheable) {
-        const cached = withSource(result.prompt, SOURCE_CACHE)
+        const cached = withCacheSource(result.prompt)
         if (hot) this.hotCache.set(request.key, cached)
         if (!request.resolve) this.warmCache.set(request.key, cached)
       }
@@ -335,7 +333,7 @@ class PromptManager {
   async #backgroundFetch (request, signal) {
     const result = await this.#fetchAndCache(request, { hot: false, signal })
     if (!result.cacheable) return
-    if (result.prompt) return withSource(result.prompt, SOURCE_CACHE)
+    if (result.prompt) return withCacheSource(result.prompt)
     if (result.notFound) return
     throw new Error(result.reason)
   }

package/packages/dd-trace/src/llmobs/prompts/prompt.js

@@ -93,7 +93,7 @@ class ManagedPrompt {
   format (variables = {}) {
     if (typeof this.template === 'string') return render(this.template, variables)
     return this.template.flatMap(item => {
-      if (!isPlaceholder(item)) return [{ ...item, content: render(item.content, variables) }]
+      if (!isPlaceholder(item)) return { ...item, content: render(item.content, variables) }
       if (!Object.hasOwn(variables, item.name)) {
         throw new TypeError(`Missing message placeholder variable '${item.name}'`)
       }

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

@@ -29,7 +29,7 @@ const {
   getFunctionArguments,
   validateKind,
 } = require('./util')
-const { buildAgentDeclaration } = require('./agent-manifest')
+const { buildAgentDeclaration, toAgentVersion } = require('./agent-manifest')
 /** @typedef {import('./agent-manifest').AgentDeclaration} AgentDeclaration */
 const { storage } = require('./storage')
 const telemetry = require('./telemetry')
@@ -163,7 +163,7 @@ class LLMObs extends NoopLLMObs {
     const {
       spanOptions,
       ...llmobsOptions
-    } = this.#extractOptions(options)
+    } = this.#extractOptions(options, kind)
 
     if (fn.length > 1) {
       return this._tracer.trace(name, spanOptions, (span, cb) =>
@@ -193,7 +193,7 @@ class LLMObs extends NoopLLMObs {
     const {
       spanOptions,
       ...llmobsOptions
-    } = this.#extractOptions(options)
+    } = this.#extractOptions(options, kind)
 
     const llmobs = this
 
@@ -719,21 +719,32 @@ class LLMObs extends NoopLLMObs {
     }
   }
 
-  #extractOptions (options) {
+  #extractOptions (options, kind) {
     const {
       modelName,
       modelProvider,
       sessionId,
       mlApp,
+      version,
       _decorator,
       ...spanOptions
     } = options
 
+    let agentVersion
+    if (version !== undefined) {
+      if (kind === 'agent') {
+        agentVersion = toAgentVersion(version)
+      } else {
+        logger.warn('Dropping the version option on a %s span, it is only supported for agent spans.', kind)
+      }
+    }
+
     return {
       mlApp,
       modelName,
       modelProvider,
       sessionId,
+      agentVersion,
       _decorator,
       spanOptions,
     }

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

@@ -16,6 +16,8 @@ const {
   METADATA,
   COST_TAGS,
   AGENT_MANIFEST,
+  AGENT_VERSION,
+  AGENT_VERSION_TAG_KEY,
   TOOL_DEFINITIONS,
   EXPERIMENT_INPUT,
   EXPERIMENT_OUTPUT,
@@ -32,6 +34,7 @@ const {
   PARENT_ID_KEY,
   PARENT_AGENT_NAME,
   PARENT_AGENT_SPAN_ID,
+  PARENT_AGENT_VERSION,
   SESSION_ID,
   NAME,
   INPUT_PROMPT,
@@ -92,9 +95,8 @@ class LLMObsSpanProcessor {
 
   // TODO: instead of relying on the tagger's weakmap registry, can we use some namespaced storage correlation?
   process (span) {
-    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     // if the span is not in our private tagger map, it is not an llmobs span
-    if (!LLMObsTagger.tagMap.has(span)) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED || !LLMObsTagger.tagMap.has(span)) return
 
     try {
       this.#setGenAiApmTags(span)
@@ -407,6 +409,15 @@ class LLMObsSpanProcessor {
     const existingTags = LLMObsTagger.tagMap.get(span)?.[TAGS] || {}
     if (existingTags) tags = { ...tags, ...existingTags }
 
+    const mlObsTags = LLMObsTagger.tagMap.get(span)
+    // Resolved here because a span can become an agent after registration. An agent without its own version, and
+    // any other span, reports the version inherited at registration. Either wins over a user
+    // tag of the same name.
+    const agentVersion = mlObsTags?.[SPAN_KIND] === 'agent'
+      ? mlObsTags[AGENT_VERSION] || mlObsTags[PARENT_AGENT_VERSION]
+      : mlObsTags?.[PARENT_AGENT_VERSION]
+    if (agentVersion) tags[AGENT_VERSION_TAG_KEY] = agentVersion
+
     return tags
   }
 

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

@@ -19,6 +19,7 @@ const {
   METADATA,
   COST_TAGS,
   AGENT_MANIFEST,
+  AGENT_VERSION,
   METRICS,
   TOOL_DEFINITIONS,
   PARENT_ID_KEY,
@@ -28,6 +29,7 @@ const {
   NAME,
   PARENT_AGENT_NAME,
   PARENT_AGENT_SPAN_ID,
+  PARENT_AGENT_VERSION,
   PROPAGATED_PARENT_ID_KEY,
   PROPAGATED_PARENT_AGENT_ID_KEY,
   PROPAGATED_PARENT_AGENT_NAME_KEY,
@@ -116,10 +118,11 @@ class LLMObsTagger {
     kind,
     name,
     integration,
+    agentVersion,
     _decorator,
   } = {}) {
-    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
-    if (!kind) return // do not register it in the map if it doesn't have an llmobs span kind
+    // Do not register it in the map if it does not have an LLMObs span kind.
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED || !kind) return
 
     const spanMlApp =
       mlApp ||
@@ -193,6 +196,8 @@ class LLMObsTagger {
       storage.getStore()?.agentDeclarations
     )
     if (agentDeclarations) this.#applyAgentDeclarations(span, agentDeclarations)
+    // The span's own version wins over the enclosing contexts.
+    if (agentVersion) this._setTag(span, AGENT_VERSION, agentVersion)
 
     // apply annotation context name
     const annotationContextName = annotationContext?.name
@@ -213,15 +218,16 @@ class LLMObsTagger {
 
   /**
    * Applies the agents declared by the enclosing annotation contexts, outermost first, to every span in the block.
-   * The manifest is emitted only if the span is an agent when it finishes, since some integrations promote a span
-   * to an agent after registration.
+   * Both are emitted only if the span is an agent when it finishes, since some integrations promote a span to an
+   * agent after registration.
    *
    * @param {import('../opentracing/span')} span
    * @param {import('./agent-manifest').AgentDeclaration[]} declarations
    */
   #applyAgentDeclarations (span, declarations) {
     for (const declaration of declarations) {
-      this.#tagAgentManifestFields(span, declaration.manifest)
+      if (declaration.version) this._setTag(span, AGENT_VERSION, declaration.version)
+      if (declaration.manifest) this.#tagAgentManifestFields(span, declaration.manifest)
     }
   }
 
@@ -233,7 +239,9 @@ class LLMObsTagger {
    */
   tagAgent (span, agent) {
     const declaration = buildAgentDeclaration(agent)
-    if (declaration) this.#tagAgentManifestFields(span, declaration.manifest)
+    if (!declaration) return
+    if (declaration.version) this._setTag(span, AGENT_VERSION, declaration.version)
+    if (declaration.manifest) this.#tagAgentManifestFields(span, declaration.manifest)
   }
 
   /**
@@ -276,8 +284,9 @@ class LLMObsTagger {
 
   /**
    * Store the nearest agent ancestor on the span so it can be surfaced as
-   * `meta.agent_attribution` at finish. Resolved once here, at registration, so downstream
-   * children inherit it with a single lookup rather than walking the ancestor chain.
+   * `meta.agent_attribution` at finish, along with that agent's version, which the agent panel reads
+   * off each span to attribute its spend. Resolved once here, at registration, so downstream children
+   * inherit it with a single lookup rather than walking the ancestor chain.
    *
    * @param {import('../opentracing/span')} span
    * @param {import('../opentracing/span')} [parent] the LLMObs parent span, if any
@@ -285,10 +294,10 @@ class LLMObsTagger {
   // TODO: spans whose kind changes after registration (e.g. claude-agent-sdk tools promoted to
   // sub-agents) will not retroactively update already-finished children's attribution. Follow up.
   #tagAgentAttribution (span, parent) {
-    let name, spanId
+    let name, spanId, version
     if (registry.has(parent)) {
       // Local LLMObs parent: attribute to it if it is an agent, else inherit its resolution.
-      ({ name, spanId } = resolveAgentAttribution(registry.get(parent), parent))
+      ({ name, spanId, version } = resolveAgentAttribution(registry.get(parent), parent))
     } else if (span.context()._trace.tags[PROPAGATED_PARENT_ID_KEY]) {
       // Distributed LLMObs parent: inherit the nearest agent propagated from upstream. The
       // name may be absent when the upstream hop ran an older SDK or its name was not
@@ -300,6 +309,7 @@ class LLMObsTagger {
 
     if (name != null) this._setTag(span, PARENT_AGENT_NAME, name)
     if (spanId != null) this._setTag(span, PARENT_AGENT_SPAN_ID, spanId)
+    if (version) this._setTag(span, PARENT_AGENT_VERSION, version)
   }
 
   // TODO: similarly for the following `tag` methods,

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

@@ -8,8 +8,10 @@ const {
   SPAN_KINDS,
   SPAN_KIND,
   NAME,
+  AGENT_VERSION,
   PARENT_AGENT_NAME,
   PARENT_AGENT_SPAN_ID,
+  PARENT_AGENT_VERSION,
 } = require('./constants/tags')
 
 const DECIMAL_TRACE_ID_REGEX = /^\d+$/
@@ -260,8 +262,7 @@ function findArgumentsBounds (str) {
 
 const memo = new WeakMap()
 function getFunctionArguments (fn, args = []) {
-  if (!fn) return
-  if (!args.length) return
+  if (!fn || !args.length) return
   if (args.length === 1) return args[0]
 
   try {
@@ -326,14 +327,18 @@ function agentNameWireSafe (name) {
  *
  * @param {Record<string, unknown> | undefined} tags - Registry entry for the parent span.
  * @param {import('../opentracing/span')} [span] - The parent span itself (needed for span id / name).
- * @returns {{ name: string | undefined, spanId: string | undefined }}
+ * @returns {{ name: string | undefined, spanId: string | undefined, version: string | undefined }}
  */
 function resolveAgentAttribution (tags, span) {
-  if (!tags) return { name: undefined, spanId: undefined }
+  if (!tags) return { name: undefined, spanId: undefined, version: undefined }
   if (tags[SPAN_KIND] === 'agent') {
-    return { name: tags[NAME] || span._name, spanId: span.context().toSpanId() }
+    return {
+      name: tags[NAME] || span._name,
+      spanId: span.context().toSpanId(),
+      version: tags[AGENT_VERSION] || tags[PARENT_AGENT_VERSION],
+    }
   }
-  return { name: tags[PARENT_AGENT_NAME], spanId: tags[PARENT_AGENT_SPAN_ID] }
+  return { name: tags[PARENT_AGENT_NAME], spanId: tags[PARENT_AGENT_SPAN_ID], version: tags[PARENT_AGENT_VERSION] }
 }
 
 function spanHasError (span) {

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

@@ -23,13 +23,12 @@ class LLMObsBuffer {
   /**
    * @param {{
    *   events: Record<string, unknown>[],
-   *   size: number,
    *   routing?: { apiKey?: string, site?: string }
    * }} options
    */
-  constructor ({ events, size, routing = {} }) {
+  constructor ({ events, routing = {} }) {
     this.events = events
-    this.size = size
+    this.size = 0
     this.routing = routing
   }
 
@@ -53,7 +52,7 @@ class BaseLLMObsWriter {
     this._eventType = eventType
 
     /** @type {LLMObsBuffer} */
-    this._buffer = new LLMObsBuffer({ events: [], size: 0 })
+    this._buffer = new LLMObsBuffer({ events: [] })
 
     /** @type {import('../../config/config-base')} */
     this._config = config
@@ -92,7 +91,7 @@ class BaseLLMObsWriter {
     const apiKey = routing.apiKey
     let buffer = this.#multiTenantBuffers.get(apiKey)
     if (!buffer) {
-      buffer = new LLMObsBuffer({ events: [], size: 0, routing })
+      buffer = new LLMObsBuffer({ events: [], routing })
       this.#multiTenantBuffers.set(apiKey, buffer)
     }
     return buffer

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

@@ -17,11 +17,7 @@ class Log {
   get formatted () {
     const { message, args } = this
 
-    let formatted = message
-    if (message && args && args.length) {
-      formatted = format(message, ...args)
-    }
-    return formatted
+    return message && args && args.length ? format(message, ...args) : message
   }
 
   static parse (...args) {