dd-trace 5.105.0 → 5.106.0

package/packages/datadog-plugin-aws-sdk/src/services/bedrockruntime/utils.js

@@ -131,6 +131,7 @@ class Generation {
     outputTokens,
     cacheReadTokens,
     cacheWriteTokens,
+    messages,
   } = {}) {
     // stringify message as it could be a single generated message as well as a list of embeddings
     this.message = typeof message === 'string' ? message : JSON.stringify(message) || ''
@@ -143,6 +144,7 @@ class Generation {
       cacheReadTokens,
       cacheWriteTokens,
     }
+    this.messages = messages ?? [{ content: this.message, role: this.role }]
   }
 }
 
@@ -401,10 +403,7 @@ function extractTextAndResponseReason (response, provider, modelName) {
             message: output.message?.content[0]?.text ?? 'Unsupported content type',
             finishReason: body.stopReason,
             role: output.message?.role,
-            inputTokens: body.usage?.inputTokens,
-            outputTokens: body.usage?.outputTokens,
-            cacheReadInputTokenCount: body.usage?.cacheReadInputTokenCount,
-            cacheWriteInputTokenCount: body.usage?.cacheWriteInputTokenCount,
+            ...buildUsage(body.usage),
           })
         }
         break
@@ -476,6 +475,216 @@ function extractTextAndResponseReason (response, provider, modelName) {
   return new Generation()
 }
 
