dd-trace 5.109.0 → 5.111.0

package/packages/dd-trace/src/profiling/oom.js

@@ -0,0 +1,71 @@
+'use strict'
+
+const path = require('path')
+
+const log = require('../log')
+const { snapshotKinds } = require('./constants')
+
+const oomExportStrategies = Object.freeze({
+  PROCESS: 'process',
+  ASYNC_CALLBACK: 'async',
+  LOGS: 'logs',
+})
+
+/** @param {string} name */
+function getExportStrategy (name) {
+  const strategy = Object.values(oomExportStrategies).find(value => value === name)
+  if (strategy === undefined) {
+    log.error('Unknown oom export strategy "%s"', name)
+  }
+  return strategy
+}
+
+/**
+ * Validates the configured strategies, dropping any the tracer does not recognize (each logged once).
+ *
+ * @param {string[]} strategies
+ * @returns {string[]}
+ */
+function ensureOOMExportStrategies (strategies) {
+  const valid = new Set()
+  for (const strategy of strategies) {
+    const resolved = getExportStrategy(strategy)
+    if (resolved !== undefined) {
+      valid.add(resolved)
+    }
+  }
+  return [...valid]
+}
+
+/**
+ * @param {string[]} strategies
+ * @param {{ Async: number }} callbackMode
+ */
+function strategiesToCallbackMode (strategies, callbackMode) {
+  return strategies.includes(oomExportStrategies.ASYNC_CALLBACK) ? callbackMode.Async : 0
+}
+
+/**
+ * Builds the argv the near-OOM export subprocess ({@link ./exporter_cli.js}) is spawned with. Each
+ * exporter reports its own destination URL, so the command stays agnostic of the exporter types.
+ *
+ * @param {Array<{ getExportUrl(): URL | undefined }>} exporters
+ * @param {Record<string, string>} tags
+ * @returns {string[]}
+ */
+function buildExportCommand (exporters, tags) {
+  const tagString = [...Object.entries(tags),
+    ['snapshot', snapshotKinds.ON_OUT_OF_MEMORY]].map(([key, value]) => `${key}:${value}`).join(',')
+  const urls = []
+  for (const exporter of exporters) {
+    const url = exporter.getExportUrl()
+    if (url !== undefined) {
+      urls.push(url.toString())
+    }
+  }
+  return [process.execPath,
+    path.join(__dirname, 'exporter_cli.js'),
+    urls.join(','), tagString, 'space']
+}
+
+module.exports = { oomExportStrategies, ensureOOMExportStrategies, strategiesToCallbackMode, buildExportCommand }

package/packages/dd-trace/src/profiling/profiler.js

@@ -4,7 +4,7 @@ const { EventEmitter } = require('events')
 const dc = require('dc-polyfill')
 const crashtracker = require('../crashtracking')
 const log = require('../log')
