dd-trace 6.15.0 → 6.17.0

package/packages/dd-trace/src/opentelemetry/metrics/periodic_metric_reader.js

@@ -8,6 +8,19 @@ const {
 const { ObservableInstrument } = require('./instruments')
 const { nowUnixNano } = require('./time')
 
+/**
+ * @param {(error: Error | null) => void} [done]
+ * @param {Error | null} [error]
+ */
+function callDone (done, error) {
+  if (!done) return
+  try {
+    done(error ?? null)
+  } catch (callbackError) {
+    log.error('Error completing OTLP metrics lifecycle callback:', callbackError)
+  }
+}
+
 /**
  * @typedef {import('@opentelemetry/api').Attributes} Attributes
  * @typedef {import('@opentelemetry/core').InstrumentationScope} InstrumentationScope
@@ -105,6 +118,10 @@ class PeriodicMetricReader {
   #exportInterval
   #aggregator
   #batchCallbacks = []
+  #exportQueue = []
+  #isExporting = false
+  #shutdownCallbacks = []
+  #shutdownComplete = false
 
   /**
    * Creates a new PeriodicMetricReader instance.
@@ -161,9 +178,9 @@ class PeriodicMetricReader {
   }
 
   /**
+   * Returns the matching index, or `-1` when no batch callback matches.
    * @param {Function} callback
    * @param {Set} instruments
-   * @returns {number} index in #batchCallbacks, or -1
    */
   #findBatchCallback (callback, instruments) {
     return this.#batchCallbacks.findIndex(record =>
@@ -197,47 +214,34 @@ class PeriodicMetricReader {
 
   /**
    * Forces an immediate collection and export of all metrics.
-   * @param {Function} [done] Called after the metric export completes
+   * @param {(error: Error | null) => void} [done] Called after the metric export completes
    */
   forceFlush (done) {
     if (this.#isShutdown) {
       log.warn('PeriodicMetricReader is shutdown. %d measurement(s) were dropped', this.#droppedCount)
-      done?.()
+      if (this.#shutdownComplete) callDone(done)
+      else if (done) this.#shutdownCallbacks.push(done)
       return
     }
-    let pending = 2
-    const complete = () => {
-      if (--pending === 0) done?.()
-    }
-
-    // Snapshot requests already active before starting this flush's export.
-    try {
-      if (typeof this.exporter.flush === 'function') this.exporter.flush(complete)
-      else complete()
-    } catch (error) {
-      log.error('Error flushing OTLP metrics:', error)
-      complete()
-    }
-    try {
-      this.#collectAndExport(complete)
-    } catch (error) {
-      log.error('Error exporting OTLP metrics:', error)
-      complete()
-    }
+    this.#enqueueExport(true, done)
   }
 
   /**
    * Shuts down the reader and stops periodic collection.
-   * @returns {void}
+   * @param {(error: Error | null) => void} [done] Called after the final export and exporter shutdown complete
    */
-  shutdown () {
+  shutdown (done) {
     if (this.#isShutdown) {
       log.warn('PeriodicMetricReader is already shutdown')
+      if (this.#shutdownComplete) callDone(done)
+      else if (done) this.#shutdownCallbacks.push(done)
       return
     }
+    if (done) this.#shutdownCallbacks.push(done)
+
     this.#isShutdown = true
     this.#clearTimer()
-    this.forceFlush()
+    this.#enqueueExport(true, error => this.#shutdownExporter(error))
   }
 
   /**
@@ -248,7 +252,7 @@ class PeriodicMetricReader {
     if (this.#timer) return
 
     this.#timer = setInterval(() => {
-      this.#collectAndExport()
+      if (!this.#isExporting && this.#exportQueue.length === 0) this.#enqueueExport(false)
     }, this.#exportInterval)
     this.#timer.unref?.()
   }
@@ -264,6 +268,72 @@ class PeriodicMetricReader {
     }
   }
 
+  /**
+   * @param {boolean} flushExporter Whether to flush the exporter after export
+   * @param {(error: Error | null) => void} [done] Called when the queued export completes
+   */
+  #enqueueExport (flushExporter, done) {
+    this.#exportQueue.push({ flushExporter, done })
+    this.#drainExportQueue()
+  }
+
+  #drainExportQueue () {
+    if (this.#isExporting || this.#exportQueue.length === 0) return
+
+    this.#isExporting = true
+    const { flushExporter, done } = this.#exportQueue.shift()
+    let completed = false
+    const complete = error => {
+      if (completed) return
+      completed = true
+      this.#isExporting = false
+      queueMicrotask(() => this.#drainExportQueue())
+      callDone(done, error)
+    }
+    let exportCompleted = false
+    const afterExport = error => {
+      if (exportCompleted) return
+      exportCompleted = true
+      if (!flushExporter || typeof this.exporter.flush !== 'function') return complete(error)
+
+      try {
+        this.exporter.flush(flushError => complete(error || flushError))
+      } catch (flushError) {
+        log.error('Error flushing OTLP metrics:', flushError)
+        complete(error || flushError)
+      }
+    }
+
+    try {
+      this.#collectAndExport(afterExport)
+    } catch (error) {
+      log.error('Error exporting OTLP metrics:', error)
+      afterExport(error)
+    }
+  }
+
+  /**
+   * @param {Error} [exportError] Error from the final export
+   */
+  #shutdownExporter (exportError) {
+    let completed = false
+    const complete = shutdownError => {
+      if (completed) return
+      completed = true
+      this.#shutdownComplete = true
+      const callbacks = this.#shutdownCallbacks.splice(0)
+      for (const callback of callbacks) callDone(callback, exportError || shutdownError)
+    }
+
+    try {
+      if (typeof this.exporter.shutdown === 'function') this.exporter.shutdown(complete)
+      else complete()
+    } catch (error) {
+      log.error('Error shutting down OTLP metrics exporter:', error)
+      complete(error)
+    }
+  }
+
   /**
    * Collects measurements and exports metrics.
    *
@@ -322,7 +392,13 @@ class PeriodicMetricReader {
       this.#lastExportedState
     )
 
-    this.exporter.export(metrics, callback)
+    this.exporter.export(metrics, result => {
+      if (result?.code === 1) {
+        callback?.(result.error || new Error('OTLP metrics export failed'))
+      } else {
+        callback?.()
+      }
+    })
   }
 }
 
@@ -344,7 +420,6 @@ class MetricAggregator {
    * Gets the temporality for a given metric type.
    *
    * @param {string} type - Metric type from METRIC_TYPES
-   * @returns {string} Temporality from TEMPORALITY
    */
   #getTemporality (type) {
     // UpDownCounter and Observable UpDownCounter always use CUMULATIVE
@@ -439,7 +514,6 @@ class MetricAggregator {
    * Gets unique identifier for a given instrumentation scope.
    *
    * @param {InstrumentationScope} instrumentationScope - The instrumentation scope
-   * @returns {string} - The scope identifier
    */
   #getScopeKey (instrumentationScope) {
     return `${instrumentationScope.name}@${instrumentationScope.version}@${instrumentationScope.schemaUrl}`
@@ -452,7 +526,6 @@ class MetricAggregator {
    * @param {string} name - The metric name
    * @param {string} type - The metric type from METRIC_TYPES
    * @param {string} attrKey - The attribute key
-   * @returns {string} - The metric identifier
    */
   #getStateKey (scopeKey, name, type, attrKey) {
     return `${scopeKey}:${name}:${type}:${attrKey}`
@@ -462,7 +535,6 @@ class MetricAggregator {
    * Checks if a given metric type is a delta type.
    *
    * @param {string} type - The metric type from METRIC_TYPES
-   * @returns {boolean} - True if the metric type is a delta type
    */
   #isDeltaType (type) {
     return type === METRIC_TYPES.COUNTER ||
@@ -475,7 +547,6 @@ class MetricAggregator {
    *
    * @param {Iterable<AggregatedMetric>} metrics - The metrics to apply delta temporality to
    * @param {Map<string, LastExportedStateValue>} lastExportedState - The last exported state of the metrics
-   * @returns {void}
    */
   #applyDeltaTemporality (metrics, lastExportedState) {
     for (const metric of metrics) {
@@ -600,7 +671,6 @@ class MetricAggregator {
    * @param {number} timestamp - The timestamp of the measurement
    * @param {string} stateKey - The state key
    * @param {Map<string, CumulativeStateValue>} cumulativeState - The cumulative state of the metrics
-   * @returns {void}
    */
   #aggregateHistogram (metric, value, attributes, attrKey, timestamp, stateKey, cumulativeState) {
     if (!cumulativeState.has(stateKey)) {
@@ -652,7 +722,6 @@ class MetricAggregator {
 
 /**
  * @param {object} x
- * @returns {boolean}
  */
 function isObservableInstrument (x) {
   return x instanceof ObservableInstrument
@@ -661,7 +730,6 @@ function isObservableInstrument (x) {
 /**
  * @param {Set} a
  * @param {Set} b
- * @returns {boolean}
  */
 function setEquals (a, b) {
   if (a.size !== b.size) return false

package/packages/dd-trace/src/opentelemetry/metrics/time.js

@@ -10,7 +10,6 @@ const { timeOrigin } = performance
  * the value on the epoch while `performance.now()` keeps it monotonic, so a
  * backward wall-clock jump can't make `timeUnixNano` precede `startTimeUnixNano`.
  *
- * @returns {number} Nanoseconds since the UNIX epoch
  */
 function nowUnixNano () {
   return Math.round((timeOrigin + performance.now()) * 1e6)

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

@@ -42,15 +42,9 @@ class OtlpHttpExporterBase {
 
     const isJson = protocol === 'http/json'
 
-    const parsedUrl = new URL(url)
-    this.#transport = parsedUrl.protocol === 'http:' ? http : https
     this.options = {
       method: 'POST',
       timeout,
-      hostname: parsedUrl.hostname,
-      port: parsedUrl.port,
-      path: parsedUrl.pathname + parsedUrl.search,
-      agent: parsedUrl.protocol === 'https:' ? getHttpsProxyAgent(parsedUrl) : undefined,
       headers: {
         'Content-Type': isJson ? 'application/json' : 'application/x-protobuf',
         'User-Agent': `dd-trace-js/${tracerVersion}`,
@@ -59,9 +53,10 @@ class OtlpHttpExporterBase {
     }
 
     this.telemetryTags = [
-      `protocol:${this.#transport === https ? 'https' : 'http'}`,
+      '',
       `encoding:${isJson ? 'json' : 'protobuf'}`,
     ]
+    this.#applyUrl(url)
   }
 
   /**
@@ -164,20 +159,48 @@ class OtlpHttpExporterBase {
   }
 
   /**
-   * Re-targets the exporter to a different URL, updating transport, hostname, port, and path.
    * @param {string} url
    */
-  setUrl (url) {
+  #applyUrl (url) {
     const parsedUrl = new URL(url)
-    this.#transport = parsedUrl.protocol === 'http:' ? http : https
+    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:') {
+      throw new TypeError(`Unsupported OTLP endpoint protocol: ${parsedUrl.protocol}`)
+    }
+
+    const transport = parsedUrl.protocol === 'http:' ? http : https
+    const agent = transport === https ? getHttpsProxyAgent(parsedUrl) : undefined
+
+    this.#transport = transport
     this.options.hostname = parsedUrl.hostname
     this.options.port = parsedUrl.port
     this.options.path = parsedUrl.pathname + parsedUrl.search
-    this.options.agent = parsedUrl.protocol === 'https:' ? getHttpsProxyAgent(parsedUrl) : undefined
-    this.telemetryTags[0] = `protocol:${this.#transport === https ? 'https' : 'http'}`
+    this.options.agent = agent
+    this.telemetryTags[0] = `protocol:${transport === https ? 'https' : 'http'}`
+  }
+
+  /**
+   * Re-targets the exporter to a different URL, updating transport, hostname, port, and path.
+   * @param {string} url
+   */
+  setUrl (url) {
+    try {
+      this.#applyUrl(url)
+    } catch (error) {
+      log.error(
+        'Invalid OTLP %s URL: %s. Using previous URL. Error: %s',
+        this.signalType,
+        url,
+        error.message
+      )
+    }
   }
 
-  shutdown () {}
+  /**
+   * @param {() => void} [done]
+   */
+  shutdown (done) {
+    done?.()
+  }
 }
 
 module.exports = OtlpHttpExporterBase

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

@@ -171,7 +171,6 @@ class OtlpTransformerBase {
  * Supports string keys with primitive values or arrays of primitives.
  *
  * @param {Attributes} attributes - Attributes object to stringify
- * @returns {string} Stable string representation
  */
 function stableStringify (attributes) {
   if (attributes == null) {

package/packages/dd-trace/src/opentelemetry/span-helpers.js

@@ -261,7 +261,6 @@ function recordException (ddSpan, exception, timeInput, otelTraceSemanticsEnable
  * @param {number} currentCode 0 = UNSET, 1 = OK, 2 = ERROR.
  * @param {{ code?: number, message?: string }} [status]
  * @param {boolean} [otelTraceSemanticsEnabled]
- * @returns {number} The new status code to track on the caller.
  */
 function applyOtelStatus (ddSpan, currentCode, status, otelTraceSemanticsEnabled) {
   if (!isWritable(ddSpan)) return currentCode

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

@@ -57,7 +57,6 @@ class OtlpHttpTraceExporter extends OtlpHttpExporterBase {
    * Exports DD-formatted spans via OTLP over HTTP.
    *
    * @param {import('./otlp_transformer').DDFormattedSpan[]} spans - Array of DD-formatted spans to export
-   * @returns {void}
    */
   export (spans) {
     if (spans.length === 0) {

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

@@ -248,7 +248,6 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    * Maps a DD span.kind string to an OTLP SpanKind enum value.
    *
    * @param {string | undefined} kind - DD span kind string
-   * @returns {number} OTLP SpanKind enum value
    */
   #mapSpanKind (kind) {
     if (!kind) return SPAN_KIND_UNSPECIFIED
@@ -340,7 +339,6 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    *
    * @param {Identifier} identifier - DD Identifier
    * @param {number} targetLength - Target byte length (16 for trace ID, 8 for span ID)
-   * @returns {string} Hex-encoded string of the specified length
    */
   #idToBytes (identifier, targetLength) {
     const buffer = identifier.toBuffer()
@@ -363,7 +361,6 @@ class OtlpTraceTransformer extends OtlpTransformerBase {
    *
    * @param {string | undefined} hexString - Hex string to normalize
    * @param {number} targetLength - Target byte length
-   * @returns {string} Hex-encoded string of the specified length
    */
   #hexToBytes (hexString, targetLength) {
     if (!hexString) return '0'.repeat(targetLength * 2)

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

@@ -88,7 +88,6 @@ const percentByte = /%([0-9A-Fa-f]{2})/g
 /**
  * @param {Array<string | undefined>} traceTagReplacements
  * @param {string} key
- * @returns {boolean}
  */
 function hasTraceTagReplacement (traceTagReplacements, key) {
   for (let index = 0; index < traceTagReplacements.length; index += 2) {
@@ -117,7 +116,6 @@ function extractGenericContext (traceId, spanId, radix) {
 /**
  * @param {string} traceId
  * @param {DatadogSpanContext} spanContext
- * @returns {void}
  */
 function extract128BitTraceId (traceId, spanContext) {
   const buffer = spanContext._traceId.toBuffer()
@@ -485,7 +483,6 @@ class TextMapPropagator {
    * @param {Record<string, string>} traceTags
    * @param {Array<string | undefined>} [traceTagReplacements]
    * @param {number} optionalTraceTagCount
-   * @returns {void}
    */
   #injectTags (carrier, traceTags, traceTagReplacements, optionalTraceTagCount) {
     if (this.#config.DD_TRACE_X_DATADOG_TAGS_MAX_LENGTH === 0) {
@@ -688,7 +685,6 @@ class TextMapPropagator {
   /**
    * @param {'inject' | 'extract'} mode
    * @param {string} name
-   * @returns {boolean}
    */
   #hasPropagationStyle (mode, name) {
     return this.#config.tracePropagationStyle[mode].includes(name)
@@ -974,7 +970,6 @@ class TextMapPropagator {
   /**
    * @param {Record<string, unknown>} carrier
    * @param {DatadogSpanContext} spanContext
-   * @returns {void}
    */
   #extractLegacyBaggageItems (carrier, spanContext) {
     if (!this.#config.legacyBaggageEnabled) return
@@ -985,7 +980,6 @@ class TextMapPropagator {
    * @param {Record<string, unknown> | undefined} carrier
    * @param {DatadogSpanContext | undefined} spanContext
    * @param {boolean} extractBaggage
-   * @returns {void}
    */
   #extractBaggageItems (carrier, spanContext, extractBaggage) {
     removeAllBaggageItems()

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

@@ -108,7 +108,6 @@ class DatadogSpanContext {
   /**
    * Check if a tag exists.
    * @param {string} key - Tag key
-   * @returns {boolean}
    */
   hasTag (key) { return Object.hasOwn(this._tags, key) }
 

package/packages/dd-trace/src/otel-thread-ctx.js

@@ -25,6 +25,7 @@
 
 const { isMainThread, threadId } = require('worker_threads')
 
+const { AUTO_KEEP } = require('../../../ext/priority')
 const { isACFActive } = require('../../datadog-core/src/storage')
 const log = require('./log')
 const {
@@ -94,6 +95,20 @@ const ATTRIBUTE_KEYS = [
 const THREAD_NAME = (isMainThread ? 'Main' : `Worker #${threadId}`) + ' Event Loop'
 const THREAD_ID = String(threadId)
 
+// W3C trace-flags byte for a record, derived the same way DatadogSpanContext
+// #toTraceparent derives the flags it puts on the wire — sampled iff the
+// priority is AUTO_KEEP or above.
+//
+// Unlike toTraceparent, this does NOT materialize a not-yet-taken decision
+// (_ensureSamplingPriority): that would move every trace's sampling decision
+// forward to the first activation of its first span, on the tracer's hot path,
+// as a side effect of profiling being enabled. An undefined priority therefore
+// reads as not sampled, which is also what OTEP-4947 prescribes when the flags
+// are not known yet. See the note on setTraceFlags in getOrBuildContext.
+function traceFlagsOf (spanContext) {
+  return spanContext._sampling?.priority >= AUTO_KEEP ? 1 : 0
+}
+
 // Cache slot on span objects. One ThreadContext is built per span on first
 // activation and re-installed across every async-context frame that
 // re-enters the span — V8's AsyncContextFrame inherits the JS
@@ -140,7 +155,13 @@ function getOrBuildContext (span) {
     cached = {}
     span[CachedSym] = cached
   }
-  cached.context = new ThreadContext(traceId, spanId, attrs)
+  // The flags are the one part of the record that can still change after
+  // publication: a decision taken later, or overridden, is pushed into the live
+  // record with setTraceFlags rather than by rebuilding the context, which would
+  // strand every async-context frame already holding this one. Nothing calls it
+  // yet — the tracer publishes no event for a sampling decision — so a record
+  // built before the decision keeps reading as not sampled.
+  cached.context = new ThreadContext(traceId, spanId, traceFlagsOf(spanContext), attrs)
   cached.webTags = webTags
   if (endpoint === undefined) awaitEndpoint(webTags, cached)
   return cached.context
@@ -279,7 +300,7 @@ function missingApiMember (ns) {
   for (const name of ['ThreadContext', 'getContext', 'clearContext', 'getProcessContextAttributes']) {
     if (typeof ns[name] !== 'function') return name
   }
-  for (const name of ['appendAttributes', 'enter', 'invalidate']) {
+  for (const name of ['appendAttributes', 'enter', 'invalidate', 'setTraceFlags']) {
     if (typeof ns.ThreadContext.prototype[name] !== 'function') return `ThreadContext.prototype.${name}`
   }
 }
@@ -287,15 +308,21 @@ function missingApiMember (ns) {
 // Install and detach one throwaway context, to establish that this process can
 // actually do it before any span depends on it.
 //
-// @datadog/pprof decides whether AsyncContextFrame is available by inspecting
-// `process.execArgv`, and throws from enter() when it concludes it isn't. That
-// disagrees with the feature detection behind `isACFActive` whenever the flag
-// reached Node by another route: `NODE_OPTIONS=--experimental-async-context-frame`
-// is accepted on Node 22 and 23 and leaves `execArgv` empty, and a worker thread
-// created with an explicit `execArgv` loses it too. Since our subscribers run
-// inline with `storage.enterWith`, letting that throw would put the exception in
-// application code on the first span activation, so find out here instead, where
-// declining to start is still an option.
+// @datadog/pprof throws from enter() when it concludes AsyncContextFrame is not
+// active. It reaches that conclusion by its own feature detection, asking the
+// addon what is in the CPED slot during a `run()` — direct evidence about the
+// exact slot the out-of-process reader walks. `isACFActive` above tests the same
+// property through a weaker proxy: whether `run()` delegates to `enterWith()`,
+// which holds today but relies on unspecified dispatch that anything patching
+// `AsyncLocalStorage` can break. So the two can disagree, and pprof's answer is
+// the one that governs whether a record ever gets written. Its enter() can also
+// fail for reasons `isACFActive` says nothing about, such as an addon that
+// loaded but whose TLS block is unusable.
+//
+// Since our subscribers run inline with `storage.enterWith`, letting enter()
+// throw would put the exception in application code on the first span
+// activation, so find out here instead, where declining to start is still an
+// option.
 function canInstallContext (ns) {
   try {
     // Zero-filled ids: the record is only readable while it is installed, which

package/packages/dd-trace/src/payload-tagging/tagging.js

@@ -1,18 +1,29 @@
 'use strict'
 
 const { PAYLOAD_TAGGING_MAX_TAGS } = require('../constants')
+const { truncateString } = require('../util')
 
 const redactedKeys = new Set([
   'authorization', 'x-authorization', 'password', 'token',
 ])
 const truncated = 'truncated'
 const redacted = 'redacted'
+const maxValueLength = 5000
+const maxRetainedValueLength = maxValueLength * 2
+
+/**
+ * @param {string} value
+ */
+function truncateValue (value) {
+  return value.length > maxRetainedValueLength
+    ? truncateString(value, maxValueLength)
+    : value.slice(0, maxValueLength)
+}
 
 /**
  * Escapes dots in keys to preserve hierarchy in flattened tag names.
  *
  * @param {string} key
- * @returns {string}
  */
 function escapeKey (key) {
   return key.replaceAll('.', String.raw`\.`)
@@ -67,13 +78,14 @@ function tagsFromObject (object, opts) {
 
     if (['number', 'boolean'].includes(typeof object) || Buffer.isBuffer(object)) {
       tagCount += 1
-      result[prefix] = object.toString().slice(0, 5000)
+      const value = object.toString()
+      result[prefix] = value.length > maxValueLength ? truncateValue(value) : value
       return
     }
 
     if (typeof object === 'string') {
       tagCount += 1
-      result[prefix] = object.slice(0, 5000)
+      result[prefix] = object.length > maxValueLength ? truncateValue(object) : object
     }
 
     if (typeof object === 'object') {

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

@@ -2,7 +2,11 @@
 
 const { channel } = require('dc-polyfill')
 
-const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
+const {
+  getEnvironmentVariable,
+  getValueFromEnvSources,
+  isSupportedConfiguration,
+} = require('./config/helper')
 const { isFalse, isTrue, normalizePluginEnvName } = require('./util')
 const plugins = require('./plugins')
 const log = require('./log')
@@ -59,12 +63,14 @@ function maybeEnable (Plugin) {
 }
 
 function getEnabled (Plugin) {
-  const envName = `DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`
+  const envName = normalizePluginEnvName(`DD_TRACE_${Plugin.id.toUpperCase()}_ENABLED`)
+  if (!isSupportedConfiguration(envName)) return
+
   // skipDefault: only an explicitly configured value should drive enablement here. A registered
   // default of `false` (e.g. an opt-in plugin like `nats`) must not be read as an explicit
   // "disabled via configuration option" — that path both logs a misleading line and nulls the
   // plugin class, bypassing the opt-in handled by `loadPlugin`.
-  return getValueFromEnvSources(normalizePluginEnvName(envName), true)
+  return getValueFromEnvSources(envName, true)
 }
 
 // TODO this must always be a singleton.

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

@@ -593,7 +593,6 @@ module.exports = class CiPlugin extends Plugin {
    * @param {string|undefined} repositoryRoot - Repository root discovered by the coordinator process.
    * @param {Array<{ pattern: string, owners: string[] }>|null|undefined} codeOwnersEntries
    * Parsed CODEOWNERS entries discovered by the coordinator process.
-   * @returns {void}
    */
   _setRepositoryRoot (repositoryRoot, codeOwnersEntries) {
     if (codeOwnersEntries !== undefined) {