dd-trace 5.109.0 → 5.110.0

package/packages/dd-trace/src/debugger/devtools_client/probe_sampler.js

@@ -0,0 +1,83 @@
+'use strict'
+
+const { DD_TRACE_SYMBOL, PROBE_SAMPLER_SYMBOL } = require('../probe_sampler_constants')
+
+const SAMPLER_EXPRESSION = `globalThis[Symbol.for(${JSON.stringify(DD_TRACE_SYMBOL)})]?.` +
+  `[Symbol.for(${JSON.stringify(PROBE_SAMPLER_SYMBOL)})]`
+
+module.exports = {
+  compileBreakpointCondition,
+  getRemoveProbeExpression,
+}
+
+/**
+ * Build the expression that removes a probe from runtime sampler state. Called by the devtools worker and evaluated on
+ * the debuggee.
+ *
+ * @param {string} id - The probe id.
+ * @returns {string}
+ */
+function getRemoveProbeExpression (id) {
+  return `${SAMPLER_EXPRESSION}?.remove(${JSON.stringify(id)})`
+}
+
+/**
+ * Build a Chrome DevTools breakpoint condition that samples all matching probes at a location. Called by the devtools
+ * worker.
+ *
+ * @param {{
+ *   id: string,
+ *   samplingIndex: number,
+ *   nsBetweenSampling: bigint,
+ *   condition?: string,
+ *   captureSnapshot?: boolean,
+ *   compiledCaptureExpressions?: object[]
+ * }[]} probes - The probes at the breakpoint location.
+ * @returns {string}
+ */
+function compileBreakpointCondition (probes) {
+  const probeConditions = []
+  for (const probe of probes) {
+    probeConditions.push(compileProbeCondition(probe))
+  }
+
+  // NOTE: $dd_sampler is read from the realm-local `globalThis` where it was installed (the main
+  // realm). A probe whose code runs in a different V8 realm (e.g. a `vm.createContext` script with a
+  // file-path filename) won't see it and will silently never fire. Known limitation: a breakpoint
+  // condition has no realm-independent handle to reach, so we degrade rather than crash.
+  return `(() => {
+    const $dd_sampler = ${SAMPLER_EXPRESSION}
+    if ($dd_sampler === undefined) return false
+    let $dd_sampled = false
+    ${probeConditions.join('\n    ')}
+    return $dd_sampled
+  })()`
+}
+
+/**
+ * Build the condition fragment for a single probe. Called by the devtools worker while building breakpoint conditions.
+ *
+ * @param {{
+ *   id: string,
+ *   samplingIndex: number,
+ *   nsBetweenSampling: bigint,
+ *   condition?: string,
+ *   captureSnapshot?: boolean,
+ *   compiledCaptureExpressions?: object[]
+ * }} probe - The probe to sample.
+ * @returns {string}
+ */
+function compileProbeCondition (probe) {
+  const sample = `$dd_sampler.makeSampleDecision(${probe.samplingIndex}, ${JSON.stringify(probe.id)}, ` +
+    `${probe.nsBetweenSampling}n, ${probe.captureSnapshot === true || probe.compiledCaptureExpressions !== undefined})`
+
+  if (probe.condition === undefined) {
+    return `$dd_sampled = ${sample} || $dd_sampled`
+  }
+
+  return `try {
+      if ((${probe.condition}) === true) {
+        $dd_sampled = ${sample} || $dd_sampled
+      }
+    } catch {}`
+}

package/packages/dd-trace/src/debugger/devtools_client/state.js

