dd-trace 5.53.0 → 5.55.0

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

@@ -5,7 +5,6 @@ const RateLimiter = require('./rate_limiter')
 const Sampler = require('./sampler')
 const { setSamplingRules } = require('./startup-log')
 const SamplingRule = require('./sampling_rule')
-const { hasOwn } = require('./util')
 
 const {
   SAMPLING_MECHANISM_DEFAULT,
@@ -40,16 +39,28 @@ const DEFAULT_KEY = 'service:,env:'
 const defaultSampler = new Sampler(AUTO_KEEP)
 
 /**
- * from config.js
- * @typedef { sampleRate: number, provenance: string, rateLimit: number, rules: SamplingRule[] } SamplingConfig
+ * PrioritySampler is responsible for determining whether a span should be sampled
+ * based on various rules, rate limits, and priorities. It supports manual and
+ * automatic sampling mechanisms and integrates with Datadog's tracing system.
  *
- * empirically defined
- * @typedef {2|-1|1|0} SamplingPriority
+ * @class PrioritySampler
+ * @typedef {import('./opentracing/span')} DatadogSpan
+ * @typedef {import('./opentracing/span_context')} DatadogSpanContext
+ * @typedef {import('./standalone/product')} PRODUCTS
+ * @typedef {2|-1|1|0} SamplingPriority Empirically defined sampling priorities.
  */
 class PrioritySampler {
   /**
-   * @param env {string}
-   * @param config {SamplingConfig}
+   * Creates an instance of PrioritySampler.
+   *
+   * @typedef {Object} SamplingConfig
+   * @property {number} [sampleRate] - The default sample rate for traces.
+   * @property {string} [provenance] - The provenance of the sampling rule (e.g., "customer", "dynamic").
+   * @property {number} [rateLimit=100] - The maximum number of traces to sample per second.
+   * @property {Array<SamplingRule>} [rules=[]] - An array of sampling rules to apply.
+   *
+   * @param {string} env - The environment name (e.g., "production", "staging").
+   * @param {SamplingConfig} config - The configuration object for sampling.
    */
   constructor (env, config) {
     this.configure(env, config)
@@ -62,9 +73,9 @@ class PrioritySampler {
    * @param opts {SamplingConfig}
    */
   configure (env, opts = {}) {
-    const { sampleRate, provenance = undefined, rateLimit = 100, rules = [] } = opts
+    const { sampleRate, provenance, rateLimit = 100, rules } = opts
     this._env = env
-    this._rules = this.#_normalizeRules(rules, sampleRate, rateLimit, provenance)
+    this._rules = this.#normalizeRules(rules || [], sampleRate, rateLimit, provenance)
     this._limiter = new RateLimiter(rateLimit)
 
     log.trace(env, opts)
@@ -110,7 +121,7 @@ class PrioritySampler {
       return
     }
 
-    this.#_addDecisionMaker(root)
+    this.#addDecisionMaker(root)
   }
 
   /**
@@ -154,7 +165,7 @@ class PrioritySampler {
    *
    * @param span {DatadogSpan}
    * @param samplingPriority {SamplingPriority}
-   * @param product {import('./standalone/product').PRODUCTS}
+   * @param product {import('./standalone/product')}
    */
   setPriority (span, samplingPriority, product) {
     if (!span || !this.validate(samplingPriority)) return
@@ -174,7 +185,7 @@ class PrioritySampler {
 
     log.trace(span, samplingPriority, mechanism)
 
-    this.#_addDecisionMaker(root)
+    this.#addDecisionMaker(root)
   }
 
   /**
@@ -193,11 +204,11 @@ class PrioritySampler {
    */
   _getPriorityFromAuto (span) {
     const context = this._getContext(span)
-    const rule = this.#_findRule(span)
+    const rule = this.#findRule(span)
 
     return rule
-      ? this.#_getPriorityByRule(context, rule)
-      : this.#_getPriorityByAgent(context)
+      ? this.#getPriorityByRule(context, rule)
+      : this.#getPriorityByAgent(context)
   }
 
   /**
@@ -208,18 +219,17 @@ class PrioritySampler {
    * @returns {SamplingPriority}
    */
   _getPriorityFromTags (tags, _context) {
-    if (hasOwn(tags, MANUAL_KEEP) && tags[MANUAL_KEEP] !== false) {
+    if (Object.hasOwn(tags, MANUAL_KEEP) && tags[MANUAL_KEEP] !== false) {
       return USER_KEEP
-    } else if (hasOwn(tags, MANUAL_DROP) && tags[MANUAL_DROP] !== false) {
+    } else if (Object.hasOwn(tags, MANUAL_DROP) && tags[MANUAL_DROP] !== false) {
       return USER_REJECT
-    } else {
-      const priority = parseInt(tags[SAMPLING_PRIORITY], 10)
+    }
+    const priority = Number.parseInt(tags[SAMPLING_PRIORITY], 10)
 
-      if (priority === 1 || priority === 2) {
-        return USER_KEEP
-      } else if (priority === 0 || priority === -1) {
-        return USER_REJECT
-      }
+    if (priority === 1 || priority === 2) {
+      return USER_KEEP
+    } else if (priority === 0 || priority === -1) {
+      return USER_REJECT
     }
   }
 
@@ -229,13 +239,13 @@ class PrioritySampler {
    * @param rule {SamplingRule}
    * @returns {SamplingPriority}
    */
-  #_getPriorityByRule (context, rule) {
+  #getPriorityByRule (context, rule) {
     context._trace[SAMPLING_RULE_DECISION] = rule.sampleRate
     context._sampling.mechanism = SAMPLING_MECHANISM_RULE
     if (rule.provenance === 'customer') context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_USER
     if (rule.provenance === 'dynamic') context._sampling.mechanism = SAMPLING_MECHANISM_REMOTE_DYNAMIC
 
-    return rule.sample() && this._isSampledByRateLimit(context)
+    return rule.sample(context) && this._isSampledByRateLimit(context)
       ? USER_KEEP
       : USER_REJECT
   }
@@ -258,19 +268,14 @@ class PrioritySampler {
    *
    * @param context {DatadogSpanContext}
    * @returns {SamplingPriority}
-   * @private
    */
-  #_getPriorityByAgent (context) {
+  #getPriorityByAgent (context) {
     const key = `service:${context._tags[SERVICE_NAME]},env:${this._env}`
     const sampler = this._samplers[key] || this._samplers[DEFAULT_KEY]
 
     context._trace[SAMPLING_AGENT_DECISION] = sampler.rate()
 
-    if (sampler === defaultSampler) {
-      context._sampling.mechanism = SAMPLING_MECHANISM_DEFAULT
-    } else {
-      context._sampling.mechanism = SAMPLING_MECHANISM_AGENT
-    }
+    context._sampling.mechanism = sampler === defaultSampler ? SAMPLING_MECHANISM_DEFAULT : SAMPLING_MECHANISM_AGENT
 
     return sampler.isSampled(context) ? AUTO_KEEP : AUTO_REJECT
   }
@@ -278,10 +283,9 @@ class PrioritySampler {
   /**
    *
    * @param span {DatadogSpan}
-   * @private
    * @returns {void}
    */
-  #_addDecisionMaker (span) {
+  #addDecisionMaker (span) {
     const context = span.context()
     const trace = context._trace
     const priority = context._sampling.priority
@@ -297,32 +301,39 @@ class PrioritySampler {
   }
 
   /**
-   *
-   * @param rules {SamplingRule[]}
-   * @param sampleRate {number}
-   * @param rateLimit {number}
-   * @param provenance {string}
+   * @param {Record<string, unknown>[] | Record<string, unknown>} rules - The sampling rules to normalize.
+   * @param {number} sampleRate
+   * @param {number} rateLimit
+   * @param {string} provenance
    * @returns {SamplingRule[]}
-   * @private
    */
-  #_normalizeRules (rules, sampleRate, rateLimit, provenance) {
-    rules = [].concat(rules || [])
-
-    return rules
-      .concat({ sampleRate, maxPerSecond: rateLimit, provenance })
-      .map(rule => ({ ...rule, sampleRate: parseFloat(rule.sampleRate) }))
-      .filter(rule => !isNaN(rule.sampleRate))
-      .map(SamplingRule.from)
+  #normalizeRules (rules, sampleRate, rateLimit, provenance) {
+    rules = Array.isArray(rules) ? rules.flat() : [rules]
+
+    rules.push({ sampleRate, maxPerSecond: rateLimit, provenance })
+
+    const result = []
+    for (const rule of rules) {
+      const sampleRate = Number.parseFloat(rule.sampleRate)
+      // TODO(BridgeAR): Debug logging invalid rules fails our tests.
+      // Should we definitely not know about these?
+      if (!Number.isNaN(sampleRate)) {
+        result.push(SamplingRule.from({ ...rule, sampleRate }))
+      }
+    }
+    return result
   }
 
   /**
    *
    * @param span {DatadogSpan}
-   * @returns {SamplingRule}
-   * @private
+   * @returns {SamplingRule|undefined}
    */
-  #_findRule (span) {
+  #findRule (span) {
     for (const rule of this._rules) {
+      // Rule is a special object with a .match() property.
+      // It has nothing to do with a regular expression.
+      // eslint-disable-next-line unicorn/prefer-regexp-test
       if (rule.match(span)) return rule
     }
   }
@@ -330,7 +341,7 @@ class PrioritySampler {
   /**
    *
    * @param span {DatadogSpan}
-   * @param product {import('./standalone/product').PRODUCTS}
+   * @param product {import('./standalone/product')}
    */
   static keepTrace (span, product) {
     span?._prioritySampler?.setPriority(span, USER_KEEP, product)

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

@@ -15,26 +15,26 @@ const { GIT_REPOSITORY_URL, GIT_COMMIT_SHA } = require('../plugins/util/tags')
 const { tagger } = require('./tagger')
 const { isFalse, isTrue } = require('../util')
 const { getAzureTagsFromMetadata, getAzureAppMetadata } = require('../azure_metadata')
+const { getEnvironmentVariables } = require('../config-helper')
 
 class Config {
   constructor (options = {}) {
     const {
+      AWS_LAMBDA_FUNCTION_NAME: functionname,
       DD_AGENT_HOST,
       DD_ENV,
       DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, // used for testing
       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_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_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_EXPERIMENTAL_TIMELINE_ENABLED,
       DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_HEAP_SAMPLING_INTERVAL,
       DD_PROFILING_PPROF_PREFIX,
       DD_PROFILING_PROFILERS,
       DD_PROFILING_SOURCE_MAP,
@@ -48,13 +48,12 @@ class Config {
       DD_TRACE_AGENT_PORT,
       DD_TRACE_AGENT_URL,
       DD_VERSION
-    } = process.env
+    } = getEnvironmentVariables()
 
     const env = coalesce(options.env, DD_ENV)
     const service = options.service || DD_SERVICE || 'node'
     const host = os.hostname()
     const version = coalesce(options.version, DD_VERSION)
-    const functionname = process.env.AWS_LAMBDA_FUNCTION_NAME
     // Must be longer than one minute so pad with five seconds
     const flushInterval = coalesce(options.interval, Number(DD_PROFILING_UPLOAD_PERIOD) * 1000, 65 * 1000)
     const uploadTimeout = coalesce(options.uploadTimeout,
@@ -84,16 +83,6 @@ class Config {
     }
 
     this.logger = ensureLogger(options.logger)
-    const logger = this.logger
-    function logExperimentalVarDeprecation (shortVarName) {
-      const deprecatedEnvVarName = `DD_PROFILING_EXPERIMENTAL_${shortVarName}`
-      const v = process.env[deprecatedEnvVarName]
-      // not null, undefined, or NaN -- same logic as koalas.hasValue
-      // eslint-disable-next-line no-self-compare
-      if (v != null && v === v) {
-        logger.warn(`${deprecatedEnvVarName} is deprecated. Use DD_PROFILING_${shortVarName} instead.`)
-      }
-    }
     // 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.
@@ -117,9 +106,7 @@ class Config {
     this.sourceMap = sourceMap
     this.debugSourceMaps = isTrue(coalesce(options.debugSourceMaps, DD_PROFILING_DEBUG_SOURCE_MAPS, false))
     this.endpointCollectionEnabled = isTrue(coalesce(options.endpointCollection,
-      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_ENDPOINT_COLLECTION_ENABLED, samplingContextsAvailable))
-    logExperimentalVarDeprecation('ENDPOINT_COLLECTION_ENABLED')
+      DD_PROFILING_ENDPOINT_COLLECTION_ENABLED, samplingContextsAvailable))
     checkOptionWithSamplingContextAllowed(this.endpointCollectionEnabled, 'Endpoint collection')
 
     this.pprofPrefix = pprofPrefix
@@ -163,34 +150,63 @@ class Config {
       exportCommand
     }
 
-    const profilers = options.profilers
-      ? options.profilers
-      : getProfilers({
-        DD_PROFILING_HEAP_ENABLED,
-        DD_PROFILING_WALLTIME_ENABLED,
-        DD_PROFILING_PROFILERS
-      })
+    const profilers = options.profilers || getProfilers({
+      DD_PROFILING_HEAP_ENABLED,
+      DD_PROFILING_WALLTIME_ENABLED,
+      DD_PROFILING_PROFILERS
+    })
 
     this.timelineEnabled = isTrue(coalesce(options.timelineEnabled,
-      DD_PROFILING_TIMELINE_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_TIMELINE_ENABLED, samplingContextsAvailable))
-    logExperimentalVarDeprecation('TIMELINE_ENABLED')
+      DD_PROFILING_TIMELINE_ENABLED, samplingContextsAvailable))
     checkOptionWithSamplingContextAllowed(this.timelineEnabled, 'Timeline view')
     this.timelineSamplingEnabled = isTrue(coalesce(options.timelineSamplingEnabled,
       DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, true))
 
     this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
-      DD_PROFILING_CODEHOTSPOTS_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_CODEHOTSPOTS_ENABLED, samplingContextsAvailable))
-    logExperimentalVarDeprecation('CODEHOTSPOTS_ENABLED')
+      DD_PROFILING_CODEHOTSPOTS_ENABLED, samplingContextsAvailable))
     checkOptionWithSamplingContextAllowed(this.codeHotspotsEnabled, 'Code hotspots')
 
     this.cpuProfilingEnabled = isTrue(coalesce(options.cpuProfilingEnabled,
       DD_PROFILING_CPU_ENABLED,
-      DD_PROFILING_EXPERIMENTAL_CPU_ENABLED, samplingContextsAvailable))
-    logExperimentalVarDeprecation('CPU_ENABLED')
+      samplingContextsAvailable))
     checkOptionWithSamplingContextAllowed(this.cpuProfilingEnabled, 'CPU profiling')
 
+    this.heapSamplingInterval = coalesce(options.heapSamplingInterval,
+      Number(DD_PROFILING_HEAP_SAMPLING_INTERVAL))
+    const uploadCompression0 = coalesce(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 gzip
+    if (uploadCompression === 'on') {
+      uploadCompression = 'gzip'
+    }
+
+    this.uploadCompression = { method: uploadCompression, level }
+
     this.profilers = ensureProfilers(profilers, this)
   }
 }