+/**
+ * Convert a Converse content-block array to an LLMObs message array.
+ *
+ * @param {string} role
+ * @param {Array<object>} contentBlocks
+ * @returns {{ content?: string, role: string, toolCalls?: Array, toolResults?: Array } | undefined}
+ */
+function extractMessagesFromConverseContent (role, contentBlocks) {
+  let content = ''
+  const toolCalls = []
+  const toolResults = []
+
+  for (const block of contentBlocks || []) {
+    if (block == null || typeof block !== 'object') continue
+    if (typeof block.text === 'string') {
+      content += block.text
+    } else if (block.toolUse) {
+      toolCalls.push(buildToolCall(block.toolUse))
+    } else if (block.toolResult) {
+      toolResults.push(buildToolResult(block.toolResult))
+    } else {
+      content += `[Unsupported content type: ${getContentBlockType(block)}]`
+    }
+  }
+
+  if (!content && toolCalls.length === 0 && toolResults.length === 0) return
+
+  const message = { role }
+  if (content) message.content = content
+  if (toolCalls.length > 0) message.toolCalls = toolCalls
+  if (toolResults.length > 0) message.toolResults = toolResults
+  return message
+}
+
+/**
+ * Resolve a Converse `ContentBlock`'s member type. The block is a key-presence
+ * tagged union (no `type` discriminator), so the active member is its sole own
+ * key. For forward-compat `$unknown` members the real type is the first element
+ * of the `[name, value]` tuple.
+ *
+ * @param {object} block
+ * @returns {string}
+ */
+function getContentBlockType (block) {
+  const key = Object.keys(block)[0]
+  if (key === '$unknown') return block.$unknown?.[0] ?? 'unknown'
+  return key ?? 'unknown'
+}
+
+// Always emit at least one output message so downstream tagging has a role to attach to.
+function toOutputMessages (role, contentBlocks) {
+  const message = extractMessagesFromConverseContent(role, contentBlocks)
+  return message ? [message] : [{ role, content: '' }]
+}
+
+function buildToolCall ({ name, input, toolUseId }) {
+  return { name: name ?? '', arguments: input ?? {}, toolId: toolUseId ?? '', type: 'toolUse' }
+}
+
+function parseToolInput (inputStr) {
+  try {
+    return JSON.parse(inputStr)
+  } catch {
+    log.warn('Failed to parse Converse stream toolUse.input JSON; emitting empty arguments')
+    return {}
+  }
+}
+
+function buildToolResult ({ toolUseId, content }) {
+  const result = (content || []).map(resolveToolResultItem).join('')
+  return { name: '', result, toolId: toolUseId ?? '', type: 'tool_result' }
+}
+
+function resolveToolResultItem (item) {
+  if (typeof item.text === 'string') return item.text
+  if (item.json != null) return JSON.stringify(item.json)
+  return `[Unsupported content type(s): ${getContentBlockType(item)}]`
+}
+
+function buildUsage (usage = {}) {
+  return {
+    inputTokens: usage.inputTokens,
+    outputTokens: usage.outputTokens,
+    cacheReadTokens: usage.cacheReadInputTokens ?? usage.cacheReadInputTokenCount,
+    cacheWriteTokens: usage.cacheWriteInputTokens ?? usage.cacheWriteInputTokenCount,
+  }
+}
+
+/**
+ * Extract tool definitions from a Converse request's `toolConfig.tools`,
+ * mapping Bedrock's `toolSpec` shape to LLMObs `ToolDefinition` shape.
+ *
+ * @param {object} params - Converse request params with optional `toolConfig.tools[].toolSpec`.
+ * @returns {Array<{ name: string, description: string, schema: object }>}
+ */
+function extractConverseToolDefinitions (params) {
+  const toolDefinitions = []
+  for (const tool of params.toolConfig?.tools || []) {
+    const toolSpec = tool?.toolSpec
+    if (!toolSpec?.name) continue
+    toolDefinitions.push({
+      name: toolSpec.name,
+      description: toolSpec.description ?? '',
+      schema: toolSpec.inputSchema ?? {},
+    })
+  }
+  return toolDefinitions
+}
+
+/**
+ * Extract request metadata + rendered input messages from a Converse /
+ * ConverseStream request.
+ *
+ * @param {{ modelId?: string, messages?: Array, system?: Array, inferenceConfig?: object, toolConfig?: object }} params
+ * @returns {RequestParams}
+ */
+function extractRequestParamsConverse (params) {
+  const prompt = []
+  for (const block of params.system || []) {
+    if (typeof block?.text === 'string') prompt.push({ content: block.text, role: 'system' })
+  }
+  for (const msg of params.messages || []) {
+    if (msg == null || typeof msg !== 'object') continue
+    const message = extractMessagesFromConverseContent(msg.role || 'user', msg.content)
+    if (message) prompt.push(message)
+  }
+
+  const { temperature, topP, maxTokens, stopSequences } = params.inferenceConfig || {}
+  return new RequestParams({ prompt, temperature, topP, maxTokens, stopSequences })
+}
+
+/**
+ * Extract output messages + usage from a non-stream Converse response.
+ *
+ * @param {{ output?: { message?: { role?: string, content?: Array } }, stopReason?: string, usage?: object }} response
+ * @returns {Generation}
+ */
+function extractTextAndResponseReasonConverse (response) {
+  const outputMessage = response?.output?.message
+  const role = outputMessage?.role || 'assistant'
+
+  return new Generation({
+    role,
+    finishReason: response?.stopReason || '',
+    ...buildUsage(response?.usage),
+    messages: toOutputMessages(role, outputMessage?.content),
+  })
+}
+
+/**
+ * Aggregate Converse stream events into a single output message + usage.
+ * One messageStart / messageStop pair per response, so one message out.
+ *
+ * Stream events describe the same content-block structure as the non-stream
+ * response, spread across start/delta chunks. We reassemble those chunks
+ * into a normalized content-block array and reuse the non-stream extractor.
+ *
+ * @param {Array<object>} chunks - Ordered ConverseStreamOutput events.
+ * @returns {Generation}
+ */
+function extractTextAndResponseReasonConverseFromStream (chunks) {
+  let role = 'assistant'
+  let stopReason = ''
+  let usage = {}
+  const blocksByIdx = new Map()
+
+  for (const chunk of chunks || []) {
+    if (chunk.messageStart?.role) {
+      role = chunk.messageStart.role
+    } else if (chunk.messageStop?.stopReason) {
+      stopReason = chunk.messageStop.stopReason
+    } else if (chunk.metadata?.usage) {
+      usage = chunk.metadata.usage
+    } else if (chunk.contentBlockStart?.start?.toolUse) {
+      const { contentBlockIndex, start: { toolUse } } = chunk.contentBlockStart
+      blocksByIdx.set(contentBlockIndex, {
+        toolUse: { toolUseId: toolUse.toolUseId, name: toolUse.name, inputStr: '' },
+      })
+    } else if (chunk.contentBlockDelta) {
+      const { contentBlockIndex, delta } = chunk.contentBlockDelta
+      if (typeof delta?.text === 'string') {
+        const block = blocksByIdx.get(contentBlockIndex) ?? {}
+        block.text = (block.text ?? '') + delta.text
+        blocksByIdx.set(contentBlockIndex, block)
+      } else if (typeof delta?.toolUse?.input === 'string') {
+        const block = blocksByIdx.get(contentBlockIndex) ?? { toolUse: { inputStr: '' } }
+        block.toolUse ??= { inputStr: '' }
+        block.toolUse.inputStr += delta.toolUse.input
+        blocksByIdx.set(contentBlockIndex, block)
+      }
+    }
+  }
+
+  const contentBlocks = [...blocksByIdx.keys()].sort((a, b) => a - b).map(i => {
+    const block = blocksByIdx.get(i)
+    if (block.toolUse) {
+      const { toolUseId, name, inputStr } = block.toolUse
+      block.toolUse = { toolUseId, name, input: parseToolInput(inputStr) }
+    }
+    return block
+  })
+
+  return new Generation({
+    role,
+    finishReason: stopReason,
+    ...buildUsage(usage),
+    messages: toOutputMessages(role, contentBlocks),
+  })
+}
+
 module.exports = {
   Generation,
   RequestParams,
@@ -483,5 +692,10 @@ module.exports = {
   parseModelId,
   extractRequestParams,
   extractTextAndResponseReason,
+  extractMessagesFromConverseContent,
+  extractConverseToolDefinitions,
+  extractRequestParamsConverse,
+  extractTextAndResponseReasonConverse,
+  extractTextAndResponseReasonConverseFromStream,
   PROVIDER,
 }

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,
-    })
+    }))
   }
 }
 

