dd-trace 6.21.0 → 6.22.0

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

@@ -8,7 +8,7 @@ const {
 } = require('../../constants/tags')
 const { audioMimeTypeFromFormat, formatAudioPart } = require('../../audio-utils')
 const { safeJsonParse } = require('../../util')
-const { AUDIO_MIME_TYPES } = require('./constants')
+const { AUDIO_MIME_TYPES, IMAGE_FALLBACK, INPUT_TYPE_IMAGE } = require('./constants')
 const {
   extractChatTemplateFromInstructions,
   normalizePromptVariables,
@@ -16,6 +16,7 @@ const {
   extractContentParts,
   hasMultimodalInputs,
   getModelProviderAndClient,
+  getServerToolUsageMetrics,
 } = require('./utils')
 
 const allowedParamKeys = new Set([
@@ -107,6 +108,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 +151,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 +172,8 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
       if (reasoningOutputTokens !== undefined) metrics.reasoningOutputTokens = reasoningOutputTokens
     }
 
+    Object.assign(metrics, getServerToolUsageMetrics(response))
+
     return metrics
   }
 
@@ -464,6 +477,30 @@ class OpenAiLLMObsPlugin extends LLMObsPlugin {
 
     this._tagger.tagMetadata(span, outputMetadata) // update the metadata with the output metadata
   }
+
+  #tagDecision (span, inputs, response, error) {
+    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 +522,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 +558,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/span_processor.js

@@ -92,9 +92,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)

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

