dd-trace 5.82.0 → 5.83.0

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

@@ -3,7 +3,7 @@
 const { URL, format } = require('node:url')
 const path = require('node:path')
 const request = require('../../exporters/common/request')
-const { getEnvironmentVariable } = require('../../config-helper')
+const { getEnvironmentVariable } = require('../../config/helper')
 
 const logger = require('../../log')
 
@@ -16,85 +16,163 @@ const {
 } = require('../constants/writers')
 const { parseResponseAndLog } = require('./util')
 
+class LLMObsBuffer {
+  constructor ({ events, size, routing = {}, isDefault = false, limit = 1000 }) {
+    this.events = events
+    this.size = size
+    this.routing = routing
+    this.isDefault = isDefault
+    this.limit = limit
+  }
+
+  clear () {
+    this.events = []
+    this.size = 0
+  }
+}
+
 class BaseLLMObsWriter {
+  #destroyer
+  /** @type {Map<string, LLMObsBuffer>} */
+  #multiTenantBuffers = new Map()
+
   constructor ({ interval, timeout, eventType, config, endpoint, intake }) {
     this._interval = interval ?? getEnvironmentVariable('_DD_LLMOBS_FLUSH_INTERVAL') ?? 1000 // 1s
     this._timeout = timeout ?? getEnvironmentVariable('_DD_LLMOBS_TIMEOUT') ?? 5000 // 5s
     this._eventType = eventType
 
-    this._buffer = []
-    this._bufferLimit = 1000
-    this._bufferSize = 0
+    /** @type {LLMObsBuffer} */
+    this._buffer = new LLMObsBuffer({ events: [], size: 0, isDefault: true })
 
     this._config = config
     this._endpoint = endpoint
+    this._baseEndpoint = endpoint // should not be unset
     this._intake = intake
 
     this._periodic = setInterval(() => {
       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.#destroyer = destroyer
+  }
 
-    this._destroyed = false
+  // Split on protocol separator to preserve it
+  // path.join will remove some slashes unnecessarily
+  #buildUrl (baseUrl, endpoint) {
+    const [protocol, rest] = baseUrl.split('://')
+    return protocol + '://' + path.join(rest, endpoint)
   }
 
   get url () {
     if (this._agentless == null) return null
+    return this.#buildUrl(this._baseUrl.href, this._endpoint)
+  }
 
-    const baseUrl = this._baseUrl.href
-    const endpoint = this._endpoint
-
-    // Split on protocol separator to preserve it
-    // path.join will remove some slashes unnecessarily
-    const [protocol, rest] = baseUrl.split('://')
-    return protocol + '://' + path.join(rest, endpoint)
+  _getBuffer (routing) {
+    if (!routing?.apiKey) {
+      return this._buffer
+    }
+    const apiKey = routing.apiKey
+    let buffer = this.#multiTenantBuffers.get(apiKey)
+    if (!buffer) {
+      buffer = new LLMObsBuffer({ events: [], size: 0, routing })
+      this.#multiTenantBuffers.set(apiKey, buffer)
+    }
+    return buffer
   }
 
-  append (event, byteLength) {
-    if (this._buffer.length >= this._bufferLimit) {
-      logger.warn(`${this.constructor.name} event buffer full (limit is ${this._bufferLimit}), dropping event`)
+  append (event, routing, byteLength) {
+    const buffer = this._getBuffer(routing)
+
+    if (buffer.events.length >= buffer.limit) {
+      logger.warn(`${this.constructor.name} event buffer full (limit is ${buffer.limit}), dropping event`)
       telemetry.recordDroppedPayload(1, this._eventType, 'buffer_full')
       return
     }
 
-    this._bufferSize += byteLength || Buffer.byteLength(JSON.stringify(event))
-    this._buffer.push(event)
+    const eventSize = byteLength || Buffer.byteLength(JSON.stringify(event))
+
+    buffer.size += eventSize
+    buffer.events.push(event)
   }
 
   flush () {
-    const noAgentStrategy = this._agentless == null
-
-    if (this._buffer.length === 0 || noAgentStrategy) {
+    if (this._agentless == null) {
       return
     }
 
-    const events = this._buffer
-    this._buffer = []
-    this._bufferSize = 0
-    const payload = this._encode(this.makePayload(events))
+    // Flush default buffer
+    if (this._buffer.events.length > 0) {
+      const events = this._buffer.events
+      this._buffer.clear()
+
+      const payload = this._encode(this.makePayload(events))
 
-    log.debug('Encoded LLMObs payload: %s', payload)
+      log.debug('Encoded LLMObs payload: %s', payload)
 
-    const options = this._getOptions()
+      const options = this._getOptions()
+
+      request(payload, options, (err, resp, code) => {
+        parseResponseAndLog(err, code, events.length, this.url, this._eventType)
+      })
+    }
 
-    request(payload, options, (err, resp, code) => {
-      parseResponseAndLog(err, code, events.length, this.url, this._eventType)
-    })
+    // Flush multi-tenant buffers
+    for (const [apiKey, buffer] of this.#multiTenantBuffers) {
+      if (buffer.events.length === 0) continue
+
+      const events = buffer.events
+      buffer.clear()
+
+      const payload = this._encode(this.makePayload(events))
+      const site = buffer.routing.site || this._config.site
+      const options = {
+        headers: {
+          'Content-Type': 'application/json',
+          'DD-API-KEY': apiKey
+        },
+        method: 'POST',
+        timeout: this._timeout,
+        url: new URL(format({
+          protocol: 'https:',
+          hostname: `${this._intake}.${site}`
+        })),
+        path: this._baseEndpoint
+      }
+      const url = this.#buildUrl(options.url.href, options.path)
+      const maskedApiKey = apiKey ? `****${apiKey.slice(-4)}` : ''
+
+      log.debug('Encoding and flushing multi-tenant buffer for %s', maskedApiKey)
+      log.debug('Encoded LLMObs payload: %s', payload)
+
+      request(payload, options, (err, resp, code) => {
+        parseResponseAndLog(err, code, events.length, url, this._eventType)
+      })
+    }
+
+    this.#cleanupEmptyBuffers()
+  }
+
+  #cleanupEmptyBuffers () {
+    for (const [key, buffer] of this.#multiTenantBuffers) {
+      if (buffer.events.length === 0) {
+        this.#multiTenantBuffers.delete(key)
+      }
+    }
   }
 
   makePayload (events) {}
 
   destroy () {
-    if (!this._destroyed) {
+    if (this.#destroyer) {
       logger.debug(`Stopping ${this.constructor.name}`)
       clearInterval(this._periodic)
-      process.removeListener('beforeExit', this._beforeExitHandler)
+      globalThis[Symbol.for('dd-trace')].beforeExitHandlers.delete(this.#destroyer)
       this.flush()
-      this._destroyed = true
+      this.#destroyer = undefined
     }
   }
 
@@ -110,10 +188,11 @@ class BaseLLMObsWriter {
 
   _getUrlAndPath () {
     if (this._agentless) {
+      const site = this._config.site
       return {
         url: new URL(format({
           protocol: 'https:',
-          hostname: `${this._intake}.${this._config.site}`
+          hostname: `${this._intake}.${site}`
         })),
         endpoint: this._endpoint
       }

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

@@ -24,7 +24,7 @@ class LLMObsSpanWriter extends BaseWriter {
     })
   }
 
-  append (event) {
+  append (event, routing) {
     const eventSizeBytes = Buffer.byteLength(JSON.stringify(event))
     telemetry.recordLLMObsRawSpanSize(event, eventSizeBytes)
 
@@ -39,12 +39,13 @@ class LLMObsSpanWriter extends BaseWriter {
 
     telemetry.recordLLMObsSpanSize(event, processedEventSizeBytes, shouldTruncate)
 
-    if (this._bufferSize + eventSizeBytes > EVP_PAYLOAD_SIZE_LIMIT) {
+    const buffer = this._getBuffer(routing)
+    if (buffer.size + processedEventSizeBytes > EVP_PAYLOAD_SIZE_LIMIT) {
       logger.debug('Flushing queue because queuing next event will exceed EvP payload limit')
       this.flush()
     }
 
-    super.append(event, processedEventSizeBytes)
+    super.append(event, routing, processedEventSizeBytes)
   }
 
   makePayload (events) {

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')
@@ -112,8 +112,8 @@ const log = {
   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,8 +126,8 @@ 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
   }

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

@@ -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`)

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 = {

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

@@ -1,7 +1,8 @@
 'use strict'
 
 const { channel } = require('dc-polyfill')
-const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
+
+const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
 const { isFalse, isTrue, normalizePluginEnvName } = require('./util')
 const plugins = require('./plugins')
 const log = require('./log')
@@ -24,7 +25,7 @@ if (getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined) {
   require('./lambda')
 }
 
-const DD_TRACE_DISABLED_PLUGINS = getEnvironmentVariable('DD_TRACE_DISABLED_PLUGINS')
+const DD_TRACE_DISABLED_PLUGINS = getValueFromEnvSources('DD_TRACE_DISABLED_PLUGINS')
 
 const disabledPlugins = new Set(
   DD_TRACE_DISABLED_PLUGINS && DD_TRACE_DISABLED_PLUGINS.split(',').map(plugin => plugin.trim())
@@ -41,7 +42,7 @@ loadChannel.subscribe(({ name }) => {
 function maybeEnable (Plugin) {
   if (!Plugin || typeof Plugin !== 'function') return
   if (!pluginClasses[Plugin.id]) {
-    const enabled = getEnvEnabled(Plugin)
+    const enabled = getEnabled(Plugin)
 
     // TODO: remove the need to load the plugin class in order to disable the plugin
     if (isFalse(enabled) || disabledPlugins.has(Plugin.id)) {
@@ -54,9 +55,9 @@ function maybeEnable (Plugin) {
   }
 }
 
-function getEnvEnabled (Plugin) {
+function getEnabled (Plugin) {
   const envName = `DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`
-  return getEnvironmentVariable(normalizePluginEnvName(envName))
+  return getValueFromEnvSources(normalizePluginEnvName(envName))
 }
 
 // TODO this must always be a singleton.
@@ -94,7 +95,8 @@ module.exports = class PluginManager {
       this._pluginsByName[name] = new Plugin(this._tracer, this._tracerConfig)
     }
     const pluginConfig = this._configsByName[name] || {
-      enabled: this._tracerConfig.plugins !== false && (!Plugin.experimental || isTrue(getEnvEnabled(Plugin)))
+      enabled: this._tracerConfig.plugins !== false &&
+        (!Plugin.experimental || isTrue(getEnabled(Plugin)))
     }
 
     // extracts predetermined configuration from tracer and combines it with plugin-specific config

package/packages/dd-trace/src/plugins/util/ci.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { readFileSync } = require('fs')
-const { getEnvironmentVariable, getEnvironmentVariables } = require('../../config-helper')
+const { getEnvironmentVariable, getEnvironmentVariables, getValueFromEnvSources } = require('../../config/helper')
 const {
   GIT_BRANCH,
   GIT_COMMIT_SHA,
@@ -120,12 +120,12 @@ module.exports = {
         GIT_COMMIT: JENKINS_GIT_COMMIT,
         GIT_URL: JENKINS_GIT_REPOSITORY_URL,
         GIT_URL_1: JENKINS_GIT_REPOSITORY_URL_1,
-        DD_CUSTOM_TRACE_ID,
         NODE_NAME,
         NODE_LABELS,
         CHANGE_ID,
         CHANGE_TARGET
       } = env
+      const DD_CUSTOM_TRACE_ID = getValueFromEnvSources('DD_CUSTOM_TRACE_ID')
 
       tags = {
         [CI_PIPELINE_ID]: BUILD_TAG,
@@ -689,16 +689,13 @@ module.exports = {
     }
 
     if (env.CODEBUILD_INITIATOR?.startsWith('codepipeline/')) {
-      const {
-        CODEBUILD_BUILD_ARN,
-        DD_ACTION_EXECUTION_ID,
-        DD_PIPELINE_EXECUTION_ID
-      } = env
+      const DD_ACTION_EXECUTION_ID = getValueFromEnvSources('DD_ACTION_EXECUTION_ID')
+      const DD_PIPELINE_EXECUTION_ID = getValueFromEnvSources('DD_PIPELINE_EXECUTION_ID')
       tags = {
         [CI_PROVIDER_NAME]: 'awscodepipeline',
         [CI_PIPELINE_ID]: DD_PIPELINE_EXECUTION_ID,
         [CI_ENV_VARS]: JSON.stringify({
-          CODEBUILD_BUILD_ARN,
+          CODEBUILD_BUILD_ARN: env.CODEBUILD_BUILD_ARN,
           DD_PIPELINE_EXECUTION_ID,
           DD_ACTION_EXECUTION_ID
         }),