@@ -33,6 +33,7 @@ module.exports = {
   locationToBreakpoint: new Map(),
   breakpointToProbes: new Map(),
   probeToLocation: new Map(),
+  samplingIndexToProbe: new Map(),
 
   _loadedScripts: loadedScripts, // Only exposed for testing
   _scriptUrls: scriptUrls, // Only exposed for testing

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

@@ -8,6 +8,7 @@ const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
 const getDebuggerConfig = require('./config')
 const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('./constants')
+const { installProbeSampler, uninstallProbeSampler } = require('./probe_sampler')
 
 /**
  * @typedef {ReturnType<import('../config')>} Config
@@ -65,6 +66,8 @@ function start (config, rcInstance) {
 
   globalThis[Symbol.for('dd-trace')].utilTypes = types
 
+  const probeSamplerBuffer = installProbeSampler()
+
   readProbeFile(config.dynamicInstrumentation.probeFile, (probes) => {
     const action = 'apply'
     for (const probe of probes) {
@@ -110,6 +113,7 @@ function start (config, rcInstance) {
           probePort: probeChannel.port1,
           logPort: logChannel.port1,
           configPort: configChannel.port1,
+          probeSamplerBuffer,
         },
         transferList: [probeChannel.port1, logChannel.port1, configChannel.port1],
       }
@@ -187,6 +191,7 @@ function cleanup (error) {
     worker.removeAllListeners()
     worker = null
   }
+  uninstallProbeSampler()
   configChannel = null
   inputPath = null
 

package/packages/dd-trace/src/debugger/probe_sampler.js

@@ -0,0 +1,112 @@
+'use strict'
+
+const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./devtools_client/defaults')
+const {
+  DD_TRACE_SYMBOL,
+  MAX_SAMPLED_PROBES_PER_PAUSE,
+  PROBE_SAMPLER_SYMBOL,
+  SAMPLED_PROBE_COUNT_INDEX,
+  SAMPLED_PROBE_INDEXES_START,
+  SAMPLED_PROBE_OVERFLOW_INDEX,
+} = require('./probe_sampler_constants')
+
+const ddTraceGlobal = /** @type {Record<symbol, SharedArrayBuffer | object | undefined>} */ (
+  /** @type {Record<symbol, unknown>} */ (globalThis)[Symbol.for(DD_TRACE_SYMBOL)]
+)
+
+module.exports = {
+  installProbeSampler,
+  uninstallProbeSampler,
+}
+
+/**
+ * Install the runtime sampler in the debuggee context.
+ *
+ * @returns {SharedArrayBuffer} The shared sampler buffer to pass to the debugger worker.
+ */
+function installProbeSampler () {
+  const buffer = createProbeSamplerBuffer()
+
+  const lastCaptureNsByProbeId = new Map()
+  const sampledProbeIndexes = new Int32Array(buffer)
+  Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 0)
+  Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 0)
+
+  const oneSecondNs = 1_000_000_000n
+  let globalSnapshotSamplingRateWindowStart = 0n
+  let snapshotsSampledWithinTheLastSecond = 0
+
+  ddTraceGlobal[Symbol.for(PROBE_SAMPLER_SYMBOL)] = {
+    /**
+     * Decide if a probe should be sampled and store sampled probe indexes for the debugger worker.
+     *
+     * @param {number} probeIndex - The worker-side probe sampling index.
+     * @param {string} probeId - The probe id.
+     * @param {bigint} nsBetweenSampling - Minimum nanoseconds between samples for this probe.
+     * @param {boolean} isSnapshotProducingProbe - Whether this probe counts toward the global snapshot sample limit.
+     * @returns {boolean} Whether this probe should make the breakpoint condition pause.
+     */
+    makeSampleDecision (probeIndex, probeId, nsBetweenSampling, isSnapshotProducingProbe) {
+      const now = process.hrtime.bigint()
+      const lastCaptureNs = lastCaptureNsByProbeId.get(probeId)
+      if (lastCaptureNs !== undefined && now - lastCaptureNs < nsBetweenSampling) return false
+
+      let shouldResetGlobalSnapshotRateWindow = false
+      if (isSnapshotProducingProbe === true) {
+        if (now - globalSnapshotSamplingRateWindowStart > oneSecondNs) {
+          shouldResetGlobalSnapshotRateWindow = true
+        } else if (snapshotsSampledWithinTheLastSecond >= MAX_SNAPSHOTS_PER_SECOND_GLOBALLY) {
+          return false
+        }
+      }
+
+      const sampledProbeCount = Atomics.add(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 1)
+      if (sampledProbeCount >= MAX_SAMPLED_PROBES_PER_PAUSE) {
+        Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 1)
+        return false
+      }
+
+      if (isSnapshotProducingProbe === true) {
+        if (shouldResetGlobalSnapshotRateWindow === true) {
+          snapshotsSampledWithinTheLastSecond = 1
+          globalSnapshotSamplingRateWindowStart = now
+        } else {
+          snapshotsSampledWithinTheLastSecond++
+        }
+      }
+
+      lastCaptureNsByProbeId.set(probeId, now)
+      Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_INDEXES_START + sampledProbeCount, probeIndex)
+      return true
+    },
+
+    /**
+     * Remove cached sampling state for a probe.
+     *
+     * @param {string} probeId - The probe id.
+     */
+    remove (probeId) {
+      lastCaptureNsByProbeId.delete(probeId)
+    },
+  }
+
+  return buffer
+}
+
+/**
+ * Remove the runtime sampler from the debuggee context.
+ */
+function uninstallProbeSampler () {
+  delete ddTraceGlobal[Symbol.for(PROBE_SAMPLER_SYMBOL)]
+}
+
+/**
+ * Create the shared buffer used to hand sampled probe indexes from breakpoint conditions to the debugger worker.
+ *
+ * @returns {SharedArrayBuffer}
+ */
+function createProbeSamplerBuffer () {
+  return new SharedArrayBuffer(
+    (SAMPLED_PROBE_INDEXES_START + MAX_SAMPLED_PROBES_PER_PAUSE) * Int32Array.BYTES_PER_ELEMENT
+  )
+}

