dd-trace 5.108.0 → 5.110.0

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

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

@@ -8,16 +8,47 @@ const version = require('../../../../../package.json').version
 const { availableParallelism, libuvThreadPoolSize } = require('../libuv-size')
 const processTags = require('../../process-tags')
 
+/** @typedef {import('../../config/config-base')} TracerConfig */
+
+/**
+ * Maps the canonical profiling.enabled value to the activation reported in the
+ * profile event.
+ *
+ * @param {string} [enabled] - config.profiling.enabled ('true' | 'false' | 'auto')
+ * @returns {string}
+ */
+function getActivation (enabled) {
+  if (enabled === 'auto') return 'auto'
+  if (enabled === 'true') return 'manual'
+  return 'unknown'
+}
+
 class EventSerializer {
-  constructor ({ env, host, service, version, libraryInjected, activation } = {}) {
-    this._env = env
-    this._host = host
-    this._service = service
-    this._appVersion = version
-    this._libraryInjected = libraryInjected
-    this._activation = activation || 'unknown'
+  #activation
+  #appVersion
+  #env
+  #host
+  #libraryInjected
+  #service
+
+  /** @param {TracerConfig} config */
+  constructor (config) {
+    this.#env = config.env
+    this.#host = config.reportHostname ? os.hostname() : undefined
+    this.#service = config.service
+    this.#appVersion = config.version
+    this.#libraryInjected = !!config.DD_INJECTION_ENABLED
+    this.#activation = getActivation(config.profiling?.enabled)
   }
 
+  /**
+   * Returns the destination URL for the near-OOM export subprocess, or nothing when this exporter
+   * does not support OOM export. Overridden by {@link AgentExporter} and {@link FileExporter}.
+   *
+   * @returns {URL | undefined}
+   */
+  getExportUrl () {}
+
   typeToFile (type) {
     return `${type}.pprof`
   }
@@ -43,21 +74,21 @@ class EventSerializer {
       endpoint_counts: endpointCounts,
       info: {
         application: {
-          env: this._env,
-          service: this._service,
+          env: this.#env,
+          service: this.#service,
           start_time: new Date(perf.nodeTiming.nodeStart + perf.timeOrigin).toISOString(),
-          version: this._appVersion,
+          version: this.#appVersion,
         },
         platform: {
-          hostname: this._host,
+          hostname: this.#host,
           kernel_name: os.type(),
           kernel_release: os.release(),
           kernel_version: os.version(),
         },
         profiler: {
-          activation: this._activation,
+          activation: this.#activation,
           ssi: {
-            mechanism: this._libraryInjected ? 'injected_agent' : 'none',
+            mechanism: this.#libraryInjected ? 'injected_agent' : 'none',
           },
           version,
           ...infos,
@@ -92,4 +123,4 @@ class EventSerializer {
   }
 }
 
-module.exports = { EventSerializer }
+module.exports = { EventSerializer, getActivation }

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

@@ -2,6 +2,7 @@
 
 const fs = require('fs')
 const { promisify } = require('util')
+const { pathToFileURL } = require('url')
 const { threadId } = require('worker_threads')
 const writeFile = promisify(fs.writeFile)
 const { EventSerializer } = require('./event_serializer')
@@ -10,14 +11,24 @@ const pad = (n) => String(n).padStart(2, '0')
 
 function formatDateTime (t) {
   return `${t.getUTCFullYear()}${pad(t.getUTCMonth() + 1)}${pad(t.getUTCDate())}` +
-         `T${pad(t.getUTCHours())}${pad(t.getUTCMinutes())}${pad(t.getUTCSeconds())}Z`
+    `T${pad(t.getUTCHours())}${pad(t.getUTCMinutes())}${pad(t.getUTCSeconds())}Z`
 }
 
 class FileExporter extends EventSerializer {
-  constructor (config = {}) {
+  #pprofPrefix
+
+  /**
+   * @param {import('./event_serializer').TracerConfig} config
+   * @param {string} [pprofPrefix] - File path prefix. Defaults to the config value, but the OOM
+   *   export subprocess passes a path derived from a `file:` URL, which is not a config value.
+   */
+  constructor (config, pprofPrefix = config.DD_PROFILING_PPROF_PREFIX) {
     super(config)
-    const { pprofPrefix } = config
-    this._pprofPrefix = pprofPrefix || ''
+    this.#pprofPrefix = pprofPrefix
+  }
+
+  getExportUrl () {
+    return pathToFileURL(this.#pprofPrefix)
   }
 
   export (exportSpec) {
@@ -25,7 +36,7 @@ class FileExporter extends EventSerializer {
     const types = Object.keys(profiles)
     const dateStr = formatDateTime(end)
     const tasks = types.map(type => {
-      return writeFile(`${this._pprofPrefix}${type}_worker_${threadId}_${dateStr}.pprof`, profiles[type])
+      return writeFile(`${this.#pprofPrefix}${type}_worker_${threadId}_${dateStr}.pprof`, profiles[type])
     })
     tasks.push(writeFile(`event_worker_${threadId}_${dateStr}.json`, this.getEventJSON(exportSpec)))
     return Promise.all(tasks)