dd-trace 6.18.0 → 6.20.0

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

@@ -1,10 +1,14 @@
 'use strict'
 
 const { storage } = require('../../../../datadog-core')
+const log = require('../../log')
 const telemetry = require('../telemetry')
+const { safeJsonParse } = require('../util')
 const {
+  buildUsage,
   extractRequestParams,
   extractTextAndResponseReason,
+  mergeStreamedUsage,
   parseModelId,
   extractTextAndResponseReasonFromStream,
   extractConverseToolDefinitions,
@@ -52,12 +56,45 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       // avoids instrumenting other non supported runtime operations
       if (!ENABLED_OPERATIONS.has(operation)) return
 
-      const { modelProvider, modelName } = parseModelId(request.params.modelId)
+      // the SDK rejects a request with no model id, and the parser assumes a string
+      const modelId = request.params?.modelId
+      if (typeof modelId !== 'string') return
+
+      const { modelProvider, modelName } = parseModelId(modelId)
 
       // avoids instrumenting non llm type
       if (modelName.includes('embed')) return
 
       const span = ctx.currentStore?.span
+      if (!span) return
+
+      if (!this._llmobsEnabledFor(ctx)) {
+        // no LLMObs payload to build, so the usage comes from the response headers and, where
+        // those are absent, from whatever reported it
+        let usage
+        if (CONVERSE_OPERATIONS.has(operation)) {
+          // a non-streamed Converse puts it on the response, a streamed one on a metadata event
+          usage = buildUsage(response.usage) ?? ctx.streamedUsage
+        } else if (operation.toLowerCase().includes('stream')) {
+          // every streamed frame was folded into the running totals as it arrived
+          usage = ctx.streamedUsage
+        } else {
+          // headers can report some counts and the body others, so both are read and
+          // `extractTokens` merges them field by field
+          usage = responseBodyUsage(response, modelProvider, modelName)
+        }
+
+        this._setGenAiApmTags(span, {
+          spanKind: 'llm',
+          modelName: modelId.toLowerCase(),
+          modelProvider: 'amazon_bedrock',
+          // a count no source reported comes back undefined and is left off the span: reporting
+          // zeros for every metric would be worse than reporting none
+          metrics: extractTokens({ tokensFromHeaders, usage: usage ?? {} }),
+        })
+        return
+      }
+
       this.setLLMObsTags({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders })
     })
 
@@ -71,6 +108,10 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       const cacheReadTokenCount = headers['x-amzn-bedrock-cache-read-input-token-count']
       const cacheWriteTokenCount = headers['x-amzn-bedrock-cache-write-input-token-count']
 
+      // Responses that report no counts at all, error responses included, would otherwise cache a
+      // record of undefined fields that reads as a measurement of zero.
+      if (!inputTokenCount && !outputTokenCount && !cacheReadTokenCount && !cacheWriteTokenCount) return
+
       pendingTokenHeaders.set(requestId, {
         inputTokensFromHeaders: inputTokenCount && Number.parseInt(inputTokenCount, 10),
         outputTokensFromHeaders: outputTokenCount && Number.parseInt(outputTokenCount, 10),
@@ -80,6 +121,13 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
     })
 
     this.addSub('apm:aws:response:streamed-chunk:bedrockruntime', ({ ctx, chunk }) => {
+      if (!this._llmobsEnabledFor(ctx)) {
+        // only the token counts are needed, for the `gen_ai.usage.*` metrics; the generated
+        // content is left to the LLMObs path, so nothing is retained past the running totals
+        ctx.streamedUsage = mergeChunkUsage(ctx, chunk)
+        return
+      }
+
       if (!ctx.chunks) ctx.chunks = []
 
       if (chunk) ctx.chunks.push(chunk)
@@ -141,10 +189,10 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       max_tokens: Number.parseInt(requestParams.maxTokens, 10) || 0,
     })
     this._tagger.tagLLMIO(span, requestParams.prompt, textAndResponseReason.messages)
