dd-trace 5.98.0 → 5.99.1

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

@@ -45,7 +45,7 @@ class LLMObsSpanWriter extends BaseWriter {
       this.flush()
     }
 
-    super.append(event, routing, processedEventSizeBytes)
+    return super.append(event, routing, processedEventSizeBytes)
   }
 
   makePayload (events) {

package/packages/dd-trace/src/openfeature/eval-metrics-hook.js

@@ -0,0 +1,103 @@
+'use strict'
+
+const log = require('../log')
+
+const METER_NAME = 'dd-trace-js/openfeature'
+const COUNTER_NAME = 'feature_flag.evaluations'
+const COUNTER_DESCRIPTION = 'Number of feature flag evaluations'
+const COUNTER_UNIT = '{evaluation}'
+
+/**
+ * OpenFeature hook that tracks feature flag evaluation metrics using an
+ * OpenTelemetry counter.
+ *
+ * Implements the OpenFeature `finally` hook interface so it can be pushed
+ * directly onto a provider's `hooks` array. We use the `finally` stage
+ * (not diagnostic channels inside the provider's `resolve*` methods) because
+ * the OpenFeature SDK short-circuits before calling the provider when it is in
+ * NOT_READY state; the `finally` hook still fires, ensuring all evaluations are
+ * captured. It also catches type-mismatch errors detected by the SDK client
+ * after the provider returns.
+ *
+ * The counter is created lazily on the first successful `finally()` call rather
+ * than in the constructor. This is necessary because `FlaggingProvider` is
+ * constructed eagerly by `proxy.js#updateTracing()`, which runs *before*
+ * `initializeOpenTelemetryMetrics()` sets the global OTel meter provider.
+ * Calling `getMeter()` in the constructor would return the noop meter and
+ * produce a noop counter that silently discards all measurements. By deferring
+ * to `finally()` time we give the meter provider a chance to be set up first.
+ *
+ * If counter creation fails (e.g. the OTel API is not yet available), the call
+ * is silently skipped and retried on the next `finally()` invocation.
+ *
+ * When `config.otelMetricsEnabled` is false, `finally()` is always a no-op.
+ */
+class EvalMetricsHook {
+  #enabled = false
+  #counter = null
+
+  /**
+   * @param {import('../config')} config - Tracer configuration object
+   */
+  constructor (config) {
+    this.#enabled = config.otelMetricsEnabled === true
+  }
+
+  /**
+   * Returns the OTel counter, creating it on first successful call.
+   * Returns `null` if counter creation fails; will retry on next call.
+   *
+   * @returns {import('@opentelemetry/api').Counter | null}
+   */
+  #getCounter () {
+    if (this.#counter) return this.#counter
+
+    try {
+      const { metrics } = require('@opentelemetry/api')
+      const meter = metrics.getMeter(METER_NAME)
+      this.#counter = meter.createCounter(COUNTER_NAME, {
+        description: COUNTER_DESCRIPTION,
+        unit: COUNTER_UNIT,
+      })
+    } catch (e) {
+      log.warn('EvalMetricsHook: failed to create counter: %s', e.message)
+    }
+
+    return this.#counter
+  }
+
+  /**
+   * Called by the OpenFeature SDK after every flag evaluation (success or error).
+   *
+   * @param {{ flagKey: string }} hookContext - Hook context containing the flag key
+   * @param {{ variant?: string, reason?: string, errorCode?: string, flagMetadata?: object }} evaluationDetails
+   *   - Full evaluation details
+   * @returns {void}
+   */
+  finally (hookContext, evaluationDetails) {
+    if (!this.#enabled) return
+
+    const counter = this.#getCounter()
+    if (!counter) return
+
+    const attributes = {
+      'feature_flag.key': hookContext?.flagKey ?? '',
+      'feature_flag.result.variant': evaluationDetails?.variant ?? '',
+      'feature_flag.result.reason': evaluationDetails?.reason?.toLowerCase() ?? 'unknown',
+    }
+
+    const errorCode = evaluationDetails?.errorCode
+    if (errorCode) {
+      attributes['error.type'] = errorCode.toLowerCase()
+    }
+
+    const allocationKey = evaluationDetails?.flagMetadata?.allocationKey
+    if (allocationKey) {
+      attributes['feature_flag.result.allocation_key'] = allocationKey
+    }
+
+    counter.add(1, attributes)
+  }
+}
+
+module.exports = EvalMetricsHook

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

