dd-trace 5.105.0 → 5.107.0

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

@@ -5,6 +5,7 @@ const {
   getOperation,
   extractMetrics,
   extractMetadata,
+  extractToolDefinitions,
   aggregateStreamingChunks,
   formatInputMessages,
   formatEmbeddingInput,
@@ -79,6 +80,9 @@ class GenAiLLMObsPlugin extends LLMObsPlugin {
     const metadata = extractMetadata(config)
     this._tagger.tagMetadata(span, metadata)
 
+    const toolDefinitions = extractToolDefinitions(config)
+    if (toolDefinitions.length > 0) this._tagger.tagToolDefinitions(span, toolDefinitions)
+
     if (error) {
       this._tagger.tagLLMIO(span, inputMessages, [{ content: '' }])
       return

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

@@ -155,6 +155,50 @@ function extractMetadata (config) {
   return metadata
 }
 
+/**
+ * Extract tool definitions from config
+ * @param {object} config
+ * @returns {Array}
+ */
+function extractToolDefinitions (config) {
+  const toolDefinitions = []
+
+  if (!Array.isArray(config?.tools)) {
+    return toolDefinitions
+  }
+
+  for (const tool of config.tools) {
+    // Only extract tools with valid function declarations
+    if (!Array.isArray(tool?.functionDeclarations)) {
+      continue
+    }
+
+    for (const currDeclaration of tool.functionDeclarations) {
+      // A valid declaration must have a name
+      if (!currDeclaration?.name) {
+        continue
+      }
+
+      const toolDef = { name: currDeclaration.name }
+
+      if (currDeclaration.description !== undefined) {
+        toolDef.description = currDeclaration.description
+      }
+
+      // Parameters can be in two different fields depending on user input
+      if (currDeclaration.parameters !== undefined) {
+        toolDef.schema = currDeclaration.parameters
+      } else if (currDeclaration.parametersJsonSchema !== undefined) {
+        toolDef.schema = currDeclaration.parametersJsonSchema
+      }
+
+      toolDefinitions.push(toolDef)
+    }
+  }
+
+  return toolDefinitions
+}
+
 /**
  * Format function call message
  * @param {Array} parts
@@ -498,6 +542,7 @@ module.exports = {
   getOperation,
   extractMetrics,
   extractMetadata,
+  extractToolDefinitions,
   aggregateStreamingChunks,
   formatInputMessages,
   formatEmbeddingInput,

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

@@ -259,7 +259,7 @@ class LLMObs extends NoopLLMObs {
         throw new Error('LLMObs span must have a span kind specified')
       }
 
-      const { inputData, outputData, metadata, metrics, tags, prompt, costTags } = options
+      const { inputData, outputData, metadata, metrics, tags, prompt, costTags, toolDefinitions } = options
 
       if (inputData || outputData) {
         if (spanKind === 'llm') {
@@ -289,6 +289,9 @@ class LLMObs extends NoopLLMObs {
       if (prompt) {
         this._tagger.tagPrompt(span, prompt)
       }
+      if (toolDefinitions != null) {
+        this._tagger.tagToolDefinitions(span, toolDefinitions)
+      }
     } catch (e) {
       if (e.ddErrorTag) {
         err = e.ddErrorTag

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

@@ -332,8 +332,24 @@ class LLMObsSpanProcessor {
     return tags
   }
 
+  /**
+   * @param {Record<string, unknown>} tags
+   */
   #objectTagsToStringArrayTags (tags) {
-    return Object.entries(tags).map(([key, value]) => `${key}:${value ?? ''}`)
+    const out = []
+    for (const [key, value] of Object.entries(tags)) {
+      // Comma is the intake-side tag delimiter, so a single `"key:v1,v2"`
+      // entry fans into two orphan tags. One-per-element keeps each value
+      // addressable; empty arrays fall through to the scalar branch and
+      // still emit `key:` so `_dd.cost_tags` references keep finding a
+      // wire entry.
+      if (Array.isArray(value) && value.length > 0) {
+        for (const item of value) out.push(`${key}:${item ?? ''}`)
+      } else {
+        out.push(`${key}:${value ?? ''}`)
+      }
+    }
+    return out
   }
 
   /**

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

@@ -43,7 +43,7 @@ const {
   INSTRUMENTATION_METHOD_ANNOTATED,
 } = require('./constants/tags')
 const { storage } = require('./storage')
-const { findGenAIAncestorSpanId, validateCostTags, writeBridgeTags } = require('./util')
+const { findGenAIAncestorSpanId, validateCostTags, writeBridgeTags, validateToolDefinitions } = require('./util')
 
 // global registry of LLMObs spans
 // maps LLMObs spans to their annotations
@@ -176,8 +176,10 @@ class LLMObsTagger {
   }
 
   tagToolDefinitions (span, toolDefinitions) {
-    if (Array.isArray(toolDefinitions) && toolDefinitions.length > 0) {
-      this._setTag(span, TOOL_DEFINITIONS, toolDefinitions)
+    const validatedToolDefinitions = validateToolDefinitions(toolDefinitions)
+
+    if (validatedToolDefinitions.length > 0) {
+      this._setTag(span, TOOL_DEFINITIONS, validatedToolDefinitions)
     } else {
       this.#handleFailure('Tool definitions must be a non-empty array.', 'invalid_tool_definitions')
     }

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

@@ -89,6 +89,59 @@ function validateCostTags (span, costTags, source, spanTags) {
   return [...validatedCostTags]
 }
 
+// Validates tool definition entires
+function validateToolDefinitions (toolDefinitions) {
+  if (!Array.isArray(toolDefinitions)) {
+    log.warn('toolDefinitions must be an array.')
+    return []
+  }
+  const validated = []
+
+  for (let i = 0; i < toolDefinitions.length; i++) {
+    const currToolDef = toolDefinitions[i]
+    if (!currToolDef || typeof currToolDef !== 'object') {
+      log.warn('Tool definition at index %d must be an object. Skipping.', i)
+      continue
+    }
+
+    // Name is not optional
+    if (!currToolDef.name || typeof currToolDef.name !== 'string' || currToolDef.name.length <= 0) {
+      log.warn('Tool definition at index %d must have a non empty string "name". Skipping.', i)
+      continue
+    }
+    const validatedToolDef = { name: currToolDef.name }
+
+    // Description, Schema, and Version are optional types
+    if (currToolDef.description !== undefined) {
+      if (typeof currToolDef.description === 'string') {
+        validatedToolDef.description = currToolDef.description
+      } else {
+        log.warn('Tool definition "description" at index %d must be a string. Skipping field.', i)
+      }
+    }
+
+    if (currToolDef.schema !== undefined) {
+      if (currToolDef.schema !== null && typeof currToolDef.schema === 'object' && !Array.isArray(currToolDef.schema)) {
+        validatedToolDef.schema = currToolDef.schema
+      } else {
+        log.warn('Tool definition "schema" at index %d must be a plain object. Skipping field.', i)
+      }
+    }
+
+    if (currToolDef.version !== undefined) {
+      if (typeof currToolDef.version === 'string') {
+        validatedToolDef.version = currToolDef.version
+      } else {
+        log.warn('Tool definition "version" at index %d must be a string. Skipping field.', i)
+      }
+    }
+
+    validated.push(validatedToolDef)
+  }
+
+  return validated
+}
+
 // extracts the argument names from a function string
 function parseArgumentNames (str) {
   const result = []
@@ -318,4 +371,5 @@ module.exports = {
   safeJsonParse,
   spanHasError,
   writeBridgeTags,
+  validateToolDefinitions,
 }

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

@@ -14,7 +14,6 @@ const {
   EVP_SUBDOMAIN_HEADER_NAME,
   EVP_PROXY_AGENT_BASE_PATH,
 } = require('../constants/writers')
-const { getAgentUrl } = require('../../agent/url')
 const { parseResponseAndLog } = require('./util')
 
 class LLMObsBuffer {
@@ -210,7 +209,7 @@ class BaseLLMObsWriter {
 
     const overrideOriginEnv = getEnvironmentVariable('_DD_LLMOBS_OVERRIDE_ORIGIN')
     const overrideOriginUrl = overrideOriginEnv && new URL(overrideOriginEnv)
-    const base = overrideOriginUrl ?? getAgentUrl(this._config)
+    const base = overrideOriginUrl ?? this._config.url
 
     return {
       url: base,

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

@@ -4,7 +4,6 @@ const logger = require('../../log')
 const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/writers')
 const telemetry = require('../telemetry')
 const { fetchAgentInfo } = require('../../agent/info')
-const { getAgentUrl } = require('../../agent/url')
 
 /**
  * @param {import('../../config/config-base')} config
@@ -17,7 +16,7 @@ function setAgentStrategy (config, setWritersAgentlessValue) {
     return
   }
 
-  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
+  fetchAgentInfo(config.url, (err, agentInfo) => {
     if (err) {
       setWritersAgentlessValue(true)
       return

package/packages/dd-trace/src/openfeature/writers/base.js

@@ -2,7 +2,6 @@
 
 const request = require('../../exporters/common/request')
 const { safeJSONStringify } = require('../../exporters/common/util')
-const { getAgentUrl } = require('../../agent/url')
 
 const log = require('../../log')
 
@@ -37,7 +36,7 @@ class BaseFFEWriter {
 
     this._config = config
     this._endpoint = endpoint
-    this._baseUrl = agentUrl ?? this._getAgentUrl()
+    this._baseUrl = agentUrl ?? config.url
     this._payloadSizeLimit = payloadSizeLimit
     this._eventSizeLimit = eventSizeLimit
     this._headers = headers || {}
@@ -154,14 +153,6 @@ class BaseFFEWriter {
     }
   }
 
-  /**
-   * @private
-   * @returns {URL} Constructs agent URL from config
-   */
-  _getAgentUrl () {
-    return getAgentUrl(this._config)
-  }
-
   /**
    * @private
    * @param {Array<object>} payload - Payload to encode

package/packages/dd-trace/src/openfeature/writers/util.js

@@ -3,7 +3,6 @@
 const logger = require('../../log')
 const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/constants')
 const { fetchAgentInfo } = require('../../agent/info')
-const { getAgentUrl } = require('../../agent/url')
 
 /**
  * Determines if the agent supports EVP proxy and sets the writer enabled state accordingly
@@ -11,7 +10,7 @@ const { getAgentUrl } = require('../../agent/url')
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
-  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
+  fetchAgentInfo(config.url, (err, agentInfo) => {
     if (err) {
       logger.debug('FFE Writer disabled - error getting agent info:', err.message)
       setWriterEnabledValue(false)

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

@@ -50,7 +50,7 @@ class Instrument {
    * Creates a measurement object for recording metric values.
    * @param {string} type - Metric type from METRIC_TYPES
    * @param {number} value - Numeric value to record
-   * @param {Attributes} attributes - Key-value pairs for metric dimensions
+   * @param {Attributes} [attributes] - Key-value pairs for metric dimensions
    * @returns {Measurement} Measurement object with metadata and timestamp
    */
   createMeasurement (type, value, attributes) {
@@ -73,9 +73,9 @@ class Instrument {
  * @class Counter
  */
 class Counter extends Instrument {
-  add (value, attributes = {}) {
+  add (value, attributes) {
     if (value < 0) return
-    this.reader?.record(this.createMeasurement(METRIC_TYPES.COUNTER, value, attributes))
+    this.reader.record(this.createMeasurement(METRIC_TYPES.COUNTER, value, attributes))
   }
 }
 
@@ -85,8 +85,8 @@ class Counter extends Instrument {
  * @class UpDownCounter
  */
 class UpDownCounter extends Instrument {
-  add (value, attributes = {}) {
-    this.reader?.record(this.createMeasurement(METRIC_TYPES.UPDOWNCOUNTER, value, attributes))
+  add (value, attributes) {
+    this.reader.record(this.createMeasurement(METRIC_TYPES.UPDOWNCOUNTER, value, attributes))
   }
 }
 
@@ -96,9 +96,9 @@ class UpDownCounter extends Instrument {
  * @class Histogram
  */
 class Histogram extends Instrument {
-  record (value, attributes = {}) {
+  record (value, attributes) {
     if (value < 0) return
-    this.reader?.record(this.createMeasurement(METRIC_TYPES.HISTOGRAM, value, attributes))
+    this.reader.record(this.createMeasurement(METRIC_TYPES.HISTOGRAM, value, attributes))
   }
 }
 
@@ -108,8 +108,8 @@ class Histogram extends Instrument {
  * @class Gauge
  */
 class Gauge extends Instrument {
-  record (value, attributes = {}) {
-    this.reader?.record(this.createMeasurement(METRIC_TYPES.GAUGE, value, attributes))
+  record (value, attributes) {
+    this.reader.record(this.createMeasurement(METRIC_TYPES.GAUGE, value, attributes))
   }
 }
 
@@ -136,7 +136,7 @@ class ObservableInstrument extends Instrument {
   addCallback (callback) {
     if (typeof callback !== 'function') return
     this.#callbacks.push(callback)
-    this.reader?.observableInstruments.add(this)
+    this.reader.observableInstruments.add(this)
   }
 
   /**
@@ -150,7 +150,7 @@ class ObservableInstrument extends Instrument {
       this.#callbacks.splice(index, 1)
       if (this.#callbacks.length === 0) {
         // Remove instrument from collection when no callbacks remain
-        this.reader?.observableInstruments.delete(this)
+        this.reader.observableInstruments.delete(this)
       }
     }
   }
@@ -163,8 +163,8 @@ class ObservableInstrument extends Instrument {
   collect () {
     const observations = []
     const observableResult = {
-      observe: (value, attributes = {}) => {
-        observations.push(this.createMeasurement(this.#type, value, attributes))
+      observe: (value, attributes) => {
+        observations.push(this.createObservation(value, attributes))
       },
     }
 
@@ -179,6 +179,18 @@ class ObservableInstrument extends Instrument {
 
     return observations
   }
+
+  /**
+   * Builds a measurement for this instrument's metric type. Keeps the type
+   * encapsulated so callers (e.g. batch observable callbacks) don't read it.
+   *
+   * @param {number} value
+   * @param {Attributes} attributes
+   * @returns {Measurement}
+   */
+  createObservation (value, attributes) {
+    return this.createMeasurement(this.#type, value, attributes)
+  }
 }
 
 /**
@@ -219,6 +231,7 @@ module.exports = {
   UpDownCounter,
   Histogram,
   Gauge,
+  ObservableInstrument,
   ObservableGauge,
   ObservableCounter,
   ObservableUpDownCounter,

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const { VERSION: packageVersion } = require('../../../../../version')
-const log = require('../../log')
 const {
   Counter, UpDownCounter, Histogram, Gauge, ObservableGauge, ObservableCounter, ObservableUpDownCounter,
 } = require('./instruments')
@@ -148,23 +147,21 @@ class Meter {
   }
 
   /**
-   * Adds a batch observable callback (not implemented).
+   * Registers a batch observable callback for the given observables.
    *
-   * @param {Function} callback - Batch observable callback
-   * @param {Array} observables - Array of observable instruments
+   * @param {Function} callback
+   * @param {Array} observables
    */
   addBatchObservableCallback (callback, observables) {
-    log.warn('addBatchObservableCallback is not implemented')
+    this.meterProvider.reader.addBatchObservableCallback(callback, observables)
   }
 
   /**
-   * Removes a batch observable callback (not implemented).
-   *
-   * @param {Function} callback - Batch observable callback
-   * @param {Array} observables - Array of observable instruments
+   * @param {Function} callback
+   * @param {Array} observables
    */
   removeBatchObservableCallback (callback, observables) {
-    log.warn('removeBatchObservableCallback is not implemented')
+    this.meterProvider.reader.removeBatchObservableCallback(callback, observables)
   }
 }
 

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

@@ -5,6 +5,7 @@ const { stableStringify } = require('../otlp/otlp_transformer_base')
 const {
   METRIC_TYPES, TEMPORALITY, DEFAULT_HISTOGRAM_BUCKETS, DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE,
 } = require('./constants')
+const { ObservableInstrument } = require('./instruments')
 
 /**
  * @typedef {import('@opentelemetry/api').Attributes} Attributes
@@ -102,6 +103,7 @@ class PeriodicMetricReader {
   #isShutdown = false
   #exportInterval
   #aggregator
+  #batchCallbacks = []
 
   /**
    * Creates a new PeriodicMetricReader instance.
@@ -132,6 +134,66 @@ class PeriodicMetricReader {
     this.#measurements.push(measurement)
   }
 
+  /**
+   * Registers a batch observable callback. Mirrors
+   * `@opentelemetry/sdk-metrics` `ObservableRegistry.addBatchCallback`.
+   *
+   * @param {Function} callback
+   * @param {Array} observables
+   */
+  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
+    this.#batchCallbacks.push({ callback, instruments })
+  }
+
+  /**
+   * @param {Function} callback
+   * @param {Array} observables
+   */
+  removeBatchObservableCallback (callback, observables) {
+    const instruments = new Set(observables?.filter(isObservableInstrument))
+    const idx = this.#findBatchCallback(callback, instruments)
+    if (idx !== -1) this.#batchCallbacks.splice(idx, 1)
+  }
+
+  /**
+   * @param {Function} callback
+   * @param {Set} instruments
+   * @returns {number} index in #batchCallbacks, or -1
+   */
+  #findBatchCallback (callback, instruments) {
+    return this.#batchCallbacks.findIndex(record =>
+      record.callback === callback && setEquals(record.instruments, instruments))
+  }
+
+  /**
+   * Invokes batch observable callbacks and returns the produced measurements.
+   *
+   * @returns {Measurement[]}
+   */
+  #collectBatchObservables () {
+    if (this.#batchCallbacks.length === 0) return []
+    const out = []
+    for (const { callback, instruments } of this.#batchCallbacks) {
+      const result = {
+        observe: (instrument, value, attributes) => {
+          if (instruments.has(instrument)) {
+            out.push(instrument.createObservation(value, attributes))
+          }
+        },
+      }
+      try {
+        callback(result)
+      } catch (e) {
+        log.error('Error running batch observable callback', e)
+      }
+    }
+    return out
+  }
+
   /**
    * Forces an immediate collection and export of all metrics.
    * @returns {void}
@@ -210,6 +272,17 @@ class PeriodicMetricReader {
       }
     }
 
+    const batchMeasurements = this.#collectBatchObservables()
+    if (batchMeasurements.length > 0) {
+      const remainingCapacity = DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE - allMeasurements.length
+      if (batchMeasurements.length <= remainingCapacity) {
+        allMeasurements.push(...batchMeasurements)
+      } else {
+        allMeasurements.push(...batchMeasurements.slice(0, remainingCapacity))
+        this.#droppedCount += batchMeasurements.length - remainingCapacity
+      }
+    }
+
     if (this.#droppedCount > 0) {
       log.warn('Metric queue exceeded limit (max: %d). Dropping %d measurements.',
         DEFAULT_MAX_MEASUREMENT_QUEUE_SIZE, this.#droppedCount)
@@ -555,4 +628,23 @@ class MetricAggregator {
   }
 }
 
+/**
+ * @param {object} x
+ * @returns {boolean}
+ */
+function isObservableInstrument (x) {
+  return x instanceof ObservableInstrument
+}
+
+/**
+ * @param {Set} a
+ * @param {Set} b
+ * @returns {boolean}
+ */
+function setEquals (a, b) {
+  if (a.size !== b.size) return false
+  for (const x of a) if (!b.has(x)) return false
+  return true
+}
+
 module.exports = PeriodicMetricReader

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

@@ -4,6 +4,7 @@ const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
 const { getProtobufTypes } = require('../otlp/protobuf_loader')
 const { VERSION } = require('../../../../../version')
 const id = require('../../id')
+const { eventTimeNano } = require('../../encode/tags-processors')
 
 const { protoSpanKind } = getProtobufTypes()
 const SPAN_KIND_UNSPECIFIED = protoSpanKind.values.SPAN_KIND_UNSPECIFIED
@@ -16,6 +17,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
  *
@@ -28,7 +34,7 @@ const ZERO_ID = id('0')
  *
  * @typedef {object} DDSpanEvent
  * @property {string} name - Event name
- * @property {number} time_unix_nano - Event time in nanoseconds since epoch
+ * @property {number} startTime - Event start time in milliseconds (sub-ms precision)
  * @property {Record<string, string | number | boolean>} [attributes] - Event attributes
  *
  * @typedef {object} DDFormattedSpan
@@ -65,6 +71,7 @@ const STATUS_CODE_ERROR = 2
 const EXCLUDED_META_KEYS = new Set([
   '_dd.span_links',
   'span.kind',
+  TRACE_ID_128,
 ])
 
 /**
@@ -113,6 +120,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 +140,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
         droppedAttributesCount: 0,
       },
       schemaUrl: '',
-      spans: spans.map(span => this.#transformSpan(span)),
+      spans: otlpSpans,
     }]
   }
 
@@ -129,14 +148,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,
@@ -255,7 +275,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    */
   #transformEvent (event) {
     return {
-      timeUnixNano: event.time_unix_nano,
+      timeUnixNano: eventTimeNano(event),
       name: event.name || '',
       attributes: this.transformAttributes(event.attributes ?? {}),
       droppedAttributesCount: 0,