dd-trace 6.19.0 → 6.20.0

package/packages/dd-trace/src/openfeature/writers/flag-evaluation-worker.js

@@ -0,0 +1,77 @@
+'use strict'
+
+const { parentPort, workerData } = require('node:worker_threads')
+const port = /** @type {import('node:worker_threads').MessagePort} */ (parentPort)
+
+// Bootstrap only the lifecycle registry, never the tracer or its preload entrypoints.
+globalThis[Symbol.for('dd-trace')] = { beforeExitHandlers: new Set() }
+
+const logWriter = require('../../log/writer')
+const { configureWorkerTelemetry } = require('./flag-evaluation-telemetry')
+const state = new Int32Array(workerData.state)
+configureWorkerTelemetry(state)
+const FlagEvaluationConsumer = require('./flag-evaluation-consumer')
+
+/** @param {'debug' | 'info' | 'warn' | 'error'} level */
+function forwardLog (level) {
+  /** @param {unknown} message */
+  return message => {
+    try {
+      port.postMessage({ type: 'log', level, message: message instanceof Error ? message.stack : String(message) })
+    } catch {
+      // Diagnostics are best-effort when the parent port is closing.
+    }
+  }
+}
+
+// Use the parent's effective settings, not a second environment-only configuration.
+// The custom logger itself stays in the parent isolate because functions cannot be cloned.
+const { enabled = false, level } = workerData.logging ?? {}
+logWriter.configure(enabled, level, {
+  debug: forwardLog('debug'),
+  info: forwardLog('info'),
+  warn: forwardLog('warn'),
+  error: forwardLog('error'),
+})
+
+/** @param {import('./flag-evaluations').SerializedFlagEvaluationRoute} route */
+function deserializeRoute (route) {
+  return {
+    url: new URL(route.url),
+    basePath: route.basePath,
+    headers: route.headers,
+    fallback: route.fallback && deserializeRoute(route.fallback),
+    onFallback: route.onFallback
+      ? () => port.postMessage({ type: 'route', id: route.id, status: 'fallback' })
+      : undefined,
+    onUnavailable: route.onUnavailable
+      ? () => port.postMessage({ type: 'route', id: route.id, status: 'unavailable' })
+      : undefined,
+  }
+}
+
+const route = deserializeRoute(workerData.route)
+const consumer = new FlagEvaluationConsumer({ ...workerData.context, url: route.url }, route, {
+  onProcessed: count => Atomics.sub(state, 0, count),
+  onDelivered: count => Atomics.sub(state, 1, count),
+  onIdle: () => port.close(),
+})
+consumer.setEnabled(true, route)
+port.on('message', message => {
+  switch (message.type) {
+    case 'batch':
+      for (const event of message.events) {
+        if (!consumer.enqueue(event)) Atomics.sub(state, 0, 1)
+      }
+      break
+    case 'enabled':
+      consumer.setEnabled(message.enabled, message.route && deserializeRoute(message.route))
+      break
+    case 'flush':
+      consumer.flush()
+      break
+    case 'close':
+      consumer.destroy()
+      break
+  }
+})

package/packages/dd-trace/src/openfeature/writers/flag-evaluations.js

