dd-trace 5.106.0 → 5.108.0

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
@@ -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
     }
   }