dd-trace 5.82.0 → 5.84.0

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

@@ -3,10 +3,8 @@
 const logger = require('../../log')
 const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/writers')
 const telemetry = require('../telemetry')
-
-const AgentInfoExporter = require('../../exporters/common/agent-info-exporter')
-/** @type {AgentInfoExporter} */
-let agentInfoExporter
+const { fetchAgentInfo } = require('../../agent/info')
+const { getAgentUrl } = require('../../agent/url')
 
 function setAgentStrategy (config, setWritersAgentlessValue) {
   const agentlessEnabled = config.llmobs.agentlessEnabled
@@ -16,11 +14,7 @@ function setAgentStrategy (config, setWritersAgentlessValue) {
     return
   }
 
-  if (!agentInfoExporter) {
-    agentInfoExporter = new AgentInfoExporter(config)
-  }
-
-  agentInfoExporter.getAgentInfo((err, agentInfo) => {
+  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
     if (err) {
       setWritersAgentlessValue(true)
       return

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

@@ -1,7 +1,7 @@
 'use strict'
 const { inspect } = require('util')
 const { isTrue } = require('../util')
-const { getEnvironmentVariable } = require('../config-helper')
+const { getValueFromEnvSources } = require('../config/helper')
 const { traceChannel, debugChannel, infoChannel, warnChannel, errorChannel } = require('./channels')
 const logWriter = require('./writer')
 const { Log, LogConfig, NoTransmitError } = require('./log')
@@ -31,31 +31,31 @@ const log = {
   use (logger) {
     config.logger = logger
     logWriter.use(logger)
-    return this
+    return log
   },
 
   toggle (enabled, logLevel) {
     config.enabled = enabled
     config.logLevel = logLevel
     logWriter.toggle(enabled, logLevel)
-    return this
+    return log
   },
 
   reset () {
     logWriter.reset()
-    this._deprecate = memoize((code, message) => {
-      errorChannel.publish(Log.parse(message))
+    log._deprecate = memoize((code, message) => {
+      publishFormatted(errorChannel, null, message)
       return true
     })
 
-    return this
+    return log
   },
 
   trace (...args) {
     if (traceChannel.hasSubscribers) {
       const logRecord = {}
 
-      Error.captureStackTrace(logRecord, this.trace)
+      Error.captureStackTrace(logRecord, log.trace)
 
       const stack = logRecord.stack.split('\n')
       const fn = stack[1].replace(/^\s+at ([^\s]+) .+/, '$1')
@@ -64,56 +64,53 @@ const log = {
 
       stack[0] = `Trace: ${fn}(${params})`
 
-      traceChannel.publish(Log.parse(stack.join('\n')))
+      publishFormatted(traceChannel, null, stack.join('\n'))
     }
-    return this
+    return log
   },
 
   debug (...args) {
-    if (debugChannel.hasSubscribers) {
-      debugChannel.publish(Log.parse(...args))
-    }
-    return this
+    publishFormatted(debugChannel, null, ...args)
+    return log
   },
 
   info (...args) {
-    if (infoChannel.hasSubscribers) {
-      infoChannel.publish(Log.parse(...args))
-    }
-    return this
+    publishFormatted(infoChannel, null, ...args)
+    return log
   },
 
   warn (...args) {
-    if (warnChannel.hasSubscribers) {
-      warnChannel.publish(Log.parse(...args))
-    }
-    return this
+    publishFormatted(warnChannel, null, ...args)
+    return log
   },
 
   error (...args) {
-    if (errorChannel.hasSubscribers) {
-      errorChannel.publish(Log.parse(...args))
-    }
-    return this
+    publishFormatted(errorChannel, formatted => {
+      const stackTraceLimitBackup = Error.stackTraceLimit
+      Error.stackTraceLimit = 0
+      const newError = new Error(formatted)
+      Error.stackTraceLimit = stackTraceLimitBackup
+      Error.captureStackTrace(newError, log.error)
+      return newError
+    }, ...args)
+    return log
   },
 
   errorWithoutTelemetry (...args) {
     args.push(NO_TRANSMIT)
-    if (errorChannel.hasSubscribers) {
-      errorChannel.publish(Log.parse(...args))
-    }
-    return this
+    publishFormatted(errorChannel, null, ...args)
+    return log
   },
 
   deprecate (code, message) {
-    return this._deprecate(code, message)
+    return log._deprecate(code, message)
   },
 
   isEnabled (fleetStableConfigValue, localStableConfigValue) {
     return isTrue(
       fleetStableConfigValue ??
-      getEnvironmentVariable('DD_TRACE_DEBUG') ??
-      (getEnvironmentVariable('OTEL_LOG_LEVEL') === 'debug' || undefined) ??
+      getValueFromEnvSources('DD_TRACE_DEBUG') ??
+      (getValueFromEnvSources('OTEL_LOG_LEVEL') === 'debug' || undefined) ??
       localStableConfigValue ??
       config.enabled
     )
@@ -126,14 +123,32 @@ const log = {
   ) {
     return optionsValue ??
       fleetStableConfigValue ??
-      getEnvironmentVariable('DD_TRACE_LOG_LEVEL') ??
-      getEnvironmentVariable('OTEL_LOG_LEVEL') ??
+      getValueFromEnvSources('DD_TRACE_LOG_LEVEL') ??
+      getValueFromEnvSources('OTEL_LOG_LEVEL') ??
       localStableConfigValue ??
       config.logLevel
   }
 }
 
-logWriter.setStackTraceLimitFunction(log.error)
+function publishFormatted (ch, formatter, ...args) {
+  if (ch.hasSubscribers) {
+    const log = Log.parse(...args)
+    const { formatted, cause } = getErrorLog(log)
+
+    // calling twice ch.publish() because Error cause is only available in Node.js v16.9.0
+    // TODO: replace it with Error(message, { cause }) when cause has broad support
+    if (formatted) ch.publish(formatter?.(formatted) || formatted)
+    if (cause) ch.publish(cause)
+  }
+}
+
+function getErrorLog (err) {
+  if (typeof err?.delegate === 'function') {
+    const result = err.delegate()
+    return Array.isArray(result) ? Log.parse(...result) : Log.parse(result)
+  }
+  return err
+}
 
 log.reset()
 

package/packages/dd-trace/src/log/writer.js

@@ -2,7 +2,6 @@
 
 const { storage } = require('../../../datadog-core')
 const { LogChannel } = require('./channels')
-const { Log } = require('./log')
 const defaultLogger = {
   debug: msg => console.debug(msg), /* eslint-disable-line no-console */
   info: msg => console.info(msg), /* eslint-disable-line no-console */
@@ -13,7 +12,6 @@ const defaultLogger = {
 let enabled = false
 let logger = defaultLogger
 let logChannel = new LogChannel()
-let stackTraceLimitFunction = onError
 
 function withNoop (fn) {
   const store = storage('legacy').getStore()
@@ -24,7 +22,7 @@ function withNoop (fn) {
 }
 
 function unsubscribeAll () {
-  logChannel.unsubscribe({ trace: onTrace, debug: onDebug, info: onInfo, warn: onWarn, error: onError })
+  logChannel.unsubscribe({ trace, debug, info, warn, error })
 }
 
 function toggleSubscription (enable, level) {
@@ -32,7 +30,7 @@ function toggleSubscription (enable, level) {
 
   if (enable) {
     logChannel = new LogChannel(level)
-    logChannel.subscribe({ trace: onTrace, debug: onDebug, info: onInfo, warn: onWarn, error: onError })
+    logChannel.subscribe({ trace, debug, info, warn, error })
   }
 }
 
@@ -53,89 +51,26 @@ function reset () {
   toggleSubscription(false)
 }
 
-function getErrorLog (err) {
-  if (typeof err?.delegate === 'function') {
-    const result = err.delegate()
-    return Array.isArray(result) ? Log.parse(...result) : Log.parse(result)
-  }
-  return err
-}
-
-function setStackTraceLimitFunction (fn) {
-  if (typeof fn !== 'function') {
-    throw new TypeError('stackTraceLimitFunction must be a function')
-  }
-  stackTraceLimitFunction = fn
-}
-
-function onError (err) {
-  const { formatted, cause } = getErrorLog(err)
-
-  // calling twice logger.error() because Error cause is only available in Node.js v16.9.0
-  // TODO: replace it with Error(message, { cause }) when cause has broad support
-  if (formatted) {
-    withNoop(() => {
-      const stackTraceLimitBackup = Error.stackTraceLimit
-      Error.stackTraceLimit = 0
-      const newError = new Error(formatted)
-      Error.stackTraceLimit = stackTraceLimitBackup
-      Error.captureStackTrace(newError, stackTraceLimitFunction)
-      logger.error(newError)
-    })
-  }
-  if (cause) withNoop(() => logger.error(cause))
+function error (err) {
+  withNoop(() => logger.error(err))
 }
 
-function onWarn (log) {
-  const { formatted, cause } = getErrorLog(log)
-  if (formatted) withNoop(() => logger.warn(formatted))
-  if (cause) withNoop(() => logger.warn(cause))
+function warn (log) {
+  withNoop(() => logger.warn ? logger.warn(log) : logger.debug(log))
 }
 
-function onInfo (log) {
-  const { formatted, cause } = getErrorLog(log)
-  if (formatted) withNoop(() => logger.info(formatted))
-  if (cause) withNoop(() => logger.info(cause))
+function info (log) {
+  withNoop(() => logger.info ? logger.info(log) : logger.debug(log))
 }
 
-function onDebug (log) {
-  const { formatted, cause } = getErrorLog(log)
-  if (formatted) withNoop(() => logger.debug(formatted))
-  if (cause) withNoop(() => logger.debug(cause))
+function debug (log) {
+  withNoop(() => logger.debug(log))
 }
 
-function onTrace (log) {
-  const { formatted, cause } = getErrorLog(log)
+function trace (log) {
   // Using logger.debug() because not all loggers have trace level,
   // and console.trace() has a completely different meaning.
-  if (formatted) withNoop(() => logger.debug(formatted))
-  if (cause) withNoop(() => logger.debug(cause))
-}
-
-function error (...args) {
-  onError(Log.parse(...args))
-}
-
-function warn (...args) {
-  const log = Log.parse(...args)
-  if (!logger.warn) return onDebug(log)
-
-  onWarn(log)
-}
-
-function info (...args) {
-  const log = Log.parse(...args)
-  if (!logger.info) return onDebug(log)
-
-  onInfo(log)
-}
-
-function debug (...args) {
-  onDebug(Log.parse(...args))
-}
-
-function trace (...args) {
-  onTrace(Log.parse(...args))
+  withNoop(() => logger.debug(log))
 }
 
-module.exports = { use, toggle, reset, error, warn, info, debug, trace, setStackTraceLimitFunction }
+module.exports = { use, toggle, reset, error, warn, info, debug, trace }

package/packages/dd-trace/src/noop/proxy.js

@@ -23,10 +23,10 @@ class NoopProxy {
     this.llmobs = noopLLMObs
     this.openfeature = noopOpenFeatureProvider
     this.aiguard = noopAIGuard
-    this.setBaggageItem = () => {}
-    this.getBaggageItem = () => {}
+    this.setBaggageItem = (key, value) => {}
+    this.getBaggageItem = (key) => {}
     this.getAllBaggageItems = () => {}
-    this.removeBaggageItem = () => {}
+    this.removeBaggageItem = (keyToRemove) => {}
     this.removeAllBaggageItems = () => {}
   }
 

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

@@ -1,8 +1,8 @@
 'use strict'
 
-const { URL, format } = require('node:url')
 const request = require('../../exporters/common/request')
 const { safeJSONStringify } = require('../../exporters/common/util')
+const { getAgentUrl } = require('../../agent/url')
 
 const log = require('../../log')
 
@@ -23,6 +23,7 @@ const log = require('../../log')
  * @class BaseFFEWriter
  */
 class BaseFFEWriter {
+  #destroyer
   /**
    * @param {BaseFFEWriterOptions} options - Writer configuration options
    */
@@ -56,12 +57,10 @@ class BaseFFEWriter {
       this.flush()
     }, this._interval).unref()
 
-    this._beforeExitHandler = () => {
-      this.destroy()
-    }
-    process.once('beforeExit', this._beforeExitHandler)
+    const destroyer = this.destroy.bind(this)
+    globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(destroyer)
 
-    this._destroyed = false
+    this.#destroyer = destroyer
     this._droppedEvents = 0
   }
 
@@ -141,12 +140,12 @@ class BaseFFEWriter {
    * Cleans up resources and flushes remaining events
    */
   destroy () {
-    if (!this._destroyed) {
+    if (this.#destroyer) {
       log.debug(() => `Stopping ${this.constructor.name}`)
       clearInterval(this._periodic)
-      process.removeListener('beforeExit', this._beforeExitHandler)
       this.flush()
-      this._destroyed = true
+      globalThis[Symbol.for('dd-trace')].beforeExitHandlers.delete(this.#destroyer)
+      this.#destroyer = undefined
 
       if (this._droppedEvents > 0) {
         log.warn(`${this.constructor.name} dropped ${this._droppedEvents} events due to buffer overflow`)
@@ -159,13 +158,7 @@ class BaseFFEWriter {
    * @returns {URL} Constructs agent URL from config
    */
   _getAgentUrl () {
-    const { hostname, port } = this._config
-
-    return this._config.url ?? new URL(format({
-      protocol: 'http:',
-      hostname: hostname || 'localhost',
-      port: port || 8126
-    }))
+    return getAgentUrl(this._config)
   }
 
   /**

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

@@ -2,9 +2,8 @@
 
 const logger = require('../../log')
 const { EVP_PROXY_AGENT_BASE_PATH } = require('../constants/constants')
-
-const AgentInfoExporter = require('../../exporters/common/agent-info-exporter')
-let agentInfoExporter
+const { fetchAgentInfo } = require('../../agent/info')
+const { getAgentUrl } = require('../../agent/url')
 
 /**
  * Determines if the agent supports EVP proxy and sets the writer enabled state accordingly
@@ -12,11 +11,7 @@ let agentInfoExporter
  * @param {Function} setWriterEnabledValue - Callback to set the writer enabled state
  */
 function setAgentStrategy (config, setWriterEnabledValue) {
-  if (!agentInfoExporter) {
-    agentInfoExporter = new AgentInfoExporter(config)
-  }
-
-  agentInfoExporter.getAgentInfo((err, agentInfo) => {
+  fetchAgentInfo(getAgentUrl(config), (err, agentInfo) => {
     if (err) {
       logger.debug('FFE Writer disabled - error getting agent info:', err.message)
       setWriterEnabledValue(false)

package/packages/dd-trace/src/opentelemetry/otlp/otlp_http_exporter_base.js

@@ -90,7 +90,7 @@ class OtlpHttpExporterBase {
         data += chunk
       })
 
-      res.on('end', () => {
+      res.once('end', () => {
         if (res.statusCode >= 200 && res.statusCode < 300) {
           resultCallback({ code: 0 })
         } else {
@@ -105,7 +105,7 @@ class OtlpHttpExporterBase {
       resultCallback({ code: 1, error })
     })
 
-    req.on('timeout', () => {
+    req.once('timeout', () => {
       req.destroy()
       const error = new Error('Request timeout')
       resultCallback({ code: 1, error })

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

@@ -5,12 +5,48 @@ const { sanitizeAttributes } = require('../../../../vendor/dist/@opentelemetry/c
 
 const id = require('../id')
 const log = require('../log')
+const DatadogSpanContext = require('../opentracing/span_context')
 const TextMapPropagator = require('../opentracing/propagation/text_map')
 const TraceState = require('../opentracing/propagation/tracestate')
 const SpanContext = require('./span_context')
 const Span = require('./span')
 const Sampler = require('./sampler')
 
+function normalizeLinkContext (context) {
+  if (!context) return
+
+  // OTel API bridge SpanContext wrapper
+  if (context._ddContext) return context._ddContext
+
+  // Datadog span context
+  if (typeof context.toTraceId === 'function' && typeof context.toSpanId === 'function') {
+    return context
+  }
+
+  // Standard OTel SpanContext (traceId/spanId)
+  if (typeof context.traceId !== 'string' || typeof context.spanId !== 'string') {
+    // Invalid
+    return
+  }
+
+  let sampling
+  if (typeof context.traceFlags === 'number') {
+    sampling = { priority: context.traceFlags & 1 }
+  }
+
+  let tracestate
+  if (context.traceState?.serialize) {
+    tracestate = TraceState.fromString(context.traceState.serialize())
+  }
+
+  return new DatadogSpanContext({
+    traceId: id(context.traceId, 16),
+    spanId: id(context.spanId, 16),
+    sampling,
+    tracestate
+  })
+}
+
 class Tracer {
   constructor (library, config, tracerProvider) {
     this._sampler = new Sampler()
@@ -96,7 +132,7 @@ class Tracer {
       context = api.trace.deleteSpan(context)
     }
     const parentSpan = api.trace.getSpan(context)
-    const parentSpanContext = parentSpan && parentSpan.spanContext()
+    const parentSpanContext = parentSpan?.spanContext()
     let spanContext
     if (parentSpanContext && api.trace.isSpanContextValid(parentSpanContext)) {
       spanContext = parentSpanContext._ddContext
@@ -107,12 +143,18 @@ class Tracer {
     }
 
     const spanKind = options.kind || api.SpanKind.INTERNAL
-    const links = (options.links || []).map(link => {
-      return {
-        context: link.context,
-        attributes: sanitizeAttributes(link.attributes)
+    const links = []
+    if (options.links?.length) {
+      for (const link of options.links) {
+        const ddContext = normalizeLinkContext(link?.context)
+        if (!ddContext) continue
+
+        links.push({
+          context: ddContext,
+          attributes: sanitizeAttributes(link.attributes)
+        })
       }
-    })
+    }
     const attributes = sanitizeAttributes(options.attributes)
 
     // TODO: sampling API is not yet supported

package/packages/dd-trace/src/opentracing/propagation/text_map.js

@@ -34,11 +34,19 @@ const b3HeaderKey = 'b3'
 const sqsdHeaderHey = 'x-aws-sqsd-attr-_datadog'
 const b3HeaderExpr = /^(([0-9a-f]{16}){1,2}-[0-9a-f]{16}(-[01d](-[0-9a-f]{16})?)?|[01d])$/i
 const baggageExpr = new RegExp(`^${baggagePrefix}(.+)$`)
+// W3C Baggage key grammar: key = token (RFC 7230).
+// Spec (up-to-date): "Propagation format for distributed context: Baggage" §3.3.1
+// https://www.w3.org/TR/baggage/#header-content
+// https://www.rfc-editor.org/rfc/rfc7230#section-3.2.6
+const baggageTokenExpr = /^[!#$%&'*+\-.^_`|~0-9A-Za-z]+$/
 const tagKeyExpr = /^_dd\.p\.[\x21-\x2B\x2D-\x7E]+$/ // ASCII minus spaces and commas
 const tagValueExpr = /^[\x20-\x2B\x2D-\x7E]*$/ // ASCII minus commas
 // RFC7230 token (used by HTTP header field-name) and compatible with Node's header name validation.
 // See https://www.rfc-editor.org/rfc/rfc7230#section-3.2.6
 const httpHeaderNameExpr = /^[0-9A-Za-z!#$%&'*+\-.^_`|~]+$/
+// Compatible with Node's internal header value validation (allows HTAB, SP-~, and \x80-\xFF only)
+// https://github.com/nodejs/node/blob/main/lib/_http_common.js
+const invalidHeaderValueCharExpr = /[^\t\x20-\x7E\x80-\xFF]/
 const traceparentExpr = /^([a-f0-9]{2})-([a-f0-9]{32})-([a-f0-9]{16})-([a-f0-9]{2})(-.*)?$/i
 const traceparentKey = 'traceparent'
 const tracestateKey = 'tracestate'
@@ -124,13 +132,6 @@ class TextMapPropagator {
     }
   }
 
-  _encodeOtelBaggageKey (key) {
-    let encoded = encodeURIComponent(key)
-    encoded = encoded.replaceAll('(', '%28')
-    encoded = encoded.replaceAll(')', '%29')
-    return encoded
-  }
-
   _injectBaggageItems (spanContext, carrier) {
     if (this._config.legacyBaggageEnabled) {
       const baggageItems = spanContext?._baggageItems
@@ -145,7 +146,12 @@ class TextMapPropagator {
             continue
           }
 
-          carrier[headerName] = String(baggageItems[key])
+          let headerValue = String(baggageItems[key])
+          // Avoid Node throwing ERR_INVALID_CHAR when setting header values (e.g. newline from decoded OTEL baggage).
+          if (invalidHeaderValueCharExpr.test(headerValue)) {
+            headerValue = encodeURIComponent(headerValue)
+          }
+          carrier[headerName] = headerValue
         }
       }
     }
@@ -157,7 +163,13 @@ class TextMapPropagator {
       const baggageItems = getAllBaggageItems()
       if (!baggageItems) return
       for (const [key, value] of Object.entries(baggageItems)) {
-        const item = `${this._encodeOtelBaggageKey(String(key).trim())}=${encodeURIComponent(String(value).trim())},`
+        const baggageKey = String(key).trim()
+        if (!baggageKey || !baggageTokenExpr.test(baggageKey)) continue
+
+        // Do not trim values. If callers include leading/trailing whitespace, it must be percent-encoded.
+        // W3C list-member allows optional properties after ';'.
+        // https://www.w3.org/TR/baggage/#header-content
+        const item = `${baggageKey}=${encodeURIComponent(String(value))},`
         itemCounter += 1
         byteCounter += Buffer.byteLength(item)
 
@@ -640,13 +652,6 @@ class TextMapPropagator {
     }
   }
 
-  _decodeOtelBaggageKey (key) {
-    let decoded = decodeURIComponent(key)
-    decoded = decoded.replaceAll('%28', '(')
-    decoded = decoded.replaceAll('%29', ')')
-    return decoded
-  }
-
   _extractLegacyBaggageItems (carrier, spanContext) {
     if (this._config.legacyBaggageEnabled) {
       Object.keys(carrier).forEach(key => {
@@ -668,19 +673,38 @@ class TextMapPropagator {
       ? undefined
       : new Set(this._config.baggageTagKeys.split(','))
     for (const keyValue of baggages) {
-      if (!keyValue.includes('=')) {
+      if (!keyValue) continue
+
+      // Per W3C baggage, list-members can contain optional properties after `;`.
+      // Example: key=value;prop=1;prop2
+      // https://www.w3.org/TR/baggage/#header-content
+      const semicolonIdx = keyValue.indexOf(';')
+      const member = (semicolonIdx === -1 ? keyValue : keyValue.slice(0, semicolonIdx)).trim()
+      if (!member) continue
+
+      const eqIdx = member.indexOf('=')
+      if (eqIdx === -1) {
         tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
         removeAllBaggageItems()
         return
       }
-      let [key, value] = keyValue.split('=')
-      key = this._decodeOtelBaggageKey(key.trim())
-      value = decodeURIComponent(value.trim())
-      if (!key || !value) {
+
+      const key = member.slice(0, eqIdx).trim()
+      let value = member.slice(eqIdx + 1).trim()
+
+      if (!baggageTokenExpr.test(key) || !value) {
         tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
         removeAllBaggageItems()
         return
       }
+      try {
+        value = decodeURIComponent(value)
+      } catch {
+        tracerMetrics.count('context_header_style.malformed', ['header_style:baggage']).inc()
+        removeAllBaggageItems()
+        return
+      }
+
       if (spanContext && (tagAllKeys || keysToSpanTag?.has(key))) {
         spanContext._trace.tags['baggage.' + key] = value
       }

package/packages/dd-trace/src/opentracing/span.js

@@ -12,18 +12,18 @@ const runtimeMetrics = require('../runtime_metrics')
 const log = require('../log')
 const { storage } = require('../../../datadog-core')
 const telemetryMetrics = require('../telemetry/metrics')
-const { getEnvironmentVariable } = require('../config-helper')
+const { getValueFromEnvSources } = require('../config/helper')
 const SpanContext = require('./span_context')
 
 const tracerMetrics = telemetryMetrics.manager.namespace('tracers')
 
-const DD_TRACE_EXPERIMENTAL_STATE_TRACKING = getEnvironmentVariable('DD_TRACE_EXPERIMENTAL_STATE_TRACKING')
-const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = getEnvironmentVariable('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS')
+const DD_TRACE_EXPERIMENTAL_STATE_TRACKING = getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_STATE_TRACKING')
+const DD_TRACE_EXPERIMENTAL_SPAN_COUNTS = getValueFromEnvSources('DD_TRACE_EXPERIMENTAL_SPAN_COUNTS')
 
 const unfinishedRegistry = createRegistry('unfinished')
 const finishedRegistry = createRegistry('finished')
 
-const OTEL_ENABLED = !!getEnvironmentVariable('DD_TRACE_OTEL_ENABLED')
+const OTEL_ENABLED = !!getValueFromEnvSources('DD_TRACE_OTEL_ENABLED')
 const ALLOWED = new Set(['string', 'number', 'boolean'])
 
 const integrationCounters = {