package/packages/dd-trace/src/debugger/probe_sampler_constants.js

@@ -0,0 +1,19 @@
+'use strict'
+
+const DD_TRACE_SYMBOL = 'dd-trace'
+const PROBE_SAMPLER_SYMBOL = 'dd-trace.debugger.probeSampler'
+
+// Shared sampler contract used by the main debugger bootstrap and the devtools worker.
+const MAX_SAMPLED_PROBES_PER_PAUSE = 256
+const SAMPLED_PROBE_COUNT_INDEX = 0
+const SAMPLED_PROBE_OVERFLOW_INDEX = 1
+const SAMPLED_PROBE_INDEXES_START = 2
+
+module.exports = {
+  DD_TRACE_SYMBOL,
+  MAX_SAMPLED_PROBES_PER_PAUSE,
+  PROBE_SAMPLER_SYMBOL,
+  SAMPLED_PROBE_COUNT_INDEX,
+  SAMPLED_PROBE_INDEXES_START,
+  SAMPLED_PROBE_OVERFLOW_INDEX,
+}

package/packages/dd-trace/src/encode/agentless-ci-visibility.js

@@ -1,6 +1,6 @@
 'use strict'
 const { version: ddTraceVersion } = require('../../../../package.json')
-const { ITR_CORRELATION_ID } = require('../../src/plugins/util/test')
+const { ITR_CORRELATION_ID, TEST_LEVELS_METADATA } = require('../../src/plugins/util/test')
 const id = require('../../src/id')
 const {
   distributionMetric,
@@ -9,10 +9,15 @@ const {
 } = require('../ci-visibility/telemetry')
 const { MsgpackChunk } = require('../msgpack')
 const { AgentEncoder } = require('./0.4')
-const { truncateSpanTestOpt, normalizeSpan } = require('./tags-processors')
+const {
+  truncateSpanTestOpt,
+  normalizeSpan,
+  MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION,
+} = require('./tags-processors')
 
 const ENCODING_VERSION = 1
 const ALLOWED_CONTENT_TYPES = new Set(['test_session_end', 'test_module_end', 'test_suite_end', 'test'])
+const ALLOWED_METADATA_TARGETS = new Set([...ALLOWED_CONTENT_TYPES, TEST_LEVELS_METADATA])
 
 const TEST_SUITE_KEYS_LENGTH = 12
 const TEST_MODULE_KEYS_LENGTH = 11
@@ -36,6 +41,33 @@ function formatSpan (span) {
   }
 }
 
+function isAllowedMetadataTarget (target) {
+  return ALLOWED_METADATA_TARGETS.has(target)
+}
+
+function isEncodableMetadataValue (value) {
+  return typeof value === 'string' || typeof value === 'number'
+}
+
+function truncateTestLevelMetadataValue (value) {
+  if (typeof value !== 'string' || value.length <= MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION) {
+    return value
+  }
+  return `${value.slice(0, MAX_META_VALUE_LENGTH_TEST_OPTIMIZATION)}...`
+}
+
+function truncateTestLevelMetadataTags (tags) {
+  const truncatedTags = {}
+  let hasTags = false
+  for (const key of Object.keys(tags)) {
+    const value = truncateTestLevelMetadataValue(tags[key])
+    if (!isEncodableMetadataValue(value)) continue
+    truncatedTags[key] = value
+    hasTags = true
+  }
+  return hasTags ? truncatedTags : undefined
+}
+
 class AgentlessCiVisibilityEncoder extends AgentEncoder {
   constructor (writer, { runtimeId, service, env }) {
     super(writer, INTAKE_SOFT_LIMIT)
@@ -49,6 +81,7 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
 
     this.metadataTags = {}
     this.wildcardMetadataTags = {}
+    this.testLevelsMetadataKeys = []
 
     this.reset()
   }
@@ -60,12 +93,39 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
         ...tags['*'],
       }
     }
