dd-trace 6.19.0 → 6.20.0

package/packages/dd-trace/src/otel-sampling.js

@@ -0,0 +1,171 @@
+'use strict'
+
+const { AUTO_KEEP } = require('../../../ext/priority')
+const knuthHash = require('./knuth-hash')
+const { SAMPLING_AGENT_DECISION, SAMPLING_RULE_DECISION } = require('./constants')
+
+const MAX_THRESHOLD = 2n ** 56n
+const MAX_ENCODABLE_THRESHOLD = MAX_THRESHOLD - 1n
+const UINT64_MASK = 2n ** 64n - 1n
+
+/**
+ * @param {unknown} value
+ * @param {number} minLength
+ * @param {number} maxLength
+ * @returns {value is string}
+ */
+function isLowerHex (value, minLength, maxLength) {
+  if (typeof value !== 'string' || value.length < minLength || value.length > maxLength) return false
+
+  for (let index = 0; index < value.length; index++) {
+    const code = value.charCodeAt(index)
+    if ((code < 48 || code > 57) && (code < 97 || code > 102)) return false
+  }
+
+  return true
+}
+
+/**
+ * Derives the OTel 56-bit random value from Datadog's sampling hash.
+ *
+ * @param {bigint} traceId
+ */
+function randomValueFor (traceId) {
+  return ((~knuthHash(traceId)) & UINT64_MASK) >> 8n
+}
+
+/**
+ * Converts a sample rate to an OTel 56-bit rejection threshold.
+ *
+ * @param {number} sampleRate
+ */
+function thresholdFor (sampleRate) {
+  if (sampleRate === 1) return 0n
+  if (sampleRate === 0) return MAX_ENCODABLE_THRESHOLD
+
+  const threshold = BigInt(Math.round((1 - sampleRate) * Number(MAX_THRESHOLD)))
+  if (threshold < 0n) return 0n
+  if (threshold > MAX_ENCODABLE_THRESHOLD) return MAX_ENCODABLE_THRESHOLD
+  return threshold
+}
+
+/**
+ * Formats an OTel threshold with trailing zero nibbles removed.
+ *
+ * @param {bigint} threshold
+ */
+function formatThreshold (threshold) {
+  const value = threshold.toString(16).padStart(14, '0')
+  let end = value.length
+  while (end > 0 && value.charCodeAt(end - 1) === 48) end--
+  return end === 0 ? '0' : value.slice(0, end)
+}
+
+/**
+ * Generates OTel sampling fields for a local probability decision.
+ *
+ * @param {import('./opentracing/span_context')} context
+ * @param {number} probabilityRate
+ * @returns {{ randomValue: string, threshold: string } | undefined}
+ */
+function generateFields (context, probabilityRate) {
+  const { priority } = context._sampling
+  if (priority === undefined || probabilityRate === undefined) return
+
+  const thresholdValue = thresholdFor(probabilityRate)
+  let randomValue = randomValueFor(context._traceId.toBigInt())
+  const kept = priority >= AUTO_KEEP
+
+  if (kept) {
+    if (randomValue < thresholdValue) {
+      randomValue = thresholdValue
+    }
+  } else if (randomValue >= thresholdValue) {
+    randomValue = thresholdValue > 0n ? thresholdValue - 1n : 0n
+  }
+
+  return {
+    randomValue: randomValue.toString(16).padStart(14, '0'),
+    threshold: formatThreshold(thresholdValue),
+  }
+}
+
+/**
+ * Returns the probability rate recorded by a committed Datadog sampling decision.
+ * Sampling probes deliberately leave these rate fields unset.
+ *
+ * @param {import('./opentracing/span_context')} context
+ * @returns {number | undefined}
+ */
+function getProbabilityRate (context) {
+  if (context._sampling.isProbabilityDecision === false) return
+  return (context._trace[SAMPLING_RULE_DECISION] ?? context._trace[SAMPLING_AGENT_DECISION]) || undefined
+}
+
+/**
+ * Removes malformed OTel sampling fields and returns the valid values.
+ *
+ * @param {import('./opentracing/propagation/tracestate')} state
+ * @returns {{ randomValue: string | undefined, threshold: string | undefined }}
+ */
+function sanitizeFields (state) {
+  let randomValue = state.get('rv')
+  let threshold = state.get('th')
+
+  if (!isLowerHex(randomValue, 14, 14)) {
+    state.delete('rv')
+    randomValue = undefined
+  }
+  if (!isLowerHex(threshold, 1, 14)) {
+    state.delete('th')
+    threshold = undefined
+  }
+
+  return { randomValue, threshold }
+}
+
+/**
+ * Sanitizes inherited OTel sampling fields without changing valid state.
+ *
+ * @param {import('./opentracing/propagation/tracestate')} traceState
+ */
+function normalizeOtelTraceState (traceState) {
+  if (traceState.get('ot') === undefined) return
+  traceState.forVendor('ot', sanitizeFields)
+}
+
+/**
+ * Updates the OTel tracestate member to represent the context's sampling decision.
+ *
+ * @param {import('./opentracing/span_context')} context
+ * @param {import('./opentracing/propagation/tracestate')} traceState
+ */
+function updateOtelTraceState (context, traceState) {
+  const otelMember = traceState.get('ot')
+  const probabilityRate = getProbabilityRate(context)
+  if (context._sampling.isProbabilityDecision === false) {
+    if (otelMember === undefined) return
+  } else if (probabilityRate === undefined) {
+    return
+  }
+
+  traceState.forVendor('ot', state => {
+    const { randomValue, threshold } = sanitizeFields(state)
+
+    if (context._sampling.isProbabilityDecision === false) {
+      state.delete('th')
+    } else if (randomValue === undefined && threshold === undefined) {
+      const generated = generateFields(context, probabilityRate)
+      if (generated) {
+        // Entries serialize in reverse insertion order, so add th before rv.
+        state.set('th', generated.threshold)
+        state.set('rv', generated.randomValue)
+      }
+    }
+  })
+}
+
+module.exports = {
+  normalizeOtelTraceState,
+  updateOtelTraceState,
+}

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

