dd-trace 6.13.0 → 6.14.0

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

@@ -17,13 +17,20 @@ const {
 } = require('../constants/writers')
 const { parseResponseAndLog } = require('./util')
 
+const MAX_BUFFER_EVENTS = 1000
+
 class LLMObsBuffer {
-  constructor ({ events, size, routing = {}, isDefault = false, limit = 1000 }) {
+  /**
+   * @param {{
+   *   events: Record<string, unknown>[],
+   *   size: number,
+   *   routing?: { apiKey?: string, site?: string }
+   * }} options
+   */
+  constructor ({ events, size, routing = {} }) {
     this.events = events
     this.size = size
     this.routing = routing
-    this.isDefault = isDefault
-    this.limit = limit
   }
 
   clear () {
@@ -46,7 +53,7 @@ class BaseLLMObsWriter {
     this._eventType = eventType
 
     /** @type {LLMObsBuffer} */
-    this._buffer = new LLMObsBuffer({ events: [], size: 0, isDefault: true })
+    this._buffer = new LLMObsBuffer({ events: [], size: 0 })
 
     /** @type {import('../../config/config-base')} */
     this._config = config
@@ -102,8 +109,8 @@ class BaseLLMObsWriter {
   append (event, routing, byteLength) {
     const buffer = this._getBuffer(routing)
 
-    if (buffer.events.length >= buffer.limit) {
-      logger.warn(`${this.constructor.name} event buffer full (limit is ${buffer.limit}), dropping event`)
+    if (buffer.events.length >= MAX_BUFFER_EVENTS) {
+      logger.warn(`${this.constructor.name} event buffer full (limit is ${MAX_BUFFER_EVENTS}), dropping event`)
       telemetry.recordDroppedPayload(1, this._eventType, 'buffer_full')
       return false
     }
@@ -158,30 +165,48 @@ class BaseLLMObsWriter {
     }
 
     for (const [apiKey, buffer] of this.#multiTenantBuffers) {
-      if (buffer.events.length === 0) continue
-      const events = buffer.events
-      buffer.clear()
+      if (buffer.events.length === 0) {
+        this.#multiTenantBuffers.delete(apiKey)
+        continue
+      }
       const site = buffer.routing.site || this._config.site
-      const options = {
-        headers: {
-          'Content-Type': 'application/json',
-          'DD-API-KEY': apiKey,
-        },
-        method: 'POST',
-        timeout: this._timeout,
-        url: new URL(format({
-          protocol: 'https:',
-          hostname: `${this._intake}.${site}`,
-        })),
-        path: this._baseEndpoint,
+      const maskedApiKey = `****${apiKey.slice(-4)}`
+      let options
+      let url
+      try {
+        options = {
+          headers: {
+            'Content-Type': 'application/json',
+            'DD-API-KEY': apiKey,
+          },
+          method: 'POST',
+          timeout: this._timeout,
+          url: new URL(format({
+            protocol: 'https:',
+            hostname: `${this._intake}.${site}`,
+          })),
+          path: this._baseEndpoint,
+        }
+        url = this.#buildUrl(options.url.href, options.path)
+      } catch (error) {
+        buffer.clear()
+        this.#multiTenantBuffers.delete(apiKey)
+        logger.error(
+          'Failed to route LLMObs %s events for API key %s: %s',
+          this._eventType,
+          maskedApiKey,
+          error.message
+        )
+        continue
       }
-      const url = this.#buildUrl(options.url.href, options.path)
-      const maskedApiKey = apiKey ? `****${apiKey.slice(-4)}` : ''
+
+      const events = buffer.events
+      buffer.clear()
+      this.#multiTenantBuffers.delete(apiKey)
       log.debug('Encoding and flushing multi-tenant buffer for %s', maskedApiKey)
       requests.push({ events, options, url })
     }
 
-    this.#cleanupEmptyBuffers()
     return requests
   }
 
@@ -194,14 +219,6 @@ class BaseLLMObsWriter {
     })
   }
 
-  #cleanupEmptyBuffers () {
-    for (const [key, buffer] of this.#multiTenantBuffers) {
-      if (buffer.events.length === 0) {
-        this.#multiTenantBuffers.delete(key)
-      }
-    }
-  }
-
   makePayload (events) {}
 
   /**

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

@@ -29,7 +29,13 @@ const log = {
       const stack = logRecord.stack.split('\n')
       const fn = stack[1].replace(/^\s+at ([^\s]+) .+/, '$1')
       const options = { depth: 2, breakLength: Infinity, compact: true, maxArrayLength: Infinity }
-      const params = args.map(a => inspect(a, options)).join(', ')
+      let params = ''
+      let isFirstParameter = true
+      for (const argument of args) {
+        if (!isFirstParameter) params += ', '
+        params += inspect(argument, options)
+        isFirstParameter = false
+      }
 
       stack[0] = `Trace: ${fn}(${params})`
 

package/packages/dd-trace/src/{ci-visibility/log-submission → log-submission}/log-submission-plugin.js

@@ -2,19 +2,29 @@
 
 const { Writable } = require('node:stream')
 
-const request = require('../../exporters/common/request')
-const log = require('../../log')
-const Plugin = require('../../plugins/plugin')
-const { FinalFlushRequestTracker } = require('../exporters/agentless/request-tracker')
-const { FINAL_FLUSH_TIMEOUT } = require('../final-flush')
+const FinalFlushRequestTracker = require('../exporters/common/final-flush-request-tracker')
+const request = require('../exporters/common/request')
+const log = require('../log')
+const Plugin = require('../plugins/plugin')
 
 const MAX_BATCH_BYTES = 5 * 1024 * 1024
 const MAX_BATCH_LOGS = 1000
 const BATCH_FLUSH_INTERVAL = 1000
+const FINAL_FLUSH_TIMEOUT = 60_000
 
 /**
- * @param {import('../../config/config-base')} config
- * @returns {URL | undefined}
+ * @returns {Error & { code: string }}
+ */
+function createFinalFlushTimeoutError () {
+  return Object.assign(
+    new Error('Timed out waiting for automatic log submission to flush'),
+    { code: 'ERR_DD_LOG_SUBMISSION_FLUSH_TIMEOUT' }
+  )
+}
+
+/**
+ * @param {import('../config/config-base')} config
+ * @returns {URL | void}
  */
 function getLogSubmissionUrl (config) {
   if (config.DD_AGENTLESS_LOG_SUBMISSION_URL) {
@@ -39,7 +49,15 @@ function getLogSubmissionUrl (config) {
 }
 
 /**
- * @param {import('../../config/config-base')} config
+ * @param {unknown} config
+ * @returns {import('../config/config-base')}
+ */
+function asTracerConfig (config) {
+  return /** @type {import('../config/config-base')} */ (config)
+}
+
+/**
+ * @param {import('../config/config-base')} config
  * @param {string} source
  * @returns {string}
  */
@@ -54,6 +72,8 @@ class LogSubmissionPlugin extends Plugin {
   #batch = []
   #batchBytes = 2
   #batchSource
+  /** @type {import('../config/config-base') | undefined} */
+  #config
   #logSubmissionUrl
   #requestTracker
   #timer
@@ -71,12 +91,19 @@ class LogSubmissionPlugin extends Plugin {
     },
   })
 
-  constructor (...args) {
-    super(...args)
-    this.#requestTracker = new FinalFlushRequestTracker((done) => {
-      this.#flushLogs()
-      done?.()
-    })
+  /**
+   * @param {object} tracer
+   * @param {unknown} tracerConfig
+   */
+  constructor (tracer, tracerConfig) {
+    super(tracer, asTracerConfig(tracerConfig))
+    this.#requestTracker = new FinalFlushRequestTracker(
+      (done) => {
+        this.#flushLogs()
+        done?.()
+      },
+      createFinalFlushTimeoutError
+    )
 
     // The main-module hook (configure) and the logger.js hook (add-transport) can fire in either
     // order depending on how Winston is required, so buffer loggers that arrive before configure.
@@ -128,8 +155,9 @@ class LogSubmissionPlugin extends Plugin {
     if (this._enabled) this.#flushLogs()
 
     const isEnabled = typeof config === 'boolean' ? config : config.enabled
-    this.#logSubmissionUrl = isEnabled && typeof config !== 'boolean'
-      ? getLogSubmissionUrl(config)
+    this.#config = isEnabled && typeof config !== 'boolean' ? asTracerConfig(config) : undefined
+    this.#logSubmissionUrl = this.#config
+      ? getLogSubmissionUrl(this.#config)
       : undefined
     super.configure(config)
 
@@ -189,7 +217,8 @@ class LogSubmissionPlugin extends Plugin {
     clearTimeout(this.#timer)
     this.#timer = undefined
 
-    if (this.#batch.length === 0 || !this.#logSubmissionUrl) return
+    const config = this.#config
+    if (this.#batch.length === 0 || !this.#logSubmissionUrl || !config) return
 
     const source = this.#batchSource
     const data = `[${this.#batch.join(',')}]`
@@ -197,10 +226,10 @@ class LogSubmissionPlugin extends Plugin {
     this.#batchBytes = 2
     this.#batchSource = undefined
     const options = {
-      path: getLogSubmissionPath(this.config, source),
+      path: getLogSubmissionPath(config, source),
       method: 'POST',
       headers: {
-        'DD-API-KEY': this.config.DD_API_KEY,
+        'DD-API-KEY': config.DD_API_KEY,
         'Content-Type': 'application/json',
       },
       url: this.#logSubmissionUrl,

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

@@ -214,21 +214,23 @@ class BaseFFEWriter {
    * @returns {ActiveWriterRoute} Active route state
    */
   #createRoute (route) {
+    const requestOptions = {
+      headers: {
+        ...route.headers,
+        'Content-Type': 'application/json',
+      },
+      method: 'POST',
+      retry: true,
+      timeout: this._timeout,
+      url: route.url,
+      path: route.endpoint,
+    }
+    if (route.agent) requestOptions.agent = route.agent
+
     return {
       url: route.url,
       endpoint: route.endpoint,
-      requestOptions: {
-        ...(route.agent && { agent: route.agent }),
-        headers: {
-          ...route.headers,
-          'Content-Type': 'application/json',
-        },
-        method: 'POST',
-        retry: true,
-        timeout: this._timeout,
-        url: route.url,
-        path: route.endpoint,
-      },
+      requestOptions,
     }
   }
 

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

@@ -75,8 +75,8 @@ function setAgentlessStrategy (config, setWriterEnabledValue) {
         headers: {
           [EVP_SUBDOMAIN_HEADER_NAME]: EVP_EVENT_PLATFORM_SUBDOMAIN,
         },
-        ...(directRoute && { fallback: directRoute }),
       }
+      if (directRoute) route.fallback = directRoute
       logger.debug('FFE Writer enabled with local EVP route %s', route.basePath)
       setWriterEnabledValue(true, route)
       return

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const os = require('os')
+const { buildResourceAttributes, registerResourceAttributeRefresh } = require('../resource-attributes')
 
 /**
  * @typedef {import('../../config')} Config
@@ -37,35 +37,13 @@ const OtlpHttpLogExporter = require('./otlp_http_log_exporter')
  * @param {import('../../config/config-base')} config - Tracer configuration instance
  */
 function initializeOpenTelemetryLogs (config) {
-  // Build resource attributes
-  const resourceAttributes = {
-    'service.name': config.service,
-    'service.version': config.version,
-    'deployment.environment': config.env,
-  }
-
-  // Add all tracer tags (includes DD_TAGS, OTEL_RESOURCE_ATTRIBUTES, DD_TRACE_TAGS, etc.)
-  // Exclude Datadog-style keys that duplicate OpenTelemetry standard keys
-  if (config.tags) {
-    const filteredTags = { ...config.tags }
-    delete filteredTags.service
-    delete filteredTags.version
-    delete filteredTags.env
-    Object.assign(resourceAttributes, filteredTags)
-  }
-
-  // Add host.name if reportHostname is enabled
-  if (config.reportHostname) {
-    resourceAttributes['host.name'] = os.hostname()
-  }
-
   // Create OTLP exporter using resolved config values
   const exporter = new OtlpHttpLogExporter(
     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
+    buildResourceAttributes(config)
   )
 
   // Create batch processor for exporting logs to Datadog Agent
@@ -80,8 +58,11 @@ function initializeOpenTelemetryLogs (config) {
 
   // Expose this provider to application calls through the OpenTelemetry Logs API.
   loggerProvider.register()
+
   // Include final log batches in lifecycle retention with trace delivery.
   registerTelemetryFlusher(done => loggerProvider.forceFlush(done))
+
+  registerResourceAttributeRefresh(exporter, () => buildResourceAttributes(config))
 }
 
 module.exports = {

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

@@ -4,7 +4,7 @@ const OtlpHttpExporterBase = require('../otlp/otlp_http_exporter_base')
 const OtlpTransformer = require('./otlp_transformer')
 
 /**
- * @typedef {import('@opentelemetry/resources').Resource} Resource
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
  * @typedef {import('@opentelemetry/api-logs').LogRecord} LogRecord
  */
 
@@ -26,11 +26,21 @@ class OtlpHttpLogExporter extends OtlpHttpExporterBase {
    *   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
+   * @param {Attributes} resourceAttributes - Resource attributes
    */
-  constructor (url, headers, timeout, protocol, resource) {
+  constructor (url, headers, timeout, protocol, resourceAttributes) {
     super(url, headers, timeout, protocol, 'logs')
-    this.transformer = new OtlpTransformer(resource, protocol)
+    this.transformer = new OtlpTransformer(resourceAttributes, protocol)
+  }
+
+  /**
+   * Recomputes the resource attributes baked into the transformer (e.g. after a MicroVM clone
+   * resume regenerates `runtime-id`).
+   *
+   * @param {Attributes} resourceAttributes - Resource attributes
+   */
+  updateResourceAttributes (resourceAttributes) {
+    this.transformer.updateResourceAttributes(resourceAttributes)
   }
 
   /**

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

@@ -7,6 +7,10 @@ const { metrics } = require('@opentelemetry/api')
 const { VERSION } = require('../../../../../version')
 const processTags = require('../../process-tags')
 const { registerTelemetryFlusher } = require('../../flush')
+const {
+  buildResourceAttributes: buildGeneralResourceAttributes,
+  registerResourceAttributeRefresh,
+} = require('../resource-attributes')
 const MeterProvider = require('./meter_provider')
 const PeriodicMetricReader = require('./periodic_metric_reader')
 const OtlpHttpMetricExporter = require('./otlp_http_metric_exporter')
@@ -43,30 +47,12 @@ const RESERVED_TRACER_TAGS = new Set(['service', 'env', 'version', 'runtime_id',
  * @param {import('../../config/config-base')} config - Tracer configuration instance
  */
 function initializeOpenTelemetryMetrics (config) {
-  const resourceAttributes = {
-    'service.name': config.service,
-    'service.version': config.version,
-    'deployment.environment': config.env,
-  }
-
-  if (config.tags) {
-    const filteredTags = { ...config.tags }
-    delete filteredTags.service
-    delete filteredTags.version
-    delete filteredTags.env
-    Object.assign(resourceAttributes, filteredTags)
-  }
-
-  if (config.reportHostname) {
-    resourceAttributes['host.name'] = os.hostname()
-  }
-
   const exporter = new OtlpHttpMetricExporter(
     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
+    buildGeneralResourceAttributes(config)
   )
 
   const reader = new PeriodicMetricReader(
@@ -78,8 +64,11 @@ function initializeOpenTelemetryMetrics (config) {
 
   const meterProvider = new MeterProvider({ reader })
   metrics.setGlobalMeterProvider(meterProvider)
+
   // Include the final metric collection and export in lifecycle retention.
   registerTelemetryFlusher(done => meterProvider.forceFlush(done))
+
+  registerResourceAttributeRefresh(exporter, () => buildGeneralResourceAttributes(config))
 }
 
 /**
@@ -122,19 +111,23 @@ function buildResourceAttributes (tags, { reportHostname, service, env, serviceV
 function createOtlpSpanStatsExporter (config) {
   const { OtlpStatsExporter } = require('./otlp_span_stats_exporter')
   const protocol = config.OTEL_EXPORTER_OTLP_METRICS_PROTOCOL || 'http/json'
-  const resourceAttributes = buildResourceAttributes(config.tags, {
+  const buildSpanStatsResourceAttributes = () => buildResourceAttributes(config.tags, {
     reportHostname: config.reportHostname,
     service: config.service,
     env: config.env,
     serviceVersion: config.version,
   })
-  return new OtlpStatsExporter(
+  const exporter = new OtlpStatsExporter(
     config.OTEL_EXPORTER_OTLP_METRICS_ENDPOINT,
     protocol,
-    resourceAttributes,
+    buildSpanStatsResourceAttributes(),
     config.OTEL_EXPORTER_OTLP_METRICS_HEADERS,
     config.OTEL_EXPORTER_OTLP_METRICS_TIMEOUT
   )
+
+  registerResourceAttributeRefresh(exporter, buildSpanStatsResourceAttributes)
+
+  return exporter
 }
 
 module.exports = {

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

@@ -4,7 +4,7 @@ const OtlpHttpExporterBase = require('../otlp/otlp_http_exporter_base')
 const OtlpTransformer = require('./otlp_transformer')
 
 /**
- * @typedef {import('@opentelemetry/resources').Resource} Resource
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
  * @typedef {import('./periodic_metric_reader').AggregatedMetric} AggregatedMetric
  */
 
@@ -22,11 +22,21 @@ class OtlpHttpMetricExporter extends OtlpHttpExporterBase {
    *   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
+   * @param {Attributes} resourceAttributes - Resource attributes
    */
-  constructor (url, headers, timeout, protocol, resource) {
+  constructor (url, headers, timeout, protocol, resourceAttributes) {
     super(url, headers, timeout, protocol, 'metrics')
-    this.transformer = new OtlpTransformer(resource, protocol)
+    this.transformer = new OtlpTransformer(resourceAttributes, protocol)
+  }
+
+  /**
+   * Recomputes the resource attributes baked into the transformer (e.g. after a MicroVM clone
+   * resume regenerates `runtime-id`). Leaves the reader's export interval untouched.
+   *
+   * @param {Attributes} resourceAttributes - Resource attributes
+   */
+  updateResourceAttributes (resourceAttributes) {
+    this.transformer.updateResourceAttributes(resourceAttributes)
   }
 
   /**

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

@@ -19,6 +19,16 @@ class OtlpStatsExporter extends OtlpHttpExporterBase {
     this.#transformer = new OtlpStatsTransformer(resourceAttributes, protocol)
   }
 
+  /**
+   * Recomputes the resource attributes baked into the transformer (e.g. after a MicroVM clone
+   * resume regenerates `runtime-id`).
+   *
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes
+   */
+  updateResourceAttributes (resourceAttributes) {
+    this.#transformer.updateResourceAttributes(resourceAttributes)
+  }
+
   /**
    * @param {Array<{timeNs: number, bucket: import('../../span_stats').SpanBuckets}>} drained
    * @param {number} bucketSizeNs

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

@@ -75,6 +75,16 @@ class OtlpTransformerBase {
     }
   }
 
+  /**
+   * Recomputes the cached OTLP resource attributes (e.g. after `config.tags` changes post-
+   * construction, such as a MicroVM clone resume regenerating its runtime-id). Leaves the
+   * reader/exporter/protocol otherwise untouched.
+   * @param {Attributes} resourceAttributes - Resource attributes
+   */
+  updateResourceAttributes (resourceAttributes) {
+    this.#resourceAttributes = this.transformAttributes(resourceAttributes)
+  }
+
   /**
    * Transforms attributes to OTLP KeyValue format.
    * @param {Attributes} attributes - Attributes to transform
@@ -170,10 +180,15 @@ function stableStringify (attributes) {
   // Attributes are sorted by key to ensure consistent serialization regardless of key order.
   // Keys are always strings and values are always strings, numbers, booleans,
   // or arrays of strings, numbers, or booleans.
-  return Object.keys(attributes)
-    .sort()
-    .map(key => `${key}:${JSON.stringify(attributes[key])}`)
-    .join(',')
+  const keys = Object.keys(attributes).sort()
+  let serialized = ''
+  let isFirstKey = true
+  for (const key of keys) {
+    if (!isFirstKey) serialized += ','
+    serialized += `${key}:${JSON.stringify(attributes[key])}`
+    isFirstKey = false
+  }
+  return serialized
 }
 
 module.exports = OtlpTransformerBase

package/packages/dd-trace/src/opentelemetry/resource-attributes.js

@@ -0,0 +1,55 @@
+'use strict'
+
+const os = require('node:os')
+
+const { channel } = require('dc-polyfill')
+
+const identityRefreshChannel = channel('datadog:identity:refresh')
+const resourceAttributeRefreshers = new Map()
+
+function refreshActiveResourceAttributes () {
+  for (const refreshResourceAttributes of resourceAttributeRefreshers.values()) {
+    refreshResourceAttributes()
+  }
+}
+
+/**
+ * @typedef {import('@opentelemetry/api').Attributes} Attributes
+ * @typedef {{
+ *   signalType: string,
+ *   updateResourceAttributes: (resourceAttributes: Attributes) => void
+ * }} ResourceAttributeExporter
+ */
+
+/**
+ * @param {import('../config/config-base')} config
+ * @returns {Attributes}
+ */
+function buildResourceAttributes (config) {
+  const { service, version, env, ...tags } = config.tags
+  const resourceAttributes = {
+    'service.name': config.service,
+    'service.version': config.version,
+    'deployment.environment': config.env,
+    ...tags,
+  }
+
+  if (config.reportHostname) resourceAttributes['host.name'] = os.hostname()
+
+  return resourceAttributes
+}
+
+/**
+ * @param {ResourceAttributeExporter} exporter
+ * @param {() => Attributes} buildResourceAttributes
+ */
+function registerResourceAttributeRefresh (exporter, buildResourceAttributes) {
+  if (resourceAttributeRefreshers.size === 0) {
+    identityRefreshChannel.subscribe(refreshActiveResourceAttributes)
+  }
+  resourceAttributeRefreshers.set(exporter.signalType, () => {
+    exporter.updateResourceAttributes(buildResourceAttributes())
+  })
+}
+
+module.exports = { buildResourceAttributes, registerResourceAttributeRefresh }

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

@@ -1,6 +1,7 @@
 'use strict'
 
 const { VERSION } = require('../../../../../version')
+const { registerResourceAttributeRefresh } = require('../resource-attributes')
 const OtlpHttpTraceExporter = require('./otlp_http_trace_exporter')
 
 /**
@@ -59,13 +60,17 @@ function buildResourceAttributes (config) {
  * @returns {OtlpHttpTraceExporter} The OTLP HTTP/JSON exporter
  */
 function createOtlpTraceExporter (config) {
-  return new OtlpHttpTraceExporter(
+  const exporter = new OtlpHttpTraceExporter(
     config.OTEL_EXPORTER_OTLP_TRACES_ENDPOINT,
     config.OTEL_EXPORTER_OTLP_TRACES_HEADERS,
     config.OTEL_EXPORTER_OTLP_TRACES_TIMEOUT,
     buildResourceAttributes(config),
     config.DD_TRACE_OTEL_SEMANTICS_ENABLED
   )
+
+  registerResourceAttributeRefresh(exporter, () => buildResourceAttributes(config))
+
+  return exporter
 }
 
 module.exports = {

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

@@ -43,6 +43,16 @@ class OtlpHttpTraceExporter extends OtlpHttpExporterBase {
     this.#transformer = new OtlpTraceTransformer(resourceAttributes, otelTraceSemanticsEnabled)
   }
 
+  /**
+   * Recomputes the resource attributes baked into the transformer (e.g. after a MicroVM clone
+   * resume regenerates `runtime-id`).
+   *
+   * @param {import('@opentelemetry/api').Attributes} resourceAttributes - Resource attributes
+   */
+  updateResourceAttributes (resourceAttributes) {
+    this.#transformer.updateResourceAttributes(resourceAttributes)
+  }
+
   /**
    * Exports DD-formatted spans via OTLP over HTTP.
    *