dd-trace 6.12.0 → 6.14.0

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
@@ -27,6 +27,7 @@ const os = require('os')
  * @package
  */
 
+const { registerTelemetryFlusher } = require('../../flush')
 const LoggerProvider = require('./logger_provider')
 const BatchLogRecordProcessor = require('./batch_log_processor')
 const OtlpHttpLogExporter = require('./otlp_http_log_exporter')
@@ -36,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
@@ -77,8 +56,13 @@ function initializeOpenTelemetryLogs (config) {
   // Create logger provider with processor for Datadog Agent export
   const loggerProvider = new LoggerProvider({ processor })
 
-  // Register the logger provider globally with OpenTelemetry API
+  // 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/logger_provider.js

@@ -84,12 +84,15 @@ class LoggerProvider {
 
   /**
    * Forces a flush of all pending log records.
-   * @returns {undefined} Promise that resolves when flush is n ssue cncomplete
+   * @param {Function} [done] Called after all pending log exports complete
    */
-  forceFlush () {
-    if (!this.isShutdown) {
-      return this.processor?.forceFlush()
+  forceFlush (done) {
+    if (this.isShutdown || !this.processor) {
+      done?.()
+      return
     }
+
+    this.processor.forceFlush(done)
   }
 
   /**

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

@@ -6,12 +6,16 @@ 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')
 
 const RESERVED_TRACER_TAGS = new Set(['service', 'env', 'version', 'runtime_id', 'runtime-id'])
-
 /**
  * @typedef {import('../../config')} Config
  */
@@ -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,6 +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))
 }
 
 /**
@@ -120,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/meter_provider.js

@@ -49,6 +49,14 @@ class MeterProvider {
     }
     return meter
   }
+
+  /**
+   * @param {Function} [done] Called after the metric export completes
+   */
+  forceFlush (done) {
+    if (this.reader) this.reader.forceFlush(done)
+    else done?.()
+  }
 }
 
 module.exports = MeterProvider

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)
   }
 
   /**
@@ -34,10 +44,11 @@ class OtlpHttpMetricExporter extends OtlpHttpExporterBase {
    *
    * @param {Map<string, AggregatedMetric>} metrics - Map of metric data to export
    *
-   * @returns {void}
+   * @param {Function} [done] Called after the HTTP export completes
    */
-  export (metrics) {
+  export (metrics, done) {
     if (metrics.size === 0) {
+      done?.({ code: 0 })
       return
     }
 
@@ -56,6 +67,7 @@ class OtlpHttpMetricExporter extends OtlpHttpExporterBase {
       if (result.code === 0) {
         this.recordTelemetry('otel.metrics_export_successes', 1, additionalTags)
       }
+      done?.(result)
     })
   }
 }

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

@@ -19,17 +19,29 @@ 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
+   * @param {Function} [done] Called after the HTTP export completes
    */
-  export (drained, bucketSizeNs) {
-    if (drained.length === 0) return
+  export (drained, bucketSizeNs, done) {
+    if (drained.length === 0) return done?.()
     const payload = this.#transformer.transform(drained, bucketSizeNs)
     this.sendPayload(payload, (result) => {
       if (result.code !== 0) {
         log.error('Failed to export span stats: %s', result.error?.message)
       }
+      done?.()
     })
   }
 }

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

