dd-trace 5.96.0 → 5.98.0

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

@@ -7,8 +7,9 @@ const log = require('../../log')
 const tags = require('../../../../../ext/tags')
 const types = require('../../../../../ext/types')
 const kinds = require('../../../../../ext/kinds')
-const { ERROR_MESSAGE, ERROR_TYPE, ERROR_STACK } = require('../../constants')
+const { ERROR_MESSAGE } = require('../../constants')
 const TracingPlugin = require('../tracing')
+const { storage } = require('../../../../datadog-core')
 const urlFilter = require('./urlfilter')
 const { createInferredProxySpan, finishInferredProxySpan } = require('./inferred_proxy')
 const { extractURL, obfuscateQs, calculateHttpEndpoint } = require('./url')
@@ -125,33 +126,13 @@ const web = {
     context.tracer = tracer
     context.span = span
     context.res = res
+    context.store = storage('legacy').getStore()
 
     this.setConfig(req, config)
     addRequestTags(context, this.TYPE)
 
     return span
   },
-  wrap (req) {
-    const context = contexts.get(req)
-    if (!context.instrumented) {
-      this.wrapEnd(context)
-      context.instrumented = true
-    }
-  },
-  // Start a span and activate a scope for a request.
-  instrument (tracer, config, req, res, name, callback) {
-    const span = this.startSpan(tracer, config, req, res, name)
-
-    this.wrap(req)
-
-    return callback && tracer.scope().activate(span, () => callback(span))
-  },
-
-  // Reactivate the request scope in case it was changed by a middleware.
-  reactivate (req, fn) {
-    return reactivate(req, fn)
-  },
-
   // Add a route segment that will be used for the resource name.
   enterRoute (req, path) {
     if (typeof path === 'string') {
@@ -172,61 +153,6 @@ const web = {
     contexts.get(req).paths.pop()
   },
 
-  // Start a new middleware span and activate a new scope with the span.
-  wrapMiddleware (req, middleware, name, fn) {
-    if (!this.active(req)) return fn()
-
-    const context = contexts.get(req)
-    const tracer = context.tracer
-    const childOf = this.active(req)
-    const config = context.config
-    const traceCtx = context.traceCtx
-
-    if (config.middleware === false) return this.bindAndWrapMiddlewareErrors(fn, req, tracer, childOf)
-
-    const span = startSpanHelper(tracer, name, { childOf }, traceCtx, config)
-
-    analyticsSampler.sample(span, config.measured)
-
-    span.addTags({
-      [RESOURCE_NAME]: middleware._name || middleware.name || '<anonymous>',
-    })
-
-    context.middleware.push(span)
-
-    return tracer.scope().activate(span, fn)
-  },
-
-  // catch errors and apply to active span
-  bindAndWrapMiddlewareErrors (fn, req, tracer, activeSpan) {
-    try {
-      return tracer.scope().bind(fn, activeSpan).apply(this, arguments)
-    } catch (e) {
-      web.addError(req, e) // TODO: remove when error formatting is moved to Span
-      throw e
-    }
-  },
-
-  // Finish the active middleware span.
-  finish (req, error) {
-    if (!this.active(req)) return
-
-    const context = contexts.get(req)
-    const span = context.middleware.pop()
-
-    if (span) {
-      if (error) {
-        span.addTags({
-          [ERROR_TYPE]: error.name,
-          [ERROR_MESSAGE]: error.message,
-          [ERROR_STACK]: error.stack,
-        })
-      }
-
-      span.finish()
-    }
-  },
-
   // Register a callback to run before res.end() is called.
   beforeEnd (req, callback) {
     contexts.get(req).beforeEnd.push(callback)
@@ -278,7 +204,6 @@ const web = {
   startServerlessSpanWithInferredProxy (tracer, config, name, req, traceCtx) {
     const headers = req.headers
     const reqCtx = contexts.get(req)
-    const { storage } = require('../../../../datadog-core')
     const store = storage('legacy').getStore()
     const pubsubSpan = store?.span?._name === 'pubsub.push.receive' ? store.span : null
 
@@ -391,7 +316,6 @@ const web = {
     }
   },
   wrapEnd (context) {
-    const scope = context.tracer.scope()
     const req = context.req
     const res = context.res
     const end = res.end
@@ -406,7 +330,9 @@ const web = {
         return ends.get(this)
       },
       set (value) {
-        ends.set(this, scope.bind(value, context.span))
+        ends.set(this, function () {
+          return storage('legacy').run(context.store, value, ...arguments)
+        })
       },
     })
   },
@@ -453,14 +379,6 @@ function splitHeader (str) {
   return typeof str === 'string' ? str.split(/\s*,\s*/) : []
 }
 
-function reactivate (req, fn) {
-  const context = contexts.get(req)
-
-  return context
-    ? context.tracer.scope().activate(context.span, fn)
-    : fn()
-}
-
 function addRequestTags (context, spanType) {
   const { req, span, inferredProxySpan, config } = context
   const url = extractURL(req)

package/packages/dd-trace/src/process-tags/index.js

@@ -72,6 +72,9 @@ function buildProcessTags (config) {
 
 // Singleton with constant defaults so pre-init reads don't blow up
 const processTags = module.exports = {
+  /**
+   * @param {import('../config/config-base')} config
+   */
   initialize (config) {
     // check if one of the properties added during build exist and if so return
     if (processTags.tags) return

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

@@ -5,13 +5,38 @@ const { profiler } = require('./profiling')
 globalThis[Symbol.for('dd-trace')].beforeExitHandlers.add(() => { profiler.stop() })
 
 module.exports = {
-  start: config => {
+  /**
+   * @param {import('./config/config-base')} config - Tracer configuration
+   */
+  start (config) {
     // Forward the full tracer config to the profiling layer.
     // Profiling code is responsible for deriving the specific options it needs.
     return profiler.start(config)
   },
 
-  stop: () => {
+  stop () {
     profiler.stop()
   },
+
+  /**
+   * Declares the set of custom label keys that will be used with
+   * {@link runWithLabels}.
+   *
+   * @param {Iterable<string>} keys - Custom label key names
+   */
+  setCustomLabelKeys: (keys) => {
+    profiler.setCustomLabelKeys(keys)
+  },
+
+  /**
+   * Runs a function with custom profiling labels attached to wall profiler samples.
+   *
+   * @param {Record<string, string | number>} labels - Custom labels to attach
+   * @param {function(): T} fn - Function to execute with the labels
+   * @returns {T} The return value of fn
+   * @template T
+   */
+  runWithLabels: (labels, fn) => {
+    return profiler.runWithLabels(labels, fn)
+  },
 }

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

@@ -6,9 +6,8 @@ const { pathToFileURL } = require('url')
 const satisfies = require('../../../../vendor/dist/semifies')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { getIsAzureFunction } = require('../serverless')
-const { isFalse, isTrue } = require('../util')
 const { getAzureTagsFromMetadata, getAzureAppMetadata, getAzureFunctionMetadata } = require('../azure_metadata')
-const { getEnvironmentVariable, getValueFromEnvSources } = require('../config/helper')
+const { getEnvironmentVariable } = require('../config/helper')
 const { getAgentUrl } = require('../agent/url')
 const { isACFActive } = require('../../../datadog-core/src/storage')
 
@@ -22,59 +21,22 @@ const { oomExportStrategies, snapshotKinds } = require('./constants')
 const { tagger } = require('./tagger')
 
 class Config {
-  constructor (options = {}) {
-    // TODO: Remove entries that were already resolved in config.
-    // For the others, move them over to config.
+  constructor (options) {
     const AWS_LAMBDA_FUNCTION_NAME = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME')
 
-    // TODO: Move initialization of these values to packages/dd-trace/src/config/index.js, and just read from config
-    const {
-      DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED,
-      DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED,
-      DD_PROFILING_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_CPU_ENABLED,
-      DD_PROFILING_DEBUG_SOURCE_MAPS,
-      DD_PROFILING_DEBUG_UPLOAD_COMPRESSION,
-      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
-      DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
-      DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
-      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED,
-      DD_PROFILING_HEAP_ENABLED,
-      DD_PROFILING_HEAP_SAMPLING_INTERVAL,
-      DD_PROFILING_PPROF_PREFIX,
-      DD_PROFILING_PROFILERS,
-      DD_PROFILING_TIMELINE_ENABLED,
-      DD_PROFILING_UPLOAD_PERIOD,
-      DD_PROFILING_UPLOAD_TIMEOUT,
-      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
-      DD_PROFILING_WALLTIME_ENABLED,
-      DD_TAGS,
-    } = getProfilingEnvValues()
-
-    // Must be longer than one minute so pad with five seconds
-    const flushInterval = options.interval ?? (Number(DD_PROFILING_UPLOAD_PERIOD) * 1000 || 65 * 1000)
-    const uploadTimeout = options.uploadTimeout ?? (Number(DD_PROFILING_UPLOAD_TIMEOUT) || 60 * 1000)
-    const pprofPrefix = options.pprofPrefix ?? DD_PROFILING_PPROF_PREFIX ?? ''
-
-    // TODO: Remove the fallback. Just use the value from the config.
-    this.service = options.service || 'node'
+    this.version = options.version
+    this.service = options.service
     this.env = options.env
     this.functionname = AWS_LAMBDA_FUNCTION_NAME
 
-    this.version = options.version
-    this.tags = Object.assign(
-      tagger.parse(DD_TAGS),
-      tagger.parse(options.tags),
-      tagger.parse({
-        env: options.env,
+    this.tags = {
+      ...options.tags,
+      ...tagger.parse({
         host: options.reportHostname ? require('os').hostname() : undefined,
-        service: this.service,
-        version: this.version,
         functionname: AWS_LAMBDA_FUNCTION_NAME,
       }),
-      getAzureTagsFromMetadata(getIsAzureFunction() ? getAzureFunctionMetadata() : getAzureAppMetadata())
-    )
+      ...getAzureTagsFromMetadata(getIsAzureFunction() ? getAzureFunctionMetadata() : getAzureAppMetadata()),
+    }
 
     // Add source code integration tags if available
     if (options.repositoryUrl && options.commitSHA) {
@@ -82,58 +44,35 @@ class Config {
       this.tags[GIT_COMMIT_SHA] = options.commitSHA
     }
 
-    this.logger = ensureLogger(options.logger)
-    // Profiler sampling contexts are not available on Windows, so features
-    // depending on those (code hotspots and endpoint collection) need to default
-    // to false on Windows.
-    const samplingContextsAvailable = process.platform !== 'win32'
-    function checkOptionAllowed (option, description, condition) {
-      if (option && !condition) {
-        // injection hardening: all of these can only happen if user explicitly
-        // sets an environment variable to its non-default value on the platform.
-        // In practical terms, it'd require someone explicitly turning on OOM
-        // monitoring, code hotspots, endpoint profiling, or CPU profiling on
-        // Windows, where it is not supported.
-        throw new Error(`${description} not supported on ${process.platform}.`)
-      }
-    }
-    function checkOptionWithSamplingContextAllowed (option, description) {
-      checkOptionAllowed(option, description, samplingContextsAvailable)
-    }
+    // Normalize from seconds to milliseconds. Default must be longer than a minute.
+    this.flushInterval = options.DD_PROFILING_UPLOAD_PERIOD * 1000
+    this.uploadTimeout = options.DD_PROFILING_UPLOAD_TIMEOUT
+    this.sourceMap = options.DD_PROFILING_SOURCE_MAP
+    this.debugSourceMaps = options.DD_PROFILING_DEBUG_SOURCE_MAPS
+    this.endpointCollectionEnabled = options.DD_PROFILING_ENDPOINT_COLLECTION_ENABLED
+    this.pprofPrefix = options.DD_PROFILING_PPROF_PREFIX
+    this.v8ProfilerBugWorkaroundEnabled = options.DD_PROFILING_V8_PROFILER_BUG_WORKAROUND
 
-    this.flushInterval = flushInterval
-    this.uploadTimeout = uploadTimeout
-    this.sourceMap = options.sourceMap
-    this.debugSourceMaps = isTrue(options.debugSourceMaps ?? DD_PROFILING_DEBUG_SOURCE_MAPS)
-    this.endpointCollectionEnabled = isTrue(options.endpointCollection ??
-      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED ?? samplingContextsAvailable)
-    checkOptionWithSamplingContextAllowed(this.endpointCollectionEnabled, 'Endpoint collection')
-
-    this.pprofPrefix = pprofPrefix
-    this.v8ProfilerBugWorkaroundEnabled = isTrue(options.v8ProfilerBugWorkaround ??
-      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND ?? true)
+    this.logger = ensureLogger(options.logger)
     this.url = getAgentUrl(options)
 
-    this.libraryInjected = options.libraryInjected
-    this.activation = options.activation
-    this.exporters = ensureExporters(options.exporters || [
-      new AgentExporter(this),
-    ], this)
+    this.libraryInjected = !!options.DD_INJECTION_ENABLED
 
-    // OOM monitoring does not work well on Windows, so it is disabled by default.
-    const oomMonitoringSupported = process.platform !== 'win32'
+    let activation
+    if (options.profiling.enabled === 'auto') {
+      activation = 'auto'
+    } else if (options.profiling.enabled === 'true') {
+      activation = 'manual'
+    } // else activation = undefined
 
-    const oomMonitoringEnabled = isTrue(options.oomMonitoring ??
-      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED ?? oomMonitoringSupported)
-    checkOptionAllowed(oomMonitoringEnabled, 'OOM monitoring', oomMonitoringSupported)
+    this.activation = activation
+    this.exporters = ensureExporters(options.DD_PROFILING_EXPORTERS, this)
 
-    const heapLimitExtensionSize = options.oomHeapLimitExtensionSize ??
-      (Number(DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE) || 0)
-    const maxHeapExtensionCount = options.oomMaxHeapExtensionCount ??
-      (Number(DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT) || 0)
+    const oomMonitoringEnabled = options.DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED
+    const heapLimitExtensionSize = options.DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE
+    const maxHeapExtensionCount = options.DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT
     const exportStrategies = oomMonitoringEnabled
-      ? ensureOOMExportStrategies(options.oomExportStrategies ?? DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES ??
-        [oomExportStrategies.PROCESS], this)
+      ? ensureOOMExportStrategies(options.DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES, this)
       : []
     const exportCommand = oomMonitoringEnabled ? buildExportCommand(this) : undefined
     this.oomMonitoring = {
@@ -144,61 +83,26 @@ class Config {
       exportCommand,
     }
 
-    const profilers = options.profilers || getProfilers({
-      DD_PROFILING_HEAP_ENABLED,
-      DD_PROFILING_WALLTIME_ENABLED,
-      DD_PROFILING_PROFILERS,
-    })
+    const profilers = getProfilers(options)
 
-    this.timelineEnabled = isTrue(
-      options.timelineEnabled ?? DD_PROFILING_TIMELINE_ENABLED ?? samplingContextsAvailable
-    )
-    checkOptionWithSamplingContextAllowed(this.timelineEnabled, 'Timeline view')
-    this.timelineSamplingEnabled = isTrue(
-      options.timelineSamplingEnabled ?? DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED ?? true
-    )
+    this.timelineEnabled = options.DD_PROFILING_TIMELINE_ENABLED
+    this.timelineSamplingEnabled = options.DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED
+    this.codeHotspotsEnabled = options.DD_PROFILING_CODEHOTSPOTS_ENABLED
+    this.cpuProfilingEnabled = options.DD_PROFILING_CPU_ENABLED
+    this.heapSamplingInterval = options.DD_PROFILING_HEAP_SAMPLING_INTERVAL
 
-    this.codeHotspotsEnabled = isTrue(
-      options.codeHotspotsEnabled ?? DD_PROFILING_CODEHOTSPOTS_ENABLED ?? samplingContextsAvailable
-    )
-    checkOptionWithSamplingContextAllowed(this.codeHotspotsEnabled, 'Code hotspots')
-
-    this.cpuProfilingEnabled = isTrue(
-      options.cpuProfilingEnabled ?? DD_PROFILING_CPU_ENABLED ?? samplingContextsAvailable
-    )
-    checkOptionWithSamplingContextAllowed(this.cpuProfilingEnabled, 'CPU profiling')
-
-    this.samplingInterval = options.samplingInterval || 1e3 / 99 // 99hz in millis
-
-    this.heapSamplingInterval = options.heapSamplingInterval ??
-      (Number(DD_PROFILING_HEAP_SAMPLING_INTERVAL) || 512 * 1024)
+    this.samplingInterval = 1e3 / 99 // 99hz in milliseconds
 
     const isAtLeast24 = satisfies(process.versions.node, '>=24.0.0')
 
-    const uploadCompression0 = options.uploadCompression ?? DD_PROFILING_DEBUG_UPLOAD_COMPRESSION ?? 'on'
+    const uploadCompression0 = options.DD_PROFILING_DEBUG_UPLOAD_COMPRESSION
     let [uploadCompression, level0] = uploadCompression0.split('-')
-    if (!['on', 'off', 'gzip', 'zstd'].includes(uploadCompression)) {
-      this.logger.warn(`Invalid profile upload compression method "${uploadCompression0}". Will use "on".`)
-      uploadCompression = 'on'
-    }
     let level = level0 ? Number.parseInt(level0, 10) : undefined
     if (level !== undefined) {
-      if (['on', 'off'].includes(uploadCompression)) {
-        this.logger.warn(`Compression levels are not supported for "${uploadCompression}".`)
-        level = undefined
-      } else if (Number.isNaN(level)) {
-        this.logger.warn(
-          `Invalid compression level "${level0}". Will use default level.`)
-        level = undefined
-      } else if (level < 1) {
-        this.logger.warn(`Invalid compression level ${level}. Will use 1.`)
-        level = 1
-      } else {
-        const maxLevel = { gzip: 9, zstd: 22 }[uploadCompression]
-        if (level > maxLevel) {
-          this.logger.warn(`Invalid compression level ${level}. Will use ${maxLevel}.`)
-          level = maxLevel
-        }
+      const maxLevel = { gzip: 9, zstd: 22 }[uploadCompression]
+      if (level > maxLevel) {
+        this.logger.warn(`Invalid compression level ${level}. Will use ${maxLevel}.`)
+        level = maxLevel
       }
     }
 
@@ -219,13 +123,9 @@ class Config {
       that.asyncContextFrameEnabled = false
     }
 
-    const canUseAsyncContextFrame = samplingContextsAvailable && isACFActive
-
-    this.asyncContextFrameEnabled = isTrue(DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED ?? canUseAsyncContextFrame)
-    if (this.asyncContextFrameEnabled && !canUseAsyncContextFrame) {
-      if (!samplingContextsAvailable) {
-        turnOffAsyncContextFrame(`on ${process.platform}`)
-      } else if (isAtLeast24) {
+    this.asyncContextFrameEnabled = options.DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED ?? isACFActive
+    if (this.asyncContextFrameEnabled && !isACFActive) {
+      if (isAtLeast24) {
         turnOffAsyncContextFrame('with --no-async-context-frame')
       } else if (satisfies(process.versions.node, '>=22.9.0')) {
         turnOffAsyncContextFrame('without --experimental-async-context-frame')
@@ -234,7 +134,7 @@ class Config {
       }
     }
 
-    this.heartbeatInterval = options.heartbeatInterval || 60 * 1000 // 1 minute
+    this.heartbeatInterval = options.telemetry.heartbeatInterval
 
     this.profilers = ensureProfilers(profilers, this)
   }
@@ -248,7 +148,7 @@ class Config {
       endpointCollectionEnabled: this.endpointCollectionEnabled,
       heapSamplingInterval: this.heapSamplingInterval,
       oomMonitoring: { ...this.oomMonitoring },
-      profilerTypes: this.profilers.map(p => p.type),
+      profilerTypes: this.profilers.map(profiler => profiler.type),
       sourceMap: this.sourceMap,
       timelineEnabled: this.timelineEnabled,
       timelineSamplingEnabled: this.timelineSamplingEnabled,
@@ -263,7 +163,9 @@ class Config {
 module.exports = { Config }
 
 function getProfilers ({
-  DD_PROFILING_HEAP_ENABLED, DD_PROFILING_WALLTIME_ENABLED, DD_PROFILING_PROFILERS,
+  DD_PROFILING_HEAP_ENABLED,
+  DD_PROFILING_WALLTIME_ENABLED,
+  DD_PROFILING_PROFILERS,
 }) {
   // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to space + wall
   // Use a Set to avoid duplicates
@@ -272,26 +174,26 @@ function getProfilers ({
   // snapshots the space profile won't include memory taken by profiles created
   // before it in the sequence. That memory is ultimately transient and will be
   // released when all profiles are subsequently encoded.
-  const profilers = new Set((DD_PROFILING_PROFILERS ?? 'space,wall').split(','))
+  const profilers = new Set(DD_PROFILING_PROFILERS)
 
   let spaceExplicitlyEnabled = false
   // Add/remove space depending on the value of DD_PROFILING_HEAP_ENABLED
-  if (DD_PROFILING_HEAP_ENABLED != null) {
-    if (isTrue(DD_PROFILING_HEAP_ENABLED)) {
+  if (DD_PROFILING_HEAP_ENABLED !== undefined) {
+    if (DD_PROFILING_HEAP_ENABLED) {
       if (!profilers.has('space')) {
         profilers.add('space')
         spaceExplicitlyEnabled = true
       }
-    } else if (isFalse(DD_PROFILING_HEAP_ENABLED)) {
+    } else {
       profilers.delete('space')
     }
   }
 
   // Add/remove wall depending on the value of DD_PROFILING_WALLTIME_ENABLED
-  if (DD_PROFILING_WALLTIME_ENABLED != null) {
-    if (isTrue(DD_PROFILING_WALLTIME_ENABLED)) {
+  if (DD_PROFILING_WALLTIME_ENABLED !== undefined) {
+    if (DD_PROFILING_WALLTIME_ENABLED) {
       profilers.add('wall')
-    } else if (isFalse(DD_PROFILING_WALLTIME_ENABLED)) {
+    } else {
       profilers.delete('wall')
       profilers.delete('cpu') // remove alias too
     }
@@ -321,22 +223,12 @@ function getExportStrategy (name, options) {
 }
 
 function ensureOOMExportStrategies (strategies, options) {
-  if (!strategies) {
-    return []
+  const set = new Set()
+  for (const strategy of strategies) {
+    set.add(getExportStrategy(strategy, options))
   }
 
-  if (typeof strategies === 'string') {
-    strategies = strategies.split(',')
-  }
-
-  for (let i = 0; i < strategies.length; i++) {
-    const strategy = strategies[i]
-    if (typeof strategy === 'string') {
-      strategies[i] = getExportStrategy(strategy, options)
-    }
-  }
-
-  return [...new Set(strategies)]
+  return [...set]
 }
 
 function getExporter (name, options) {
@@ -345,22 +237,13 @@ function getExporter (name, options) {
       return new AgentExporter(options)
     case 'file':
       return new FileExporter(options)
+    default:
+      options.logger.error(`Unknown exporter "${name}"`)
   }
 }
 
 function ensureExporters (exporters, options) {
-  if (typeof exporters === 'string') {
-    exporters = exporters.split(',')
-  }
-
-  for (let i = 0; i < exporters.length; i++) {
-    const exporter = exporters[i]
-    if (typeof exporter === 'string') {
-      exporters[i] = getExporter(exporter, options)
-    }
-  }
-
-  return exporters
+  return exporters.map((exporter) => getExporter(exporter, options))
 }
 
 function getProfiler (name, options) {
@@ -376,30 +259,26 @@ function getProfiler (name, options) {
 }
 
 function ensureProfilers (profilers, options) {
-  if (typeof profilers === 'string') {
-    profilers = profilers.split(',')
-  }
+  const filteredProfilers = []
 
   for (let i = 0; i < profilers.length; i++) {
-    const profiler = profilers[i]
-    if (typeof profiler === 'string') {
-      profilers[i] = getProfiler(profiler, options)
+    const profiler = getProfiler(profilers[i], options)
+    if (profiler !== undefined) {
+      filteredProfilers.push(profiler)
     }
   }
 
   // Events profiler is a profiler that produces timeline events. It is only
   // added if timeline is enabled and there's a wall profiler.
-  if (options.timelineEnabled && profilers.some(p => p instanceof WallProfiler)) {
-    profilers.push(new EventsProfiler(options))
+  if (options.timelineEnabled && filteredProfilers.some(profiler => profiler instanceof WallProfiler)) {
+    filteredProfilers.push(new EventsProfiler(options))
   }
 
-  // Filter out any invalid profilers
-  return profilers.filter(Boolean)
+  return filteredProfilers
 }
 
 function ensureLogger (logger) {
-  if (typeof logger !== 'object' ||
-    typeof logger.debug !== 'function' ||
+  if (typeof logger?.debug !== 'function' ||
     typeof logger.info !== 'function' ||
     typeof logger.warn !== 'function' ||
     typeof logger.error !== 'function') {
@@ -424,50 +303,3 @@ function buildExportCommand (options) {
     path.join(__dirname, 'exporter_cli.js'),
     urls.join(','), tags, 'space']
 }
-
-function getProfilingEnvValues () {
-  return {
-    DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED:
-      getValueFromEnvSources('DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED'),
-    DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED'),
-    DD_PROFILING_CODEHOTSPOTS_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_CODEHOTSPOTS_ENABLED'),
-    DD_PROFILING_CPU_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_CPU_ENABLED'),
-    DD_PROFILING_DEBUG_SOURCE_MAPS:
-      getValueFromEnvSources('DD_PROFILING_DEBUG_SOURCE_MAPS'),
-    DD_PROFILING_DEBUG_UPLOAD_COMPRESSION:
-      getValueFromEnvSources('DD_PROFILING_DEBUG_UPLOAD_COMPRESSION'),
-    DD_PROFILING_ENDPOINT_COLLECTION_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_ENDPOINT_COLLECTION_ENABLED'),
-    DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES:
-      getValueFromEnvSources('DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES'),
-    DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE:
-      getValueFromEnvSources('DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE'),
-    DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT:
-      getValueFromEnvSources('DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT'),
-    DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED'),
-    DD_PROFILING_HEAP_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_HEAP_ENABLED'),
-    DD_PROFILING_HEAP_SAMPLING_INTERVAL:
-      getValueFromEnvSources('DD_PROFILING_HEAP_SAMPLING_INTERVAL'),
-    DD_PROFILING_PPROF_PREFIX:
-      getValueFromEnvSources('DD_PROFILING_PPROF_PREFIX'),
-    DD_PROFILING_PROFILERS:
-      getValueFromEnvSources('DD_PROFILING_PROFILERS'),
-    DD_PROFILING_TIMELINE_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_TIMELINE_ENABLED'),
-    DD_PROFILING_UPLOAD_PERIOD:
-      getValueFromEnvSources('DD_PROFILING_UPLOAD_PERIOD'),
-    DD_PROFILING_UPLOAD_TIMEOUT:
-      getValueFromEnvSources('DD_PROFILING_UPLOAD_TIMEOUT'),
-    DD_PROFILING_V8_PROFILER_BUG_WORKAROUND:
-      getValueFromEnvSources('DD_PROFILING_V8_PROFILER_BUG_WORKAROUND'),
-    DD_PROFILING_WALLTIME_ENABLED:
-      getValueFromEnvSources('DD_PROFILING_WALLTIME_ENABLED'),
-    DD_TAGS:
-      getValueFromEnvSources('DD_TAGS'),
-  }
-}

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

@@ -17,9 +17,6 @@ function exporterFromURL (url) {
   if (url.protocol === 'file:') {
     return new FileExporter({ pprofPrefix: fileURLToPath(url) })
   }
-  // TODO: Why is DD_INJECTION_ENABLED a comma separated list?
-  const injectionEnabled = (getValueFromEnvSources('DD_INJECTION_ENABLED') ?? '').split(',')
-  const libraryInjected = injectionEnabled.length > 0
   const profilingEnabled = (getValueFromEnvSources('DD_PROFILING_ENABLED') ?? '').toLowerCase()
   const activation = ['true', '1'].includes(profilingEnabled)
     ? 'manual'
@@ -30,7 +27,7 @@ function exporterFromURL (url) {
     url,
     logger,
     uploadTimeout: timeoutMs,
-    libraryInjected,
+    libraryInjected: !!getValueFromEnvSources('DD_INJECTION_ENABLED'),
     activation,
   })
 }