package/packages/dd-trace/src/opentelemetry/trace/otlp_transformer.js

@@ -16,6 +16,11 @@ const SPAN_KIND_CONSUMER = protoSpanKind.values.SPAN_KIND_CONSUMER
 // Cached zero Identifier used to detect zero IDs without re-allocating per span.
 const ZERO_ID = id('0')
 
+// DD propagation tag carrying the upper 64 bits of a 128-bit trace ID as 16 hex chars.
+// span_format.js#extractChunkTags only copies this onto the first-in-chunk span, so the
+// transformer scans the batch to find it and applies it to every span's traceId.
+const TRACE_ID_128 = '_dd.p.tid'
+
 /**
  * @typedef {import('../../id').Identifier} Identifier
  *
@@ -65,6 +70,7 @@ const STATUS_CODE_ERROR = 2
 const EXCLUDED_META_KEYS = new Set([
   '_dd.span_links',
   'span.kind',
+  TRACE_ID_128,
 ])
 
 /**
@@ -113,6 +119,18 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    * @returns {object[]} Array of scope span objects
    */
   #transformScopeSpans (spans) {
+    let traceKey
+    let traceIdHigh
+    const otlpSpans = spans.map((span) => {
+      // `_dd.p.tid` lives only on the first-in-chunk span of each trace.
+      // Reset at each trace boundary for batching of multiple traces.
+      const key = span.trace_id.toString(16)
+      if (key !== traceKey) {
+        traceKey = key
+        traceIdHigh = span.meta?.[TRACE_ID_128]?.toLowerCase()
+      }
+      return this.#transformSpan(span, traceIdHigh)
+    })
     return [{
       scope: {
         name: 'dd-trace-js',
@@ -121,7 +139,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
         droppedAttributesCount: 0,
       },
       schemaUrl: '',
-      spans: spans.map(span => this.#transformSpan(span)),
+      spans: otlpSpans,
     }]
   }
 
@@ -129,14 +147,15 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    * Transforms a single DD-formatted span to an OTLP Span object.
    *
    * @param {DDFormattedSpan} span - DD-formatted span to transform
+   * @param {string | undefined} traceIdHigh - 16-char hex of the upper 64 bits of the trace ID
    * @returns {object} OTLP Span object
    */
-  #transformSpan (span) {
+  #transformSpan (span, traceIdHigh) {
     const parentId = span.parent_id
     const links = this.#extractLinks(span.meta?.['_dd.span_links'])
 
     return {
-      traceId: this.#idToBytes(span.trace_id, 16),
+      traceId: span.trace_id.toTraceIdHex(traceIdHigh).padStart(32, '0'),
       spanId: this.#idToBytes(span.span_id, 8),
       parentSpanId: (parentId && !parentId.equals(ZERO_ID)) ? this.#idToBytes(parentId, 8) : undefined,
       name: span.resource,

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -284,7 +284,7 @@ class TextMapPropagator {
       (DD_MAJOR < 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3multi) return
 
-    carrier[b3TraceKey] = this._getB3TraceId(spanContext)
+    carrier[b3TraceKey] = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     carrier[b3SpanKey] = spanContext._spanId.toString(16)
     carrier[b3SampledKey] = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
 
@@ -303,7 +303,7 @@ class TextMapPropagator {
       (DD_MAJOR >= 6 && this._hasPropagationStyle('inject', 'b3'))
     if (!hasB3SingleHeader) return
 
-    const traceId = this._getB3TraceId(spanContext)
+    const traceId = spanContext._traceId.toTraceIdHex(spanContext._trace.tags['_dd.p.tid'])
     const spanId = spanContext._spanId.toString(16)
     const sampled = spanContext._sampling.priority >= AUTO_KEEP ? '1' : '0'
 
@@ -859,14 +859,6 @@ class TextMapPropagator {
     }
   }
 
-  _getB3TraceId (spanContext) {
-    if (spanContext._traceId.toBuffer().length <= 8 && spanContext._trace.tags['_dd.p.tid']) {
-      return spanContext._trace.tags['_dd.p.tid'] + spanContext._traceId.toString(16)
-    }
-
-    return spanContext._traceId.toString(16)
-  }
-
   /**
    * @param {number} traceparentSampled
    * @param {number|undefined} tracestateSamplingPriority

package/packages/dd-trace/src/opentracing/span_context.js

@@ -46,9 +46,7 @@ class DatadogSpanContext {
 
   toTraceId (get128bitId = false) {
     if (get128bitId) {
-      return this._traceId.toBuffer().length <= 8 && this._trace.tags[TRACE_ID_128]
-        ? this._trace.tags[TRACE_ID_128] + this._traceId.toString(16).padStart(16, '0')
-        : this._traceId.toString(16).padStart(32, '0')
+      return this._traceId.toTraceIdHex(this._trace.tags[TRACE_ID_128]).padStart(32, '0')
     }
     return this._traceId.toString(10)
   }