-    for (const type of ALLOWED_CONTENT_TYPES) {
-      if (tags[type]) {
-        this.metadataTags[type] = {
-          ...this.metadataTags[type],
-          ...tags[type],
-        }
+
+    for (const target of Object.keys(tags)) {
+      if (target === '*' || !tags[target] || !isAllowedMetadataTarget(target)) continue
+
+      const targetTags = target === TEST_LEVELS_METADATA
+        ? truncateTestLevelMetadataTags(tags[target])
+        : tags[target]
+      if (!targetTags) continue
+
+      this.metadataTags[target] = {
+        ...this.metadataTags[target],
+        ...targetTags,
+      }
+
+      if (target === TEST_LEVELS_METADATA) {
+        this.testLevelsMetadataKeys = Object.keys(this.metadataTags[target])
+      }
+    }
+  }
+
+  _removeDuplicateTestLevelsMetadata (event) {
+    if (!ALLOWED_CONTENT_TYPES.has(event.type)) return
+
+    const meta = event.content.meta
+    if (!meta) return
+
+    const testLevelsMetadataTags = this.metadataTags[TEST_LEVELS_METADATA]
+    const testLevelsMetadataKeys = this.testLevelsMetadataKeys
+
+    for (let i = 0; i < testLevelsMetadataKeys.length; i++) {
+      const key = testLevelsMetadataKeys[i]
+      if (meta[key] === testLevelsMetadataTags[key]) {
+        delete meta[key]
       }
     }
   }
@@ -276,7 +336,11 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
 
     this._eventCount += events.length
 
+    const hasTestLevelsMetadata = this.testLevelsMetadataKeys.length !== 0
     for (const event of events) {
+      if (hasTestLevelsMetadata) {
+        this._removeDuplicateTestLevelsMetadata(event)
+      }
       this._encodeEvent(bytes, event)
     }
     distributionMetric(
@@ -343,24 +407,11 @@ class AgentlessCiVisibilityEncoder extends AgentEncoder {
     this._encodeString(bytes, 'version')
     bytes.writeNumber(payload.version)
     this._encodeString(bytes, 'metadata')
-    bytes.writeMapPrefix(Object.keys(payload.metadata).length)
-    this._encodeString(bytes, '*')
-    this._encodeMap(bytes, payload.metadata['*'])
-    if (payload.metadata.test) {
-      this._encodeString(bytes, 'test')
-      this._encodeMap(bytes, payload.metadata.test)
-    }
-    if (payload.metadata.test_suite_end) {
-      this._encodeString(bytes, 'test_suite_end')
-      this._encodeMap(bytes, payload.metadata.test_suite_end)
-    }
-    if (payload.metadata.test_module_end) {
-      this._encodeString(bytes, 'test_module_end')
-      this._encodeMap(bytes, payload.metadata.test_module_end)
-    }
-    if (payload.metadata.test_session_end) {
-      this._encodeString(bytes, 'test_session_end')
-      this._encodeMap(bytes, payload.metadata.test_session_end)
+    const metadataKeys = Object.keys(payload.metadata)
+    bytes.writeMapPrefix(metadataKeys.length)
+    for (const metadataKey of metadataKeys) {
+      this._encodeString(bytes, metadataKey)
+      this._encodeMap(bytes, payload.metadata[metadataKey])
     }
     this._encodeString(bytes, 'events')
     this._eventsOffset = bytes.length

package/packages/dd-trace/src/exporters/common/request.js

@@ -11,7 +11,7 @@ const zlib = require('zlib')
 
 const { storage } = require('../../../../datadog-core')
 const log = require('../../log')
-const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
+const { parseUrl } = require('./url')
 const docker = require('./docker')
 const { httpAgent, httpsAgent } = require('./agents')
 const {
@@ -27,25 +27,6 @@ const maxActiveBufferSize = 1024 * 1024 * 64
 
 let activeBufferSize = 0
 
-/**
- * @param {string|URL|object} urlObjOrString
- * @returns {object}
- */
-function parseUrl (urlObjOrString) {
-  if (urlObjOrString !== null && typeof urlObjOrString === 'object') return urlToHttpOptions(urlObjOrString)
-
-  const url = urlToHttpOptions(new URL(urlObjOrString))
-
-  // Special handling if we're using named pipes on Windows
-  if (url.protocol === 'unix:' && url.hostname === '.') {
-    const udsPath = urlObjOrString.slice(5)
-    url.path = udsPath
-    url.pathname = udsPath
-  }
-
-  return url
-}
-
 /**
  * @param {string} hostname Host as resolved by {@link parseUrl}; IPv6 is unbracketed (`::1`).
  */

package/packages/dd-trace/src/exporters/common/url.js

@@ -0,0 +1,34 @@
+'use strict'
+
+const { urlToHttpOptions } = require('./url-to-http-options-polyfill')
+
+/**
+ * Convert an agent/intake URL into Node http(s) request options.
+ *
+ * A Windows named pipe (`unix://./pipe/<name>`) parses the `.` as the URL
+ * authority, dropping it from the path. Fold it back so the socket path stays
+ * `//./pipe/<name>`; otherwise it collapses to `/pipe/<name>` and misses the
+ * pipe. Exporters receive `config.url` as a URL object, so this must run for
+ * both string and object input.
+ *
+ * @param {string|URL|object} urlObjOrString
+ * @returns {object}
+ */
+function parseUrl (urlObjOrString) {
+  // `urlToHttpOptions` returns `pathname` at runtime, but @types/node narrows it
+  // to `ClientRequestArgs`, which omits it; cast so the named-pipe fold below can
+  // read and rewrite it.
+  const url = /** @type {import('node:http').ClientRequestArgs & { pathname: string }} */ (
+    urlObjOrString !== null && typeof urlObjOrString === 'object'
+      ? urlToHttpOptions(urlObjOrString)
+      : urlToHttpOptions(new URL(urlObjOrString))
+  )
+
+  if (url.protocol === 'unix:' && url.hostname === '.') {
+    url.path = url.pathname = `//.${url.pathname}`
+  }
+
+  return url
+}
+
+module.exports = { parseUrl }

package/packages/dd-trace/src/exporters/span-stats/writer.js

@@ -37,9 +37,7 @@ function makeRequest (data, url, cb) {
       'Datadog-Meta-Tracer-Version': pkg.version,
       'Content-Type': 'application/msgpack',
     },
-    protocol: url.protocol,
-    hostname: url.hostname,
-    port: url.port,
+    url,
   }
 
   log.debug('Request to the intake: %j', options)

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

@@ -14,11 +14,13 @@ function guard (fn) {
   var initBailout = false
   var clobberBailout = false
   var forced = isTrue(process.env.DD_INJECT_FORCE)
-  var engines = require('../../../../package.json').engines
-  var versions = engines.node.match(/^>=(\d+) <(\d+)$/)
+  var pkg = require('../../../../package.json')
+  var engines = pkg.engines
+  var versions = engines.node.match(/^>=(\d+)$/)
   var minMajor = versions[1]
-  var nextMajor = versions[2]
+  var nextMajor = pkg.nodeMaxMajor
   var version = process.versions.node
+  var supportedRange = engines.node + ' <' + nextMajor
 
   if (process.env.DD_INJECTION_ENABLED) {
     // If we're running via single-step install, and we're in the app's
@@ -45,16 +47,17 @@ function guard (fn) {
   // should not initialize the tracer.
   if (!clobberBailout && (NODE_MAJOR < minMajor || NODE_MAJOR >= nextMajor)) {
     initBailout = true
+    var runtimeInfo = 'Incompatible runtime Node.js ' + version + ', supported runtimes: Node.js ' + supportedRange
     telemetry([
       { name: 'abort', tags: ['reason:incompatible_runtime'] },
       { name: 'abort.runtime', tags: [] }
     ], undefined, {
       result: 'abort',
       result_class: 'incompatible_runtime',
-      result_reason: 'Incompatible runtime Node.js ' + version + ', supported runtimes: Node.js ' + engines.node
+      result_reason: runtimeInfo
     })
     log.info('Aborting application instrumentation due to incompatible_runtime.')
-    log.info('Found incompatible runtime Node.js %s, Supported runtimes: Node.js %s.', version, engines.node)
+    log.info('Found incompatible runtime Node.js %s, Supported runtimes: Node.js %s.', version, supportedRange)
     if (forced) {
       log.info('DD_INJECT_FORCE enabled, allowing unsupported runtimes and continuing.')
     }

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

@@ -1,14 +1,16 @@
 'use strict'
 
 const { getValueFromEnvSources } = require('./config/helper')
-const { isFalse } = require('./util')
 
 // Global `jest` is only present in Jest workers.
 const inJestWorker = typeof jest !== 'undefined'
 
-const ddTraceDisabled = getValueFromEnvSources('DD_TRACE_ENABLED')
-  ? isFalse(getValueFromEnvSources('DD_TRACE_ENABLED'))
-  : String(getValueFromEnvSources('OTEL_TRACES_EXPORTER')).toLowerCase() === 'none'
+// skipDefault: distinguish an unset DD_TRACE_ENABLED (fall back to the OTel signal) from an
+// explicit value; the registered default would otherwise mask the OTEL_TRACES_EXPORTER check.
+const ddTraceEnabled = getValueFromEnvSources('DD_TRACE_ENABLED', true)
+const ddTraceDisabled = ddTraceEnabled === undefined
+  ? getValueFromEnvSources('OTEL_TRACES_EXPORTER') === 'none'
+  : ddTraceEnabled === false
 
 module.exports = ddTraceDisabled || inJestWorker
   ? require('./noop/proxy')

package/packages/dd-trace/src/llmobs/constants/tags.js

@@ -14,6 +14,12 @@ module.exports = {
   PROPAGATED_PARENT_ID_KEY: '_dd.p.llmobs_parent_id',
   PROPAGATED_ML_APP_KEY: '_dd.p.llmobs_ml_app',
   PARENT_ID_KEY: '_ml_obs.llmobs_parent_id',
+  PROPAGATED_SAMPLE_RATE_KEY: '_dd.p.llmobs_sr',
+  PROPAGATED_SAMPLING_DECISION_KEY: '_dd.p.llmobs_sd',
+  SAMPLE_RATE: '_ml_obs.sample_rate',
+  SAMPLING_DECISION: '_ml_obs.sampling_decision',
+  SAMPLING_DECISION_SAMPLED: '1',
+  SAMPLING_DECISION_DROPPED: '0',
   TAGS: '_ml_obs.tags',
   NAME: '_ml_obs.name',
   TRACE_ID: '_ml_obs.trace_id',

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

@@ -9,6 +9,10 @@ const {
   ML_APP,
   PROPAGATED_ML_APP_KEY,
   PROPAGATED_PARENT_ID_KEY,
+  SAMPLE_RATE,
+  SAMPLING_DECISION,
+  PROPAGATED_SAMPLE_RATE_KEY,
+  PROPAGATED_SAMPLING_DECISION_KEY,
 } = require('./constants/tags')
 const { storage } = require('./storage')
 const telemetry = require('./telemetry')
@@ -68,7 +72,7 @@ function enable (config) {
   spanFinishCh.subscribe(handleSpanProcess)
 
   // distributed tracing for llmobs
-  injectCh.subscribe(handleLLMObsParentIdInjection)
+  injectCh.subscribe(handleLLMObsInjection)
 
   setAgentStrategy(config, useAgentless => {
     if (useAgentless && !(config.apiKey && config.site)) {
@@ -92,7 +96,7 @@ function disable () {
   if (evalMetricAppendCh.hasSubscribers) evalMetricAppendCh.unsubscribe(handleEvalMetricAppend)
   if (flushCh.hasSubscribers) flushCh.unsubscribe(handleFlush)
   if (spanFinishCh.hasSubscribers) spanFinishCh.unsubscribe(handleSpanProcess)
-  if (injectCh.hasSubscribers) injectCh.unsubscribe(handleLLMObsParentIdInjection)
+  if (injectCh.hasSubscribers) injectCh.unsubscribe(handleLLMObsInjection)
   if (registerUserSpanProcessorCh.hasSubscribers) registerUserSpanProcessorCh.unsubscribe(handleRegisterProcessor)
 
   spanWriter?.destroy()
@@ -106,8 +110,8 @@ function disable () {
 }
 
 // since LLMObs traces can extend between services and be the same trace,
-// we need to propagate the parent id and mlApp.
-function handleLLMObsParentIdInjection ({ carrier }) {
+// we need to propagate the parent id, mlApp, and sampling rate/decision.
+function handleLLMObsInjection ({ carrier }) {
   // Respect the standard propagator's gate: when trace tag propagation is
   // disabled, don't write `x-datadog-tags` for LLMObs either.
   if (globalTracerConfig.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) return
@@ -122,7 +126,12 @@ function handleLLMObsParentIdInjection ({ carrier }) {
     parentContext?._trace?.tags?.[PROPAGATED_ML_APP_KEY] ||
     globalTracerConfig.llmobs.mlApp
 
-  if (!parentId && !mlApp) return
+  const sampleRate =
+    mlObsSpanTags?.[SAMPLE_RATE] ?? parentContext?._trace?.tags?.[PROPAGATED_SAMPLE_RATE_KEY]
+  const samplingDecision =
+    mlObsSpanTags?.[SAMPLING_DECISION] ?? parentContext?._trace?.tags?.[PROPAGATED_SAMPLING_DECISION_KEY]
+
+  if (!parentId && !mlApp && samplingDecision == null) return
 
   // `_injectTags` only writes `x-datadog-tags` when the trace has `_dd.p.*`
   // tags, so it may be undefined here — coalesce before appending.
@@ -130,6 +139,8 @@ function handleLLMObsParentIdInjection ({ carrier }) {
   let tags = existing || ''
   if (parentId) tags += `${tags ? ',' : ''}${PROPAGATED_PARENT_ID_KEY}=${parentId}`
   if (mlApp) tags += `${tags ? ',' : ''}${PROPAGATED_ML_APP_KEY}=${mlApp}`
+  if (sampleRate != null) tags += `${tags ? ',' : ''}${PROPAGATED_SAMPLE_RATE_KEY}=${sampleRate}`
+  if (samplingDecision != null) tags += `${tags ? ',' : ''}${PROPAGATED_SAMPLING_DECISION_KEY}=${samplingDecision}`
   if (tags !== existing) carrier['x-datadog-tags'] = tags
 }
 

package/packages/dd-trace/src/llmobs/plugins/genai/util.js

@@ -114,7 +114,7 @@ function extractMetrics (response) {
   }
 
   const totalTokens = tokenUsage.totalTokenCount ||
-                     (tokenUsage.promptTokenCount || 0) + (tokenUsage.candidatesTokenCount || 0)
+                    (tokenUsage.promptTokenCount || 0) + (tokenUsage.candidatesTokenCount || 0)
   if (totalTokens) {
     metrics.totalTokens = totalTokens
   }
@@ -458,8 +458,8 @@ function formatStreamingOutput (response) {
 
     // Skip special cases in streaming (handle them as non-streaming)
     if (content.parts.some(part => part.functionCall ||
-                                   part.executableCode ||
-                                   part.codeExecutionResult)) {
+                                  part.executableCode ||
+                                  part.codeExecutionResult)) {
       messages.push(...formatNonStreamingCandidate(candidate))
       continue
     }

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

@@ -9,7 +9,11 @@ const ANTHROPIC_PROVIDER_NAME = 'anthropic'
 const BEDROCK_PROVIDER_NAME = 'amazon_bedrock'
 const OPENAI_PROVIDER_NAME = 'openai'
 
-const SUPPORTED_INTEGRATIONS = new Set(['openai'])
+// Providers that ship their own LLMObs integration. When one of these is also
+// enabled, the LangChain model span is demoted to `workflow` so the provider
+// integration emits the single `llm` span — avoiding two llm spans (and
+// double-counted tokens/cost) for one underlying call.
+const SUPPORTED_INTEGRATIONS = new Set(['openai', 'anthropic'])
 const LLM_SPAN_TYPES = new Set(['llm', 'chat_model', 'embedding'])
 const LLM = 'llm'
 const WORKFLOW = 'workflow'