-const { Config } = require('./config')
+const { buildProfilingRuntime } = require('./config')
 const { snapshotKinds } = require('./constants')
 const { threadNamePrefix } = require('./profilers/shared')
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('./webspan-utils')
@@ -54,14 +54,19 @@ class Profiler extends EventEmitter {
   #compressionFn
   #compressionFnInitialized = false
   #compressionOptions
-  #config
   #customLabelKeys = new Set()
   #enabled = false
   #endpointCounts = new Map()
+  #exporters
+  #flushInterval
   #lastStart
   #profileSeq = 0
+  #profilers
   #spanFinishListener
+  #systemInfoReport
+  #tags
   #timer
+  #uploadCompression
 
   constructor () {
     super()
@@ -71,7 +76,7 @@ class Profiler extends EventEmitter {
   get serverless () { return false }
 
   get flushInterval () {
-    return this.#config?.flushInterval
+    return this.#flushInterval
   }
 
   get enabled () {
@@ -90,8 +95,8 @@ class Profiler extends EventEmitter {
     for (const key of keys) {
       this.#customLabelKeys.add(key)
     }
-    if (this.#config) {
-      for (const profiler of this.#config.profilers) {
+    if (this.#profilers) {
+      for (const profiler of this.#profilers) {
         profiler.setCustomLabelKeys?.(this.#customLabelKeys)
       }
     }
@@ -106,10 +111,10 @@ class Profiler extends EventEmitter {
    * @template T
    */
   runWithLabels (labels, fn) {
-    if (!this.#enabled || !this.#config) {
+    if (!this.#enabled || !this.#profilers) {
       return fn()
     }
-    for (const profiler of this.#config.profilers) {
+    for (const profiler of this.#profilers) {
       if (profiler.runWithLabels) {
         return profiler.runWithLabels(labels, fn)
       }
@@ -123,7 +128,7 @@ class Profiler extends EventEmitter {
       try {
         const { promisify } = require('util')
         const zlib = require('zlib')
-        const { method, level: clevel } = this.#config.uploadCompression
+        const { method, level: clevel } = this.#uploadCompression
         switch (method) {
           case 'gzip':
             this.#compressionFn = promisify(zlib.gzip)
@@ -161,13 +166,20 @@ class Profiler extends EventEmitter {
   }
 
   /**
-   * @param {import('../config/config-base')} options - Tracer configuration
+   * @param {import('../config/config-base')} config - Tracer configuration
    */
-  start (options) {
+  start (config) {
     if (this.enabled) return true
     this.#enabled = true
 
-    const config = this.#config = new Config(options)
+    const { tags, exporters, flushInterval, profilers, uploadCompression, systemInfoReport } =
+      buildProfilingRuntime(config)
+    this.#tags = tags
+    this.#exporters = exporters
+    this.#flushInterval = flushInterval
+    this.#profilers = profilers
+    this.#uploadCompression = uploadCompression
+    this.#systemInfoReport = systemInfoReport
 
     this._setInterval()
     // Log errors if the source map finder fails, but don't prevent the rest
@@ -176,11 +188,11 @@ class Profiler extends EventEmitter {
     const { setLogger, SourceMapper } = require('@datadog/pprof')
     setLogger(pprofLogger)
 
-    if (config.sourceMap) {
-      mapper = new SourceMapper(config.debugSourceMaps)
+    if (config.DD_PROFILING_SOURCE_MAP) {
+      mapper = new SourceMapper(config.DD_PROFILING_DEBUG_SOURCE_MAPS)
       mapper.loadDirectory(process.cwd())
         .then(() => {
-          if (config.debugSourceMaps) {
+          if (config.DD_PROFILING_DEBUG_SOURCE_MAPS) {
             const count = mapper.infoMap.size
             // eslint-disable-next-line eslint-rules/eslint-log-printf-style
             log.debug(() => {
@@ -198,7 +210,7 @@ class Profiler extends EventEmitter {
     try {
       const start = new Date()
       const nearOOMCallback = this.#nearOOMExport.bind(this)
-      for (const profiler of config.profilers) {
+      for (const profiler of profilers) {
         // TODO: move this out of Profiler when restoring sourcemap support
         profiler.start({
           mapper,
@@ -207,7 +219,7 @@ class Profiler extends EventEmitter {
         log.debug('Started %s profiler in %s thread', profiler.type, threadNamePrefix)
       }
 
-      if (config.endpointCollectionEnabled) {
+      if (config.DD_PROFILING_ENDPOINT_COLLECTION_ENABLED) {
         this.#spanFinishListener = this.#onSpanFinish.bind(this)
         spanFinishedChannel.subscribe(this.#spanFinishListener)
       }
@@ -233,7 +245,7 @@ class Profiler extends EventEmitter {
   }
 
   _setInterval () {
-    this._timeoutInterval = this.#config.flushInterval
+    this._timeoutInterval = this.#flushInterval
   }
 
   stop () {
@@ -255,7 +267,7 @@ class Profiler extends EventEmitter {
       this.#spanFinishListener = undefined
     }
 
-    for (const profiler of this.#config.profilers) {
+    for (const profiler of this.#profilers) {
       profiler.stop()
       log.debug('Stopped %s profiler in %s thread', profiler.type, threadNamePrefix)
     }
@@ -298,7 +310,7 @@ class Profiler extends EventEmitter {
   #createInitialInfos () {
     return {
       serverless: this.serverless,
-      settings: this.#config.systemInfoReport,
+      settings: this.#systemInfoReport,
       hasMissingSourceMaps: false,
     }
   }
@@ -307,7 +319,7 @@ class Profiler extends EventEmitter {
     if (!this.enabled) return
 
     try {
-      if (this.#config.profilers.length === 0) {
+      if (this.#profilers.length === 0) {
         throw new Error('No profile types configured.')
       }
 
@@ -317,7 +329,7 @@ class Profiler extends EventEmitter {
 
       crashtracker.withProfilerSerializing(() => {
         // collect profiles synchronously so that profilers can be safely stopped asynchronously
-        for (const profiler of this.#config.profilers) {
+        for (const profiler of this.#profilers) {
           const info = profiler.getInfo()
           const profile = profiler.profile(restart, startDate, endDate)
           if (!restart) {
@@ -377,7 +389,7 @@ class Profiler extends EventEmitter {
   }
 
   #submit (profiles, infos, start, end, snapshotKind) {
-    const { tags } = this.#config
+    const tags = this.#tags
 
     // Flatten endpoint counts
     const endpointCounts = {}
@@ -392,7 +404,7 @@ class Profiler extends EventEmitter {
       ? [...this.#customLabelKeys]
       : undefined
     const exportSpec = { profiles, infos, start, end, tags, endpointCounts, customAttributes }
-    const tasks = this.#config.exporters.map(exporter =>
+    const tasks = this.#exporters.map(exporter =>
       exporter.export(exportSpec).catch(error => {
         log.warn(error)
       })

package/packages/dd-trace/src/profiling/profilers/events.js

@@ -12,6 +12,7 @@ const {
   ValueType,
 } = require('../../../../../vendor/dist/pprof-format')
 const { availableParallelism, effectiveLibuvThreadCount } = require('../libuv-size')
+const { SAMPLING_INTERVAL } = require('../constants')
 const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL, encodeProfileAsync } = require('./shared')
 const PoissonProcessSamplingFilter = require('./poisson')
 // perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
@@ -19,6 +20,8 @@ const MS_TO_NS = 1_000_000
 // The number of sampling intervals that need to pass before we reset the Poisson process sampling instant.
 const POISSON_RESET_FACTOR = 2
 
+/** @typedef {import('../../config/config-base')} TracerConfig */
+
 // While this is an "events profiler", meaning it emits a pprof file based on events observed as
 // perf_hooks events, the emitted pprof file uses the type "timeline".
 const pprofValueType = 'timeline'
@@ -50,8 +53,8 @@ function labelFromStrStr (stringTable, keyStr, valStr) {
   return labelFromStr(stringTable, stringTable.dedup(keyStr), valStr)
 }
 
-function getMaxSamples (options) {
-  const maxCpuSamples = options.flushInterval / options.samplingInterval
+function getMaxSamples (flushInterval, samplingInterval) {
+  const maxCpuSamples = flushInterval / samplingInterval
 
   // The lesser of max parallelism and libuv thread pool size, plus one so we can detect
   // oversubscription on libuv thread pool, plus another one for GC.
@@ -439,14 +442,18 @@ class EventsProfiler {
 
   get type () { return 'events' }
 
-  constructor (options) {
-    this.#maxSamples = getMaxSamples(options)
-    this.#timelineSamplingEnabled = !!options.timelineSamplingEnabled
+  /**
+   * @param {TracerConfig} config
+   * @param {{ flushInterval: number }} runtime
+   */
+  constructor (config, { flushInterval }) {
+    this.#maxSamples = getMaxSamples(flushInterval, SAMPLING_INTERVAL)
+    this.#timelineSamplingEnabled = config.DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED
     this.#eventSerializer = new EventSerializer(this.#maxSamples)
 
     const eventHandler = event => this.#eventSerializer.addEvent(event)
     const eventFilter = this.#timelineSamplingEnabled
-      ? createPoissonProcessSamplingFilter(options.samplingInterval)
+      ? createPoissonProcessSamplingFilter(SAMPLING_INTERVAL)
       : () => true
     const filteringEventHandler = event => {
       if (eventFilter(event)) {
@@ -454,7 +461,7 @@ class EventsProfiler {
       }
     }
 
-    this.#eventSources = options.codeHotspotsEnabled
+    this.#eventSources = config.DD_PROFILING_CODEHOTSPOTS_ENABLED
       // Use Datadog instrumentation to collect events with span IDs. Still use
       // Node API for GC events.
       ? [

package/packages/dd-trace/src/profiling/profilers/space.js

@@ -1,27 +1,35 @@
 'use strict'
 
-const { oomExportStrategies } = require('../constants')
+const { oomExportStrategies, ensureOOMExportStrategies, strategiesToCallbackMode, buildExportCommand } =
+  require('../oom')
 const { encodeProfileAsync, getThreadLabels } = require('./shared')
 
-function strategiesToCallbackMode (strategies, callbackMode) {
-  return strategies.includes(oomExportStrategies.ASYNC_CALLBACK) ? callbackMode.Async : 0
-}
+/** @typedef {import('../../config/config-base')} TracerConfig */
+/**
+ * @typedef {import('../exporters/agent').AgentExporter
+ *   | import('../exporters/file').FileExporter} ProfilingExporter
+ */
 
 const STACK_DEPTH = 64
 
 class NativeSpaceProfiler {
+  #config
+  #exporters
   #mapper
-  #oomMonitoring
   #pprof
-  #allocationProfilingEnabled = false
-  #samplingInterval = 512 * 1024
+  #samplingInterval
   #started = false
+  #tags
 
-  constructor (options = {}) {
-    // TODO: Remove default value. It is only used in testing.
-    this.#samplingInterval = options.heapSamplingInterval || 512 * 1024
-    this.#allocationProfilingEnabled = options.allocationProfilingEnabled
-    this.#oomMonitoring = options.oomMonitoring || {}
+  /**
+   * @param {TracerConfig} config
+   * @param {{ tags: Record<string, string>, exporters: ProfilingExporter[] }} runtime
+   */
+  constructor (config, { tags, exporters }) {
+    this.#config = config
+    this.#tags = tags
+    this.#exporters = exporters
+    this.#samplingInterval = config.DD_PROFILING_HEAP_SAMPLING_INTERVAL
   }
 
   get type () {
@@ -31,16 +39,17 @@ class NativeSpaceProfiler {
   start ({ mapper, nearOOMCallback } = {}) {
     if (this.#started) return
 
+    const config = this.#config
     this.#mapper = mapper
     this.#pprof = require('@datadog/pprof')
-    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH, this.#allocationProfilingEnabled)
-    if (this.#oomMonitoring.enabled) {
-      const strategies = this.#oomMonitoring.exportStrategies
+    this.#pprof.heap.start(this.#samplingInterval, STACK_DEPTH, config.DD_PROFILING_ALLOCATION_ENABLED)
+    if (config.DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED) {
+      const strategies = ensureOOMExportStrategies(config.DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES)
       this.#pprof.heap.monitorOutOfMemory(
-        this.#oomMonitoring.heapLimitExtensionSize,
-        this.#oomMonitoring.maxHeapExtensionCount,
+        config.DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
+        config.DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
         strategies.includes(oomExportStrategies.LOGS),
-        strategies.includes(oomExportStrategies.PROCESS) ? this.#oomMonitoring.exportCommand : [],
+        strategies.includes(oomExportStrategies.PROCESS) ? buildExportCommand(this.#exporters, this.#tags) : [],
         (profile) => nearOOMCallback(this.type, this.#pprof.encodeSync(profile), this.getInfo()),
         strategiesToCallbackMode(strategies, this.#pprof.heap.CallbackMode)
       )

package/packages/dd-trace/src/profiling/profilers/wall.js

@@ -7,6 +7,7 @@ const log = require('../../log')
 const runtimeMetrics = require('../../runtime_metrics')
 const telemetryMetrics = require('../../telemetry/metrics')
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('../webspan-utils')
+const { SAMPLING_INTERVAL } = require('../constants')
 
 const {
   END_TIMESTAMP_LABEL,
@@ -18,6 +19,8 @@ const {
 } = require('./shared')
 const TRACE_ENDPOINT_LABEL = 'trace endpoint'
 
+/** @typedef {import('../../config/config-base')} TracerConfig */
+
 let beforeCh
 const enterCh = dc.channel('dd-trace:storage:enter')
 const spanFinishCh = dc.channel('dd-trace:span:finish')
@@ -108,13 +111,17 @@ class NativeWallProfiler {
   #asyncContextFrameEnabled = false
   #captureSpanData = false
   #codeHotspotsEnabled = false
+  #contextCountGaugeUpdater
   #cpuProfilingEnabled = false
+  #currentContext
   #customLabelsActive = false
   #customLabelKeys
   #endpointCollectionEnabled = false
   #flushIntervalMillis = 0
+  #lastSampleCount = 0
   #mapper
   #pprof
+  #profilerState
   #samplingIntervalMicros = 0
   #started = false
   #telemetryHeartbeatIntervalMillis = 0
@@ -130,17 +137,20 @@ class NativeWallProfiler {
 
   get type () { return 'wall' }
 
-  constructor (options = {}) {
-    this.#asyncContextFrameEnabled = !!options.asyncContextFrameEnabled
-    this.#codeHotspotsEnabled = !!options.codeHotspotsEnabled
-    this.#cpuProfilingEnabled = !!options.cpuProfilingEnabled
-    this.#endpointCollectionEnabled = !!options.endpointCollectionEnabled
-    this.#flushIntervalMillis = options.flushInterval || 60 * 1e3 // 60 seconds
-    // TODO: Remove default value. It is only used in testing.
-    this.#samplingIntervalMicros = (options.samplingInterval || 1e3 / 99) * 1000
-    this.#telemetryHeartbeatIntervalMillis = options.heartbeatInterval || 60 * 1e3 // 60 seconds
-    this.#timelineEnabled = !!options.timelineEnabled
-    this.#v8ProfilerBugWorkaroundEnabled = !!options.v8ProfilerBugWorkaroundEnabled
+  /**
+   * @param {TracerConfig} config
+   * @param {{ asyncContextFrameEnabled: boolean, flushInterval: number }} runtime
+   */
+  constructor (config, { asyncContextFrameEnabled, flushInterval }) {
+    this.#asyncContextFrameEnabled = asyncContextFrameEnabled
+    this.#codeHotspotsEnabled = config.DD_PROFILING_CODEHOTSPOTS_ENABLED
+    this.#cpuProfilingEnabled = config.DD_PROFILING_CPU_ENABLED
+    this.#endpointCollectionEnabled = config.DD_PROFILING_ENDPOINT_COLLECTION_ENABLED
+    this.#flushIntervalMillis = flushInterval
+    this.#samplingIntervalMicros = SAMPLING_INTERVAL * 1000
+    this.#telemetryHeartbeatIntervalMillis = config.telemetry.DD_TELEMETRY_HEARTBEAT_INTERVAL
+    this.#timelineEnabled = config.DD_PROFILING_TIMELINE_ENABLED
+    this.#v8ProfilerBugWorkaroundEnabled = config.DD_PROFILING_V8_PROFILER_BUG_WORKAROUND
 
     // We need to capture span data into the sample context for either code hotspots
     // or endpoint collection.
@@ -192,8 +202,8 @@ class NativeWallProfiler {
       }
 
       if (this.#captureSpanData) {
-        this._profilerState = this.#pprof.time.getState()
-        this._lastSampleCount = 0
+        this.#profilerState = this.#pprof.time.getState()
+        this.#lastSampleCount = 0
 
         ensureChannelsActivated(this.#asyncContextFrameEnabled)
 
@@ -217,12 +227,12 @@ class NativeWallProfiler {
     const asyncContextsLiveGauge = profilerTelemetryMetrics.gauge('wall.async_contexts_live')
     const asyncContextsUsedGauge = profilerTelemetryMetrics.gauge('wall.async_contexts_used')
 
-    this._contextCountGaugeUpdater = setInterval(() => {
+    this.#contextCountGaugeUpdater = setInterval(() => {
       const { totalAsyncContextCount, usedAsyncContextCount } = this.#pprof.time.getMetrics()
       asyncContextsLiveGauge.mark(totalAsyncContextCount)
       asyncContextsUsedGauge.mark(usedAsyncContextCount)
     }, this.#telemetryHeartbeatIntervalMillis)
-    this._contextCountGaugeUpdater.unref?.()
+    this.#contextCountGaugeUpdater.unref?.()
   }
 
   #enter () {
@@ -271,16 +281,16 @@ class NativeWallProfiler {
         this.#pprof.time.setContext(sampleContext)
       }
     } else {
-      const sampleCount = this._profilerState[kSampleCount]
-      if (sampleCount !== this._lastSampleCount) {
-        this._lastSampleCount = sampleCount
-        const context = this._currentContext.ref
+      const sampleCount = this.#profilerState[kSampleCount]
+      if (sampleCount !== this.#lastSampleCount) {
+        this.#lastSampleCount = sampleCount
+        const context = this.#currentContext.ref
         this.#setNewContext()
 
         updateContext(context)
       }
 
-      this._currentContext.ref = sampleContext
+      this.#currentContext.ref = sampleContext
     }
   }
 
@@ -322,10 +332,10 @@ class NativeWallProfiler {
   }
 
   #setNewContext () {
-    this._currentContext = {
+    this.#currentContext = {
       ref: {},
     }
-    this.#pprof.time.setContext(this._currentContext)
+    this.#pprof.time.setContext(this.#currentContext)
   }
 
   #spanFinished (span) {
@@ -360,7 +370,7 @@ class NativeWallProfiler {
     if (this.#captureSpanData && !this.#asyncContextFrameEnabled) {
       // update last sample context if needed
       this.#enter()
-      this._lastSampleCount = 0
+      this.#lastSampleCount = 0
     }
 
     // Mark thread labels and trace endpoint label as good deduplication candidates
@@ -382,7 +392,7 @@ class NativeWallProfiler {
         this.#reportV8bug(v8BugDetected === 1)
       }
     } else {
-      clearInterval(this._contextCountGaugeUpdater)
+      clearInterval(this.#contextCountGaugeUpdater)
       if (this.#captureSpanData) {
         if (!this.#asyncContextFrameEnabled) {
           beforeCh.unsubscribe(this.#boundEnter)
@@ -392,7 +402,7 @@ class NativeWallProfiler {
         if (this.#endpointCollectionEnabled) {
           tagsUpdateCh.unsubscribe(this.#boundSpanTagsUpdated)
         }
-        this._profilerState = undefined
+        this.#profilerState = undefined
       }
       this.#started = false
     }

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

@@ -138,7 +138,7 @@ class Tracer extends NoopProxy {
         spanleak.startScrubber()
       }
 
-      if (config.remoteConfig.enabled && !config.isCiVisibility) {
+      if (config.remoteConfig.DD_REMOTE_CONFIGURATION_ENABLED && !config.isCiVisibility) {
         const RemoteConfig = require('./remote_config')
         const rc = new RemoteConfig(config)
 
@@ -180,11 +180,11 @@ class Tracer extends NoopProxy {
         openfeatureRemoteConfig.enable(rc, config, () => this.openfeature)
       }
 
-      if (config.profiling.enabled === 'true') {
+      if (config.profiling.DD_PROFILING_ENABLED === 'true') {
         this._profilerStarted = this._startProfiler(config)
       } else {
         this._profilerStarted = false
-        if (config.profiling.enabled === 'auto') {
+        if (config.profiling.DD_PROFILING_ENABLED === 'auto') {
           const { SSIHeuristics } = require('./profiling/ssi-heuristics')
           const ssiHeuristics = new SSIHeuristics(config)
           ssiHeuristics.start()
@@ -216,7 +216,7 @@ class Tracer extends NoopProxy {
 
       this._modules.rewriter.enable(config)
 
-      if (config.tracing && config.DD_CIVISIBILITY_MANUAL_API_ENABLED) {
+      if (config.DD_TRACE_ENABLED && config.testOptimization.DD_CIVISIBILITY_MANUAL_API_ENABLED) {
         const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
         this._testApiManualPlugin = new TestApiManualPlugin(this)
         // `shouldGetEnvironmentData` is passed as false so that we only lazily calculate it
@@ -225,7 +225,7 @@ class Tracer extends NoopProxy {
         this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
       }
       if (config.DD_AGENTLESS_LOG_SUBMISSION_ENABLED) {
-        if (config.apiKey) {
+        if (config.DD_API_KEY) {
           const LogSubmissionPlugin = require('./ci-visibility/log-submission/log-submission-plugin')
           const automaticLogPlugin = new LogSubmissionPlugin(this)
           automaticLogPlugin.configure({ ...config, enabled: true })
@@ -237,7 +237,7 @@ class Tracer extends NoopProxy {
         }
       }
 
-      if (config.isTestDynamicInstrumentationEnabled) {
+      if (config.testOptimization.DD_TEST_FAILED_TEST_REPLAY_ENABLED) {
         const getDynamicInstrumentationClient = require('./ci-visibility/dynamic-instrumentation')
         // We instantiate the client but do not start the Worker here. The worker is started lazily
         getDynamicInstrumentationClient(config)
@@ -270,11 +270,11 @@ class Tracer extends NoopProxy {
    * @param {import('./config/config-base')} config - Tracer configuration
    */
   #updateTracing (config) {
-    if (config.tracing !== false) {
+    if (config.DD_TRACE_ENABLED !== false) {
       if (config.appsec.enabled) {
         this._modules.appsec.enable(config)
       }
-      if (config.llmobs.enabled) {
+      if (config.llmobs.DD_LLMOBS_ENABLED) {
         this._modules.llmobs.enable(config)
       }
       if (!this._tracingInitialized) {

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

@@ -8,7 +8,7 @@ const dc = require('dc-polyfill')
 
 const parse = require('../../../vendor/dist/module-details-from-path')
 const { isRelativeRequire } = require('../../datadog-instrumentations/src/helpers/shared-utils')
-const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
+const { getConfiguredEnvName, getEnvironmentVariable } = require('./config/helper')
 
 const origRequire = Module.prototype.require
 // derived from require-in-the-middle@3 with tweaks
@@ -143,7 +143,9 @@ function Hook (modules, options, onrequire) {
       name = moduleId
     } else {
       const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
-      const hasLambdaHandler = getValueFromEnvSources('DD_LAMBDA_HANDLER') !== undefined
+      // Presence check over all sources (incl. stable config) without parsing —
+      // parsing here would re-enter this require hook via config/defaults.
+      const hasLambdaHandler = getConfiguredEnvName('DD_LAMBDA_HANDLER') !== undefined
       const segments = filename.split(path.sep)
       const filenameFromNodeModule = segments.includes('node_modules')
       // decide how to assign the stat

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

@@ -1,7 +1,6 @@
 'use strict'
 
 const { getEnvironmentVariable, getValueFromEnvSources } = require('./config/helper')
-const { isFalse } = require('./util')
 
 function getIsGCPFunction () {
   const isDeprecatedGCPFunction =
@@ -23,7 +22,7 @@ function getIsGCPFunction () {
  */
 function enableGCPPubSubPushSubscription () {
   return getEnvironmentVariable('K_SERVICE') !== undefined &&
-    !isFalse(getValueFromEnvSources('DD_TRACE_GCP_PUBSUB_PUSH_ENABLED'))
+    getValueFromEnvSources('DD_TRACE_GCP_PUBSUB_PUSH_ENABLED')
 }
 
 function getIsAzureFunction () {