@@ -15,7 +15,6 @@ const plugins = {
   get '@supabase/postgrest-js' () { return require('../../../datadog-plugin-supabase/src') },
   get '@supabase/realtime-js' () { return require('../../../datadog-plugin-supabase/src') },
   get '@supabase/storage-js' () { return require('../../../datadog-plugin-supabase/src') },
-  get '@supabase/supabase-js' () { return require('../../../datadog-plugin-supabase/src') },
   get 'durable-functions' () { return require('../../../datadog-plugin-azure-durable-functions/src') },
   get '@azure/service-bus' () { return require('../../../datadog-plugin-azure-service-bus/src') },
   get '@cucumber/cucumber' () { return require('../../../datadog-plugin-cucumber/src') },

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

@@ -26,8 +26,10 @@ const {
   SAMPLING_MECHANISM_AGENT,
   SAMPLING_MECHANISM_RULE,
   SAMPLING_MECHANISM_MANUAL,
+  SAMPLING_MECHANISM_APPSEC,
   SAMPLING_MECHANISM_REMOTE_USER,
   SAMPLING_MECHANISM_REMOTE_DYNAMIC,
+  SAMPLING_MECHANISM_AI_GUARD,
   SAMPLING_RULE_DECISION,
   SAMPLING_LIMIT_DECISION,
   SAMPLING_AGENT_DECISION,
@@ -39,6 +41,17 @@ const DEFAULT_KEY = 'service:,env:'
 
 const defaultSampler = new Sampler(AUTO_KEEP)
 
+/**
+ * Returns whether a product has already force-kept the trace.
+ *
+ * @param {import('./opentracing/span_context')} context
+ */
+function isProductForceKeep (context) {
+  const { priority, mechanism } = context._sampling
+  return priority === USER_KEEP &&
+    (mechanism === SAMPLING_MECHANISM_APPSEC || mechanism === SAMPLING_MECHANISM_AI_GUARD)
+}
+
 /**
  * PrioritySampler is responsible for determining whether a span should be sampled
  * based on various rules, rate limits, and priorities. It supports manual and
@@ -114,10 +127,10 @@ class PrioritySampler {
     const tag = this._getPriorityFromTags(context.getTags(), context)
 
     if (this.validate(tag)) {
-      context._sampling.priority = tag
       context._sampling.mechanism = SAMPLING_MECHANISM_MANUAL
+      this._recordDecision(context, tag)
     } else if (auto) {
-      context._sampling.priority = this._getPriorityFromAuto(root)
+      this.decideFromAuto(root)
     } else {
       return
     }
@@ -125,6 +138,22 @@ class PrioritySampler {
     this.#addDecisionMaker(root)
   }
 
+  /**
+   * Applies manual sampling tags from a supplied tag collection using their defined precedence.
+   *
+   * @param {DatadogSpan} span
+   * @param {Record<string, unknown>} tags
+   */
+  setPriorityFromTags (span, tags) {
+    if (!span) return
+
+    const context = this._getContext(span)
+    if (isProductForceKeep(context)) return
+
+    const priority = this._getPriorityFromTags(tags, context)
+    if (this.validate(priority)) this.setPriority(span, priority)
+  }
+
   /**
    * Updates agent-provided sampling rates keyed by `service:,env:`.
    *
@@ -179,14 +208,13 @@ class PrioritySampler {
       return // noop span
     }
 
-    context._sampling.priority = samplingPriority
-
     const mechanism = product?.mechanism ?? SAMPLING_MECHANISM_MANUAL
     context._sampling.mechanism = mechanism
+    this._recordDecision(context, samplingPriority)
 
     log.trace(span, samplingPriority, mechanism)
 
-    this.#addDecisionMaker(root)
+    this.#addDecisionMaker(root, product === undefined)
   }
 
   /**
@@ -201,6 +229,23 @@ class PrioritySampler {
       : /** @type {DatadogSpanContext} */ (span)
   }
 
+  /**
+   * Evaluates and records an automatic sampling decision.
+   *
+   * @param {DatadogSpan} span
+   * @returns {SamplingPriority}
+   */
+  decideFromAuto (span) {
+    const context = this._getContext(span)
+    const rule = this.#findRule(span)
+    const priority = rule
+      ? this.#getPriorityByRule(context, rule, true)
+      : this.#getPriorityByAgent(context, true)
+
+    context._sampling.priority = priority
+    return priority
+  }
+
   /**
    * Computes priority using rules and agent rates when no manual tag is present.
    *
@@ -212,27 +257,25 @@ class PrioritySampler {
     const rule = this.#findRule(span)
 
     return rule
-      ? this.#getPriorityByRule(context, rule)
-      : this.#getPriorityByAgent(context)
+      ? this.#getPriorityByRule(context, rule, false)
+      : this.#getPriorityByAgent(context, false)
   }
 
   /**
-   * Computes priority from manual sampling tags if present.
-   * Included for compatibility with {@link import('./standalone/tracesource_priority_sampler')._getPriorityFromTags}
+   * Converts one sampling tag into a user priority.
    *
-   * @param {Record<string, unknown>} tags
+   * @param {string} key
+   * @param {unknown} value
    * @param {DatadogSpanContext} _context
    * @returns {SamplingPriority|undefined}
    */
-  _getPriorityFromTags (tags, _context) {
-    if (Object.hasOwn(tags, MANUAL_KEEP) && tags[MANUAL_KEEP] !== false) {
+  _getPriorityFromTag (key, value, _context) {
+    if (key === MANUAL_KEEP && value !== false) {
       return USER_KEEP
-    } else if (Object.hasOwn(tags, MANUAL_DROP) && tags[MANUAL_DROP] !== false) {
+    } else if (key === MANUAL_DROP && value !== false) {
       return USER_REJECT
-    }
-    const rawPriority = tags[SAMPLING_PRIORITY]
-    if (rawPriority !== undefined) {
-      const priority = Math.trunc(rawPriority)
+    } else if (key === SAMPLING_PRIORITY && (typeof value === 'number' || typeof value === 'string')) {
+      const priority = Math.trunc(/** @type {number} */ (value))
 
       if (priority === 1 || priority === 2) {
         return USER_KEEP
@@ -242,30 +285,85 @@ class PrioritySampler {
     }
   }
 
+  /**
+   * Computes priority from manual sampling tags if present.
+   * Calls the overridable single-tag conversion so specialized samplers retain their filtering rules.
+   *
+   * @param {Record<string, unknown>} tags
+   * @param {DatadogSpanContext} _context
+   * @returns {SamplingPriority|undefined}
+   */
+  _getPriorityFromTags (tags, _context) {
+    if (!Object.hasOwn(tags, MANUAL_KEEP) && !Object.hasOwn(tags, MANUAL_DROP)) {
+      const priority = tags[SAMPLING_PRIORITY]
+      if (priority !== undefined) return this._getPriorityFromTag(SAMPLING_PRIORITY, priority, _context)
+      return
+    }
+
+    return this.#getPriorityFromManualTags(tags, _context)
+  }
+
+  /**
+   * Computes priority when at least one manual keep/drop tag is present.
+   * Value checks cover the common case; own-property checks preserve undefined-valued manual tags.
+   *
+   * @param {Record<string, unknown>} tags
+   * @param {DatadogSpanContext} context
+   * @returns {SamplingPriority|undefined}
+   */
+  #getPriorityFromManualTags (tags, context) {
+    const manualKeep = tags[MANUAL_KEEP]
+    if (manualKeep !== undefined || Object.hasOwn(tags, MANUAL_KEEP)) {
+      const priority = this._getPriorityFromTag(MANUAL_KEEP, manualKeep, context)
+      if (priority !== undefined) return priority
+    }
+
+    const manualDrop = tags[MANUAL_DROP]
+    if (manualDrop !== undefined || Object.hasOwn(tags, MANUAL_DROP)) {
+      const priority = this._getPriorityFromTag(MANUAL_DROP, manualDrop, context)
+      if (priority !== undefined) return priority
+    }
+    const priority = tags[SAMPLING_PRIORITY]
+    if (priority !== undefined) return this._getPriorityFromTag(SAMPLING_PRIORITY, priority, context)
+  }
+
   /**
    * Applies a matching rule and rate limit to compute the sampling priority.
    *
    * @param {DatadogSpanContext} context
    * @param {import('./sampling_rule')} rule
+   * @param {boolean} recordDecision
    * @returns {SamplingPriority}
    */
-  #getPriorityByRule (context, rule) {
-    context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
+  #getPriorityByRule (context, rule, recordDecision) {
+    if (recordDecision) context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
     context._trace.tags[SAMPLING_KNUTH_RATE] = formatKnuthRate(rule.sampleRate)
-    context._sampling.mechanism = SAMPLING_MECHANISM_RULE
-    if (rule.provenance === 'customer') {
-      context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_USER
-    } else if (rule.provenance === 'dynamic') {
-      context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_DYNAMIC
+    if (recordDecision) {
+      context._sampling.mechanism = SAMPLING_MECHANISM_RULE
+      if (rule.provenance === 'customer') {
+        context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_USER
+      } else if (rule.provenance === 'dynamic') {
+        context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_DYNAMIC
+      }
     }
 
     if (rule.discard) {
       context._sampling.discard = true
     }
 
-    return rule.sample(context) && this._isSampledByRateLimit(context)
-      ? USER_KEEP
-      : USER_REJECT
+    const sampled = rule.sample(context, true)
+    if (sampled !== true) {
+      if (recordDecision && sampled === undefined) this._recordDecisionMetadata(context)
+      return USER_REJECT
+    }
+
+    if (!this._isSampledByRateLimit(context)) {
+      // The limiter makes only rejected traces non-probabilistic; allowed traces retain the rule probability.
+      if (recordDecision) this._recordDecisionMetadata(context)
+      return USER_REJECT
+    }
+
+    return USER_KEEP
   }
 
   /**
@@ -287,39 +385,63 @@ class PrioritySampler {
    * Computes priority using agent-provided sampling rates.
    *
    * @param {DatadogSpanContext} context
+   * @param {boolean} recordDecision
    * @returns {SamplingPriority}
    */
-  #getPriorityByAgent (context) {
+  #getPriorityByAgent (context, recordDecision) {
     const key = `service:${context.getTag(SERVICE_NAME)},env:${this._env}`
     // TODO: Change underscored properties to private ones.
     const sampler = this._samplers[key] || this._samplers[DEFAULT_KEY]
 
     const rate = sampler.rate()
-    context._trace[SAMPLING_AGENT_DECISION] = rate
+    if (recordDecision) context._trace[SAMPLING_AGENT_DECISION] = rate
 
     if (sampler === defaultSampler) {
-      context._sampling.mechanism = SAMPLING_MECHANISM_DEFAULT
+      if (recordDecision) context._sampling.mechanism = SAMPLING_MECHANISM_DEFAULT
     } else {
       context._trace.tags[SAMPLING_KNUTH_RATE] = formatKnuthRate(rate)
-      context._sampling.mechanism = SAMPLING_MECHANISM_AGENT
+      if (recordDecision) context._sampling.mechanism = SAMPLING_MECHANISM_AGENT
     }
 
     return sampler.isSampled(context) ? AUTO_KEEP : AUTO_REJECT
   }
 
+  /**
+   * Records that a sampling decision does not represent a probability.
+   *
+   * @param {DatadogSpanContext} context
+   */
+  _recordDecisionMetadata (context) {
+    context._sampling.isProbabilityDecision = false
+  }
+
+  /**
+   * Records a local non-probability sampling decision.
+   *
+   * @param {DatadogSpanContext} context
+   * @param {SamplingPriority} priority
+   * @returns {SamplingPriority}
+   */
+  _recordDecision (context, priority) {
+    context._sampling.priority = priority
+    this._recordDecisionMetadata(context)
+    return priority
+  }
+
   /**
    * Tags the trace with a decision maker when priority is keep, or removes it otherwise.
    *
    * @param {DatadogSpan} span
+   * @param {boolean} [overwrite]
    */
-  #addDecisionMaker (span) {
+  #addDecisionMaker (span, overwrite = false) {
     const context = span.context()
     const trace = context._trace
     const priority = context._sampling.priority
     const mechanism = context._sampling.mechanism
 
     if (priority >= AUTO_KEEP) {
-      if (!trace.tags[DECISION_MAKER_KEY]) {
+      if (overwrite || !trace.tags[DECISION_MAKER_KEY]) {
         trace.tags[DECISION_MAKER_KEY] = `-${mechanism}`
       }
     } else if (trace.tags[DECISION_MAKER_KEY] !== undefined) {

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

@@ -12,19 +12,28 @@ module.exports = {
   ASM_CUSTOM_BLOCKING_RESPONSE: 1n << 9n,
   ASM_TRUSTED_IPS: 1n << 10n,
   ASM_API_SECURITY_SAMPLE_RATE: 1n << 11n, // deprecated
+  APM_TRACING_SAMPLE_RATE: 1n << 12n,
+  APM_TRACING_LOGS_INJECTION: 1n << 13n,
+  APM_TRACING_HTTP_HEADER_TAGS: 1n << 14n,
+  APM_TRACING_CUSTOM_TAGS: 1n << 15n,
   ASM_PROCESSOR_OVERRIDES: 1n << 16n,
   ASM_CUSTOM_DATA_SCANNERS: 1n << 17n,
   ASM_EXCLUSION_DATA: 1n << 18n,
+  APM_TRACING_ENABLED: 1n << 19n,
   ASM_RASP_SQLI: 1n << 21n,
   ASM_RASP_LFI: 1n << 22n,
   ASM_RASP_SSRF: 1n << 23n,
   ASM_RASP_SHI: 1n << 24n,
+  APM_TRACING_SAMPLE_RULES: 1n << 29n,
   ASM_AUTO_USER_INSTRUM_MODE: 1n << 31n,
   ASM_ENDPOINT_FINGERPRINT: 1n << 32n,
   ASM_SESSION_FINGERPRINT: 1n << 33n,
   ASM_NETWORK_FINGERPRINT: 1n << 34n,
   ASM_HEADER_FINGERPRINT: 1n << 35n,
   ASM_RASP_CMDI: 1n << 37n,
+  APM_TRACING_ENABLE_DYNAMIC_INSTRUMENTATION: 1n << 38n,
+  APM_TRACING_ENABLE_CODE_ORIGIN: 1n << 40n,
+  APM_TRACING_ENABLE_LIVE_DEBUGGING: 1n << 41n,
   ASM_DD_MULTICONFIG: 1n << 42n,
   ASM_TRACE_TAGGING_RULES: 1n << 43n,
   ASM_EXTENDED_DATA_COLLECTION: 1n << 44n,

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

@@ -5,10 +5,7 @@
 // as it is cast into a float64 when computing the threshold
 const MAX_TRACE_ID = 2 ** 64 - 1
 
-const UINT64_MODULO = 2n ** 64n
-
-// Knuth's factor for the sampling algorithm
-const SAMPLING_KNUTH_FACTOR = 1_111_111_111_111_111_111n
+const knuthHash = require('./knuth-hash')
 
 /**
  * `Sampler` determines whether or not to sample a trace/span based on the trace ID.
@@ -52,7 +49,7 @@ class Sampler {
 
     span = typeof span.context === 'function' ? span.context() : span
 
-    return (span._traceId.toBigInt() * SAMPLING_KNUTH_FACTOR) % UINT64_MODULO <= this.#threshold
+    return knuthHash(span._traceId.toBigInt()) <= this.#threshold
   }
 }
 

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

@@ -274,16 +274,12 @@ class SamplingRule {
    * Determines whether a span should be sampled based on the configured sampling rule.
    *
    * @param {DatadogSpan|DatadogSpanContext} span - The span or span context to evaluate.
+   * @param {boolean} [distinguishRateLimit] Return `undefined` instead of `false` for a rate-limit rejection.
    */
-  sample (span) {
-    if (!this._sampler.isSampled(span)) {
-      return false
-    }
-
-    if (this._limiter) {
-      return this._limiter.isAllowed()
-    }
+  sample (span, distinguishRateLimit = false) {
+    if (!this._sampler.isSampled(span)) return false
 
+    if (this._limiter && !this._limiter.isAllowed()) return distinguishRateLimit ? undefined : false
     return true
   }
 }

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

@@ -47,6 +47,7 @@ const { IGNORE_OTEL_ERROR } = constants
  * @property {number} duration
  * @property {Array} links
  * @property {Array<SpanEvent> | undefined} span_events
+ * @property {string} [trace_state] W3C tracestate, populated only for OTLP export.
  *
  * @typedef {object} SpanEvent Raw span event as stored on the span; the encoder
  *   layer derives `time_unix_nano` from `startTime` via `eventTimeNano`.
@@ -55,6 +56,11 @@ const { IGNORE_OTEL_ERROR } = constants
  * @property {Record<string, string>} [attributes]
  */
 
+/**
+ * @param {import('./opentracing/span')} span
+ * @param {boolean} [isFirstSpanInChunk]
+ * @param {string | false} [tagForFirstSpanInChunk]
+ */
 function format (span, isFirstSpanInChunk = false, tagForFirstSpanInChunk = false) {
   const formatted = formatSpan(span)
 

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

@@ -7,17 +7,40 @@ const SpanSampler = require('./span_sampler')
 const GitMetadataTagger = require('./git_metadata_tagger')
 const processTags = require('./process-tags')
 const { applyHttpOtelSemantics } = require('./plugins/util/http-otel-semantics')
+const TraceState = require('./opentracing/propagation/tracestate')
 const { APM_TRACING_ENABLED_KEY, SDK_OTLP_EXPORT_KEY } = require('./constants')
 
 const startedSpans = new WeakSet()
 const finishedSpans = new WeakSet()
 
+let otelSampling
+
+/**
+ * Adds first-class OTLP trace context to a DD-formatted span.
+ *
+ * @param {import('./opentracing/span')} span
+ * @param {boolean} isFirstSpanInChunk
+ * @param {string | false} processTagsValue
+ */
+function formatOtlpSpan (span, isFirstSpanInChunk, processTagsValue) {
+  const formattedSpan = spanFormat(span, isFirstSpanInChunk, processTagsValue)
+  const context = span.context()
+  const traceState = context._tracestate?.clone() ?? new TraceState()
+  otelSampling ??= require('./otel-sampling')
+  otelSampling.updateOtelTraceState(context, traceState)
+  formattedSpan.trace_state = traceState.toString()
+  return formattedSpan
+}
+
 class SpanProcessor {
-  constructor (exporter, prioritySampler, config, otlpStatsExporter) {
+  #formatSpan
+
+  constructor (exporter, prioritySampler, config, otlpStatsExporter, exportOtlpTraces) {
     this._exporter = exporter
     this._prioritySampler = prioritySampler
     this._config = config
     this._killAll = false
+    this.#formatSpan = exportOtlpTraces ? formatOtlpSpan : spanFormat
 
     if (config.stats?.DD_TRACE_STATS_COMPUTATION_ENABLED &&
         !config.appsec?.DD_EXPERIMENTAL_APPSEC_STANDALONE_ENABLED) {
@@ -72,12 +95,13 @@ class SpanProcessor {
       let isFirstSpanInChunk = true
       const stampApmDisabled = this._config.apmTracingEnabled === false
       const discard = this.#isDiscarded(spanContext)
+      const formatSpan = this.#formatSpan
 
       for (const span of started) {
         if (span._duration === undefined) {
           active.push(span)
         } else if (!discard) {
-          const formattedSpan = spanFormat(span, isFirstSpanInChunk, this._processTags)
+          const formattedSpan = formatSpan(span, isFirstSpanInChunk, this._processTags)
           if (stampApmDisabled) {
             formattedSpan.metrics[APM_TRACING_ENABLED_KEY] = 0
           }

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

@@ -23,11 +23,12 @@ function configure (config) {
 function onSpanExtract ({ spanContext = {} }) {
   if (!spanContext._trace?.tags || !spanContext._sampling) return
 
-  // reset upstream priority if _dd.p.ts is not found
-  if (!hasTraceSourcePropagationTag(spanContext._trace.tags)) {
-    spanContext._sampling.priority = undefined
-  } else if (spanContext._sampling.priority !== USER_KEEP) {
+  if (hasTraceSourcePropagationTag(spanContext._trace.tags)) {
     spanContext._sampling.priority = USER_KEEP
+    spanContext._sampling.isProbabilityDecision = false
+  } else {
+    // Reset upstream priority if _dd.p.ts is not found.
+    spanContext._sampling.priority = undefined
   }
 }