@@ -307,7 +323,7 @@ function ensureProfilers (profilers, options) {
   }
 
   // Filter out any invalid profilers
-  return profilers.filter(v => v)
+  return profilers.filter(Boolean)
 }
 
 function ensureLogger (logger) {

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

@@ -8,6 +8,7 @@ const { ConsoleLogger } = require('./loggers/console')
 const { tagger } = require('./tagger')
 const fs = require('fs')
 const { fileURLToPath } = require('url')
+const { getEnvironmentVariable } = require('../config-helper')
 
 const logger = new ConsoleLogger()
 const timeoutMs = 15 * 1000
@@ -15,25 +16,24 @@ const timeoutMs = 15 * 1000
 function exporterFromURL (url) {
   if (url.protocol === 'file:') {
     return new FileExporter({ pprofPrefix: fileURLToPath(url) })
-  } else {
-    const injectionEnabled = (process.env.DD_INJECTION_ENABLED || '').split(',')
-    const libraryInjected = injectionEnabled.length > 0
-    const profilingEnabled = (process.env.DD_PROFILING_ENABLED || '').toLowerCase()
-    const activation = ['true', '1'].includes(profilingEnabled)
-      ? 'manual'
-      : profilingEnabled === 'auto'
-        ? 'auto'
-        : injectionEnabled.includes('profiling')
-          ? 'injection'
-          : 'unknown'
-    return new AgentExporter({
-      url,
-      logger,
-      uploadTimeout: timeoutMs,
-      libraryInjected,
-      activation
-    })
   }
+  const injectionEnabled = (getEnvironmentVariable('DD_INJECTION_ENABLED') ?? '').split(',')
+  const libraryInjected = injectionEnabled.length > 0
+  const profilingEnabled = (getEnvironmentVariable('DD_PROFILING_ENABLED') ?? '').toLowerCase()
+  const activation = ['true', '1'].includes(profilingEnabled)
+    ? 'manual'
+    : profilingEnabled === 'auto'
+      ? 'auto'
+      : injectionEnabled.includes('profiling')
+        ? 'injection'
+        : 'unknown'
+  return new AgentExporter({
+    url,
+    logger,
+    uploadTimeout: timeoutMs,
+    libraryInjected,
+    activation
+  })
 }
 
 async function exportProfile (urls, tags, profileType, profile) {
@@ -46,7 +46,7 @@ async function exportProfile (urls, tags, profileType, profile) {
 
   const encodedProfile = await encode(heap.convertProfile(profile, undefined, mapper))
   const start = new Date()
-  for (const url of urls) {
+  await Promise.all(urls.map(async (url) => {
     const exporter = exporterFromURL(url)
 
     await exporter.export({
@@ -57,7 +57,7 @@ async function exportProfile (urls, tags, profileType, profile) {
       end: start,
       tags
     })
-  }
+  }))
 }
 
 /** Expected command line arguments are:

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

@@ -150,7 +150,7 @@ class AgentExporter extends EventSerializer {
             'DD-EVP-ORIGIN-VERSION': version,
             ...form.getHeaders()
           },
-          timeout: this._backoffTime * Math.pow(2, attempt)
+          timeout: this._backoffTime * 2 ** attempt
         }
 
         docker.inject(options.headers)

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

@@ -1,21 +1,22 @@
 const os = require('os')
 const perf = require('perf_hooks').performance
 const version = require('../../../../../package.json').version
+const { getEnvironmentVariable } = require('../../config-helper')
 
 const libuvThreadPoolSize = (() => {
-  const ss = process.env.UV_THREADPOOL_SIZE
+  const ss = getEnvironmentVariable('UV_THREADPOOL_SIZE')
   if (ss === undefined) {
     // Backend will apply the default size based on Node version.
-    return undefined
+    return
   }
   // libuv uses atoi to parse the value, which is almost the same as parseInt, except that parseInt
   // will return NaN on invalid input, while atoi will return 0. This is handled at return.
-  const s = parseInt(ss)
-  // We dont' interpret the value further here in the library. Backend will interpret the number
+  const s = Number.parseInt(ss)
+  // We don't interpret the value further here in the library. Backend will interpret the number
   // based on Node version. In all currently known Node versions, 0 results in 1 worker thread,
   // negative values (because they're assigned to an unsigned int) become very high positive values,
   // and the value is finally capped at 1024.
-  return isNaN(s) ? 0 : s
+  return Number.isNaN(s) ? 0 : s
 })()
 
 class EventSerializer {
@@ -87,7 +88,7 @@ class EventSerializer {
           // We'll keep it like this as we want cross-engine consistency. We
           // also aren't changing the format of the existing tag as we don't want
           // to break it.
-          version: process.version.substring(1)
+          version: process.version.slice(1)
         }
       }
     })

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

@@ -6,8 +6,9 @@ const { threadId } = require('worker_threads')
 const writeFile = promisify(fs.writeFile)
 const { EventSerializer } = require('./event_serializer')
 
+const pad = (n) => String(n).padStart(2, '0')
+
 function formatDateTime (t) {
-  const pad = (n) => String(n).padStart(2, '0')
   return `${t.getUTCFullYear()}${pad(t.getUTCMonth() + 1)}${pad(t.getUTCDate())}` +
          `T${pad(t.getUTCHours())}${pad(t.getUTCMinutes())}${pad(t.getUTCSeconds())}Z`
 }

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

@@ -6,8 +6,9 @@ const SpaceProfiler = require('./profilers/space')
 const { AgentExporter } = require('./exporters/agent')
 const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
+const { getEnvironmentVariable } = require('../config-helper')
 
-const profiler = process.env.AWS_LAMBDA_FUNCTION_NAME ? new ServerlessProfiler() : new Profiler()
+const profiler = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') ? new ServerlessProfiler() : new Profiler()
 
 module.exports = {
   profiler,

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

@@ -8,6 +8,9 @@ const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('./we
 const dc = require('dc-polyfill')
 const crashtracker = require('../crashtracking')
 
+const { promisify } = require('util')
+const zlib = require('zlib')
+
 const profileSubmittedChannel = dc.channel('datadog:profiling:profile-submitted')
 const spanFinishedChannel = dc.channel('dd-trace:span:finish')
 
@@ -83,9 +86,37 @@ class Profiler extends EventEmitter {
         this._logger.debug(() => {
           return mapper.infoMap.size === 0
             ? 'Found no source maps'
-            : `Found source maps for following files: [${Array.from(mapper.infoMap.keys()).join(', ')}]`
+            : `Found source maps for following files: [${[...mapper.infoMap.keys()].join(', ')}]`
         })
       }
+
+      const clevel = config.uploadCompression.level
+      switch (config.uploadCompression.method) {
+        case 'gzip':
+          this._compressionFn = promisify(zlib.gzip)
+          if (clevel !== undefined) {
+            this._compressionOptions = {
+              level: clevel
+            }
+          }
+          break
+        case 'zstd':
+          if (typeof zlib.zstdCompress === 'function') {
+            this._compressionFn = promisify(zlib.zstdCompress)
+            if (clevel !== undefined) {
+              this._compressionOptions = {
+                params: {
+                  [zlib.constants.ZSTD_c_compressionLevel]: clevel
+                }
+              }
+            }
+          } else {
+            const zstdCompress = require('@datadog/libdatadog').load('datadog-js-zstd').zstd_compress
+            const level = clevel ?? 0 // 0 is zstd default compression level
+            this._compressionFn = (buffer) => Promise.resolve(Buffer.from(zstdCompress(buffer, level)))
+          }
+          break
+      }
     } catch (err) {
       this._logError(err)
     }
@@ -195,7 +226,7 @@ class Profiler extends EventEmitter {
     const encodedProfiles = {}
 
     try {
-      if (Object.keys(this._config.profilers).length === 0) {
+      if (this._config.profilers.length === 0) {
         throw new Error('No profile types configured.')
       }
 
@@ -215,24 +246,31 @@ class Profiler extends EventEmitter {
         this._capture(this._timeoutInterval, endDate)
       }
 
+      let hasEncoded = false
+
       // encode and export asynchronously
-      for (const { profiler, profile } of profiles) {
+      await Promise.all(profiles.map(async ({ profiler, profile }) => {
         try {
-          encodedProfiles[profiler.type] = await profiler.encode(profile)
+          const encoded = await profiler.encode(profile)
+          const compressed = encoded instanceof Buffer && this._compressionFn !== undefined
+            ? await this._compressionFn(encoded, this._compressionOptions)
+            : encoded
+          encodedProfiles[profiler.type] = compressed
           this._logger.debug(() => {
             const profileJson = JSON.stringify(profile, (key, value) => {
               return typeof value === 'bigint' ? value.toString() : value
             })
             return `Collected ${profiler.type} profile: ` + profileJson
           })
+          hasEncoded = true
         } catch (err) {
           // If encoding one of the profile types fails, we should still try to
           // encode and submit the other profile types.
           this._logError(err)
         }
-      }
+      }))
 
-      if (Object.keys(encodedProfiles).length > 0) {
+      if (hasEncoded) {
         await this._submit(encodedProfiles, startDate, endDate, snapshotKind)
         profileSubmittedChannel.publish()
         this._logger.debug('Submitted profiles')