@@ -197,14 +197,33 @@ class PeriodicMetricReader {
 
   /**
    * Forces an immediate collection and export of all metrics.
-   * @returns {void}
+   * @param {Function} [done] Called after the metric export completes
    */
-  forceFlush () {
+  forceFlush (done) {
     if (this.#isShutdown) {
       log.warn('PeriodicMetricReader is shutdown. %d measurement(s) were dropped', this.#droppedCount)
+      done?.()
       return
     }
-    this.#collectAndExport()
+    let pending = 2
+    const complete = () => {
+      if (--pending === 0) done?.()
+    }
+
+    // Snapshot requests already active before starting this flush's export.
+    try {
+      if (typeof this.exporter.flush === 'function') this.exporter.flush(complete)
+      else complete()
+    } catch (error) {
+      log.error('Error flushing OTLP metrics:', error)
+      complete()
+    }
+    try {
+      this.#collectAndExport(complete)
+    } catch (error) {
+      log.error('Error exporting OTLP metrics:', error)
+      complete()
+    }
   }
 
   /**
@@ -250,7 +269,8 @@ class PeriodicMetricReader {
    *
    * @param {Function} [callback] - Called after export completes
    */
-  #collectAndExport (callback = () => {}) {
+  #collectAndExport (callback) {
+    // Observable instruments must be collected even without synchronous measurements.
     // Atomically drain measurements for export. New measurements can be recorded
     // during export without interfering with this batch.
     const allMeasurements = this.#measurements
@@ -292,7 +312,7 @@ class PeriodicMetricReader {
     }
 
     if (allMeasurements.length === 0) {
-      callback()
+      callback?.()
       return
     }
 

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

@@ -5,6 +5,7 @@ const https = require('node:https')
 const { URL } = require('node:url')
 const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
+const { createServerlessDeliveryTracker } = require('../../serverless')
 const telemetryMetrics = require('../../telemetry/metrics')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
@@ -20,6 +21,7 @@ const legacyStorage = storage('legacy')
  */
 class OtlpHttpExporterBase {
   #transport = https
+  #serverlessDeliveryTracker
 
   /**
    * Creates a new OtlpHttpExporterBase instance.
@@ -32,6 +34,7 @@ class OtlpHttpExporterBase {
    * @param {string} signalType - Signal type for error messages (e.g., 'logs', 'metrics')
    */
   constructor (url, headers, timeout, protocol, signalType) {
+    this.#serverlessDeliveryTracker = createServerlessDeliveryTracker()
     this.protocol = protocol
     this.signalType = signalType
 
@@ -80,6 +83,13 @@ class OtlpHttpExporterBase {
    * @protected
    */
   sendPayload (payload, resultCallback) {
+    if (this.#serverlessDeliveryTracker) {
+      return this.#serverlessDeliveryTracker.track(done => this.#sendPayload(payload, resultCallback, done))
+    }
+    this.#sendPayload(payload, resultCallback)
+  }
+
+  #sendPayload (payload, resultCallback, done) {
     const options = {
       ...this.options,
       headers: {
@@ -88,39 +98,65 @@ class OtlpHttpExporterBase {
       },
     }
 
-    legacyStorage.run({ noop: true }, () => {
-      const req = this.#transport.request(options, (res) => {
-        let data = ''
+    let completed = false
+    const complete = result => {
+      if (completed) return
+      completed = true
+      resultCallback(result)
+      done?.()
+    }
 
-        res.on('data', (chunk) => {
-          data += chunk
+    try {
+      legacyStorage.run({ noop: true }, () => {
+        const req = this.#transport.request(options, (res) => {
+          let data = ''
+
+          res.on('data', (chunk) => {
+            data += chunk
+          })
+
+          res.once('error', (error) => {
+            complete({ code: 1, error })
+          })
+
+          res.once('end', () => {
+            // @ts-expect-error - res.statusCode can be undefined
+            if (res.statusCode >= 200 && res.statusCode < 300) {
+              complete({ code: 0 })
+            } else {
+              const error = new Error(`HTTP ${res.statusCode}: ${data}`)
+              complete({ code: 1, error })
+            }
+          })
         })
 
-        res.once('end', () => {
-          // @ts-expect-error - res.statusCode can be undefined
-          if (res.statusCode >= 200 && res.statusCode < 300) {
-            resultCallback({ code: 0 })
-          } else {
-            const error = new Error(`HTTP ${res.statusCode}: ${data}`)
-            resultCallback({ code: 1, error })
-          }
+        req.on('error', (error) => {
+          log.error('Error sending OTLP %s:', this.signalType, error)
+          complete({ code: 1, error })
         })
-      })
 
-      req.on('error', (error) => {
-        log.error('Error sending OTLP %s:', this.signalType, error)
-        resultCallback({ code: 1, error })
-      })
+        req.once('timeout', () => {
+          req.destroy()
+          const error = new Error('Request timeout')
+          complete({ code: 1, error })
+        })
 
-      req.once('timeout', () => {
-        req.destroy()
-        const error = new Error('Request timeout')
-        resultCallback({ code: 1, error })
+        req.write(payload)
+        req.end()
       })
+    } catch (error) {
+      log.error('Error sending OTLP %s:', this.signalType, error)
+      complete({ code: 1, error })
+    }
+  }
 
-      req.write(payload)
-      req.end()
-    })
+  /**
+   * Calls back once Vercel-tracked requests active at the flush boundary complete.
+   * @param {Function} [done]
+   */
+  flush (done) {
+    if (this.#serverlessDeliveryTracker) return this.#serverlessDeliveryTracker.waitForIdle(done)
+    done?.()
   }
 
   /**

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.
    *