-    this._tagger.tagMetrics(span, extractTokens({
+    this._tagger.tagMetrics(span, zeroFilled(extractTokens({
       tokensFromHeaders,
       usage: textAndResponseReason.usage,
-    }))
+    })))
   }
 }
 
@@ -159,9 +207,74 @@ function consumeTokenHeaders (requestId) {
 }
 
 /**
- * Combine response-body usage with header-derived counts, preferring the body.
+ * Fold one streamed frame's token counts into the totals on `ctx`. Converse reports them on a
+ * metadata event; `invokeModel` reports them in the frame body, in a shape that varies by
+ * provider, so the body is read through the same table the LLMObs path uses.
+ *
+ * @param {object} ctx
+ * @param {object} [chunk]
+ * @returns {import('../../../../datadog-plugin-aws-sdk/src/services/bedrockruntime/utils')
+ *   .StreamedUsage | undefined}
+ */
+function mergeChunkUsage (ctx, chunk) {
+  const metadataUsage = chunk?.metadata?.usage
+  if (metadataUsage) return buildUsage(metadataUsage) ?? ctx.streamedUsage
+
+  const bytes = chunk?.chunk?.bytes
+  if (!ArrayBuffer.isView(bytes)) return ctx.streamedUsage
+
+  // a view, not a copy: this runs on every frame of every streamed response
+  const text = Buffer.from(bytes.buffer, bytes.byteOffset, bytes.byteLength).toString('utf8')
+  const body = safeJsonParse(text, null)
+  // a frame the model filled with generated text rather than JSON must not reach the application
+  if (typeof body !== 'object' || body === null) return ctx.streamedUsage
+
+  return mergeStreamedUsage(ctx.streamedUsage, body, streamModelProvider(ctx))
+}
+
+/**
+ * Token usage a non-streamed `invokeModel` reports in its own response body, which several
+ * providers carry and the headers do not always correlate. Read through the same extractor the
+ * LLMObs path uses, which parses this body on every request anyway.
+ *
+ * @param {{ body?: Uint8Array }} response
+ * @param {string} modelProvider
+ * @param {string} modelName
+ * @returns {Record<string, number | undefined> | undefined}
+ */
+function responseBodyUsage (response, modelProvider, modelName) {
+  if (!response?.body) return
+
+  try {
+    return extractTextAndResponseReason(response, modelProvider, modelName).usage
+  } catch (e) {
+    // the extractor parses the body itself; a malformed one must not disable the plugin
+    log.debug('Failed to read Bedrock response usage: %s', e.message)
+  }
+}
+
+/**
+ * The provider is fixed for the life of the stream, so it is parsed off the request once.
+ *
+ * @param {object} ctx
+ */
+function streamModelProvider (ctx) {
+  if (ctx.streamModelProvider === undefined) {
+    const modelId = (ctx.request ?? ctx.response?.request)?.params?.modelId
+    ctx.streamModelProvider = typeof modelId === 'string'
+      ? parseModelId(modelId).modelProvider.toUpperCase()
+      : ''
+  }
+
+  return ctx.streamModelProvider
+}
+
+/**
+ * Combine response-body usage with header-derived counts, preferring the body. A count no source
+ * reported stays undefined rather than becoming a zero that reads as a measurement.
  *
  * @param {{ tokensFromHeaders: HeaderTokens | undefined, usage: Record<string, number | undefined> }} options
+ * @returns {Record<string, number | undefined>}
  */
 function extractTokens ({ tokensFromHeaders, usage }) {
   const {
@@ -171,21 +284,60 @@ function extractTokens ({ tokensFromHeaders, usage }) {
     cacheWriteTokensFromHeaders,
   } = tokensFromHeaders ?? {}
 
-  const inputTokens = usage.inputTokens || inputTokensFromHeaders || 0
-  const outputTokens = usage.outputTokens || outputTokensFromHeaders || 0
-  const cacheReadTokens = usage.cacheReadTokens || cacheReadTokensFromHeaders || 0
-  const cacheWriteTokens = usage.cacheWriteTokens || cacheWriteTokensFromHeaders || 0
+  const inputTokens = resolveCount(usage.inputTokens, inputTokensFromHeaders)
+  const outputTokens = resolveCount(usage.outputTokens, outputTokensFromHeaders)
+  const cacheReadTokens = resolveCount(usage.cacheReadTokens, cacheReadTokensFromHeaders)
+  const cacheWriteTokens = resolveCount(usage.cacheWriteTokens, cacheWriteTokensFromHeaders)
 
   // adjust for the fact that bedrock input tokens only count non-cached tokens
-  const normalizedInputTokens = inputTokens + cacheReadTokens + cacheWriteTokens
+  const normalizedInputTokens = inputTokens === undefined &&
+    cacheReadTokens === undefined &&
+    cacheWriteTokens === undefined
+    ? undefined
+    : (inputTokens ?? 0) + (cacheReadTokens ?? 0) + (cacheWriteTokens ?? 0)
+
+  const totalTokens = normalizedInputTokens === undefined && outputTokens === undefined
+    ? undefined
+    : (normalizedInputTokens ?? 0) + (outputTokens ?? 0)
 
   return {
     inputTokens: normalizedInputTokens,
     outputTokens,
-    totalTokens: normalizedInputTokens + outputTokens,
+    totalTokens,
     cacheReadTokens,
     cacheWriteTokens,
   }
 }
 
+/**
+ * The body wins over the headers whenever it reported a count, a measured zero included, and a
+ * value neither reported as a number is left undefined: header counts are parsed from strings
+ * and can arrive empty.
+ *
+ * @param {unknown} fromBody
+ * @param {unknown} fromHeaders
+ * @returns {number | undefined}
+ */
+function resolveCount (fromBody, fromHeaders) {
+  const value = typeof fromBody === 'number' ? fromBody : fromHeaders
+  return typeof value === 'number' && !Number.isNaN(value) ? value : undefined
+}
+
+/**
+ * The LLMObs metrics contract reports an unmeasured count as zero, where the `gen_ai.*` APM
+ * attributes leave it off the span entirely.
+ *
+ * @param {Record<string, number | undefined>} tokens
+ * @returns {Record<string, number>}
+ */
+function zeroFilled (tokens) {
+  return {
+    inputTokens: tokens.inputTokens ?? 0,
+    outputTokens: tokens.outputTokens ?? 0,
+    totalTokens: tokens.totalTokens ?? 0,
+    cacheReadTokens: tokens.cacheReadTokens ?? 0,
+    cacheWriteTokens: tokens.cacheWriteTokens ?? 0,
+  }
+}
+
 module.exports = BedrockRuntimeLLMObsPlugin

package/packages/dd-trace/src/llmobs/plugins/claude-agent-sdk/index.js

@@ -5,6 +5,7 @@ const { storage: llmobsStorage } = require('../../storage')
 const { NAME, SESSION_ID } = require('../../constants/tags')
 const { splitModel } = require('../../../../../datadog-plugin-claude-agent-sdk/src/util')
 
+const SYSTEM_PROMPT_DYNAMIC_BOUNDARY = '__SYSTEM_PROMPT_DYNAMIC_BOUNDARY__'
 const subagentToolIds = new Set()
 
 function normalizeToolOutputString (raw) {
@@ -39,6 +40,27 @@ function getToolOutputText (raw) {
   return JSON.stringify(raw)
 }
 
+/**
+ * @param {object} [usage]
+ * @returns {Record<string, number> | undefined}
+ */
+function extractUsageMetrics (usage) {
+  if (!usage) return
+
+  const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0
+  const cacheReadTokens = usage.cache_read_input_tokens ?? 0
+  const inputTokens = (usage.input_tokens ?? 0) + cacheWriteTokens + cacheReadTokens
+  const outputTokens = usage.output_tokens ?? 0
+
+  return {
+    input_tokens: inputTokens,
+    output_tokens: outputTokens,
+    cache_read_input_tokens: cacheReadTokens,
+    cache_write_input_tokens: cacheWriteTokens,
+    total_tokens: inputTokens + outputTokens,
+  }
+}
+
 function buildOutputMessages (chunks, llmStartIdx, llmEndIdx) {
   let thinking = ''
   let text = ''
@@ -85,6 +107,13 @@ class QueryLLMObsPlugin extends LLMObsPlugin {
     super.asyncEnd(ctx)
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    return { sessionId: ctx.session_id }
+  }
+
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     if (!span) return
@@ -99,6 +128,11 @@ class QueryLLMObsPlugin extends LLMObsPlugin {
 
     if (cwd) metadata.cwd = cwd
     if (permissionMode) metadata.permissionMode = permissionMode
+    const systemPrompt = ctx.arguments?.[0]?.options?.systemPrompt
+    if (systemPrompt?.type === 'preset') {
+      if (typeof systemPrompt.preset === 'string') metadata.systemPromptPreset = systemPrompt.preset
+      if (typeof systemPrompt.append === 'string') metadata.systemPromptAppend = systemPrompt.append
+    }
 
     this._tagger.tagMetadata(span, metadata)
   }
@@ -149,6 +183,13 @@ class LlmLlmObsPlugin extends LLMObsPlugin {
     return { kind: 'llm', name: ctx.model, modelName, modelProvider, sessionId: ctx.sessionId }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    return { metrics: extractUsageMetrics(ctx.usage) }
+  }
+
   end (ctx) {
     super.end(ctx)
     super.asyncEnd(ctx)
@@ -158,31 +199,32 @@ class LlmLlmObsPlugin extends LLMObsPlugin {
     const span = ctx.currentStore?.span
     if (!span) return
 
-    const { chunks, llmStartIdx, llmEndIdx, parentToolUseId, initialPrompt, usage } = ctx
+    const { chunks, llmStartIdx, llmEndIdx, parentToolUseId, initialPrompt, systemPrompt, usage } = ctx
 
     if (chunks) {
-      const inputMessages = this.#buildInputMessages(chunks, llmStartIdx, parentToolUseId, initialPrompt)
+      const inputMessages = this.#buildInputMessages(chunks, llmStartIdx, parentToolUseId, initialPrompt, systemPrompt)
       const outputMessages = buildOutputMessages(chunks, llmStartIdx, llmEndIdx)
       this._tagger.tagLLMIO(span, inputMessages, outputMessages)
     }
 
-    if (usage) {
-      const cacheWriteTokens = usage.cache_creation_input_tokens ?? 0
-      const cacheReadTokens = usage.cache_read_input_tokens ?? 0
-      const inputTokens = (usage.input_tokens ?? 0) + cacheWriteTokens + cacheReadTokens
-      const outputTokens = usage.output_tokens ?? 0
-      this._tagger.tagMetrics(span, {
-        input_tokens: inputTokens,
-        output_tokens: outputTokens,
-        cache_read_input_tokens: cacheReadTokens,
-        cache_write_input_tokens: cacheWriteTokens,
-        total_tokens: inputTokens + outputTokens,
-      })
-    }
+    const metrics = extractUsageMetrics(usage)
+    if (metrics) this._tagger.tagMetrics(span, metrics)
   }
 
-  #buildInputMessages (chunks, llmStartIdx, parentToolUseId, initialPrompt) {
+  #buildInputMessages (chunks, llmStartIdx, parentToolUseId, initialPrompt, systemPrompt) {
     const messages = []
+    let configuredPrompt = systemPrompt
+    if (systemPrompt?.type === 'custom') configuredPrompt = systemPrompt.prompt
+    else if (systemPrompt?.type === 'preset') configuredPrompt = systemPrompt.append
+    if (typeof configuredPrompt === 'string') {
+      if (configuredPrompt) messages.push({ role: 'system', content: configuredPrompt })
+    } else if (Array.isArray(configuredPrompt)) {
+      for (const part of configuredPrompt) {
+        if (typeof part === 'string' && part && part !== SYSTEM_PROMPT_DYNAMIC_BOUNDARY) {
+          messages.push({ role: 'system', content: part })
+        }
+      }
+    }
     if (initialPrompt) messages.push({ role: 'user', content: initialPrompt })
     const seenIds = new Set()
 
@@ -245,6 +287,13 @@ class ToolLlmObsPlugin extends LLMObsPlugin {
     super.asyncEnd(ctx)
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    return subagentToolIds.delete(ctx.id) ? { spanKind: 'agent' } : {}
+  }
+
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     if (!span) return

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

@@ -23,6 +23,13 @@ class GenAiLLMObsPlugin extends LLMObsPlugin {
 
     // Subscribe to streaming chunk events
     this.addSub('apm:google:genai:request:chunk', ({ ctx, chunk, done }) => {
+      if (!this._llmobsEnabledFor(ctx)) {
+        // only the token usage is needed, for the `gen_ai.usage.*` metrics. The aggregated
+        // response is left alone: it feeds the LLMObs payload and `google_genai.response.model`.
+        if (chunk?.usageMetadata) ctx.streamedUsageMetadata = chunk.usageMetadata
+        return
+      }
+
       ctx.isStreaming = true
       ctx.chunks ||= []
 
@@ -49,6 +56,13 @@ class GenAiLLMObsPlugin extends LLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    return { metrics: extractMetrics(ctx.result ?? { usageMetadata: ctx.streamedUsageMetadata }) }
+  }
+
   setLLMObsTags (ctx) {
     const { args, methodName } = ctx
     const span = ctx.currentStore?.span

package/packages/dd-trace/src/llmobs/plugins/langchain/handlers/chat_model.js

@@ -38,19 +38,6 @@ class LangChainLLMObsChatModelHandler extends LangChainLLMObsHandler {
     }
 
     const outputMessages = []
-    let inputTokens = 0
-    let outputTokens = 0
-    let totalTokens = 0
-    let tokensSetTopLevel = false
-    const tokensPerRunId = {}
-
-    if (!isWorkflow) {
-      const tokens = this.checkTokenUsageChatOrLLMResult(results)
-      inputTokens = tokens.inputTokens
-      outputTokens = tokens.outputTokens
-      totalTokens = tokens.totalTokens
-      tokensSetTopLevel = totalTokens > 0
-    }
 
     for (const messageSet of results.generations) {
       for (const chatCompletion of messageSet) {
@@ -59,35 +46,47 @@ class LangChainLLMObsChatModelHandler extends LangChainLLMObsHandler {
         const content = chatCompletionMessage.text || ''
         const toolCalls = this.extractToolCalls(chatCompletionMessage)
         outputMessages.push({ content, role, toolCalls })
-
-        if (!isWorkflow && !tokensSetTopLevel) {
-          const { tokens, runId } = this.checkTokenUsageFromAIMessage(chatCompletionMessage)
-          if (tokensPerRunId[runId]) {
-            tokensPerRunId[runId].inputTokens += tokens.inputTokens
-            tokensPerRunId[runId].outputTokens += tokens.outputTokens
-            tokensPerRunId[runId].totalTokens += tokens.totalTokens
-          } else {
-            tokensPerRunId[runId] = tokens
-          }
-        }
       }
     }
 
-    if (!isWorkflow && !tokensSetTopLevel) {
-      inputTokens = Object.values(tokensPerRunId).reduce((acc, val) => acc + val.inputTokens, 0)
-      outputTokens = Object.values(tokensPerRunId).reduce((acc, val) => acc + val.outputTokens, 0)
-      totalTokens = Object.values(tokensPerRunId).reduce((acc, val) => acc + val.totalTokens, 0)
-    }
-
     if (isWorkflow) {
       this._tagger.tagTextIO(span, inputMessages, outputMessages)
     } else {
       this._tagger.tagLLMIO(span, inputMessages, outputMessages)
-      this._tagger.tagMetrics(span, {
-        inputTokens,
-        outputTokens,
-        totalTokens,
-      })
+      this._tagger.tagMetrics(span, this.getTokenUsage(results))
+    }
+  }
+
+  /**
+   * @override
+   */
+  getTokenUsage (results) {
+    const tokens = this.checkTokenUsageChatOrLLMResult(results)
+    if (tokens.totalTokens > 0) return tokens
+
+    // providers that report usage on each generated message instead of on `llmOutput`; counts are
+    // summed per run so a run split across generations is totalled once
+    if (!results.generations) return tokens
+
+    const tokensPerRunId = {}
+    for (const messageSet of results.generations) {
+      for (const chatCompletion of messageSet) {
+        const { tokens: messageTokens, runId } = this.checkTokenUsageFromAIMessage(chatCompletion.message)
+        if (tokensPerRunId[runId]) {
+          tokensPerRunId[runId].inputTokens += messageTokens.inputTokens
+          tokensPerRunId[runId].outputTokens += messageTokens.outputTokens
+          tokensPerRunId[runId].totalTokens += messageTokens.totalTokens
+        } else {
+          tokensPerRunId[runId] = messageTokens
+        }
+      }
+    }
+
+    const perRun = Object.values(tokensPerRunId)
+    return {
+      inputTokens: perRun.reduce((acc, val) => acc + val.inputTokens, 0),
+      outputTokens: perRun.reduce((acc, val) => acc + val.outputTokens, 0),
+      totalTokens: perRun.reduce((acc, val) => acc + val.totalTokens, 0),
     }
   }
 

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

@@ -12,6 +12,16 @@ class LangChainLLMObsHandler {
 
   setMetaTags () {}
 
+  /**
+   * Token usage for a chat or LLM result. Subclasses widen this where the provider reports usage
+   * somewhere other than `llmOutput`.
+   *
+   * @param {object} results
+   */
+  getTokenUsage (results) {
+    return this.checkTokenUsageChatOrLLMResult(results)
+  }
+
   checkTokenUsageChatOrLLMResult (results) {
     const llmOutput = results.llmOutput
     const tokens = {

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

@@ -3,8 +3,6 @@
 const log = require('../../../log')
 const LLMObsPlugin = require('../base')
 
-const pluginManager = require('../../../../../..')._pluginManager
-
 const ANTHROPIC_PROVIDER_NAME = 'anthropic'
 const BEDROCK_PROVIDER_NAME = 'amazon_bedrock'
 const OPENAI_PROVIDER_NAME = 'openai'
@@ -76,6 +74,28 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx, spanKind) {
+    // the helper reports zeros when the result carries no usage, and zeroed token metrics would
+    // read as a real measurement
+    const tokens = this._handlers[ctx.type]?.getTokenUsage(ctx.result ?? {})
+    const metrics = tokens?.totalTokens ? tokens : undefined
+
+    // langchain-openai calls an untraced beta client when `response_format` is set, so this span is
+    // the only model span for the call. `handlers/chat_model.js` applies the same correction through
+    // `changeKind` while building the LLMObs payload.
+    if (spanKind !== WORKFLOW || ctx.type !== 'chat_model' || !ctx.arguments?.[1]?.response_format) {
+      return { metrics }
+    }
+
+    const provider = ctx.currentStore?.span?.context().getTags()['langchain.request.provider']
+    const isOpenAI = this.getIntegrationName(ctx.type, provider) === OPENAI_PROVIDER_NAME
+
+    return isOpenAI ? { spanKind: LLM, metrics } : { metrics }
+  }
+
   setLLMObsTags (ctx) {
     ctx.args = ctx.arguments
     ctx.instance = ctx.self
@@ -158,6 +178,9 @@ class BaseLangChainLLMObsPlugin extends LLMObsPlugin {
   }
 
   isLLMIntegrationEnabled (integration) {
+    // read off the owning manager rather than a module-scope capture: the tracer, and with it the
+    // plugin manager, can be rebuilt after this module is first loaded
+    const pluginManager = this._tracer?._pluginManager
     return SUPPORTED_INTEGRATIONS.has(integration) && pluginManager?._pluginsByName[integration]?.llmobs?._enabled
   }
 }

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

@@ -14,15 +14,16 @@ class PregelStreamLLMObsPlugin extends LLMObsPlugin {
   getLLMObsSpanRegisterOptions (ctx) {
     const name = ctx.self.name || 'LangGraph'
 
-    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
-    if (!enabled) return
-
     const span = ctx.currentStore?.span
     if (!span) return
-    streamDataMap.set(span, {
-      streamInputs: ctx.arguments?.[0],
-      chunks: [],
-    })
+
+    // only the LLMObs payload consumes the accumulated stream
+    if (this._llmobsEnabledFor(ctx)) {
+      streamDataMap.set(span, {
+        streamInputs: ctx.arguments?.[0],
+        chunks: [],
+      })
+    }
 
     return {
       kind: 'workflow',

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

@@ -74,6 +74,19 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    const response = ctx.result?.data
+
+    return {
+      // the response model is the resolved one, e.g. the dated version behind an alias
+      modelName: response?.model,
+      metrics: response && this._extractMetrics(response),
+    }
+  }
+
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     const resource = ctx.methodName
@@ -81,8 +94,8 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
     if (!methodName) return // we will not trace all openai methods for llmobs
 
     const inputs = ctx.args[0] // completion, chat completion, and embeddings take one argument
-    const response = ctx.result?.data // no result if error
-    const error = !!span.context().getTag('error')
+    const response = ctx.result?.data // no result if error, or if a stream ended before any response arrived
+    const error = !!span.context().getTag('error') || response == null
 
     const operation = getOperation(methodName)
 

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

@@ -155,6 +155,11 @@ class RealtimeLLMObsPlugin extends LLMObsPlugin {
   static integration = 'openai'
   static system = 'openai'
 
+  // The instrumentation retains a turn's audio only while these plugins are subscribed, and only
+  // the LLM Observability payload reads those bytes. Staying subscribed for the `gen_ai.*` tags
+  // alone would buffer megabytes per turn for no consumer, so realtime opts out.
+  static emitsGenAiApmTags = false
+
   /**
    * The instrumentation replays the turn with `traceSync`, which never publishes `asyncEnd`, so tag
    * on `end` instead — before the sibling tracing plugin's `end` finishes the span, since the LLM

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

@@ -23,6 +23,13 @@ class VertexAILLMObsPlugin extends LLMObsPlugin {
     }
   }
 
+  /**
+   * @override
+   */
+  getGenAiApmEndTags (ctx) {
+    return { metrics: extractMetrics(ctx.result) }
+  }
+
   setLLMObsTags (ctx) {
     const span = ctx.currentStore?.span
     if (!span) return

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

@@ -2,7 +2,8 @@
 
 /** @typedef {import('../../../../../index').llmobs.FormattedPromptMessage} FormattedPromptMessage */
 
-const VARIABLE_PATTERN = /(?<!\{)(?:\{\{\s*(\w+)\s*\}\}(?!\})|\{\s*(\w+)\s*\}(?!\}))/g
+// Match double braces first; preserve surrounding braces such as the closing object in {"age": {age}}.
+const VARIABLE_PATTERN = /\{\{\s*(\w+)\s*\}\}|\{\s*(\w+)\s*\}/g
 
 function isMessage (value) {
   return typeof value?.role === 'string' &&