@@ -4,6 +4,7 @@ const { DatadogNodeServerProvider } = require('@datadog/openfeature-node-server'
 const { channel } = require('dc-polyfill')
 const log = require('../log')
 const { EXPOSURE_CHANNEL } = require('./constants/constants')
+const EvalMetricsHook = require('./eval-metrics-hook')
 
 /**
  * OpenFeature provider that integrates with Datadog's feature flagging system.
@@ -24,6 +25,8 @@ class FlaggingProvider extends DatadogNodeServerProvider {
     this._tracer = tracer
     this._config = config
 
+    this.hooks.push(new EvalMetricsHook(config))
+
     log.debug('%s created with timeout: %dms', this.constructor.name,
       config.experimental.flaggingProvider.initializationTimeoutMs)
   }

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

@@ -60,18 +60,18 @@ function initializeOpenTelemetryLogs (config) {
 
   // Create OTLP exporter using resolved config values
   const exporter = new OtlpHttpLogExporter(
-    config.otelLogsUrl,
-    config.otelLogsHeaders,
-    config.otelLogsTimeout,
-    config.otelLogsProtocol,
+    config.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+    config.OTEL_EXPORTER_OTLP_LOGS_HEADERS,
+    config.OTEL_EXPORTER_OTLP_LOGS_TIMEOUT,
+    config.OTEL_EXPORTER_OTLP_LOGS_PROTOCOL,
     resourceAttributes
   )
 
   // Create batch processor for exporting logs to Datadog Agent
   const processor = new BatchLogRecordProcessor(
     exporter,
-    config.otelBatchTimeout,
-    config.otelMaxExportBatchSize
+    config.OTEL_BSP_SCHEDULE_DELAY,
+    config.OTEL_BSP_MAX_EXPORT_BATCH_SIZE
   )
 
   // Create logger provider with processor for Datadog Agent export

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

@@ -22,13 +22,14 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
    * Creates a new OtlpHttpLogExporter instance.
    *
    * @param {string} url - OTLP endpoint URL
-   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {Record<string, string>|undefined} headers - Additional HTTP headers parsed from the
+   *   corresponding `OTEL_EXPORTER_OTLP_*_HEADERS` env by the MAP parser.
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
    * @param {Resource} resource - Resource attributes
    */
   constructor (url, headers, timeout, protocol, resource) {
-    super(url, headers, timeout, protocol, '/v1/logs', 'logs')
+    super(url, headers, timeout, protocol, 'logs')
     this.transformer = new OtlpTransformer(resource, protocol)
   }
 

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

@@ -57,18 +57,18 @@ function initializeOpenTelemetryMetrics (config) {
   }
 
   const exporter = new OtlpHttpMetricExporter(
-    config.otelMetricsUrl,
-    config.otelMetricsHeaders,
-    config.otelMetricsTimeout,
-    config.otelMetricsProtocol,
+    config.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
+    config.OTEL_EXPORTER_OTLP_METRICS_HEADERS,
+    config.OTEL_EXPORTER_OTLP_METRICS_TIMEOUT,
+    config.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL,
     resourceAttributes
   )
 
   const reader = new PeriodicMetricReader(
     exporter,
-    config.otelMetricsExportInterval,
-    config.otelMetricsTemporalityPreference,
-    config.otelMaxQueueSize
+    config.OTEL_METRIC_EXPORT_INTERVAL,
+    config.OTEL_EXPORTER_OTLP_METRICS_TEMPORALITY_PREFERENCE,
+    config.OTEL_BSP_MAX_QUEUE_SIZE
   )
 
   const meterProvider = new MeterProvider({ reader })

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

@@ -18,13 +18,14 @@ class OtlpHttpMetricExporter extends OtlpHttpExporterBase {
    * Creates a new OtlpHttpMetricExporter instance.
    *
    * @param {string} url - OTLP endpoint URL
-   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {Record<string, string>|undefined} headers - Additional HTTP headers parsed from the
+   *   corresponding `OTEL_EXPORTER_OTLP_*_HEADERS` env by the MAP parser.
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
    * @param {Resource} resource - Resource attributes
    */
   constructor (url, headers, timeout, protocol, resource) {
-    super(url, headers, timeout, protocol, '/v1/metrics', 'metrics')
+    super(url, headers, timeout, protocol, 'metrics')
     this.transformer = new OtlpTransformer(resource, protocol)
   }
 

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -19,34 +19,31 @@ class OtlpHttpExporterBase {
   /**
    * Creates a new OtlpHttpExporterBase instance.
    *
-   * @param {string} url - OTLP endpoint URL
-   * @param {string|undefined} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {string} url - OTLP endpoint URL (callers are expected to supply the full signal URL)
+   * @param {Record<string, string>|undefined} headers - Additional HTTP headers parsed from the
+   *   corresponding `OTEL_EXPORTER_OTLP_*_HEADERS` env by the MAP parser.
    * @param {number} timeout - Request timeout in milliseconds
    * @param {string} protocol - OTLP protocol (http/protobuf or http/json)
-   * @param {string} defaultPath - Default path to use if URL has no path
    * @param {string} signalType - Signal type for error messages (e.g., 'logs', 'metrics')
    */
-  constructor (url, headers, timeout, protocol, defaultPath, signalType) {
-    const parsedUrl = new URL(url)
-
+  constructor (url, headers, timeout, protocol, signalType) {
     this.protocol = protocol
     this.signalType = signalType
 
-    // If no path is provided, use default path
-    const path = parsedUrl.pathname === '/' ? defaultPath : parsedUrl.pathname
     const isJson = protocol === 'http/json'
 
+    // Initialize fields setUrl doesn't touch; it fills in hostname/port/path below.
     this.options = {
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port,
-      path: path + parsedUrl.search,
       method: 'POST',
       timeout,
       headers: {
         'Content-Type': isJson ? 'application/json' : 'application/x-protobuf',
-        ...this.#parseAdditionalHeaders(headers),
+        ...headers,
       },
     }
+
+    this.setUrl(url)
+
     this.telemetryTags = [
       'protocol:http',
       `encoding:${isJson ? 'json' : 'protobuf'}`,
@@ -61,6 +58,7 @@ class OtlpHttpExporterBase {
    * @protected
    */
   recordTelemetry (metricName, count, additionalTags) {
+    // @ts-expect-error - additionalTags is optional and can be undefined
     if (additionalTags?.length > 0) {
       tracerMetrics.count(metricName, [...this.telemetryTags, ...additionalTags || []]).inc(count)
     } else {
@@ -91,6 +89,7 @@ class OtlpHttpExporterBase {
       })
 
       res.once('end', () => {
+        // @ts-expect-error - res.statusCode can be undefined
         if (res.statusCode >= 200 && res.statusCode < 300) {
           resultCallback({ code: 0 })
         } else {
@@ -116,61 +115,15 @@ class OtlpHttpExporterBase {
   }
 
   /**
-   * Parses additional HTTP headers from a comma-separated string or pre-parsed map.
-   * @param {string|Record<string, string>} [headersString=''] - Comma-separated key=value pairs or map
-   * @returns {Record<string, string>} Parsed headers object
+   * Updates the target URL used by this exporter. The URL is used as-is per the OTel spec: the
+   * caller is responsible for including the signal-specific path (`/v1/traces` etc.).
+   * @param {string} url - New OTLP endpoint URL
    */
-  #parseAdditionalHeaders (headersString = '') {
-    if (headersString !== null && typeof headersString === 'object') {
-      // The config MAP parser uses tagger.add (which splits on ':'), so OTEL-format
-      // headers ('key=value') arrive with the full 'key=value' string as the map key
-      // and an empty string as the value. Re-split on '=' to get the correct pairs.
-      const result = {}
-      for (const [k, v] of Object.entries(headersString)) {
-        if (v === '' && k.includes('=')) {
-          const idx = k.indexOf('=')
-          result[k.slice(0, idx).trim()] = k.slice(idx + 1).trim()
-        } else {
-          result[k] = v
-        }
-      }
-      return result
-    }
-    const headers = {}
-    let key = ''
-    let value = ''
-    let readingKey = true
-
-    for (const char of headersString) {
-      if (readingKey) {
-        if (char === '=') {
-          readingKey = false
-          key = key.trim()
-        } else {
-          key += char
-        }
-      } else if (char === ',') {
-        value = value.trim()
-        if (key && value) {
-          headers[key] = value
-        }
-        key = ''
-        value = ''
-        readingKey = true
-      } else {
-        value += char
-      }
-    }
-
-    // Add the last pair if present
-    if (!readingKey) {
-      value = value.trim()
-      if (value) {
-        headers[key] = value
-      }
-    }
-
-    return headers
+  setUrl (url) {
+    const parsedUrl = new URL(url)
+    this.options.hostname = parsedUrl.hostname
+    this.options.port = parsedUrl.port
+    this.options.path = parsedUrl.pathname + parsedUrl.search
   }
 
   /**

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

@@ -4,7 +4,7 @@ const { VERSION } = require('../../../../../version')
 const OtlpHttpTraceExporter = require('./otlp_http_trace_exporter')
 
 /**
- * @typedef {import('../../config')} Config
+ * @typedef {import('../../config/config-base')} Config
  * @typedef {import('../../opentracing/tracer')} DatadogTracer
  */
 
@@ -33,21 +33,17 @@ const OtlpHttpTraceExporter = require('./otlp_http_trace_exporter')
  */
 function buildResourceAttributes (config) {
   const resourceAttributes = {
-    'service.name': config.service || config.tags.service,
+    'service.name': config.service,
     'telemetry.sdk.name': 'datadog',
     'telemetry.sdk.version': VERSION,
     'telemetry.sdk.language': 'nodejs',
   }
 
-  const env = config.env || config.tags.env
-  if (env) resourceAttributes['deployment.environment'] = env
-  const version = config.version || config.tags.version
-  if (version) resourceAttributes['service.version'] = version
+  if (config.env) resourceAttributes['deployment.environment.name'] = config.env
+  if (config.version) resourceAttributes['service.version'] = config.version
 
-  if (config.tags) {
-    const { service, version, env, ...filteredTags } = config.tags
-    Object.assign(resourceAttributes, filteredTags)
-  }
+  const { service, version, env, ...filteredTags } = config.tags
+  Object.assign(resourceAttributes, filteredTags)
 
   return resourceAttributes
 }
@@ -56,15 +52,14 @@ function buildResourceAttributes (config) {
  * Creates the OTLP HTTP/JSON trace exporter.
  *
  * @param {Config} config - Tracer configuration instance
- * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
  * @returns {OtlpHttpTraceExporter} The OTLP HTTP/JSON exporter
  */
-function createOtlpTraceExporter (config, resourceAttributes) {
+function createOtlpTraceExporter (config) {
   return new OtlpHttpTraceExporter(
-    config.otelTracesUrl,
-    config.otelTracesHeaders,
-    config.otelTracesTimeout,
-    resourceAttributes
+    config.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
+    config.OTEL_EXPORTER_OTLP_TRACES_HEADERS,
+    config.OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
+    buildResourceAttributes(config)
   )
 }
 

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

@@ -8,13 +8,20 @@ const OtlpTraceTransformer = require('./otlp_transformer')
 /**
  * OtlpHttpTraceExporter exports DD-formatted spans via OTLP over HTTP/JSON.
  *
- * This implementation follows the OTLP HTTP v1.7.0 specification:
+ * This implementation follows the OTLP HTTP specification:
  * https://opentelemetry.io/docs/specs/otlp/#otlphttp
  *
  * It receives DD-formatted spans (from span_format.js), transforms them
  * to OTLP ExportTraceServiceRequest JSON format, and sends them to the
  * configured OTLP endpoint via HTTP POST.
  *
+ * TODO: Add batch handling similar to the OpenTelemetry SDK Batch Processor
+ * (https://opentelemetry.io/docs/specs/otel/trace/sdk/#batching-processor).
+ * Currently each finished trace is sent as its own HTTP request, which is
+ * unsuitable for high-traffic production environments. The config values
+ * `OTEL_BSP_SCHEDULE_DELAY`, `OTEL_BSP_MAX_EXPORT_BATCH_SIZE`, and `OTEL_BSP_MAX_QUEUE_SIZE`
+ * (OTEL_BSP_*) are already defined and should drive that implementation.
+ *
  * @class OtlpHttpTraceExporter
  * @augments OtlpHttpExporterBase
  */
@@ -25,12 +32,13 @@ class OtlpHttpTraceExporter extends OtlpHttpExporterBase {
    * Creates a new OtlpHttpTraceExporter instance.
    *
    * @param {string} url - OTLP endpoint URL
-   * @param {string} headers - Additional HTTP headers as comma-separated key=value string
+   * @param {Record<string, string>|undefined} headers - Additional HTTP headers parsed from the
+   *   corresponding `OTEL_EXPORTER_OTLP_*_HEADERS` env by the MAP parser.
    * @param {number} timeout - Request timeout in milliseconds
    * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
    */
   constructor (url, headers, timeout, resourceAttributes) {
-    super(url, headers, timeout, 'http/json', '/v1/traces', 'traces')
+    super(url, headers, timeout, 'http/json', 'traces')
     this.#transformer = new OtlpTraceTransformer(resourceAttributes)
   }
 

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

@@ -3,6 +3,7 @@
 const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
 const { getProtobufTypes } = require('../otlp/protobuf_loader')
 const { VERSION } = require('../../../../../version')
+const id = require('../../id')
 
 const { protoSpanKind } = getProtobufTypes()
 const SPAN_KIND_UNSPECIFIED = protoSpanKind.values.SPAN_KIND_UNSPECIFIED
@@ -12,11 +13,28 @@ const SPAN_KIND_CLIENT = protoSpanKind.values.SPAN_KIND_CLIENT
 const SPAN_KIND_PRODUCER = protoSpanKind.values.SPAN_KIND_PRODUCER
 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')
+
 /**
+ * @typedef {import('../../id').Identifier} Identifier
+ *
+ * @typedef {object} DDSpanLink
+ * @property {string} trace_id - Hex-encoded trace ID
+ * @property {string} span_id - Hex-encoded span ID
+ * @property {Record<string, string | number | boolean>} [attributes] - Link attributes
+ * @property {number} [flags] - Trace flags
+ * @property {string} [tracestate] - W3C trace state
+ *
+ * @typedef {object} DDSpanEvent
+ * @property {string} name - Event name
+ * @property {number} time_unix_nano - Event time in nanoseconds since epoch
+ * @property {Record<string, string | number | boolean>} [attributes] - Event attributes
+ *
  * @typedef {object} DDFormattedSpan
- * @property {import('../../id')} trace_id - DD Identifier for trace ID
- * @property {import('../../id')} span_id - DD Identifier for span ID
- * @property {import('../../id')} parent_id - DD Identifier for parent span ID
+ * @property {Identifier} trace_id - DD Identifier for trace ID
+ * @property {Identifier} span_id - DD Identifier for span ID
+ * @property {Identifier} parent_id - DD Identifier for parent span ID
  * @property {string} name - Span operation name
  * @property {string} resource - Resource name
  * @property {string} [service] - Service name
@@ -24,9 +42,10 @@ const SPAN_KIND_CONSUMER = protoSpanKind.values.SPAN_KIND_CONSUMER
  * @property {number} error - Error flag (0 or 1)
  * @property {{[key: string]: string}} meta - String key-value tags
  * @property {{[key: string]: number}} metrics - Numeric key-value tags
+ * @property {{[key: string]: object}} [meta_struct] - Structured tags (JSON-serialized, bytes in protobuf)
  * @property {number} start - Start time in nanoseconds since epoch
  * @property {number} duration - Duration in nanoseconds
- * @property {object[]} [span_events] - Span events
+ * @property {DDSpanEvent[]} [span_events] - Span events
  */
 
 // Map DD span.kind string values to OTLP SpanKind numeric values
@@ -51,7 +70,7 @@ const EXCLUDED_META_KEYS = new Set([
 /**
  * OtlpTraceTransformer transforms DD-formatted spans to OTLP trace JSON format.
  *
- * This implementation follows the OTLP Trace v1.7.0 Data Model specification:
+ * This implementation follows the OTLP trace data model:
  * https://opentelemetry.io/docs/specs/otlp/#trace-data-model
  *
  * It receives DD-formatted spans (from span_format.js) and produces
@@ -119,7 +138,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
     return {
       traceId: this.#idToBytes(span.trace_id, 16),
       spanId: this.#idToBytes(span.span_id, 8),
-      parentSpanId: (parentId && !this.#isZeroId(parentId)) ? this.#idToBytes(parentId, 8) : undefined,
+      parentSpanId: (parentId && !parentId.equals(ZERO_ID)) ? this.#idToBytes(parentId, 8) : undefined,
       name: span.resource,
       kind: this.#mapSpanKind(span.meta?.['span.kind']),
       startTimeUnixNano: span.start,
@@ -178,7 +197,10 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
       }
     }
 
-    // Add meta_struct as bytesValue attributes (JSON-serialized, base64-encoded per proto JSON mapping)
+    // TODO: meta_struct values are logically raw bytes. The OTLP http/json spec encodes the bytesValue
+    // field as base64, but when http/protobuf or gRPC support is added the payload should be sent as
+    // raw bytes directly (no JSON.stringify + base64). The backend decoding side will need to be
+    // updated in parallel to accept the unencoded bytes.
     if (span.meta_struct) {
       for (const [key, value] of Object.entries(span.meta_struct)) {
         const bytes = Buffer.from(JSON.stringify(value))
@@ -202,33 +224,40 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
 
   /**
    * Maps DD span error state to an OTLP Status object.
+   * Combines error.type and error.message when both are present so error type
+   * information is preserved on the OTel side.
    *
    * @param {DDFormattedSpan} span - DD-formatted span
    * @returns {object} OTLP Status object with code and message
    */
   #mapStatus (span) {
-    if (span.error === 1) {
-      return {
-        code: STATUS_CODE_ERROR,
-        message: span.meta?.['error.message'] || '',
-      }
+    if (span.error !== 1) {
+      return { code: STATUS_CODE_UNSET, message: '' }
+    }
+    const errorType = span.meta?.['error.type']
+    const errorMessage = span.meta?.['error.message']
+    let message = ''
+    if (errorType && errorMessage) {
+      message = `${errorType}: ${errorMessage}`
+    } else if (errorType) {
+      message = errorType
+    } else if (errorMessage) {
+      message = errorMessage
     }
-    return { code: STATUS_CODE_UNSET, message: '' }
+    return { code: STATUS_CODE_ERROR, message }
   }
 
   /**
    * Transforms a DD span event to an OTLP Event object.
    *
-   * @param {object} event - DD span event with name, time_unix_nano, and attributes
+   * @param {DDSpanEvent} event - DD span event
    * @returns {object} OTLP Event object
    */
   #transformEvent (event) {
     return {
       timeUnixNano: event.time_unix_nano,
       name: event.name || '',
-      attributes: event.attributes && Object.keys(event.attributes).length > 0
-        ? this.transformAttributes(event.attributes)
-        : [],
+      attributes: this.transformAttributes(event.attributes ?? {}),
       droppedAttributesCount: 0,
     }
   }
@@ -257,7 +286,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
   /**
    * Transforms a single DD span link to an OTLP Link object.
    *
-   * @param {object} link - DD span link with trace_id, span_id, attributes, flags, tracestate
+   * @param {DDSpanLink} link - DD span link
    * @returns {object} OTLP Link object
    */
   #transformLink (link) {
@@ -265,9 +294,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
       traceId: this.#hexToBytes(link.trace_id, 16),
       spanId: this.#hexToBytes(link.span_id, 8),
       traceState: link.tracestate || '',
-      attributes: link.attributes && Object.keys(link.attributes).length > 0
-        ? this.transformAttributes(link.attributes)
-        : [],
+      attributes: this.transformAttributes(link.attributes ?? {}),
       droppedAttributesCount: 0,
       flags: link.flags,
     }
@@ -278,7 +305,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    * 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 {object} identifier - DD Identifier object with toBuffer() method
+   * @param {Identifier} identifier - DD Identifier
    * @param {number} targetLength - Target byte length (16 for trace ID, 8 for span ID)
    * @returns {string} Hex-encoded string of the specified length
    */
@@ -290,29 +317,12 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
     if (buffer.length > targetLength) {
       return Buffer.from(buffer.slice(buffer.length - targetLength)).toString('hex')
     }
-    // Pad with leading zeros to reach target length
+    // Pad with leading zeros to reach target length.
     const result = Buffer.alloc(targetLength)
-    const offset = targetLength - buffer.length
-    for (let i = 0; i < buffer.length; i++) {
-      result[offset + i] = buffer[i]
-    }
+    Buffer.from(buffer).copy(result, targetLength - buffer.length)
     return result.toString('hex')
   }
 
-  /**
-   * Checks if a DD Identifier represents a zero ID (all bytes are 0).
-   *
-   * @param {object} identifier - DD Identifier object with toBuffer() method
-   * @returns {boolean} True if the identifier is all zeros
-   */
-  #isZeroId (identifier) {
-    const buffer = identifier.toBuffer()
-    for (let i = 0; i < buffer.length; i++) {
-      if (buffer[i] !== 0) return false
-    }
-    return true
-  }
-
   /**
    * Normalizes a hex string to the specified byte length.
    * Pads with leading zeros if the hex string is shorter than expected.