dd-trace 5.109.0 → 5.111.0

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/agent/index.js

@@ -13,7 +13,7 @@ class AgentExporter {
     this._url = config.url
 
     const headers = {}
-    if (stats.enabled || apmTracingEnabled === false) {
+    if (stats.DD_TRACE_STATS_COMPUTATION_ENABLED || apmTracingEnabled === false) {
       headers['Datadog-Client-Computed-Stats'] = 'yes'
     }
 

package/packages/dd-trace/src/exporters/agentless/writer.js

@@ -40,7 +40,7 @@ class AgentlessWriter extends BaseWriter {
       }
     }
 
-    if (!getConfig().apiKey) {
+    if (!getConfig().DD_API_KEY) {
       this.#apiKeyMissing = true
       log.error('DD_API_KEY is required for agentless trace intake. Set DD_API_KEY. Traces will not be sent.')
     }
@@ -109,8 +109,8 @@ class AgentlessWriter extends BaseWriter {
       return
     }
 
-    const apiKey = getConfig().apiKey
-    if (!apiKey) {
+    const { DD_API_KEY } = getConfig()
+    if (!DD_API_KEY) {
       if (!this.#apiKeyMissing) {
         this.#apiKeyMissing = true
         log.error('DD_API_KEY is required for agentless trace intake. Set DD_API_KEY. Traces will not be sent.')
@@ -126,7 +126,7 @@ class AgentlessWriter extends BaseWriter {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
-        'dd-api-key': apiKey,
+        'dd-api-key': DD_API_KEY,
         'X-Datadog-Trace-Count': String(count),
         'Datadog-Meta-Lang': 'nodejs',
         'Datadog-Meta-Lang-Version': process.version,

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,10 +72,10 @@ 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)) {
+    if (useAgentless && !(config.DD_API_KEY && config.site)) {
       if (DD_MAJOR < 6 || !config?.startupLogs) {
         // eslint-disable-next-line no-console
         console.error(INCOMPATIBLE_INITIALIZATION)
@@ -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/base.js

@@ -25,7 +25,7 @@ class LLMObsPlugin extends TracingPlugin {
   start (ctx) {
     // even though llmobs span events won't be enqueued if llmobs is disabled
     // we should avoid doing any computations here (these listeners aren't disabled)
-    const enabled = this._tracerConfig.llmobs.enabled
+    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
     if (!enabled) return
 
     const parentStore = llmobsStorage.getStore()
@@ -52,7 +52,7 @@ class LLMObsPlugin extends TracingPlugin {
   }
 
   end (ctx) {
-    const enabled = this._tracerConfig.llmobs.enabled
+    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
     if (!enabled) return
 
     // only attempt to restore the context if the current span was an LLMObs span
@@ -67,7 +67,7 @@ class LLMObsPlugin extends TracingPlugin {
   asyncEnd (ctx) {
     // even though llmobs span events won't be enqueued if llmobs is disabled
     // we should avoid doing any computations here (these listeners aren't disabled)
-    const enabled = this._tracerConfig.llmobs.enabled
+    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
     if (!enabled) return
 
     const apmStore = ctx.currentStore
@@ -85,7 +85,7 @@ class LLMObsPlugin extends TracingPlugin {
 
   configure (config) {
     // we do not want to enable any LLMObs plugins if it is disabled on the tracer
-    const llmobsEnabled = this._tracerConfig.llmobs.enabled
+    const llmobsEnabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
     if (llmobsEnabled === false) {
       config = typeof config === 'boolean' ? false : { ...config, enabled: false } // override to false
     }

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'

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

@@ -14,7 +14,7 @@ class PregelStreamLLMObsPlugin extends LLMObsPlugin {
   getLLMObsSpanRegisterOptions (ctx) {
     const name = ctx.self.name || 'LangGraph'
 
-    const enabled = this._tracerConfig.llmobs.enabled
+    const enabled = this._tracerConfig.llmobs.DD_LLMOBS_ENABLED
     if (!enabled) return
 
     const span = ctx.currentStore?.span

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

@@ -2,7 +2,7 @@
 
 const { channel } = require('dc-polyfill')
 
-const { isError, isTrue } = require('../util')
+const { isError } = require('../util')
 const tracerVersion = require('../../../../package.json').version
 const logger = require('../log')
 const { getValueFromEnvSources } = require('../config/helper')
@@ -49,7 +49,7 @@ class LLMObs extends NoopLLMObs {
   }
 
   get enabled () {
-    return this._config.llmobs.enabled ?? false
+    return this._config.llmobs.DD_LLMOBS_ENABLED ?? false
   }
 
   enable (options = {}) {
@@ -65,15 +65,17 @@ class LLMObs extends NoopLLMObs {
 
     logger.debug('Enabling LLMObs')
 
-    const DD_LLMOBS_ENABLED = getValueFromEnvSources('DD_LLMOBS_ENABLED')
+    // skipDefault: only an explicit DD_LLMOBS_ENABLED=false blocks enable(); an unset value
+    // (its default is false) must still allow this programmatic opt-in.
+    const DD_LLMOBS_ENABLED = getValueFromEnvSources('DD_LLMOBS_ENABLED', true)
 
-    if (DD_LLMOBS_ENABLED != null && !isTrue(DD_LLMOBS_ENABLED)) {
+    if (DD_LLMOBS_ENABLED === false) {
       logger.debug('LLMObs.enable() called when DD_LLMOBS_ENABLED is false. No action taken.')
       return
     }
 
     // TODO: These configs should be passed through directly at construction time instead.
-    this._config.llmobs.enabled = true
+    this._config.llmobs.DD_LLMOBS_ENABLED = true
     this._config.llmobs.mlApp = options.mlApp
     this._config.llmobs.agentlessEnabled = options.agentlessEnabled
 
@@ -94,7 +96,7 @@ class LLMObs extends NoopLLMObs {
 
     logger.debug('Disabling LLMObs')
 
-    this._config.llmobs.enabled = false
+    this._config.llmobs.DD_LLMOBS_ENABLED = false
 
     // disable writers and channel subscribers
     this._llmobsModule.disable()

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

@@ -33,6 +33,8 @@ const {
   ROUTING_API_KEY,
   ROUTING_SITE,
   LLMOBS_SUBMITTED_TAG_KEY,
+  SAMPLE_RATE,
+  SAMPLING_DECISION,
 } = require('./constants/tags')
 const { UNSERIALIZABLE_VALUE_TEXT } = require('./constants/text')
 const telemetry = require('./telemetry')
@@ -81,7 +83,7 @@ class LLMObsSpanProcessor {
 
   // TODO: instead of relying on the tagger's weakmap registry, can we use some namespaced storage correlation?
   process (span) {
-    if (!this.#config.llmobs.enabled) return
+    if (!this.#config.llmobs.DD_LLMOBS_ENABLED) return
     // if the span is not in our private tagger map, it is not an llmobs span
     if (!LLMObsTagger.tagMap.has(span)) return
 
@@ -248,6 +250,8 @@ class LLMObsSpanProcessor {
       _dd: {
         span_id: span.context().toSpanId(),
         trace_id: span.context().toTraceId(true),
+        sample_rate: mlObsTags[SAMPLE_RATE],
+        sampling_decision: mlObsTags[SAMPLING_DECISION],
       },
     }