dd-trace 5.109.0 → 5.110.0

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

@@ -13,7 +13,8 @@ const { storage } = require('../../../../datadog-core')
 const legacyStorage = storage('legacy')
 const urlFilter = require('./urlfilter')
 const { createInferredProxySpan, finishInferredProxySpan } = require('./inferred_proxy')
-const { extractURL, obfuscateQs, calculateHttpEndpoint } = require('./url')
+const { extractURL, obfuscateQs, getQsObfuscator, calculateHttpEndpoint } = require('./url')
+const { NETWORK_PEER_ADDRESS } = require('./http-otel-semantics')
 
 const WEB = types.WEB
 const SERVER = kinds.SERVER
@@ -389,6 +390,15 @@ function addRequestTags (context, spanType) {
     [HTTP_USERAGENT]: req.headers['user-agent'],
   })
 
+  // OTel `network.peer.address` is the immediate socket peer. It has no Datadog
+  // equivalent and the socket isn't available at serialization, so (unlike the
+  // other HTTP attributes, which are renamed centrally in span_format) it is set
+  // here directly when OTel semantics are enabled.
+  if (config.DD_TRACE_OTEL_SEMANTICS_ENABLED) {
+    const peerAddress = req.socket?.remoteAddress
+    if (peerAddress) span.setTag(NETWORK_PEER_ADDRESS, peerAddress)
+  }
+
   // if client ip has already been set by appsec, no need to run it again
   if (config.extractIp && !spanContext.hasTag(HTTP_CLIENT_IP)) {
     const clientIp = config.extractIp(config, req)
@@ -433,26 +443,25 @@ function applyRouteOrEndpointTag (context) {
   if (!span) return
   const spanContext = span.context()
 
-  // AppSec calls `web.setRouteOrEndpointTag` from a pre-finish hook so the
-  // route/endpoint tags are available for API Security sampling, and the
-  // normal finish-time path runs this again. Either tag being present
-  // means the work has already been done; paths are stable between the
-  // two calls, so the second pass has nothing to add.
-  if (spanContext.hasTag(HTTP_ROUTE) || spanContext.hasTag(HTTP_ENDPOINT)) return
+  // AppSec runs this from a pre-finish hook and the finish path runs it
+  // again. http.route is terminal once set; nothing supersedes it.
+  if (spanContext.hasTag(HTTP_ROUTE)) return
 
   // Skip the `Array.prototype.join` builtin in the empty / single-segment
   // cases; `paths[0]` covers both (`undefined` is falsy for the empty case).
   const route = paths.length > 1 ? paths.join('') : paths[0]
 
   if (route) {
-    // Use http.route from trusted framework instrumentation.
+    // A framework route supersedes any http.endpoint fallback a pre-finish
+    // call stamped before the route resolved; it must not be gated on
+    // HTTP_ENDPOINT.
     span.setTag(HTTP_ROUTE, route)
     return
   }
 
-  if (!config.resourceRenamingEnabled) return
+  // Route unavailable. Compute the http.endpoint fallback once across both calls.
+  if (!config.resourceRenamingEnabled || spanContext.hasTag(HTTP_ENDPOINT)) return
 
-  // Route is unavailable, compute http.endpoint once.
   const url = spanContext.getTag(HTTP_URL)
   const endpoint = url ? calculateHttpEndpoint(url) : '/'
   span.setTag(HTTP_ENDPOINT, endpoint)
@@ -543,30 +552,4 @@ function getMiddlewareSetting (config) {
   return true
 }
 
-function getQsObfuscator (config) {
-  const obfuscator = config.queryStringObfuscation
-
-  if (typeof obfuscator === 'boolean') {
-    return obfuscator
-  }
-
-  if (typeof obfuscator === 'string') {
-    if (obfuscator === '') return false // disable obfuscator
-
-    if (obfuscator === '.*') return true // optimize full redact
-
-    try {
-      return new RegExp(obfuscator, 'gi')
-    } catch (err) {
-      log.error('Web plugin error getting qs obfuscator', err)
-    }
-  }
-
-  if (config.hasOwnProperty('queryStringObfuscation')) {
-    log.error('Expected `queryStringObfuscation` to be a regex string or boolean.')
-  }
-
-  return true
-}
-
 module.exports = web

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

@@ -19,6 +19,7 @@ const RateLimiter = require('./rate_limiter')
 const Sampler = require('./sampler')
 const { setSamplingRules } = require('./startup-log')
 const SamplingRule = require('./sampling_rule')
+const { formatKnuthRate } = require('./util')
 
 const {
   SAMPLING_MECHANISM_DEFAULT,
@@ -36,19 +37,6 @@ const {
 
 const DEFAULT_KEY = 'service:,env:'
 
-/**
- * Formats a sampling rate as a string with up to 6 decimal digits and no trailing zeros.
- *
- * @param {number} rate
- */
-function formatKnuthRate (rate) {
-  const string = Number(rate).toFixed(6)
-  for (let i = string.length - 1; i > 0; i--) {
-    if (string[i] === '0') continue
-    return string.slice(0, i + (string[i] === '.' ? 0 : 1))
-  }
-}
-
 const defaultSampler = new Sampler(AUTO_KEEP)
 
 /**

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

@@ -1,15 +1,12 @@
 'use strict'
 
-const path = require('path')
-const { pathToFileURL } = require('url')
-
 const satisfies = require('../../../../vendor/dist/semifies')
 const getGitMetadata = require('../git_metadata')
 const log = require('../log')
 const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { getIsAzureFunction } = require('../serverless')
 const { getAzureTagsFromMetadata, getAzureAppMetadata, getAzureFunctionMetadata } = require('../azure_metadata')
-const { getEnvironmentVariable } = require('../config/helper')
+const { getEnvironmentVariable, getValueFromEnvSources } = require('../config/helper')
 const { isACFActive } = require('../../../datadog-core/src/storage')
 
 const { AgentExporter } = require('./exporters/agent')
@@ -17,152 +14,93 @@ const { FileExporter } = require('./exporters/file')
 const WallProfiler = require('./profilers/wall')
 const SpaceProfiler = require('./profilers/space')
 const EventsProfiler = require('./profilers/events')
-const { oomExportStrategies, snapshotKinds } = require('./constants')
+const { ensureOOMExportStrategies } = require('./oom')
 const { tagger } = require('./tagger')
 
-class Config {
-  constructor (options) {
-    const AWS_LAMBDA_FUNCTION_NAME = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME')
-
-    this.version = options.version
-    this.service = options.service
-    this.env = options.env
-    this.functionname = AWS_LAMBDA_FUNCTION_NAME
-
-    this.tags = {
-      ...options.tags,
-      ...tagger.parse({
-        host: options.reportHostname ? require('os').hostname() : undefined,
-        functionname: AWS_LAMBDA_FUNCTION_NAME,
-      }),
-      ...getAzureTagsFromMetadata(getIsAzureFunction() ? getAzureFunctionMetadata() : getAzureAppMetadata()),
-    }
-
-    const { commitSHA, repositoryUrl } = getGitMetadata(options)
-    if (repositoryUrl && commitSHA) {
-      this.tags[GIT_REPOSITORY_URL] = repositoryUrl
-      this.tags[GIT_COMMIT_SHA] = commitSHA
-    }
-
-    // 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.url = options.url
-
-    this.libraryInjected = !!options.DD_INJECTION_ENABLED
-
-    let activation
-    if (options.profiling.enabled === 'auto') {
-      activation = 'auto'
-    } else if (options.profiling.enabled === 'true') {
-      activation = 'manual'
-    } // else activation = undefined
-
-    this.activation = activation
-    this.exporters = ensureExporters(options.DD_PROFILING_EXPORTERS, this)
-
-    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.DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES)
-      : []
-    const exportCommand = oomMonitoringEnabled ? buildExportCommand(this) : undefined
-    this.oomMonitoring = {
-      enabled: oomMonitoringEnabled,
-      heapLimitExtensionSize,
-      maxHeapExtensionCount,
-      exportStrategies,
-      exportCommand,
-    }
-
-    const profilers = getProfilers(options)
-
-    this.timelineEnabled = options.DD_PROFILING_TIMELINE_ENABLED
-    this.timelineSamplingEnabled = options.DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED
-    this.allocationProfilingEnabled = options.DD_PROFILING_ALLOCATION_ENABLED
-    this.codeHotspotsEnabled = options.DD_PROFILING_CODEHOTSPOTS_ENABLED
-    this.cpuProfilingEnabled = options.DD_PROFILING_CPU_ENABLED
-    this.heapSamplingInterval = options.DD_PROFILING_HEAP_SAMPLING_INTERVAL
-
-    this.samplingInterval = 1e3 / 99 // 99hz in milliseconds
-
-    const isAtLeast24 = satisfies(process.versions.node, '>=24.0.0')
-
-    const uploadCompression0 = options.DD_PROFILING_DEBUG_UPLOAD_COMPRESSION
-    let [uploadCompression, level0] = uploadCompression0.split('-')
-    let level = level0 ? Number.parseInt(level0, 10) : undefined
-    if (level !== undefined) {
-      const maxLevel = { gzip: 9, zstd: 22 }[uploadCompression]
-      if (level > maxLevel) {
-        log.warn('Invalid compression level %d. Will use %d.', level, maxLevel)
-        level = maxLevel
-      }
-    }
-
-    // Default to either zstd (on Node.js 24+) or gzip (earlier Node.js). We could default to ztsd
-    // everywhere as we ship a Rust zstd compressor for older Node.js versions, but on 24+ we use
-    // the built-in one that runs asynchronously on libuv worker threads, just as gzip does. This is
-    // the least disruptive choice.
-    if (uploadCompression === 'on') {
-      uploadCompression = isAtLeast24 ? 'zstd' : 'gzip'
-    }
+/** @typedef {import('../config/config-base')} TracerConfig */
+/** @typedef {AgentExporter | FileExporter} ProfilingExporter */
+/** @typedef {WallProfiler | SpaceProfiler | EventsProfiler} ProfilingProfiler */
+
+/** @param {TracerConfig} config */
+function getProfilingTags (config) {
+  const functionName = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME')
+
+  const tags = {
+    ...config.tags,
+    ...tagger.parse({
+      host: config.reportHostname ? require('os').hostname() : undefined,
+      functionname: functionName,
+    }),
+    ...getAzureTagsFromMetadata(getIsAzureFunction() ? getAzureFunctionMetadata() : getAzureAppMetadata()),
+  }
 
-    this.uploadCompression = { method: uploadCompression, level }
+  const { commitSHA, repositoryUrl } = getGitMetadata(config)
+  if (repositoryUrl && commitSHA) {
+    tags[GIT_REPOSITORY_URL] = repositoryUrl
+    tags[GIT_COMMIT_SHA] = commitSHA
+  }
 
-    const that = this
-    function turnOffAsyncContextFrame (msg) {
-      log.warn('DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED was set %s, it will have no effect.', msg)
-      that.asyncContextFrameEnabled = false
-    }
+  return tags
+}
 
-    this.asyncContextFrameEnabled = options.DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED ?? isACFActive
-    if (this.asyncContextFrameEnabled && !isACFActive) {
-      if (isAtLeast24) {
-        turnOffAsyncContextFrame('with --no-async-context-frame')
+/** @param {TracerConfig} config */
+function getAsyncContextFrameEnabled (config) {
+  const enabled = config.DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED
+  if (enabled && !isACFActive) {
+    // The default value already tracks runtime support, so an unset config landing
+    // here is expected; only an explicit opt-in the runtime can't honor is worth a warning.
+    if (getValueFromEnvSources('DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED', true)) {
+      let reason
+      if (satisfies(process.versions.node, '>=24.0.0')) {
+        reason = 'with --no-async-context-frame'
       } else if (satisfies(process.versions.node, '>=22.9.0')) {
-        turnOffAsyncContextFrame('without --experimental-async-context-frame')
+        reason = 'without --experimental-async-context-frame'
       } else {
-        turnOffAsyncContextFrame('but it requires at least Node.js 22.9.0')
+        reason = 'but it requires at least Node.js 22.9.0'
       }
+      log.warn('DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED was set %s, it will have no effect.', reason)
     }
-
-    this.heartbeatInterval = options.telemetry.heartbeatInterval
-
-    this.profilers = ensureProfilers(profilers, this)
+    return false
   }
+  return enabled
+}
 
-  get systemInfoReport () {
-    const report = {
-      allocationProfilingEnabled: this.allocationProfilingEnabled,
-      asyncContextFrameEnabled: this.asyncContextFrameEnabled,
-      codeHotspotsEnabled: this.codeHotspotsEnabled,
-      cpuProfilingEnabled: this.cpuProfilingEnabled,
-      debugSourceMaps: this.debugSourceMaps,
-      endpointCollectionEnabled: this.endpointCollectionEnabled,
-      heapSamplingInterval: this.heapSamplingInterval,
-      oomMonitoring: { ...this.oomMonitoring },
-      profilerTypes: this.profilers.map(profiler => profiler.type),
-      sourceMap: this.sourceMap,
-      timelineEnabled: this.timelineEnabled,
-      timelineSamplingEnabled: this.timelineSamplingEnabled,
-      uploadCompression: { ...this.uploadCompression },
-      v8ProfilerBugWorkaroundEnabled: this.v8ProfilerBugWorkaroundEnabled,
+/**
+ * @param {TracerConfig} config
+ * @param {{
+ *   asyncContextFrameEnabled: boolean,
+ *   flushInterval: number,
+ *   tags: Record<string, string>,
+ *   exporters: ProfilingExporter[],
+ * }} runtime
+ */
+function createProfilers (config, { asyncContextFrameEnabled, flushInterval, tags, exporters }) {
+  const profilers = []
+  for (const name of selectProfilerTypes(config)) {
+    switch (name) {
+      case 'cpu':
+      case 'wall':
+        profilers.push(new WallProfiler(config, { asyncContextFrameEnabled, flushInterval }))
+        break
+      case 'space':
+        profilers.push(new SpaceProfiler(config, { tags, exporters }))
+        break
+      default:
+        log.error('Unknown profiler "%s"', name)
     }
-    delete report.oomMonitoring.exportCommand
-    return report
   }
-}
 
-module.exports = { Config }
+  // The events profiler produces timeline events. It is only added if timeline
+  // is enabled and there's a wall profiler.
+  if (config.DD_PROFILING_TIMELINE_ENABLED && profilers.some(profiler => profiler instanceof WallProfiler)) {
+    profilers.push(new EventsProfiler(config, { flushInterval }))
+  }
+
+  return profilers
+}
 
-function getProfilers ({
+/** @param {TracerConfig} config */
+function selectProfilerTypes ({
   DD_PROFILING_HEAP_ENABLED,
   DD_PROFILING_WALLTIME_ENABLED,
   DD_PROFILING_PROFILERS,
@@ -214,81 +152,74 @@ function getProfilers ({
   return profilersArray
 }
 
-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
-}
-
-function ensureOOMExportStrategies (strategies) {
-  const set = new Set()
-  for (const strategy of strategies) {
-    set.add(getExportStrategy(strategy))
-  }
-
-  return [...set]
-}
-
-function getExporter (name, options) {
+/**
+ * @param {string} name
+ * @param {TracerConfig} config
+ */
+function getExporter (name, config) {
   switch (name) {
     case 'agent':
-      return new AgentExporter(options)
+      return new AgentExporter(config)
     case 'file':
-      return new FileExporter(options)
+      return new FileExporter(config)
     default:
       log.error('Unknown exporter "%s"', name)
   }
 }
 
-function ensureExporters (exporters, options) {
-  return exporters.map((exporter) => getExporter(exporter, options))
-}
-
-function getProfiler (name, options) {
-  switch (name) {
-    case 'cpu':
-    case 'wall':
-      return new WallProfiler(options)
-    case 'space':
-      return new SpaceProfiler(options)
-    default:
-      log.error('Unknown profiler "%s"', name)
-  }
-}
-
-function ensureProfilers (profilers, options) {
-  const filteredProfilers = []
-
-  for (let i = 0; i < profilers.length; i++) {
-    const profiler = getProfiler(profilers[i], options)
-    if (profiler !== undefined) {
-      filteredProfilers.push(profiler)
+/**
+ * Assembles everything the profiler needs from the tracer config: the runtime objects (tags,
+ * exporters, profilers) the {@link import('./profiler').Profiler#start} consumes and the system
+ * info report sent with each profile. The leaves read the canonical DD_PROFILING_* fields straight
+ * off the config; only the genuinely runtime values (tags, exporters, the resolved async context
+ * frame flag, the flush interval) are derived here.
+ *
+ * @param {TracerConfig} config
+ */
+function buildProfilingRuntime (config) {
+  const tags = getProfilingTags(config)
+  const exporters = []
+  for (const name of config.DD_PROFILING_EXPORTERS) {
+    const exporter = getExporter(name, config)
+    // getExporter logs and returns undefined for an unknown exporter name; drop it so a misconfigured
+    // DD_PROFILING_EXPORTERS entry can't crash the export path later.
+    if (exporter !== undefined) {
+      exporters.push(exporter)
     }
   }
-
-  // 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 && filteredProfilers.some(profiler => profiler instanceof WallProfiler)) {
-    filteredProfilers.push(new EventsProfiler(options))
+  const asyncContextFrameEnabled = getAsyncContextFrameEnabled(config)
+  const flushInterval = config.DD_PROFILING_UPLOAD_PERIOD * 1000
+  const profilers = createProfilers(config, { asyncContextFrameEnabled, flushInterval, tags, exporters })
+  const uploadCompression = config.DD_PROFILING_DEBUG_UPLOAD_COMPRESSION
+
+  const oomMonitoringEnabled = config.DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED
+  const systemInfoReport = {
+    allocationProfilingEnabled: config.DD_PROFILING_ALLOCATION_ENABLED,
+    asyncContextFrameEnabled,
+    codeHotspotsEnabled: config.DD_PROFILING_CODEHOTSPOTS_ENABLED,
+    cpuProfilingEnabled: config.DD_PROFILING_CPU_ENABLED,
+    debugSourceMaps: config.DD_PROFILING_DEBUG_SOURCE_MAPS,
+    endpointCollectionEnabled: config.DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
+    heapSamplingInterval: config.DD_PROFILING_HEAP_SAMPLING_INTERVAL,
+    oomMonitoring: {
+      enabled: oomMonitoringEnabled,
+      heapLimitExtensionSize: config.DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE,
+      maxHeapExtensionCount: config.DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT,
+      exportStrategies: oomMonitoringEnabled
+        ? ensureOOMExportStrategies(config.DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES)
+        : [],
+    },
+    profilerTypes: profilers.map(profiler => profiler.type),
+    sourceMap: config.DD_PROFILING_SOURCE_MAP,
+    timelineEnabled: config.DD_PROFILING_TIMELINE_ENABLED,
+    timelineSamplingEnabled: config.DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED,
+    uploadCompression: { ...uploadCompression },
+    v8ProfilerBugWorkaroundEnabled: config.DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
   }
 
-  return filteredProfilers
+  return { tags, exporters, flushInterval, profilers, uploadCompression, systemInfoReport }
 }
 
-function buildExportCommand (options) {
-  const tags = [...Object.entries(options.tags),
-    ['snapshot', snapshotKinds.ON_OUT_OF_MEMORY]].map(([key, value]) => `${key}:${value}`).join(',')
-  const urls = []
-  for (const exporter of options.exporters) {
-    if (exporter instanceof AgentExporter) {
-      urls.push(options.url.toString())
-    } else if (exporter instanceof FileExporter) {
-      urls.push(pathToFileURL(options.pprofPrefix).toString())
-    }
-  }
-  return [process.execPath,
-    path.join(__dirname, 'exporter_cli.js'),
-    urls.join(','), tags, 'space']
+module.exports = {
+  buildProfilingRuntime,
 }

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

@@ -1,15 +1,12 @@
 'use strict'
 
+// 99hz in milliseconds.
+const SAMPLING_INTERVAL = 1e3 / 99
+
 const snapshotKinds = Object.freeze({
   PERIODIC: 'periodic',
   ON_SHUTDOWN: 'on_shutdown',
   ON_OUT_OF_MEMORY: 'on_oom',
 })
 
-const oomExportStrategies = Object.freeze({
-  PROCESS: 'process',
-  ASYNC_CALLBACK: 'async',
-  LOGS: 'logs',
-})
-
-module.exports = { snapshotKinds, oomExportStrategies }
+module.exports = { SAMPLING_INTERVAL, snapshotKinds }

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

@@ -15,20 +15,20 @@ const timeoutMs = 15 * 1000
 
 function exporterFromURL (url) {
   if (url.protocol === 'file:') {
-    return new FileExporter({ pprofPrefix: fileURLToPath(url) })
+    return new FileExporter({}, fileURLToPath(url))
   }
+  // The subprocess has no tracer config, so mirror the canonical config property
+  // names the exporters read. Normalize the raw env to the parsed profiling.enabled
+  // values ('true' | 'false' | 'auto') the main process would have produced.
   const profilingEnabled = (getValueFromEnvSources('DD_PROFILING_ENABLED') ?? '').toLowerCase()
-  const activation = ['true', '1'].includes(profilingEnabled)
-    ? 'manual'
-    : profilingEnabled === 'auto'
-      ? 'auto'
-      : 'unknown'
+  const enabled = profilingEnabled === 'auto'
+    ? 'auto'
+    : ['true', '1'].includes(profilingEnabled) ? 'true' : 'false'
   return new AgentExporter({
     url,
-    logger,
-    uploadTimeout: timeoutMs,
-    libraryInjected: !!getValueFromEnvSources('DD_INJECTION_ENABLED'),
-    activation,
+    DD_PROFILING_UPLOAD_TIMEOUT: timeoutMs,
+    DD_INJECTION_ENABLED: getValueFromEnvSources('DD_INJECTION_ENABLED'),
+    profiling: { enabled },
   })
 }
 

package/packages/dd-trace/src/profiling/exporters/agent.js

@@ -3,12 +3,12 @@
 const { request: httpRequest } = require('http')
 const { request: httpsRequest } = require('https')
 const perf = require('perf_hooks').performance
-const { urlToHttpOptions } = require('url')
 
 const retry = require('../../../../../vendor/dist/retry')
 // TODO: avoid using dd-trace internals. Make this a separate module?
 const docker = require('../../exporters/common/docker')
 const FormData = require('../../exporters/common/form-data')
+const { parseUrl } = require('../../exporters/common/url')
 const log = require('../../log')
 const { storage } = require('../../../../datadog-core')
 const version = require('../../../../../package.json').version
@@ -88,15 +88,22 @@ function computeRetries (uploadTimeout) {
 }
 
 class AgentExporter extends EventSerializer {
-  constructor (config = {}) {
+  #backoffTime
+  #backoffTries
+
+  /** @param {import('./event_serializer').TracerConfig} config */
+  constructor (config) {
     super(config)
-    const { url, uploadTimeout } = config
-    this._url = url
+    this._url = config.url
+
+    const [backoffTries, backoffTime] = computeRetries(config.DD_PROFILING_UPLOAD_TIMEOUT)
 
-    const [backoffTries, backoffTime] = computeRetries(uploadTimeout)
+    this.#backoffTime = backoffTime
+    this.#backoffTries = backoffTries
+  }
 
-    this._backoffTime = backoffTime
-    this._backoffTries = backoffTries
+  getExportUrl () {
+    return this._url
   }
 
   export (exportSpec) {
@@ -128,8 +135,8 @@ class AgentExporter extends EventSerializer {
     return new Promise((resolve, reject) => {
       const operation = retry.operation({
         randomize: true,
-        minTimeout: this._backoffTime,
-        retries: this._backoffTries,
+        minTimeout: this.#backoffTime,
+        retries: this.#backoffTries,
         unref: true,
       })
 
@@ -148,18 +155,18 @@ class AgentExporter extends EventSerializer {
             'DD-EVP-ORIGIN-VERSION': version,
             ...form.getHeaders(),
           },
-          timeout: this._backoffTime * 2 ** attempt,
+          timeout: this.#backoffTime * 2 ** attempt,
         }
 
         docker.inject(options.headers)
 
-        if (this._url.protocol === 'unix:') {
-          options.socketPath = this._url.pathname
+        const url = parseUrl(this._url)
+        if (url.protocol === 'unix:') {
+          options.socketPath = url.pathname
         } else {
-          const httpOptions = urlToHttpOptions(this._url)
-          options.protocol = httpOptions.protocol
-          options.hostname = httpOptions.hostname
-          options.port = httpOptions.port
+          options.protocol = url.protocol
+          options.hostname = url.hostname
+          options.port = url.port
         }
 
         // eslint-disable-next-line eslint-rules/eslint-log-printf-style