@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,473 @@
+'use strict'
+
+const path = require('path')
+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 { getAgentUrl } = require('../agent/url')
+const { isACFActive } = require('../../../datadog-core/src/storage')
+
+const { AgentExporter } = require('./exporters/agent')
+const { FileExporter } = require('./exporters/file')
+const { ConsoleLogger } = require('./loggers/console')
+const WallProfiler = require('./profilers/wall')
+const SpaceProfiler = require('./profilers/space')
+const EventsProfiler = require('./profilers/events')
+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.
+    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.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,
+        host: options.reportHostname ? require('os').hostname() : undefined,
+        service: this.service,
+        version: this.version,
+        functionname: AWS_LAMBDA_FUNCTION_NAME,
+      }),
+      getAzureTagsFromMetadata(getIsAzureFunction() ? getAzureFunctionMetadata() : getAzureAppMetadata())
+    )
+
+    // Add source code integration tags if available
+    if (options.repositoryUrl && options.commitSHA) {
+      this.tags[GIT_REPOSITORY_URL] = options.repositoryUrl
+      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)
+    }
+
+    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.url = getAgentUrl(options)
+
+    this.libraryInjected = options.libraryInjected
+    this.activation = options.activation
+    this.exporters = ensureExporters(options.exporters || [
+      new AgentExporter(this),
+    ], this)
+
+    // OOM monitoring does not work well on Windows, so it is disabled by default.
+    const oomMonitoringSupported = process.platform !== 'win32'
+
+    const oomMonitoringEnabled = isTrue(options.oomMonitoring ??
+      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED ?? oomMonitoringSupported)
+    checkOptionAllowed(oomMonitoringEnabled, 'OOM monitoring', oomMonitoringSupported)
+
+    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 exportStrategies = oomMonitoringEnabled
+      ? ensureOOMExportStrategies(options.oomExportStrategies ?? DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES ??
+        [oomExportStrategies.PROCESS], this)
+      : []
+    const exportCommand = oomMonitoringEnabled ? buildExportCommand(this) : undefined
+    this.oomMonitoring = {
+      enabled: oomMonitoringEnabled,
+      heapLimitExtensionSize,
+      maxHeapExtensionCount,
+      exportStrategies,
+      exportCommand,
+    }
+
+    const profilers = options.profilers || getProfilers({
+      DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_WALLTIME_ENABLED,
+      DD_PROFILING_PROFILERS,
+    })
+
+    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.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)
+
+    const isAtLeast24 = satisfies(process.versions.node, '>=24.0.0')
+
+    const uploadCompression0 = options.uploadCompression ?? DD_PROFILING_DEBUG_UPLOAD_COMPRESSION ?? 'on'
+    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
+        }
+      }
+    }
+
+    // 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'
+    }
+
+    this.uploadCompression = { method: uploadCompression, level }
+
+    const that = this
+    function turnOffAsyncContextFrame (msg) {
+      that.logger.warn(
+        `DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED was set ${msg}, it will have no effect.`)
+      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) {
+        turnOffAsyncContextFrame('with --no-async-context-frame')
+      } else if (satisfies(process.versions.node, '>=22.9.0')) {
+        turnOffAsyncContextFrame('without --experimental-async-context-frame')
+      } else {
+        turnOffAsyncContextFrame('but it requires at least Node.js 22.9.0')
+      }
+    }
+
+    this.heartbeatInterval = options.heartbeatInterval || 60 * 1000 // 1 minute
+
+    this.profilers = ensureProfilers(profilers, this)
+  }
+
+  get systemInfoReport () {
+    const report = {
+      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(p => p.type),
+      sourceMap: this.sourceMap,
+      timelineEnabled: this.timelineEnabled,
+      timelineSamplingEnabled: this.timelineSamplingEnabled,
+      uploadCompression: { ...this.uploadCompression },
+      v8ProfilerBugWorkaroundEnabled: this.v8ProfilerBugWorkaroundEnabled,
+    }
+    delete report.oomMonitoring.exportCommand
+    return report
+  }
+}
+
+module.exports = { Config }
+
+function getProfilers ({
+  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
+  // NOTE: space profiler is very deliberately in the first position. This way
+  // when profilers are stopped sequentially one after the other to create
+  // 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(','))
+
+  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 (!profilers.has('space')) {
+        profilers.add('space')
+        spaceExplicitlyEnabled = true
+      }
+    } else if (isFalse(DD_PROFILING_HEAP_ENABLED)) {
+      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)) {
+      profilers.add('wall')
+    } else if (isFalse(DD_PROFILING_WALLTIME_ENABLED)) {
+      profilers.delete('wall')
+      profilers.delete('cpu') // remove alias too
+    }
+  }
+
+  const profilersArray = [...profilers]
+  // If space was added through DD_PROFILING_HEAP_ENABLED, ensure it is in the
+  // first position. Basically, the only way for it not to be in the first
+  // position is if it was explicitly specified in a different position in
+  // DD_PROFILING_PROFILERS.
+  if (spaceExplicitlyEnabled) {
+    const spaceIdx = profilersArray.indexOf('space')
+    if (spaceIdx > 0) {
+      profilersArray.splice(spaceIdx, 1)
+      profilersArray.unshift('space')
+    }
+  }
+  return profilersArray
+}
+
+function getExportStrategy (name, options) {
+  const strategy = Object.values(oomExportStrategies).find(value => value === name)
+  if (strategy === undefined) {
+    options.logger.error(`Unknown oom export strategy "${name}"`)
+  }
+  return strategy
+}
+
+function ensureOOMExportStrategies (strategies, options) {
+  if (!strategies) {
+    return []
+  }
+
+  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)]
+}
+
+function getExporter (name, options) {
+  switch (name) {
+    case 'agent':
+      return new AgentExporter(options)
+    case 'file':
+      return new FileExporter(options)
+  }
+}
+
+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
+}
+
+function getProfiler (name, options) {
+  switch (name) {
+    case 'cpu':
+    case 'wall':
+      return new WallProfiler(options)
+    case 'space':
+      return new SpaceProfiler(options)
+    default:
+      options.logger.error(`Unknown profiler "${name}"`)
+  }
+}
+
+function ensureProfilers (profilers, options) {
+  if (typeof profilers === 'string') {
+    profilers = profilers.split(',')
+  }
+
+  for (let i = 0; i < profilers.length; i++) {
+    const profiler = profilers[i]
+    if (typeof profiler === 'string') {
+      profilers[i] = getProfiler(profiler, options)
+    }
+  }
+
+  // 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))
+  }
+
+  // Filter out any invalid profilers
+  return profilers.filter(Boolean)
+}
+
+function ensureLogger (logger) {
+  if (typeof logger !== 'object' ||
+    typeof logger.debug !== 'function' ||
+    typeof logger.info !== 'function' ||
+    typeof logger.warn !== 'function' ||
+    typeof logger.error !== 'function') {
+    return new ConsoleLogger()
+  }
+
+  return logger
+}
+
+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']
+}
+
+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/constants.js

