dd-trace 5.106.0 → 5.107.0

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
@@ -33,7 +34,7 @@ const TRACE_ID_128 = '_dd.p.tid'
  *
  * @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
@@ -274,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,

package/packages/dd-trace/src/opentracing/span.js

@@ -38,20 +38,26 @@ const tagsUpdateCh = channel('dd-trace:span:tags:update')
 // Module-scope so we don't allocate a fresh recursive closure on every
 // `addLink` / `addEvent`.
 /**
- * @param {Record<string, string>} out
+ * @param {Record<string, string> | undefined} out Accumulator, created lazily
+ * on the first surviving entry so an all-dropped set stays `undefined`.
  * @param {string} key
  * @param {unknown} value
+ * @returns {Record<string, string> | undefined}
  */
 function addArrayOrScalarAttribute (out, key, value) {
   if (Array.isArray(value)) {
     for (let i = 0; i < value.length; i++) {
-      addArrayOrScalarAttribute(out, `${key}.${i}`, value[i])
+      out = addArrayOrScalarAttribute(out, `${key}.${i}`, value[i])
     }
-  } else if (ALLOWED.has(typeof value)) {
+    return out
+  }
+  if (ALLOWED.has(typeof value)) {
+    out ??= {}
     out[key] = typeof value === 'string' ? value : String(value)
-  } else {
-    log.warn('Dropping span link attribute. It is not of an allowed type')
+    return out
   }
+  log.warn('Dropping span link attribute. It is not of an allowed type')
+  return out
 }
 
 function getIntegrationCounter (event, integration) {
@@ -79,12 +85,6 @@ class DatadogSpan {
 
     const operationName = fields.operationName
     const parent = fields.parent || null
-    // Stay on `Object.assign({}, src)` for backportability: V8 12+ (Node 22 /
-    // 24) inlines `{ ...src }` and beats `Object.assign` here, but on V8 10.2
-    // / 11.3 (Node 18 / 20) the spread takes a generic runtime path and slows
-    // `spans-finish-*` by ~140%. Revisit once those LTS lines drop.
-    // eslint-disable-next-line prefer-object-spread
-    const tags = Object.assign({}, fields.tags)
     const hostname = fields.hostname
 
     this.#parentTracer = tracer
@@ -106,7 +106,7 @@ class DatadogSpan {
 
     this._spanContext = this._createContext(parent, fields)
     this._spanContext._name = operationName
-    Object.assign(this._spanContext.getTags(), tags)
+    if (fields.tags) Object.assign(this._spanContext.getTags(), fields.tags)
     this._spanContext._hostname = hostname
 
     this._spanContext._trace.started.push(this)
@@ -348,21 +348,24 @@ class DatadogSpan {
 
   /**
    * @param {Record<string, unknown>} [attributes]
+   * @returns {Record<string, string> | undefined} `undefined` when nothing
+   * survives, so `extractSpanLinks` omits the slot without an emptiness probe.
    */
   _sanitizeAttributes (attributes = {}) {
-    /** @type {Record<string, string>} */
-    const out = {}
+    let out
     for (const key of Object.keys(attributes)) {
-      addArrayOrScalarAttribute(out, key, attributes[key])
+      out = addArrayOrScalarAttribute(out, key, attributes[key])
     }
     return out
   }
 
   /**
    * @param {Record<string, unknown>} [attributes]
+   * @returns {Record<string, unknown> | undefined} `undefined` when nothing
+   * survives, so the encoders skip the slot without an emptiness probe.
    */
   _sanitizeEventAttributes (attributes = {}) {
-    const sanitizedAttributes = {}
+    let sanitizedAttributes
 
     for (const key of Object.keys(attributes)) {
       const value = attributes[key]
@@ -375,8 +378,10 @@ class DatadogSpan {
             log.warn('Dropping span event attribute. It is not of an allowed type')
           }
         }
+        sanitizedAttributes ??= {}
         sanitizedAttributes[key] = newArray
       } else if (ALLOWED.has(typeof value)) {
+        sanitizedAttributes ??= {}
         sanitizedAttributes[key] = value
       } else {
         log.warn('Dropping span event attribute. It is not of an allowed type')
@@ -389,7 +394,7 @@ class DatadogSpan {
     let spanContext
     let startTime
 
-    let baggage = {}
+    let baggage
     const propagationBehavior = this.#parentTracer._config.DD_TRACE_PROPAGATION_BEHAVIOR_EXTRACT
     if (parent && parent._isRemote && propagationBehavior !== 'continue') {
       baggage = parent._baggageItems
@@ -431,7 +436,7 @@ class DatadogSpan {
       }
 
       if (propagationBehavior === 'restart') {
-        spanContext._baggageItems = baggage
+        spanContext._baggageItems = baggage ?? {}
       }
     }
 

package/packages/dd-trace/src/opentracing/tracer.js

@@ -23,6 +23,8 @@ class DatadogTracer {
   constructor (config, prioritySampler) {
     this._config = config
     this._service = config.service
+    // Lowercased once for span_format's per-span base-service comparison.
+    this.serviceLower = typeof config.service === 'string' ? config.service.toLowerCase() : ''
     this._version = config.version
     this._env = config.env
     this._logInjection = config.logInjection
@@ -64,21 +66,9 @@ class DatadogTracer {
       ? getContext(options.childOf)
       : getParent(options.references)
 
-    // as per spec, allow the setting of service name through options
-    const tags = {
-      'service.name': options?.tags?.service ? String(options.tags.service) : this._service,
-    }
-
-    // As per unified service tagging spec if a span is created with a service name different from the global
-    // service name it will not inherit the global version value
-    if (options?.tags?.service && options.tags.service !== this._service) {
-      options.tags.version = undefined
-    }
-
     const span = new Span(this, this._processor, this._prioritySampler, {
       operationName: options.operationName || name,
       parent,
-      tags,
       startTime: options.startTime,
       hostname: this._hostname,
       traceId128BitGenerationEnabled: this._traceId128BitGenerationEnabled,
@@ -86,6 +76,20 @@ class DatadogTracer {
       links: options.links,
     }, this._debug)
 
+    // As per unified service tagging spec if a span is created with a service name different from the global
+    // service name it will not inherit the global version value
+    const ctx = span.context()
+    if (options.tags?.service) {
+      if (options.tags.service !== this._service) options.tags.version = undefined
+      // as per spec, allow the setting of service name through options; set it
+      // after all tags are merged so config/options values take precedence
+      // eslint-disable-next-line eslint-rules/eslint-prefer-set-service-name
+      ctx.setTag('service.name', String(options.tags.service))
+    } else {
+      // eslint-disable-next-line eslint-rules/eslint-prefer-set-service-name
+      ctx.setTag('service.name', this._service)
+    }
+
     span.addTags(this._config.tags)
     span.addTags(options.tags)
 

package/packages/dd-trace/src/plugins/ci_plugin.js

@@ -143,6 +143,7 @@ module.exports = class CiPlugin extends Plugin {
     this.fileLineToProbeId = new Map()
     this.rootDir = process.cwd() // fallback in case :session:start events are not emitted
     this._testSuiteSpansByTestSuite = new Map()
+    this._pendingWorkerTracesByTestSuite = new Map()
     this._pendingRequestErrorTags = []
 
     this.addSub(`ci:${this.constructor.id}:library-configuration`, (ctx) => {
@@ -352,52 +353,8 @@ module.exports = class CiPlugin extends Plugin {
       const formattedTraces = JSON.parse(traces)
 
       for (const trace of formattedTraces) {
-        for (const span of trace) {
-          span.span_id = id(span.span_id)
-          span.trace_id = id(span.trace_id)
-          span.parent_id = id(span.parent_id)
-
-          if (span.name?.startsWith(`${this.constructor.id}.`)) {
-            span.meta[TEST_IS_TEST_FRAMEWORK_WORKER] = 'true'
-            if (span.name === `${this.constructor.id}.test` || span.name === `${this.constructor.id}.test_suite`) {
-              Object.assign(span.meta, getSessionItrSkippingEnabledTags(this.testSessionSpan))
-            }
-            // augment with git information (since it will not be available in the worker)
-            for (const key in this.testEnvironmentMetadata) {
-              // CAREFUL: this bypasses the metadata/metrics distinction
-              // Be careful not to pass numbers in `meta`
-              if (key.startsWith('git.')) {
-                span.meta[key] = this.testEnvironmentMetadata[key]
-              }
-            }
-          }
-
-          // Only test hooks run in the cucumber worker, so the test events do not have the
-          // test session, test module and test suite ids. We have to update them here.
-          if (span.name === 'cucumber.test' || span.name === 'mocha.test') {
-            const testSuite = span.meta[TEST_SUITE]
-            const testSuiteSpan = this._testSuiteSpansByTestSuite.get(testSuite)
-            if (!testSuiteSpan) {
-              log.warn('Test suite span not found for test span with test suite %s', testSuite)
-              continue
-            }
-
-            const testSuiteTags = getTestSuiteLevelVisibilityTags(testSuiteSpan, this.constructor.id)
-            span.meta = {
-              ...span.meta,
-              ...testSuiteTags,
-              ...getSessionRequestErrorTags(this.testSessionSpan),
-            }
-          }
-
-          // Jest and Vitest worker test spans are serialized in the worker and may not include
-          // request error tags; add them from the session span in the main process.
-          if ((span.name === 'jest.test' || span.name === 'vitest.test' || span.name === 'vitest.test_suite') &&
-              this.testSessionSpan) {
-            Object.assign(span.meta, getSessionRequestErrorTags(this.testSessionSpan))
-          }
-        }
-        this.tracer._exporter.export(trace)
+        this._prepareWorkerTrace(trace)
+        this._exportWorkerTraceOrBuffer(trace)
       }
     })
 
@@ -502,6 +459,134 @@ module.exports = class CiPlugin extends Plugin {
     return getSessionItrSkippingEnabledTags(this.testSessionSpan)
   }
 
+  /**
+   * Normalizes worker trace identifiers and adds process-level metadata before exporting or buffering.
+   *
+   * @param {object[]} trace - Worker trace spans decoded from the worker payload.
+   */
+  _prepareWorkerTrace (trace) {
+    for (const span of trace) {
+      span.span_id = id(span.span_id)
+      span.trace_id = id(span.trace_id)
+      span.parent_id = id(span.parent_id)
+
+      if (span.name?.startsWith(`${this.constructor.id}.`)) {
+        span.meta[TEST_IS_TEST_FRAMEWORK_WORKER] = 'true'
+        if (span.name === `${this.constructor.id}.test` || span.name === `${this.constructor.id}.test_suite`) {
+          Object.assign(span.meta, getSessionItrSkippingEnabledTags(this.testSessionSpan))
+        }
+        // augment with git information (since it will not be available in the worker)
+        for (const key in this.testEnvironmentMetadata) {
+          // CAREFUL: this bypasses the metadata/metrics distinction
+          // Be careful not to pass numbers in `meta`
+          if (key.startsWith('git.')) {
+            span.meta[key] = this.testEnvironmentMetadata[key]
+          }
+        }
+      }
+
+      // Jest and Vitest worker test spans are serialized in the worker and may not include
+      // request error tags; add them from the session span in the main process.
+      if ((span.name === 'jest.test' || span.name === 'vitest.test' || span.name === 'vitest.test_suite') &&
+          this.testSessionSpan) {
+        Object.assign(span.meta, getSessionRequestErrorTags(this.testSessionSpan))
+      }
+    }
+  }
+
+  /**
+   * Adds suite-level CI Visibility tags to worker test spans when their suite span is available.
+   *
+   * @param {object[]} trace - Worker trace spans.
+   * @returns {string|undefined} Missing test suite name, if the trace cannot be exported yet.
+   */
+  _addSuiteTagsToWorkerTrace (trace) {
+    for (const span of trace) {
+      // Only test hooks run in Cucumber and Mocha workers, so the test events do not have the
+      // test session, test module and test suite ids. We have to update them in the main process.
+      if (span.name !== 'cucumber.test' && span.name !== 'mocha.test') continue
+
+      const testSuite = span.meta[TEST_SUITE]
+      const testSuiteSpan = this._testSuiteSpansByTestSuite.get(testSuite)
+      if (!testSuiteSpan) return testSuite
+
+      const testSuiteTags = getTestSuiteLevelVisibilityTags(testSuiteSpan, this.constructor.id)
+      span.meta = {
+        ...span.meta,
+        ...testSuiteTags,
+        ...getSessionRequestErrorTags(this.testSessionSpan),
+      }
+    }
+  }
+
+  /**
+   * Stores a worker trace until the matching test suite span exists in the main process.
+   *
+   * @param {string} testSuite - Test suite path used as the pending trace key.
+   * @param {object[]} trace - Worker trace spans.
+   */
+  _bufferWorkerTrace (testSuite, trace) {
+    let pendingTraces = this._pendingWorkerTracesByTestSuite.get(testSuite)
+    if (!pendingTraces) {
+      pendingTraces = []
+      this._pendingWorkerTracesByTestSuite.set(testSuite, pendingTraces)
+    }
+    pendingTraces.push(trace)
+  }
+
+  /**
+   * Exports a worker trace immediately, or buffers it if suite-level tags cannot be added yet.
+   *
+   * @param {object[]} trace - Worker trace spans.
+   */
+  _exportWorkerTraceOrBuffer (trace) {
+    const missingTestSuite = this._addSuiteTagsToWorkerTrace(trace)
+    if (missingTestSuite) {
+      this._bufferWorkerTrace(missingTestSuite, trace)
+      return
+    }
+    this.tracer._exporter.export(trace)
+  }
+
+  /**
+   * Exports buffered worker traces for a suite after its suite span has been created.
+   *
+   * @param {string} testSuite - Test suite path that may now have pending worker traces.
+   */
+  _exportPendingWorkerTracesForTestSuite (testSuite) {
+    const pendingTraces = this._pendingWorkerTracesByTestSuite.get(testSuite)
+    if (!pendingTraces) return
+
+    this._pendingWorkerTracesByTestSuite.delete(testSuite)
+    for (const trace of pendingTraces) {
+      this._exportWorkerTraceOrBuffer(trace)
+    }
+  }
+
+  /**
+   * Drains all buffered worker traces, falling back to the previous unaugmented export behavior
+   * if a matching suite span never appears.
+   */
+  _exportPendingWorkerTraces () {
+    if (!this._pendingWorkerTracesByTestSuite.size) return
+
+    const pendingTraces = new Set()
+    for (const traces of this._pendingWorkerTracesByTestSuite.values()) {
+      for (const trace of traces) {
+        pendingTraces.add(trace)
+      }
+    }
+    this._pendingWorkerTracesByTestSuite.clear()
+
+    for (const trace of pendingTraces) {
+      const missingTestSuite = this._addSuiteTagsToWorkerTrace(trace)
+      if (missingTestSuite) {
+        log.warn('Test suite span not found for test span with test suite %s', missingTestSuite)
+      }
+      this.tracer._exporter.export(trace)
+    }
+  }
+
   /**
    * @param {import('../config/config-base')} config - Tracer configuration
    * @param {boolean} shouldGetEnvironmentData - Whether to get environment data

package/packages/dd-trace/src/priority_sampler.js

@@ -333,11 +333,12 @@ class PrioritySampler {
       if (!trace.tags[DECISION_MAKER_KEY]) {
         trace.tags[DECISION_MAKER_KEY] = `-${mechanism}`
       }
-    } else if (DECISION_MAKER_KEY in trace.tags) {
-      // Guard the `delete` so the common drop path doesn't pay the V8
-      // dictionary-mode transition unless a prior keep decision actually
-      // set the tag.
-      delete trace.tags[DECISION_MAKER_KEY]
+    } else if (trace.tags[DECISION_MAKER_KEY] !== undefined) {
+      // Clear by assigning undefined rather than deleting: `delete` drops
+      // trace.tags into V8 dictionary (slow) mode for the per-trace extract
+      // and propagation scans that follow. Both skip undefined values, so the
+      // emitted meta and injected headers are unchanged.
+      trace.tags[DECISION_MAKER_KEY] = undefined
     }
   }
 

package/packages/dd-trace/src/profiling/config.js

@@ -10,7 +10,6 @@ const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { getIsAzureFunction } = require('../serverless')
 const { getAzureTagsFromMetadata, getAzureAppMetadata, getAzureFunctionMetadata } = require('../azure_metadata')
 const { getEnvironmentVariable } = require('../config/helper')
-const { getAgentUrl } = require('../agent/url')
 const { isACFActive } = require('../../../datadog-core/src/storage')
 
 const { AgentExporter } = require('./exporters/agent')
@@ -54,7 +53,7 @@ class Config {
     this.pprofPrefix = options.DD_PROFILING_PPROF_PREFIX
     this.v8ProfilerBugWorkaroundEnabled = options.DD_PROFILING_V8_PROFILER_BUG_WORKAROUND
 
-    this.url = getAgentUrl(options)
+    this.url = options.url
 
     this.libraryInjected = !!options.DD_INJECTION_ENABLED
 

package/packages/dd-trace/src/proxy.js

@@ -195,6 +195,19 @@ class Tracer extends NoopProxy {
         }
       }
 
+      // OTel logs/metrics pipelines must be initialized BEFORE runtimeMetrics.start so that
+      // when the OTLP runtime metrics module calls metrics.getMeterProvider(), it gets the
+      // real provider, otherwise instruments register on the noop provider and never export.
+      if (config.DD_LOGS_OTEL_ENABLED) {
+        const { initializeOpenTelemetryLogs } = require('./opentelemetry/logs')
+        initializeOpenTelemetryLogs(config)
+      }
+
+      if (config.DD_METRICS_OTEL_ENABLED) {
+        const { initializeOpenTelemetryMetrics } = require('./opentelemetry/metrics')
+        initializeOpenTelemetryMetrics(config)
+      }
+
       if (config.runtimeMetrics.enabled) {
         runtimeMetrics.start(config)
       }
@@ -224,16 +237,6 @@ class Tracer extends NoopProxy {
         }
       }
 
-      if (config.DD_LOGS_OTEL_ENABLED) {
-        const { initializeOpenTelemetryLogs } = require('./opentelemetry/logs')
-        initializeOpenTelemetryLogs(config)
-      }
-
-      if (config.DD_METRICS_OTEL_ENABLED) {
-        const { initializeOpenTelemetryMetrics } = require('./opentelemetry/metrics')
-        initializeOpenTelemetryMetrics(config)
-      }
-
       if (config.isTestDynamicInstrumentationEnabled) {
         const getDynamicInstrumentationClient = require('./ci-visibility/dynamic-instrumentation')
         // We instantiate the client but do not start the Worker here. The worker is started lazily

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

@@ -8,7 +8,6 @@ const { getExtraServices } = require('../service-naming/extra-services')
 const getGitMetadata = require('../git_metadata')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const tagger = require('../tagger')
-const { getAgentUrl } = require('../agent/url')
 const processTags = require('../process-tags')
 const Scheduler = require('./scheduler')
 const { UNACKNOWLEDGED, ACKNOWLEDGED, ERROR } = require('./apply_states')
@@ -32,7 +31,7 @@ class RemoteConfig {
   constructor (config) {
     const pollInterval = Math.floor(config.remoteConfig.pollInterval * 1000)
 
-    this.url = getAgentUrl(config)
+    this.url = config.url
 
     tagger.add(config.tags, {
       '_dd.rc.client_id': clientId,

package/packages/dd-trace/src/runtime_metrics/client.js

@@ -0,0 +1,30 @@
+'use strict'
+
+const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
+const processTags = require('../process-tags')
+
+/**
+ * Builds the aggregating DogStatsD client used to emit DD-proprietary tracer
+ * metrics (runtime.node.*, datadog.tracer.*). Shared by both runtime-metrics
+ * paths (DogStatsD and OTLP) so their client construction can't drift apart.
+ *
+ * Process tags are applied here, not via config/generateClientConfig, so they only
+ * reach this bounded set of runtime metrics. Putting them on the global tags would
+ * also tag user-facing custom metrics, inflating their cardinality (and billing).
+ *
+ * @param {import('../config/config-base')} config - Tracer configuration
+ * @returns {MetricsAggregationClient}
+ */
+function createMetricsClient (config) {
+  const clientConfig = DogStatsDClient.generateClientConfig(config)
+
+  if (config.DD_EXPERIMENTAL_PROPAGATE_PROCESS_TAGS_ENABLED) {
+    for (const tag of processTags.tagsArray) {
+      clientConfig.tags.push(tag)
+    }
+  }
+
+  return new MetricsAggregationClient(new DogStatsDClient(clientConfig))
+}
+
+module.exports = { createMetricsClient }

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

@@ -1,5 +1,7 @@
 'use strict'
 
+const log = require('../log')
+
 let runtimeMetrics
 
 const noop = runtimeMetrics = {
@@ -20,11 +22,19 @@ module.exports = {
   start (config) {
     if (!config?.runtimeMetrics.enabled) return
 
-    runtimeMetrics = require('./runtime_metrics')
+    runtimeMetrics = config.DD_METRICS_OTEL_ENABLED
+      ? require('./otlp_runtime_metrics')
+      : require('./runtime_metrics')
 
     Object.setPrototypeOf(module.exports, runtimeMetrics)
 
-    runtimeMetrics.start(config)
+    try {
+      runtimeMetrics.start(config)
+    } catch (err) {
+      // Unwind whatever managed to register so a partial init doesn't leak into the next start().
+      runtimeMetrics.stop()
+      log.error('Failed to start runtime metrics', err)
+    }
   },
 
   stop () {