dd-trace 5.105.0 → 5.107.0

package/packages/dd-trace/src/debugger/devtools_client/config.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { workerData: { config: parentConfig, parentThreadId, configPort } } = require('node:worker_threads')
-const { getAgentUrl } = require('../../agent/url')
 const processTags = require('../../process-tags')
 const log = require('./log')
 
@@ -21,6 +20,8 @@ configPort.on('messageerror', (err) =>
 )
 
 function updateConfig (updates) {
-  config.url = getAgentUrl(updates)
+  // The worker receives a serialized config (see ../config.js) where `url` is a string, so it is
+  // reconstructed into a URL here rather than read directly off a Config instance.
+  config.url = new URL(updates.url)
   config.dynamicInstrumentation.captureTimeoutNs = BigInt(updates.dynamicInstrumentation.captureTimeoutMs) * 1_000_000n
 }

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

@@ -6,7 +6,6 @@ const { join } = require('path')
 const { Worker, MessageChannel, threadId: parentThreadId } = require('worker_threads')
 const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
-const { getAgentUrl } = require('../agent/url')
 const getDebuggerConfig = require('./config')
 const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('./constants')
 
@@ -211,7 +210,7 @@ function cleanup (error) {
 function detectDebuggerEndpoint (config, cb) {
   log.debug('[debugger] Detecting available debugger endpoints...')
 
-  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
+  fetchAgentInfo(config.url, (err, agentInfo) => {
     if (err) {
       log.warn('[debugger] Failed to query agent %s endpoint, falling back to %s',
         DEBUGGER_INPUT_V2,

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

@@ -6,7 +6,6 @@ const isIP = require('net').isIP
 const request = require('./exporters/common/request')
 const log = require('./log')
 const Histogram = require('./histogram')
-const { getAgentUrl } = require('./agent/url')
 const { entityId } = require('./exporters/common/docker')
 
 const MAX_BUFFER_SIZE = 1024 // limit from the agent
@@ -191,8 +190,8 @@ class DogStatsDClient {
       lookup: config.lookup,
     }
 
-    if (config.url || config.port) {
-      clientConfig.metricsProxyUrl = getAgentUrl(config)
+    if (config.url) {
+      clientConfig.metricsProxyUrl = config.url
     }
 
     return clientConfig

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

@@ -3,7 +3,7 @@
 const getConfig = require('../config')
 const { MsgpackChunk } = require('../msgpack')
 const log = require('../log')
-const { normalizeSpan } = require('./tags-processors')
+const { normalizeSpan, eventTimeNano } = require('./tags-processors')
 
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
 // Values longer than this byte threshold skip the `_stringMap` lookup and
@@ -114,8 +114,10 @@ const ATTR_PAYLOAD_BOOL_FALSE = Buffer.concat([ATTR_PREFIX_BOOL, Buffer.from([0x
 function formatSpanWithLegacyEvents (span) {
   span = normalizeSpan(span)
   if (span.span_events) {
-    // TODO: this is currently a main cost driver. By unifying it with the formatter
-    // it should be possible to improve performance significantly overall.
+    // Reads the raw `_events` array directly (no formatter pre-reshape) and
+    // serializes to the legacy meta.events JSON string. The serialization is
+    // still the main cost on the legacy path; the native span_events slot
+    // (`#encodeSpanEvents`) avoids it entirely.
     span.meta.events = stringifySpanEvents(span.span_events)
     // `= undefined` over `delete` to keep the span's hidden class — `delete`
     // would push every event-bearing span into V8 dictionary mode.
@@ -125,14 +127,15 @@ function formatSpanWithLegacyEvents (span) {
 }
 
 /**
- * Hand-written stringifier for `span.span_events`. The shape is fixed by
- * `extractSpanEvents` (`{ name, time_unix_nano, attributes? }`) and attribute
- * values are pre-sanitized to primitives or arrays of primitives, so we can
- * skip everything `JSON.stringify` does for the generic case (toJSON probing,
- * key iteration over the prototype chain, replacer hooks). Output matches
- * `JSON.stringify(spanEvents)` byte-for-byte for the post-sanitization shape.
+ * Hand-written stringifier for `span.span_events`. Events arrive in their raw
+ * `{ name, startTime, attributes? }` shape; `time_unix_nano` is derived per
+ * event via `eventTimeNano` and empty attribute objects are dropped, matching
+ * what the formatter used to precompute. Attribute values are pre-sanitized to
+ * primitives or arrays of primitives, so we skip everything `JSON.stringify`
+ * does for the generic case (toJSON probing, prototype-chain key iteration,
+ * replacer hooks).
  *
- * @param {Array<{ name: string, time_unix_nano: number, attributes?: object }>} spanEvents
+ * @param {Array<{ name: unknown, startTime: number, attributes?: object }>} spanEvents
  * @returns {string}
  */
 function stringifySpanEvents (spanEvents) {
@@ -140,17 +143,21 @@ function stringifySpanEvents (spanEvents) {
   for (let index = 0; index < spanEvents.length; index++) {
     if (index > 0) result += ','
     const event = spanEvents[index]
+    // `_sanitizeEventAttributes` leaves `attributes` undefined when empty, so a
+    // present value always has entries — no emptiness probe here.
+    const attributes = event.attributes
     // `addEvent` does not type-check `name`; defer the unusual cases to
-    // `JSON.stringify` so non-string names match the prior behaviour
-    // instead of throwing in `escapeJsonString`.
+    // `JSON.stringify` so non-string names match the prior behaviour instead
+    // of throwing in `escapeJsonString`. Build the wire-shaped object so the
+    // emitted key stays `time_unix_nano`, not the raw `startTime`.
     if (typeof event.name !== 'string') {
-      result += JSON.stringify(event)
+      result += JSON.stringify({ name: event.name, time_unix_nano: eventTimeNano(event), attributes })
       continue
     }
     result += '{"name":' + escapeJsonString(event.name) +
-      ',"time_unix_nano":' + jsonNumber(event.time_unix_nano)
-    if (event.attributes) {
-      result += ',"attributes":' + stringifyAttributes(event.attributes)
+      ',"time_unix_nano":' + jsonNumber(eventTimeNano(event))
+    if (attributes) {
+      result += ',"attributes":' + stringifyAttributes(attributes)
     }
     result += '}'
   }
@@ -241,8 +248,8 @@ class AgentEncoder {
     this.#config = getConfig()
     this.#debugEncoding = this.#config.DD_TRACE_ENCODING_DEBUG
     // Pick the per-span formatter once so the hot loop pays no per-span
-    // config check. The native path doesn't need to reshape `span_events`
-    // because `#encodeSpanEvents` works directly on the raw attributes.
+    // config check. The native path keeps the raw `span_events` slot for
+    // `#encodeSpanEvents`; the legacy path serializes it into meta.events.
     this.#formatSpan = this.#config.DD_TRACE_NATIVE_SPAN_EVENTS
       ? normalizeSpan
       : formatSpanWithLegacyEvents
@@ -320,16 +327,18 @@ class AgentEncoder {
       const resourceLen = resourceEntry.length
       const serviceLen = serviceEntry.length
 
-      // Almost every span carries `error: 0` or `error: 1` AND a nanosecond
-      // `start` timestamp ≥ 2³² (so `start` always encodes as a u64). When
-      // both hold, the block fuses error key+value, the start key + 0xCF
-      // type byte + 8-byte timestamp, and the duration key into the per-span
-      // reserve. The fallback path covers synthetic/test inputs with small
-      // starts and rare non-binary error flags by keeping per-field emits so
-      // each integer picks the shortest msgpack encoding.
-      const errorIsFixint = span.error === 0 || span.error === 1
-      const startFitsU64 = span.start >= 0x1_00_00_00_00
-      const fuseTail = errorIsFixint && startFitsU64
+      // `error` is `0` or `1` on nearly every span, and `start` is a
+      // nanosecond timestamp ≥ 2³² (always a msgpack u64). Decide the fused
+      // error key+value up front (`KEY_ERROR_0` / `KEY_ERROR_1`, or `undefined`
+      // for the rare non-binary flag) so the tail fuses without re-deciding the
+      // error shape twice. The fused tail also needs `start` as a u64; when
+      // either misses (synthetic small `start`, non-binary error) the tail
+      // routes each integer through `writeIntOrFloat` for the shortest
+      // encoding.
+      const errorEntry = span.error === 0
+        ? KEY_ERROR_0
+        : span.error === 1 ? KEY_ERROR_1 : undefined
+      const fuseTail = errorEntry !== undefined && span.start >= 0x1_00_00_00_00
 
       let blockSize = 1 +
         KEY_TRACE_ID_PREFIX.length + 8 +
@@ -340,7 +349,7 @@ class AgentEncoder {
         KEY_SERVICE.length + serviceLen
       if (typeEntry) blockSize += KEY_TYPE.length + typeEntry.length
       if (fuseTail) {
-        blockSize += KEY_ERROR_0.length + KEY_START_PREFIX.length + 8 + KEY_DURATION.length
+        blockSize += errorEntry.length + KEY_START_PREFIX.length + 8 + KEY_DURATION.length
       }
 
       const blockOffset = bytes.length
@@ -377,8 +386,8 @@ class AgentEncoder {
       cursor += serviceLen
 
       if (fuseTail) {
-        target.set(span.error === 0 ? KEY_ERROR_0 : KEY_ERROR_1, cursor)
-        cursor += KEY_ERROR_0.length
+        target.set(errorEntry, cursor)
+        cursor += errorEntry.length
 
         target.set(KEY_START_PREFIX, cursor)
         cursor += KEY_START_PREFIX.length
@@ -389,15 +398,14 @@ class AgentEncoder {
         cursor += 8
 
         target.set(KEY_DURATION, cursor)
+      } else if (errorEntry) {
+        bytes.set(errorEntry)
+        bytes.set(KEY_START)
+        bytes.writeIntOrFloat(span.start)
+        bytes.set(KEY_DURATION)
       } else {
-        if (span.error === 0) {
-          bytes.set(KEY_ERROR_0)
-        } else if (span.error === 1) {
-          bytes.set(KEY_ERROR_1)
-        } else {
-          bytes.set(KEY_ERROR)
-          bytes.writeIntOrFloat(span.error)
-        }
+        bytes.set(KEY_ERROR)
+        bytes.writeIntOrFloat(span.error)
         bytes.set(KEY_START)
         bytes.writeIntOrFloat(span.start)
         bytes.set(KEY_DURATION)
@@ -763,7 +771,7 @@ class AgentEncoder {
    * values — no `formatSpanEvents` pre-pass and no recursive generic walk.
    *
    * @param {MsgpackChunk} bytes
-   * @param {Array<{ name: string, time_unix_nano: number, attributes?: object }>} spanEvents
+   * @param {Array<{ name: unknown, startTime: number, attributes?: object }>} spanEvents
    */
   #encodeSpanEvents (bytes, spanEvents) {
     const offset = bytes.length
@@ -784,7 +792,7 @@ class AgentEncoder {
       bytes.set(KEY_NAME)
       this._encodeString(bytes, event.name)
       bytes.set(KEY_EVENT_TIME)
-      bytes.writeFloat(event.time_unix_nano)
+      bytes.writeFloat(eventTimeNano(event))
 
       const attributes = event.attributes
       if (attributes !== null && typeof attributes === 'object') {

package/packages/dd-trace/src/encode/agentless-json.js

@@ -3,6 +3,7 @@
 const log = require('../log')
 const { TOP_LEVEL_KEY } = require('../constants')
 const { normalizeSpan } = require('./tags-processors')
+const { stringifySpanEvents } = require('./0.4')
 
 // Soft limit for estimated payload size. Triggers an early flush to stay under intake request size limits.
 const SOFT_LIMIT = 8 * 1024 * 1024 // 8MB
@@ -20,7 +21,10 @@ function formatSpan (span, isFirstSpan) {
   delete span.meta['_dd.p.tid']
 
   if (span.span_events) {
-    span.meta.events = JSON.stringify(span.span_events)
+    // Events arrive raw (`{ name, startTime, attributes? }`); stringifySpanEvents
+    // derives `time_unix_nano` and drops empty attributes, matching the JSON the
+    // reshaped array used to produce.
+    span.meta.events = stringifySpanEvents(span.span_events)
     delete span.span_events
   }
 

package/packages/dd-trace/src/encode/tags-processors.js

@@ -46,6 +46,19 @@ function truncateSpanTestOpt (span) {
   return span
 }
 
+/**
+ * Convert a raw span event's `startTime` (milliseconds, sub-millisecond
+ * precision) to the wire `time_unix_nano`. Single source of truth for the
+ * formula so the four encoders that consume `span_events` stay in lockstep;
+ * the formatter no longer reshapes events, it hands the raw array through.
+ *
+ * @param {{ startTime: number }} event
+ * @returns {number}
+ */
+function eventTimeNano (event) {
+  return Math.round(event.startTime * 1e6)
+}
+
 function normalizeSpan (span) {
   span.service = span.service || DEFAULT_SERVICE_NAME
   if (span.service.length > MAX_SERVICE_LENGTH) {
@@ -69,6 +82,7 @@ module.exports = {
   truncateSpan,
   truncateSpanTestOpt,
   normalizeSpan,
+  eventTimeNano,
   MAX_META_KEY_LENGTH,
   MAX_META_VALUE_LENGTH,
   MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION,

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

@@ -2,7 +2,6 @@
 
 const { URL } = require('url')
 const log = require('../../log')
-const { getAgentUrl } = require('../../agent/url')
 const Writer = require('./writer')
 
 class AgentExporter {
@@ -11,7 +10,7 @@ class AgentExporter {
   constructor (config, prioritySampler) {
     this._config = config
     const { lookup, protocolVersion, stats = {}, apmTracingEnabled } = config
-    this._url = getAgentUrl(config)
+    this._url = config.url
 
     const headers = {}
     if (stats.enabled || apmTracingEnabled === false) {

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

@@ -18,25 +18,21 @@ class AgentlessExporter {
 
   /**
    * @param {object} config - Configuration object
-   * @param {string} [config.site] - The Datadog site. Defaults to 'datadoghq.com'.
-   * @param {string} [config.url] - Override intake URL
+   * @param {string} [config.site] - The Datadog site. Defaults to 'datadoghq.com'.
    * @param {number} [config.flushInterval] - Batch flush interval in ms
    * @param {string} [config.env] - Environment name
    * @param {object} [config.tags] - Tags including runtime-id
    */
   constructor (config) {
     this._config = config
-    const { site = 'datadoghq.com', url } = config
+    const site = config.site ?? 'datadoghq.com'
 
     try {
-      this._url = url ? new URL(url) : new URL(`https://public-trace-http-intake.logs.${site}`)
+      // Agentless traffic carries the Datadog API key, so the intake is always the public https
+      // endpoint; never derive it from config.url (the agent's cleartext http) or the key leaks.
+      this._url = new URL(`https://public-trace-http-intake.logs.${site}`)
     } catch (err) {
-      log.error(
-        'Invalid URL configuration for agentless exporter. url=%s, site=%s. Error: %s',
-        url || 'not set',
-        site,
-        err.message
-      )
+      log.error('Invalid site for agentless exporter. site=%s. Error: %s', site, err.message)
       this._url = null
     }
 

package/packages/dd-trace/src/exporters/common/buffering-exporter.js

@@ -1,7 +1,6 @@
 'use strict'
 
 const { incrementCountMetric, TELEMETRY_EVENTS_ENQUEUED_FOR_SERIALIZATION } = require('../../ci-visibility/telemetry')
-const { getAgentUrl } = require('../../agent/url')
 
 /**
  * Base exporter that buffers traces until a writer is initialized.
@@ -14,7 +13,7 @@ class BufferingExporter {
 
   constructor (tracerConfig) {
     this._config = tracerConfig
-    this._url = getAgentUrl(tracerConfig)
+    this._url = tracerConfig.url
   }
 
   export (trace) {

package/packages/dd-trace/src/exporters/common/request.js

@@ -6,6 +6,7 @@
 const { Readable } = require('stream')
 const http = require('http')
 const https = require('https')
+const net = require('net')
 const zlib = require('zlib')
 
 const { storage } = require('../../../../datadog-core')
@@ -45,6 +46,17 @@ function parseUrl (urlObjOrString) {
   return url
 }
 
+/**
+ * @param {string} hostname Host as resolved by {@link parseUrl}; IPv6 is unbracketed (`::1`).
+ */
+function isLoopbackHost (hostname) {
+  // The 127.0.0.0/8 block is loopback, but only when the host is an actual IPv4 literal: a
+  // hostname like `127.evil.com` shares the prefix yet resolves anywhere, so net.isIPv4 gates it.
+  return hostname === 'localhost' ||
+    hostname === '::1' ||
+    (hostname.startsWith('127.') && net.isIPv4(hostname))
+}
+
 /**
  * @param {Buffer|string|Readable|Array<Buffer|string>} data
  * @param {object} options
@@ -67,6 +79,20 @@ function request (data, options, callback) {
     }
   }
 
+  // Never put the Datadog API key on a cleartext connection to a non-loopback host; that would
+  // expose it on the wire. Loopback (local agent, dev proxy, tests) is exempt. Strip the key
+  // rather than drop the request: the agent proxies telemetry with its own key, while an https
+  // intake URL is required to authenticate agentless traffic.
+  const hasApiKey = options.headers['dd-api-key'] !== undefined || options.headers['DD-API-KEY'] !== undefined
+  if (hasApiKey && options.protocol === 'http:' && !isLoopbackHost(options.hostname)) {
+    log.error(
+      'Not sending the Datadog API key over a non-TLS connection to %s. Configure an https intake URL.',
+      options.hostname
+    )
+    delete options.headers['dd-api-key']
+    delete options.headers['DD-API-KEY']
+  }
+
   if (data instanceof Readable) {
     const chunks = []
 

package/packages/dd-trace/src/exporters/span-stats/index.js

@@ -1,11 +1,10 @@
 'use strict'
 
-const { getAgentUrl } = require('../../agent/url')
 const { Writer } = require('./writer')
 
 class SpanStatsExporter {
   constructor (config) {
-    this._url = getAgentUrl(config)
+    this._url = config.url
     this._writer = new Writer({ url: this._url })
   }
 

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

@@ -78,6 +78,21 @@ class Identifier {
     return this.toString()
   }
 
+  /**
+   * Returns the full hex trace ID. When this is a 64-bit identifier and `traceIdHigh`
+   * is provided, prepends it to form the 128-bit trace ID. Otherwise returns
+   * only this identifier's hex representation.
+   *
+   * @param {string | undefined} traceIdHigh - 16-char hex of the upper 64 bits, or undefined
+   * @returns {string}
+   */
+  toTraceIdHex (traceIdHigh) {
+    if (traceIdHigh && this.#buffer.length <= 8) {
+      return traceIdHigh + this.toString(16)
+    }
+    return this.toString(16)
+  }
+
   /**
    * @param {Identifier} other
    * @returns {boolean}

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

@@ -66,11 +66,22 @@ function getOperation (span) {
 }
 
 /**
- * Get the LLM token usage from the span tags
- * Supports both AI SDK v4 (promptTokens/completionTokens) and v5 (inputTokens/outputTokens)
- * @template T extends {inputTokens: number, outputTokens: number, totalTokens: number}
- * @param {T} tags
- * @returns {Pick<T, 'inputTokens' | 'outputTokens' | 'totalTokens'>}
+ * Get the LLM token usage from the span tags.
+ *
+ * Supports both AI SDK v4 (promptTokens/completionTokens) and v5+
+ * (inputTokens/outputTokens), and surfaces prompt-cache metrics for providers
+ * that report them. The AI SDK convention is that `inputTokens` already
+ * includes cached tokens, so cache reads are reported as a subset of input
+ * tokens rather than added on top.
+ *
+ * @param {SpanTags} tags
+ * @returns {{
+ *   inputTokens?: number,
+ *   outputTokens?: number,
+ *   totalTokens?: number,
+ *   cacheReadTokens?: number,
+ *   cacheWriteTokens?: number
+ * }}
  */
 function getUsage (tags) {
   const usage = {}
@@ -87,9 +98,84 @@ function getUsage (tags) {
   const totalTokens = tags['ai.usage.totalTokens'] ?? (inputTokens + outputTokens)
   if (!Number.isNaN(totalTokens)) usage.totalTokens = totalTokens
 
+  // Prompt-cache metrics. AI SDK v6 standardizes cache READ tokens via
+  // `ai.usage.cachedInputTokens`; cache WRITE tokens (and earlier AI SDK
+  // versions / providers that don't fill `cachedInputTokens`) are only
+  // available through provider-specific `ai.response.providerMetadata`.
+  // Skip zero values: the AI SDK sets `cachedInputTokens=0` on every span
+  // regardless of provider, so emitting it would add noise to spans that
+  // don't actually use prompt caching (e.g. OpenAI).
+  const providerCache = getProviderCacheTokens(tags['ai.response.providerMetadata'])
+
+  const cacheReadTokens = tags['ai.usage.cachedInputTokens'] ?? providerCache.cacheReadTokens
+  if (cacheReadTokens) usage.cacheReadTokens = cacheReadTokens
+
+  if (providerCache.cacheWriteTokens) usage.cacheWriteTokens = providerCache.cacheWriteTokens
+
+  // Normalize `inputTokens` to the sum convention used by `bedrockruntime.js`.
+  // Some SDK combinations (e.g. `ai@5` + `@ai-sdk/amazon-bedrock@3`) pass the
+  // raw fresh count through, which makes `nonCached = input - cacheRead -
+  // cacheWrite` go negative downstream.
+  //
+  // Detection: if `inputTokens < cacheSum`, the value cannot already be a sum
+  // that includes them (non-negative arithmetic). This is provider/version
+  // agnostic and won't double-count on stacks where the SDK already
+  // normalized (`ai@6` + `bedrock@4` / `anthropic@3`, OpenAI, Google).
+  if (usage.inputTokens != null) {
+    const cacheSum = (usage.cacheReadTokens || 0) + (usage.cacheWriteTokens || 0)
+    if (usage.inputTokens < cacheSum) {
+      usage.inputTokens += cacheSum
+      if (usage.totalTokens != null) {
+        usage.totalTokens = usage.inputTokens + (usage.outputTokens || 0)
+      }
+    }
+  }
+
   return usage
 }
 
+/**
+ * Extract prompt-cache token counts from the stringified
+ * `ai.response.providerMetadata` attribute.
+ *
+ * The AI SDK does not standardize cache WRITE tokens on the usage object, and
+ * earlier versions / providers may also omit `ai.usage.cachedInputTokens`, so
+ * we read the provider-specific shape directly. Only Bedrock and Anthropic
+ * are handled here as they are the providers that report cache writes today.
+ *
+ * @see https://ai-sdk.dev/providers/ai-sdk-providers/amazon-bedrock#cache-points
+ * @see https://ai-sdk.dev/providers/ai-sdk-providers/anthropic#cache-control
+ *
+ * @param {string | undefined} providerMetadataJson
+ * @returns {{ cacheReadTokens?: number, cacheWriteTokens?: number }}
+ */
+function getProviderCacheTokens (providerMetadataJson) {
+  if (!providerMetadataJson) return {}
+
+  const metadata = getJsonStringValue(providerMetadataJson, null)
+  if (!metadata || typeof metadata !== 'object') return {}
+
+  const result = {}
+
+  const bedrockUsage = metadata.bedrock?.usage
+  if (bedrockUsage) {
+    if (bedrockUsage.cacheReadInputTokens != null) result.cacheReadTokens = bedrockUsage.cacheReadInputTokens
+    if (bedrockUsage.cacheWriteInputTokens != null) result.cacheWriteTokens = bedrockUsage.cacheWriteInputTokens
+  }
+
+  const anthropic = metadata.anthropic
+  if (anthropic) {
+    if (result.cacheReadTokens == null && anthropic.cacheReadInputTokens != null) {
+      result.cacheReadTokens = anthropic.cacheReadInputTokens
+    }
+    if (result.cacheWriteTokens == null && anthropic.cacheCreationInputTokens != null) {
+      result.cacheWriteTokens = anthropic.cacheCreationInputTokens
+    }
+  }
+
+  return result
+}
+
 /**
  * Safely JSON parses a string value with a default fallback
  * @template T typeof defaultValue

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

@@ -7,12 +7,22 @@ const {
   extractTextAndResponseReason,
   parseModelId,
   extractTextAndResponseReasonFromStream,
+  extractConverseToolDefinitions,
+  extractRequestParamsConverse,
+  extractTextAndResponseReasonConverse,
+  extractTextAndResponseReasonConverseFromStream,
 } = require('../../../../datadog-plugin-aws-sdk/src/services/bedrockruntime/utils')
 const BaseLLMObsPlugin = require('./base')
 
 const llmobsStore = storage('llmobs')
 
-const ENABLED_OPERATIONS = new Set(['invokeModel', 'invokeModelWithResponseStream'])
+const ENABLED_OPERATIONS = new Set([
+  'invokeModel',
+  'invokeModelWithResponseStream',
+  'converse',
+  'converseStream',
+])
+const CONVERSE_OPERATIONS = new Set(['converse', 'converseStream'])
 
 /**
  * @typedef {{
@@ -79,10 +89,18 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
   setLLMObsTags ({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders }) {
     const isStream = request?.operation?.toLowerCase().includes('stream')
     telemetry.incrementLLMObsSpanStartCount({ autoinstrumented: true, integration: 'bedrock' })
+    this.#registerSpan(span, request)
 
+    if (CONVERSE_OPERATIONS.has(request?.operation)) {
+      this.#tagConverseSpan({ ctx, request, span, response, tokensFromHeaders, isStream })
+    } else {
+      this.#tagInvokeModelSpan({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders, isStream })
+    }
+  }
+
+  #registerSpan (span, request) {
     const parent = llmobsStore.getStore()?.span
     // Use full modelId and unified provider for LLMObs (required for backend cost estimation).
-    // Split modelProvider/modelName from parseModelId() are still used below for response parsing.
     this._tagger.registerLLMObsSpan(span, {
       parent,
       modelName: request.params.modelId.toLowerCase(),
@@ -91,38 +109,42 @@ class BedrockRuntimeLLMObsPlugin extends BaseLLMObsPlugin {
       name: 'bedrock-runtime.command',
       integration: 'bedrock',
     })
+  }
+
+  #tagConverseSpan ({ ctx, request, span, response, tokensFromHeaders, isStream }) {
+    const requestParams = extractRequestParamsConverse(request.params)
+    const textAndResponseReason = isStream
+      ? extractTextAndResponseReasonConverseFromStream(ctx.chunks)
+      : extractTextAndResponseReasonConverse(response)
+
+    const toolDefinitions = extractConverseToolDefinitions(request.params)
+    if (toolDefinitions.length > 0) this._tagger.tagToolDefinitions(span, toolDefinitions)
+    if (textAndResponseReason.finishReason) {
+      this._tagger.tagMetadata(span, { stop_reason: textAndResponseReason.finishReason })
+    }
+    this.#tagCommon({ span, requestParams, textAndResponseReason, tokensFromHeaders })
+  }
 
+  #tagInvokeModelSpan ({ ctx, request, span, response, modelProvider, modelName, tokensFromHeaders, isStream }) {
     const requestParams = extractRequestParams(request.params, modelProvider)
     // for streamed responses, we'll use the coerced response object we formed in the stream handler
     const textAndResponseReason = isStream
       ? extractTextAndResponseReasonFromStream(ctx.chunks, modelProvider, modelName)
       : extractTextAndResponseReason(response, modelProvider, modelName)
 
-    // add metadata tags
+    this.#tagCommon({ span, requestParams, textAndResponseReason, tokensFromHeaders })
+  }
+
+  #tagCommon ({ span, requestParams, textAndResponseReason, tokensFromHeaders }) {
     this._tagger.tagMetadata(span, {
       temperature: Number.parseFloat(requestParams.temperature) || 0,
       max_tokens: Number.parseInt(requestParams.maxTokens) || 0,
     })
-
-    // add I/O tags
-    this._tagger.tagLLMIO(
-      span,
-      requestParams.prompt,
-      [{ content: textAndResponseReason.message, role: textAndResponseReason.role }]
-    )
-
-    // add token metrics
-    const { inputTokens, outputTokens, totalTokens, cacheReadTokens, cacheWriteTokens } = extractTokens({
+    this._tagger.tagLLMIO(span, requestParams.prompt, textAndResponseReason.messages)
+    this._tagger.tagMetrics(span, extractTokens({
       tokensFromHeaders,
       usage: textAndResponseReason.usage,
-    })
-    this._tagger.tagMetrics(span, {
-      inputTokens,
-      outputTokens,
-      totalTokens,
-      cacheReadTokens,
-      cacheWriteTokens,
-    })
+    }))
   }
 }