@@ -0,0 +1,15 @@
+'use strict'
+
+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 }

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

@@ -0,0 +1,74 @@
+'use strict'
+
+const fs = require('fs')
+const { fileURLToPath } = require('url')
+const { SourceMapper, heap, encode } = require('@datadog/pprof')
+const { getValueFromEnvSources } = require('../config/helper')
+const { AgentExporter } = require('./exporters/agent')
+const { FileExporter } = require('./exporters/file')
+
+const { ConsoleLogger } = require('./loggers/console')
+const { tagger } = require('./tagger')
+
+const logger = new ConsoleLogger()
+const timeoutMs = 15 * 1000
+
+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'
+    : profilingEnabled === 'auto'
+      ? 'auto'
+      : 'unknown'
+  return new AgentExporter({
+    url,
+    logger,
+    uploadTimeout: timeoutMs,
+    libraryInjected,
+    activation,
+  })
+}
+
+async function exportProfile (urls, tags, profileType, profile) {
+  let mapper
+  try {
+    mapper = await SourceMapper.create([process.cwd()])
+  } catch (err) {
+    logger.error(err)
+  }
+
+  const encodedProfile = await encode(heap.convertProfile(profile, undefined, mapper))
+  const start = new Date()
+  await Promise.all(urls.map(async (url) => {
+    const exporter = exporterFromURL(url)
+
+    await exporter.export({
+      profiles: {
+        [profileType]: encodedProfile,
+      },
+      start,
+      end: start,
+      tags,
+    })
+  }))
+}
+
+/**
+ * Expected command line arguments are:
+ * - Comma separated list of URLs (eg. "http://127.0.0.1:8126/,file:///tmp/foo.pprof")
+ * - Tags (eg. "service:nodejs_oom_test,version:1.0.0")
+ * - Profile type (eg. space,wall,cpu)
+ * - JSON profile filepath
+ */
+const urls = process.argv[2].split(',').map(s => new URL(s))
+const tags = tagger.parse(process.argv[3])
+const profileType = process.argv[4]
+const profile = JSON.parse(fs.readFileSync(process.argv[5], 'utf8'))
+
+exportProfile(urls, tags, profileType, profile)