@@ -118,8 +118,8 @@ class LLMObsTagger {
     integration,
     _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 ||

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

@@ -260,8 +260,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 {

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) {

package/packages/dd-trace/src/openfeature/evaluation-telemetry-opt-out-hook.js

@@ -0,0 +1,51 @@
+'use strict'
+
+const PARAMETER = 'dd_evaluation_telemetry_opt_out'
+
+/** Gates an owned finally-only telemetry hook without changing evaluation or exposure handling. */
+class EvaluationTelemetryOptOutHook {
+  #delegate
+  #decisions = new WeakMap()
+
+  /** @param {import('@openfeature/server-sdk').Hook} delegate */
+  constructor (delegate) {
+    this.#delegate = delegate
+  }
+
+  /** @param {import('@openfeature/core').HookContext} hookContext */
+  before (hookContext) {
+    // Hook context identity is stable across stages, including each MultiProvider branch.
+    this.#decisions.set(hookContext, isOptedOut(hookContext.context))
+  }
+
+  /** @param {import('@openfeature/core').HookContext} hookContext */
+  error (hookContext) {
+    // A customer before hook can fail before this hook runs. Capture opt-out before customer error hooks change it.
+    if (!this.#decisions.has(hookContext)) {
+      this.#decisions.set(hookContext, isOptedOut(hookContext.context))
+    }
+  }
+
+  /**
+   * @param {import('@openfeature/core').HookContext} hookContext
+   * @param {import('@openfeature/core').EvaluationDetails<import('@openfeature/core').FlagValue>} evaluationDetails
+   * @param {import('@openfeature/core').HookHints} [hints]
+   */
+  finally (hookContext, evaluationDetails, hints) {
+    const optedOut = this.#decisions.get(hookContext) === true || isOptedOut(hookContext.context)
+    this.#decisions.delete(hookContext)
+    if (!optedOut) return this.#delegate.finally?.(hookContext, evaluationDetails, hints)
+  }
+}
+
+/** @param {import('@openfeature/core').EvaluationContext} context */
+function isOptedOut (context) {
+  try {
+    return context?.[PARAMETER] === true
+  } catch {
+    // An unreadable attribute is not boolean true and must not change the evaluation result.
+    return false
+  }
+}
+
+module.exports = EvaluationTelemetryOptOutHook

package/packages/dd-trace/src/openfeature/flagging_provider.js

@@ -9,6 +9,7 @@ const configurationSource = require('./configuration_source')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
 const DebugLoggingHook = require('./debug-logging-hook')
 const EvalMetricsHook = require('./eval-metrics-hook')
+const EvaluationTelemetryOptOutHook = require('./evaluation-telemetry-opt-out-hook')
 const SpanEnrichmentHook = require('./span-enrichment-hook')
 const FlagEvalEVPHook = require('./writers/flag-eval-evp-hook')
 
@@ -17,6 +18,9 @@ const FlagEvalEVPHook = require('./writers/flag-eval-evp-hook')
  * Extends DatadogNodeServerProvider to add tracer integration and configuration management.
  */
 class FlaggingProvider extends DatadogNodeServerProvider {
+  // Track this wrapper's logging lifecycle without reading the upstream provider's private state.
+  #waitingForConfiguration = false
+
   /** @type {SpanEnrichmentHook | undefined} */
   #spanEnrichmentHook
 
@@ -36,8 +40,13 @@ class FlaggingProvider extends DatadogNodeServerProvider {
       initializationTimeoutMs: config.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_INITIALIZATION_TIMEOUT_MS,
     })
 
+    const enableOptOut =
+      config.featureFlags.DD_FEATURE_FLAGS_EVALUATION_TELEMETRY_PER_SUBJECT_OPT_OUT_ENABLED === true
+    /** @param {import('@openfeature/server-sdk').Hook} hook */
+    const telemetryHook = hook => enableOptOut ? new EvaluationTelemetryOptOutHook(hook) : hook
+
     if (config.DD_METRICS_OTEL_ENABLED === true) {
-      this.hooks.push(new EvalMetricsHook(config))
+      this.hooks.push(telemetryHook(new EvalMetricsHook(config)))
     } else {
       log.debug('Feature Flags: evaluation metrics disabled; set %s=true to enable', 'DD_METRICS_OTEL_ENABLED')
     }
@@ -49,7 +58,7 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     if (config.featureFlags.DD_EXPERIMENTAL_FLAGGING_PROVIDER_SPAN_ENRICHMENT_ENABLED) {
       this.#spanEnrichmentHook = new SpanEnrichmentHook(tracer)
       // @ts-expect-error The upstream constructor always initializes its optional hooks property.
-      this.hooks.push(this.#spanEnrichmentHook)
+      this.hooks.push(telemetryHook(this.#spanEnrichmentHook))
       log.info('%s span enrichment enabled', this.constructor.name)
     } else {
       log.info('%s span enrichment disabled', this.constructor.name)
@@ -60,7 +69,7 @@ class FlaggingProvider extends DatadogNodeServerProvider {
 
     if (config.featureFlags?.DD_FLAGGING_EVALUATION_COUNTS_ENABLED !== false) {
       this.#flagEvalEVPHook = new FlagEvalEVPHook(config)
-      this.hooks.push(this.#flagEvalEVPHook)
+      this.hooks.push(telemetryHook(this.#flagEvalEVPHook))
     }
 
     this.#configurationSource = configurationSource.create(config, this.setConfiguration.bind(this))
@@ -74,6 +83,7 @@ class FlaggingProvider extends DatadogNodeServerProvider {
   initialize (context) {
     log.debug('Feature Flags: waiting for provider initialization...')
 
+    this.#waitingForConfiguration = !this.getConfiguration()
     const promise = super.initialize(context)
 
     // `DatadogNodeServerProvider#initialize` starts a timer that is never unref'd, which would
@@ -82,28 +92,45 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     // TODO: remove once `@datadog/openfeature-node-server` unrefs this timer itself.
     this.initController?.timeoutId?.unref?.()
 
-    // Only observes the outcome for logging; `promise` itself is returned unmodified below.
-    // Guarded so a logger failure can never leave the derived promise unhandled.
-    promise.then(
-      () => {
-        try {
-          log.debug('Feature Flags: provider initialized successfully')
-        } catch { /* logging failure must not crash the process */ }
-      },
-      (error) => {
-        try {
-          // errorWithoutTelemetry avoids inflating telemetry volume for every routine init timeout.
-          log.errorWithoutTelemetry(
-            'Feature Flags: provider failed to initialize: %s',
-            error instanceof Error ? error.message : String(error)
-          )
-        } catch { /* logging failure must not crash the process */ }
-      }
-    )
+    if (this.getConfiguration()) this.#logInitialConfiguration()
 
     return promise
   }
 
+  /**
+   * @param {Parameters<DatadogNodeServerProvider['setConfiguration']>[0]} configuration
+   */
+  setConfiguration (configuration) {
+    const wasWaiting = this.#waitingForConfiguration
+    super.setConfiguration(configuration)
+    this.#waitingForConfiguration = false
+    if (wasWaiting && configuration != null) this.#logInitialConfiguration()
+  }
+
+  /**
+   * @param {unknown} error
+   */
+  setError (error) {
+    const wasWaiting = this.#waitingForConfiguration
+    super.setError(error)
+    this.#waitingForConfiguration = false
+    if (!wasWaiting) return
+
+    try {
+      // Avoid inflating telemetry volume for routine initialization timeouts.
+      log.errorWithoutTelemetry(
+        'Feature Flags: provider failed to initialize: %s',
+        error instanceof Error ? error.message : String(error)
+      )
+    } catch { /* logging failure must not affect initialization */ }
+  }
+
+  #logInitialConfiguration () {
+    try {
+      log.debug('Feature Flags: initial configuration available')
+    } catch { /* logging failure must not affect initialization */ }
+  }
+
   /**
    * Called when the provider is shut down.
    * Cleans up resources including channel subscriptions.

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

@@ -52,7 +52,7 @@ function encodeHrTime (hrTime) {
  * OtlpTransformer transforms log records to OTLP format.
  *
  * This implementation follows the OTLP Logs v1.7.0 Data Model specification:
- * https://opentelemetry.io/docs/specs/otlp/#log-data-model
+ * https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/logs/v1/logs.proto
  *
  * @class OtlpTransformer
  * @augments OtlpTransformerBase

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

@@ -18,7 +18,7 @@ const AGGREGATION_TEMPORALITY_CUMULATIVE = protoAggregationTemporality.values.AG
  * OtlpTransformer transforms metrics to OTLP format.
  *
  * This implementation follows the OTLP Metrics v1.7.0 Data Model specification:
- * https://opentelemetry.io/docs/specs/otlp/#metrics-data-model
+ * https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/metrics/v1/metrics.proto
  *
  * @class OtlpTransformer
  * @augments OtlpTransformerBase

package/packages/dd-trace/src/opentelemetry/metrics/periodic_metric_reader.js

@@ -162,8 +162,7 @@ class PeriodicMetricReader {
   addBatchObservableCallback (callback, observables) {
     if (typeof callback !== 'function') return
     const instruments = new Set(observables?.filter(isObservableInstrument))
-    if (instruments.size === 0) return
-    if (this.#findBatchCallback(callback, instruments) !== -1) return
+    if (instruments.size === 0 || this.#findBatchCallback(callback, instruments) !== -1) return
     this.#batchCallbacks.push({ callback, instruments })
   }
 

package/packages/dd-trace/src/opentelemetry/otlp/common.proto

@@ -1,4 +1,4 @@
-// Vendored from: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/logs/v1/common.proto
+// Vendored from: https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/common/v1/common.proto
 // Copyright 2019, OpenTelemetry Authors
 //
 // Licensed under the Apache License, Version 2.0 (the "License");

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

@@ -84,7 +84,7 @@ const DD_ERROR_META_KEYS = new Set(['error.message'])
  * OtlpTraceTransformer transforms DD-formatted spans to OTLP trace JSON format.
  *
  * This implementation follows the OTLP trace data model:
- * https://opentelemetry.io/docs/specs/otlp/#trace-data-model
+ * https://github.com/open-telemetry/opentelemetry-proto/blob/v1.7.0/opentelemetry/proto/trace/v1/trace.proto
  *
  * It receives DD-formatted spans (from span_format.js) and produces
  * an ExportTraceServiceRequest serialized as JSON (http/json protocol only).
@@ -168,8 +168,8 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
 
     return {
       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,
+      spanId: this.#spanIdToHex(span.span_id),
+      parentSpanId: parentId && !parentId.equals(ZERO_ID) ? this.#spanIdToHex(parentId) : undefined,
       traceState: span.trace_state,
       name: span.resource,
       kind: this.#mapSpanKind(span.meta?.['span.kind']),
@@ -338,26 +338,9 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
     }
   }
 
-  /**
-   * Converts a DD Identifier object to a hex-encoded string of the specified byte length.
-   * Pads with leading zeros if the identifier buffer is shorter than the target.
-   * Per the OTLP http/json spec, trace-ids and span-ids must be hex-encoded strings.
-   *
-   * @param {Identifier} identifier - DD Identifier
-   * @param {number} targetLength - Target byte length (16 for trace ID, 8 for span ID)
-   */
-  #idToBytes (identifier, targetLength) {
-    const buffer = identifier.toBuffer()
-    if (buffer.length === targetLength) {
-      return Buffer.from(buffer).toString('hex')
-    }
-    if (buffer.length > targetLength) {
-      return Buffer.from(buffer.slice(buffer.length - targetLength)).toString('hex')
-    }
-    // Pad with leading zeros to reach target length.
-    const result = Buffer.alloc(targetLength)
-    Buffer.from(buffer).copy(result, targetLength - buffer.length)
-    return result.toString('hex')
+  /** @param {Identifier} identifier */
+  #spanIdToHex (identifier) {
+    return identifier.toString(16).slice(-16)
   }
 
   /**