@@ -0,0 +1,398 @@
+'use strict'
+
+const { join } = require('node:path')
+
+const { channel } = require('dc-polyfill')
+
+const { FLAG_EVALUATION_FLUSH_INTERVAL, FLAG_EVALUATION_QUEUE_CAP } = require('../constants/constants')
+const { EVP_PROXY_PATH_V2 } = require('../../evp_proxy/constants')
+const { getEnvironmentVariables } = require('../../config/helper')
+const log = require('../../log')
+const { normalizeFlagEvaluationEvent, normalizeTargetingKey } = require('./flag-evaluation-pii')
+const {
+  collectWorkerTelemetry, createWorkerState, recordDropped, recordTargetingKeyOmitted,
+} = require('./flag-evaluation-telemetry')
+
+const telemetryAppClosingCh = channel('datadog:telemetry:app-closing')
+const flushCh = channel('ffe:writers:flush')
+
+// Share clone/wakeup costs across event-loop turns without delaying sparse evaluations indefinitely.
+const BATCH_SIZE = 64
+const CONSENT_BATCH_SIZE = 8
+const BATCH_DELAY_MS = 20
+const permissionFlags = new Set([
+  '--permission', '--experimental-permission', '--permission-audit',
+  '--allow-addons', '--allow-child-process', '--allow-fs-read', '--allow-fs-write',
+  '--allow-ffi', '--allow-inspector', '--allow-net', '--allow-openssl-store', '--allow-wasi', '--allow-worker',
+])
+const networkFlags = new Set([
+  '--dns-result-order', '--network-family-autoselection', '--enable-network-family-autoselection',
+  '--network-family-autoselection-attempt-timeout', '--max-http-header-size', '--insecure-http-parser',
+  // TLS version defaults are worker-local; other TLS/OpenSSL options may reject worker execArgv.
+  '--tls-min-v1.0', '--tls-min-v1.1', '--tls-min-v1.2', '--tls-min-v1.3',
+  '--tls-max-v1.2', '--tls-max-v1.3',
+])
+const flagsWithValues = new Set([
+  '--allow-fs-read', '--allow-fs-write', '--dns-result-order', '--network-family-autoselection-attempt-timeout',
+  '--max-http-header-size',
+])
+
+/** @param {string} [nodeOptions] */
+function getWorkerArgs (nodeOptions = '') {
+  // eslint-disable-next-line n/no-unsupported-features/node-builtins -- Feature detection also supports Node 18.
+  const permissionEnabled = Boolean(process.permission)
+  const args = []
+  let arg = ''
+  let quoted = false
+  // Match Node's NODE_OPTIONS parsing: spaces delimit arguments; double quotes allow spaces,
+  // and backslashes escape the next character only inside double quotes (not shell quoting).
+  for (let i = 0; i < nodeOptions.length; i++) {
+    const char = nodeOptions[i]
+    if (char === '\\' && quoted) {
+      if (++i === nodeOptions.length) throw new Error('Invalid escape in NODE_OPTIONS')
+      arg += nodeOptions[i]
+    } else if (char === '"') {
+      quoted = !quoted
+    } else if (char === ' ' && !quoted) {
+      if (arg) args.push(arg)
+      arg = ''
+    } else {
+      arg += char
+    }
+  }
+  if (quoted) throw new Error('Unterminated quote in NODE_OPTIONS')
+  if (arg) args.push(arg)
+  // Node processes environment options first, then command-line overrides.
+  args.push(...process.execArgv)
+  const workerArgs = []
+  for (let i = 0; i < args.length; i++) {
+    const flag = args[i].split('=')[0].replaceAll('_', '-').replace(/^--no-/, '--')
+    if (!networkFlags.has(flag) && !(permissionEnabled && permissionFlags.has(flag))) continue
+    workerArgs.push(args[i])
+    if (flagsWithValues.has(flag) && !args[i].includes('=')) {
+      workerArgs.push(args[++i])
+    }
+  }
+  return workerArgs
+}
+
+/** @typedef {import('./flag-evaluation-consumer').FlagEvaluationRoute} FlagEvaluationRoute */
+/** @typedef {import('./flag-evaluation-aggregation').FlagEvaluationEvent} FlagEvaluationEvent */
+
+/**
+ * @typedef {object} SerializedFlagEvaluationRoute
+ * @property {number} id
+ * @property {string} url
+ * @property {string} basePath
+ * @property {object} [headers]
+ * @property {boolean} onFallback
+ * @property {boolean} onUnavailable
+ * @property {SerializedFlagEvaluationRoute} [fallback]
+ */
+
+/**
+ * @param {FlagEvaluationRoute} route
+ * @param {number} id - Generation used to reject reports from obsolete routes
+ */
+function serializeRoute (route, id) {
+  // Live custom agents cannot cross isolates. The common request helper recreates env proxy agents in the worker.
+  if (route.agent) throw new Error('Custom EVP route agents are not supported in the flag evaluation worker')
+  return {
+    id,
+    url: route.url.href,
+    basePath: route.basePath,
+    headers: route.headers,
+    onFallback: typeof route.onFallback === 'function',
+    onUnavailable: typeof route.onUnavailable === 'function',
+    fallback: route.fallback ? serializeRoute(route.fallback, id) : undefined,
+  }
+}
+
+class FlagEvaluationsWriter {
+  #enabled = false
+  #discoveryPending = true
+  #flushPending = false
+  #closed = false
+  #failed = false
+  #worker
+  #state = createWorkerState()
+  #batch = []
+  #batchTimer
+  #periodic
+  #deadline
+  #destroyer
+  #onAppClosing
+  #onFlush
+  #route
+  #routeId = 0
+  #serializedRoute
+  #context
+  #logging
+  #failureReason = 'worker_failure'
+
+  /** @param {import('../../config/config-base')} config */
+  constructor (config) {
+    this.#route = { url: /** @type {URL} */ (config.url), basePath: EVP_PROXY_PATH_V2 }
+    this.#logging = { enabled: config.debug === true, level: config.logLevel }
+    this.#context = {
+      service: typeof config.service === 'string' ? config.service : '',
+      env: typeof config.env === 'string' ? config.env : undefined,
+      version: typeof config.version === 'string' ? config.version : undefined,
+    }
+    this.#destroyer = () => this.destroy()
+    // Telemetry registers its shutdown sender before providers. Collect existing worker metrics before that send.
+    // Metrics produced by the later final drain remain best-effort; this does not coordinate telemetry shutdown.
+    this.#onAppClosing = () => collectWorkerTelemetry(this.#state)
+    this.#onFlush = () => this.flush()
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(this.#destroyer)
+    telemetryAppClosingCh.subscribe(this.#onAppClosing)
+    flushCh.subscribe(this.#onFlush)
+  }
+
+  hasCapacity () {
+    return this.getUnavailableReason() === undefined &&
+      Atomics.load(this.#state, 0) < FLAG_EVALUATION_QUEUE_CAP && Atomics.load(this.#state, 1) < 0x7F_FF_F0_00
+  }
+
+  /** @returns {'closed' | 'worker_failure' | 'unavailable' | undefined} */
+  getUnavailableReason () {
+    if (this.#closed) return 'closed'
+    if (this.#failed) return 'worker_failure'
+    return this.#enabled || this.#discoveryPending ? undefined : 'unavailable'
+  }
+
+  /**
+   * @param {boolean} enabled
+   * @param {FlagEvaluationRoute} [route]
+   */
+  setEnabled (enabled, route) {
+    if (this.#closed || this.#failed) return
+    const discoveryPending = this.#discoveryPending
+    this.#discoveryPending = false
+    this.#routeId++
+    if (route) this.#route = route
+    if (!enabled) {
+      this.#discardPartial('unavailable')
+      this.#post({ type: 'enabled', enabled: false })
+      this.#enabled = false
+      this.#flushPending = false
+      return
+    }
+    try {
+      this.#serializedRoute = serializeRoute(this.#route, this.#routeId)
+      this.#post({ type: 'enabled', enabled: true, route: this.#serializedRoute })
+      this.#enabled = !this.#failed
+      if (discoveryPending && this.#enabled) this.#drainDiscoveryQueue()
+    } catch {
+      this.#fail()
+    }
+  }
+
+  /** @param {FlagEvaluationEvent} event */
+  enqueue (event) {
+    if (!this.hasCapacity()) {
+      recordDropped(this.getUnavailableReason() ?? 'queue_overflow')
+      return false
+    }
+    const targetingKey = normalizeTargetingKey(event.targetingKey)
+    if (targetingKey === undefined && event.targetingKey !== undefined && event.targetingKey !== null) {
+      recordTargetingKeyOmitted()
+    }
+    const normalized = normalizeFlagEvaluationEvent(event, targetingKey)
+    const consent = normalized.observeFullEvaluationData
+    Atomics.add(this.#state, 0, 1)
+    Atomics.add(this.#state, 1, 1)
+    this.#batch.push(normalized)
+    // Discovery uses the same queue credits; no worker or timer is needed until a route is known.
+    if (this.#discoveryPending) return true
+    // A consented event flushes any batch of 8+, so a mixed batch contains at most 8 context snapshots.
+    if (this.#batch.length >= (consent ? CONSENT_BATCH_SIZE : BATCH_SIZE)) this.#sendBatch()
+    else if (this.#batchTimer === undefined) {
+      this.#batchTimer = setTimeout(() => this.#sendBatch(), BATCH_DELAY_MS)
+      this.#batchTimer.unref?.()
+    }
+    return true
+  }
+
+  flush () {
+    if (this.#closed || this.#failed) return
+    if (this.#discoveryPending) {
+      this.#flushPending = true
+      return
+    }
+    this.#sendBatch()
+    this.#post({ type: 'flush' })
+    collectWorkerTelemetry(this.#state)
+  }
+
+  destroy () {
+    if (this.#closed) return
+    if (this.#discoveryPending) this.#discardPartial('closed')
+    else this.#sendBatch()
+    this.#closed = true
+    this.#enabled = false
+    this.#cleanup()
+    if (!this.#worker || this.#failed) return
+    // Keep only a bounded final drain alive. An unresponsive worker can delay graceful
+    // exit by up to five seconds; unref'ing the deadline would not bypass the ref'd worker.
+    // Ordinary traffic and idle workers never keep the app alive.
+    this.#worker.ref()
+    this.#deadline = setTimeout(() => {
+      this.#failureReason = 'shutdown_timeout'
+      this.#fail()
+    }, 5000)
+    this.#post({ type: 'close' })
+  }
+
+  #sendBatch () {
+    this.#cancelBatchTimer()
+    if (this.#batch.length === 0) return
+    if (!this.#worker) {
+      this.#startWorker()
+      if (this.#failed) return
+    }
+    const events = this.#batch
+    this.#batch = []
+    this.#post({ type: 'batch', events })
+  }
+
+  #drainDiscoveryQueue () {
+    const events = this.#batch
+    this.#batch = []
+    // Keep the normal message limits when releasing a potentially queue-sized startup backlog.
+    for (const event of events) {
+      this.#batch.push(event)
+      if (this.#batch.length >= (event.observeFullEvaluationData ? CONSENT_BATCH_SIZE : BATCH_SIZE)) {
+        this.#sendBatch()
+        if (this.#failed) return
+      }
+    }
+    this.#sendBatch()
+    if (this.#flushPending) {
+      this.#flushPending = false
+      this.flush()
+    }
+  }
+
+  // Providers that never evaluate need no worker. A first batch during destroy still uses the bounded drain.
+  #startWorker () {
+    try {
+      const { Worker } = require('node:worker_threads')
+      // Intentionally use the tracer's supported-config filter (which retains non-DD/OTEL env).
+      // Strip application preloads, but retain permissions and supported HTTP/TLS/network settings.
+      const { NODE_OPTIONS, ...env } = getEnvironmentVariables()
+      const execArgv = getWorkerArgs(NODE_OPTIONS)
+      // PnP has no node_modules fallback: retain only its active resolver, not application preloads.
+      // eslint-disable-next-line n/no-missing-require -- Yarn supplies this virtual module only in PnP applications.
+      if (process.versions.pnp) execArgv.push('--require', require.resolve('pnpapi'))
+      this.#worker = new Worker(join(__dirname, 'flag-evaluation-worker.js'), {
+        name: 'dd-flag-evaluation',
+        execArgv,
+        env,
+        workerData: {
+          route: this.#serializedRoute, context: this.#context, state: this.#state.buffer, logging: this.#logging,
+        },
+      })
+      this.#worker.on('error', error => this.#fail(
+        error.code === 'MODULE_NOT_FOUND' || error.code === 'ERR_MODULE_NOT_FOUND' ? 'missing_module' : 'worker_error'
+      ))
+      this.#worker.on('messageerror', () => this.#fail('message_error'))
+      this.#worker.on('message', message => {
+        if (message?.type === 'log') this.#onLogMessage(message)
+        else this.#onRouteMessage(message)
+      })
+      this.#worker.once('exit', () => this.#exited())
+      this.#worker.unref?.()
+      this.#periodic = setInterval(() => collectWorkerTelemetry(this.#state), FLAG_EVALUATION_FLUSH_INTERVAL)
+      this.#periodic.unref?.()
+    } catch {
+      this.#fail('startup_error')
+    }
+  }
+
+  /** @param {{ level: string, message: string }} message */
+  #onLogMessage ({ level, message }) {
+    if (typeof message !== 'string') return
+    // Relay diagnostics without introducing new error-telemetry reports.
+    if (level === 'error') log.errorWithoutTelemetry('%s', message)
+    else if (level === 'debug' || level === 'info' || level === 'warn') log[level]('%s', message)
+  }
+
+  /** @param {{ type: 'route', id: number, status: 'fallback' | 'unavailable' }} message */
+  #onRouteMessage (message) {
+    if (this.#closed || this.#failed || !this.#enabled ||
+      message?.type !== 'route' || message.id !== this.#routeId) return
+    const callback = message.status === 'fallback'
+      ? this.#route.onFallback
+      : message.status === 'unavailable' ? this.#route.onUnavailable : undefined
+    if (!callback) return
+    // Consume the transition once. The strategy may synchronously publish a replacement route.
+    this.#routeId++
+    try {
+      callback()
+    } catch {
+      this.#fail('route_error')
+    }
+  }
+
+  /** @param {object} message */
+  #post (message) {
+    if (!this.#worker || this.#failed) return
+    try {
+      this.#worker.postMessage(message)
+    } catch {
+      this.#fail()
+    }
+  }
+
+  #cancelBatchTimer () {
+    if (this.#batchTimer !== undefined) clearTimeout(this.#batchTimer)
+    this.#batchTimer = undefined
+  }
+
+  /** @param {string} reason */
+  #discardPartial (reason) {
+    this.#cancelBatchTimer()
+    const count = this.#batch.length
+    this.#batch = []
+    Atomics.sub(this.#state, 0, count)
+    Atomics.sub(this.#state, 1, count)
+    recordDropped(reason, count)
+  }
+
+  #cleanup () {
+    clearInterval(this.#periodic)
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.delete(this.#destroyer)
+    telemetryAppClosingCh.unsubscribe(this.#onAppClosing)
+    flushCh.unsubscribe(this.#onFlush)
+    collectWorkerTelemetry(this.#state)
+  }
+
+  /** @param {string} [reason] - Internal diagnostic only; never include raw error messages or paths. */
+  #fail (reason = 'worker_error') {
+    if (this.#failed) return
+    this.#failed = true
+    this.#enabled = false
+    this.#cancelBatchTimer()
+    this.#batch = []
+    this.#cleanup()
+    log.warn('Flag evaluation counts disabled after worker failure (%s)', reason)
+    if (this.#worker) this.#worker.terminate()
+    else this.#exited()
+  }
+
+  #exited () {
+    clearTimeout(this.#deadline)
+    this.#failed = true
+    this.#enabled = false
+    this.#worker = undefined
+    this.#cancelBatchTimer()
+    this.#batch = []
+    this.#cleanup()
+    // Only settle ownership once the worker cannot mutate counters anymore.
+    recordDropped(this.#failureReason, Atomics.exchange(this.#state, 1, 0))
+    Atomics.store(this.#state, 0, 0)
+  }
+}
+
+module.exports = FlagEvaluationsWriter

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

@@ -34,7 +34,7 @@ function warnExposureDeliveryUnavailable () {
 /**
  * Preserves the one-time EVP v2 capability check for the Remote Configuration source.
  *
- * @param {import('../../config')} config - Tracer configuration object
+ * @param {import('../../config/config-base')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
@@ -64,7 +64,7 @@ function setAgentStrategy (config, setWriterEnabledValue) {
  * Local discovery is optional for delivery. A missing listener, discovery
  * error, or incompatible receiver selects direct intake when credentials exist.
  *
- * @param {import('../../config')} config - Tracer configuration object
+ * @param {import('../../config/config-base')} config - Tracer configuration object
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
  */
 function setAgentlessStrategy (config, setWriterEnabledValue) {
@@ -169,8 +169,9 @@ function setAgentlessStrategy (config, setWriterEnabledValue) {
 /**
  * Applies one event-delivery strategy that can be shared by all Feature Flags writers.
  *
- * @param {import('../../config')} config - Tracer configuration object
- * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
+ * @param {import('../../config/config-base')} config - Tracer configuration object
+ * @param {(enabled: boolean, route?: import('./flag-evaluations').FlagEvaluationRoute) => void} setWriterEnabledValue
+ *   Callback to set the writer enabled state
  */
 function setEventDeliveryStrategy (config, setWriterEnabledValue) {
   if (config.featureFlags?.DD_FEATURE_FLAGS_CONFIGURATION_SOURCE === 'agentless') {

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

@@ -93,6 +93,9 @@ class ContextManager {
   }
 
   bind (context, target) {
+    // Per the OTel contract, only functions are wrapped; other targets are returned as-is.
+    if (typeof target !== 'function') return target
+
     const self = this
     return function (...args) {
       return self.with(context, target, this, ...args)

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

@@ -2,7 +2,9 @@
 
 const api = require('@opentelemetry/api')
 const { AUTO_KEEP } = require('../../../../ext/priority')
+const { updateOtelTraceState } = require('../otel-sampling')
 const DatadogSpanContext = require('../opentracing/span_context')
+const TraceState = require('../opentracing/propagation/tracestate')
 const id = require('../id')
 
 function newContext () {
@@ -37,8 +39,10 @@ class SpanContext {
   }
 
   get traceState () {
-    const ts = this._ddContext._tracestate
-    return api.createTraceState(ts ? ts.toString() : '')
+    this._ddContext._ensureSamplingPriority()
+    const traceState = this._ddContext._tracestate?.clone() ?? new TraceState()
+    updateOtelTraceState(this._ddContext, traceState)
+    return api.createTraceState(traceState.toString())
   }
 }
 

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

@@ -2,7 +2,9 @@
 
 const OtlpTransformerBase = require('../otlp/otlp_transformer_base')
 const { getProtobufTypes } = require('../otlp/protobuf_loader')
+const { AUTO_KEEP } = require('../../../../../ext/priority')
 const { VERSION } = require('../../../../../version')
+const { SAMPLING_PRIORITY_KEY } = require('../../constants')
 const id = require('../../id')
 const { eventTimeNano } = require('../../encode/tags-processors')
 
@@ -52,6 +54,7 @@ const TRACE_ID_128 = '_dd.p.tid'
  * @property {number} start - Start time in nanoseconds since epoch
  * @property {number} duration - Duration in nanoseconds
  * @property {DDSpanEvent[]} [span_events] - Span events
+ * @property {string} [trace_state] - W3C tracestate for OTLP export
  */
 
 // Map DD span.kind string values to OTLP SpanKind numeric values
@@ -161,11 +164,13 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
   #transformSpan (span, traceIdHigh) {
     const parentId = span.parent_id
     const links = this.#extractLinks(span.meta?.['_dd.span_links'])
+    const samplingPriority = span.metrics?.[SAMPLING_PRIORITY_KEY]
 
     return {
       traceId: span.trace_id.toTraceIdHex(traceIdHigh).padStart(32, '0'),
       spanId: this.#idToBytes(span.span_id, 8),
       parentSpanId: (parentId && !parentId.equals(ZERO_ID)) ? this.#idToBytes(parentId, 8) : undefined,
+      traceState: span.trace_state,
       name: span.resource,
       kind: this.#mapSpanKind(span.meta?.['span.kind']),
       startTimeUnixNano: span.start,
@@ -177,6 +182,7 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
       links: links.length ? links : undefined,
       droppedLinksCount: 0,
       status: this.#mapStatus(span),
+      flags: typeof samplingPriority === 'number' ? (samplingPriority >= AUTO_KEEP ? 1 : 0) : undefined,
     }
   }
 

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

@@ -8,6 +8,7 @@ const tracer = require('../../')
 
 const id = require('../id')
 const log = require('../log')
+const { normalizeOtelTraceState } = require('../otel-sampling')
 const TraceState = require('../opentracing/propagation/tracestate')
 const SpanContext = require('./span_context')
 const Span = require('./span')
@@ -74,12 +75,12 @@ class Tracer {
   _convertOtelContextToDatadog (traceId, spanId, traceFlag, ts, meta = {}) {
     let origin = null
     let samplingPriority = traceFlag
+    let samplingMechanism
+    const traceStateValue = typeof ts?.serialize === 'function' ? ts.serialize() : ts?.traceparent
+    const traceState = TraceState.fromString(traceStateValue)
+    normalizeOtelTraceState(traceState)
 
-    ts = ts?.traceparent
-
-    if (ts) {
-      // Use TraceState.fromString to parse the tracestate header
-      const traceState = TraceState.fromString(ts)
+    if (traceStateValue) {
       let ddTraceStateData = null
 
       // Extract Datadog specific trace state data
@@ -89,29 +90,26 @@ class Tracer {
       })
 
       if (ddTraceStateData) {
-        // Assuming ddTraceStateData is now a Map or similar structure containing Datadog trace state data
-        // Extract values as needed, similar to the original logic
-        const samplingPriorityTs = ddTraceStateData.get('s')
-        origin = ddTraceStateData.get('o') ?? null
-        // Convert Map to object for meta
-        const otherPropagatedTags = Object.fromEntries(ddTraceStateData.entries())
-
-        // Update meta and samplingPriority based on extracted values
-        Object.assign(meta, otherPropagatedTags)
-        // Guard against an undefined/empty `s:` field that would result in NaN.
-        const tracestateSamplingPriority = samplingPriorityTs ? Math.trunc(samplingPriorityTs) : undefined
+        const priority = Number.parseInt(ddTraceStateData.get('s'), 10)
+        const tracestateSamplingPriority = Number.isInteger(priority) ? priority : undefined
+        origin = ddTraceStateData.get('o')?.replaceAll('~', '=') ?? null
+
+        const mechanism = Math.abs(Number.parseInt(ddTraceStateData.get('t.dm'), 10))
+        if (Number.isInteger(mechanism)) samplingMechanism = mechanism
+
         samplingPriority = getSamplingPriority(traceFlag, tracestateSamplingPriority, origin)
       } else {
-        log.debug('No dd list member in tracestate from incoming request:', ts)
+        log.debug('No dd list member in tracestate from incoming request:', traceStateValue)
       }
     }
 
     const spanContext = new SpanContext({
-      traceId: id(traceId, 16), spanId: id(), tags: meta, parentId: id(spanId, 16),
+      traceId: id(traceId, 16), spanId: id(), tags: meta, parentId: id(spanId, 16), tracestate: traceState,
     })
 
     spanContext._ddContext._sampling = { priority: samplingPriority }
     spanContext._ddContext._trace = { ...spanContext._ddContext._trace, origin }
+    if (samplingMechanism !== undefined) spanContext._ddContext._sampling.mechanism = samplingMechanism
     return spanContext
   }