dd-trace 5.67.0 → 5.69.0

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

@@ -49,6 +49,13 @@ const { SAMPLING_RULE_DECISION } = require('../../constants')
 const { AUTO_KEEP } = require('../../../../../ext/priority')
 const { version: ddTraceVersion } = require('../../../../../package.json')
 
+/**
+ * JSDoc types for test environment metadata helpers.
+ *
+ * @typedef {{ service?: string, isServiceUserProvided?: boolean }} TestEnvironmentConfig
+ * @typedef {Record<string, string|number|undefined>} TestEnvironmentMetadata
+ */
+
 // session tags
 const TEST_SESSION_NAME = 'test_session.name'
 
@@ -119,6 +126,10 @@ const MOCHA_WORKER_TRACE_PAYLOAD_CODE = 80
 // playwright worker variables
 const PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE = 90
 
+// vitest worker variables
+const VITEST_WORKER_TRACE_PAYLOAD_CODE = 100
+const VITEST_WORKER_LOGS_PAYLOAD_CODE = 102
+
 // Early flake detection util strings
 const EFD_STRING = "Retried by Datadog's Early Flake Detection"
 const EFD_TEST_NAME_REGEX = new RegExp(EFD_STRING + String.raw` \(#\d+\): `, 'g')
@@ -218,6 +229,8 @@ module.exports = {
   CUCUMBER_WORKER_TRACE_PAYLOAD_CODE,
   MOCHA_WORKER_TRACE_PAYLOAD_CODE,
   PLAYWRIGHT_WORKER_TRACE_PAYLOAD_CODE,
+  VITEST_WORKER_TRACE_PAYLOAD_CODE,
+  VITEST_WORKER_LOGS_PAYLOAD_CODE,
   TEST_SOURCE_START,
   TEST_SKIPPED_BY_ITR,
   TEST_IS_NEW,
@@ -325,6 +338,10 @@ function validateUrl (url) {
   }
 }
 
+/**
+ * @param {TestEnvironmentMetadata} metadata
+ * @returns {TestEnvironmentMetadata}
+ */
 function removeInvalidMetadata (metadata) {
   return Object.keys(metadata).reduce((filteredTags, tag) => {
     if (tag === GIT_REPOSITORY_URL && !validateGitRepositoryUrl(metadata[GIT_REPOSITORY_URL])) {
@@ -438,37 +455,49 @@ function checkShaDiscrepancies (ciMetadata, userProvidedGitMetadata) {
   )
 }
 
-function getTestEnvironmentMetadata (testFramework, config) {
-  // TODO: eventually these will come from the tracer (generally available)
+/**
+ * Build environment metadata for tests by merging CI, Git, runtime/OS and user-provided metadata.
+ *
+ * @param {string=} testFramework
+ * @param {TestEnvironmentConfig=} config
+ * @returns {TestEnvironmentMetadata}
+ */
+function getTestEnvironmentMetadata (testFramework, config, shouldSkipGitMetadataExtraction = false) {
   const ciMetadata = getCIMetadata()
-  const {
-    [GIT_COMMIT_SHA]: commitSHA,
-    [GIT_BRANCH]: branch,
-    [GIT_REPOSITORY_URL]: repositoryUrl,
-    [GIT_TAG]: tag,
-    [GIT_COMMIT_AUTHOR_NAME]: authorName,
-    [GIT_COMMIT_AUTHOR_EMAIL]: authorEmail,
-    [GIT_COMMIT_MESSAGE]: commitMessage,
-    [CI_WORKSPACE_PATH]: ciWorkspacePath,
-    [GIT_COMMIT_HEAD_SHA]: headCommitSha
-  } = ciMetadata
-
-  const gitMetadata = getGitMetadata({
-    commitSHA,
-    branch,
-    repositoryUrl,
-    tag,
-    authorName,
-    authorEmail,
-    commitMessage,
-    ciWorkspacePath,
-    headCommitSha
-  })
-
   const userProvidedGitMetadata = getUserProviderGitMetadata()
 
-  checkShaDiscrepancies(ciMetadata, userProvidedGitMetadata)
+  let gitMetadata = {}
+
+  // We don't execute git in test framework workers since the information is in the parent process
+  // and git metadata does not affect the execution of the tests
+  if (!shouldSkipGitMetadataExtraction) {
+    checkShaDiscrepancies(ciMetadata, userProvidedGitMetadata)
+
+    const {
+      [GIT_COMMIT_SHA]: commitSHA,
+      [GIT_BRANCH]: branch,
+      [GIT_REPOSITORY_URL]: repositoryUrl,
+      [GIT_TAG]: tag,
+      [GIT_COMMIT_AUTHOR_NAME]: authorName,
+      [GIT_COMMIT_AUTHOR_EMAIL]: authorEmail,
+      [GIT_COMMIT_MESSAGE]: commitMessage,
+      [CI_WORKSPACE_PATH]: ciWorkspacePath,
+      [GIT_COMMIT_HEAD_SHA]: headCommitSha
+    } = ciMetadata
+    gitMetadata = getGitMetadata({
+      commitSHA,
+      branch,
+      repositoryUrl,
+      tag,
+      authorName,
+      authorEmail,
+      commitMessage,
+      ciWorkspacePath,
+      headCommitSha
+    })
+  }
 
+  /** @type {TestEnvironmentMetadata} */
   const runtimeAndOSMetadata = getRuntimeAndOSMetadata()
 
   const metadata = {

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

@@ -387,7 +387,7 @@ const web = {
 
     return function (statusCode, statusMessage, headers) {
       headers = typeof statusMessage === 'string' ? headers : statusMessage
-      headers = Object.assign(res.getHeaders(), headers)
+      headers = { ...res.getHeaders(), ...headers }
 
       if (req.method.toLowerCase() === 'options' && isOriginAllowed(req, headers)) {
         addAllowHeaders(req, res, headers)

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

@@ -46,8 +46,9 @@ const defaultSampler = new Sampler(AUTO_KEEP)
  * @class PrioritySampler
  * @typedef {import('./opentracing/span')} DatadogSpan
  * @typedef {import('./opentracing/span_context')} DatadogSpanContext
- * @typedef {import('./standalone/product')} PRODUCTS
+ * @typedef {{ id: number, mechanism?: number }} Product
  * @typedef {2|-1|1|0} SamplingPriority Empirically defined sampling priorities.
+ * @typedef {import('./sampling_rule')|Record<string, unknown>} SamplingRuleLike
  */
 class PrioritySampler {
   /**
@@ -55,12 +56,12 @@ class 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 {string} [provenance] - Optional rule provenance ("customer" or "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.
+   * @property {Array<import('./sampling_rule')>|Array<Record<string, unknown>>} [rules=[]] - Sampling rules or configs.
    *
    * @param {string} env - The environment name (e.g., "production", "staging").
-   * @param {SamplingConfig} config - The configuration object for sampling.
+   * @param {SamplingConfig} [config] - The configuration object for sampling.
    */
   constructor (env, config) {
     this.configure(env, config)
@@ -69,22 +70,22 @@ class PrioritySampler {
 
   /**
    *
-   * @param env {string}
-   * @param opts {SamplingConfig}
+   * @param {string} env
+   * @param {SamplingConfig} config
    */
-  configure (env, opts = {}) {
-    const { sampleRate, provenance, rateLimit = 100, rules } = opts
+  configure (env, config = {}) {
+    const { sampleRate, provenance, rateLimit = 100, rules } = config
     this._env = env
     this._rules = this.#normalizeRules(rules || [], sampleRate, rateLimit, provenance)
     this._limiter = new RateLimiter(rateLimit)
 
-    log.trace(env, opts)
+    log.trace(env, config)
     setSamplingRules(this._rules)
   }
 
   /**
-   * @param span {DatadogSpan}
-   * @returns {boolean}
+   * @param {DatadogSpan} span
+   * @returns {boolean} True if the trace should be sampled based on priority.
    */
   isSampled (span) {
     const priority = this._getPriorityFromAuto(span)
@@ -93,9 +94,10 @@ class PrioritySampler {
   }
 
   /**
+   * Assigns a sampling priority to a span if not already set.
    *
-   * @param span {DatadogSpan}
-   * @param auto {boolean}
+   * @param {DatadogSpan} span
+   * @param {boolean} [auto=true] - Whether to use automatic sampling if no manual tags are present.
    * @returns {void}
    */
   sample (span, auto = true) {
@@ -125,8 +127,9 @@ class PrioritySampler {
   }
 
   /**
+   * Updates agent-provided sampling rates keyed by `service:,env:`.
    *
-   * @param rates {Record<string, number>}
+   * @param {Record<string, number>} rates
    * @returns {void}
    */
   update (rates) {
@@ -145,8 +148,9 @@ class PrioritySampler {
   }
 
   /**
+   * Validates that a sampling priority value is one of the allowed constants.
    *
-   * @param samplingPriority {SamplingPriority}
+   * @param {SamplingPriority|undefined} samplingPriority
    * @returns {boolean}
    */
   validate (samplingPriority) {
@@ -162,10 +166,11 @@ class PrioritySampler {
   }
 
   /**
+   * Explicitly sets the priority and mechanism for the span's trace.
    *
-   * @param span {DatadogSpan}
-   * @param samplingPriority {SamplingPriority}
-   * @param product {import('./standalone/product')}
+   * @param {DatadogSpan} span
+   * @param {SamplingPriority} samplingPriority
+   * @param {Product} [product]
    */
   setPriority (span, samplingPriority, product) {
     if (!span || !this.validate(samplingPriority)) return
@@ -189,17 +194,21 @@ class PrioritySampler {
   }
 
   /**
+   * Returns the span context, accepting either a span or a span context.
    *
-   * @param span {DatadogSpan}
+   * @param {DatadogSpan|DatadogSpanContext} span
    * @returns {DatadogSpanContext}
    */
   _getContext (span) {
-    return typeof span.context === 'function' ? span.context() : span
+    return typeof /** @type {DatadogSpan} */ (span).context === 'function'
+      ? /** @type {DatadogSpan} */ (span).context()
+      : /** @type {DatadogSpanContext} */ (span)
   }
 
   /**
+   * Computes priority using rules and agent rates when no manual tag is present.
    *
-   * @param span {DatadogSpan}
+   * @param {DatadogSpan} span
    * @returns {SamplingPriority}
    */
   _getPriorityFromAuto (span) {
@@ -212,11 +221,12 @@ class PrioritySampler {
   }
 
   /**
-   *
-   * @param tags {Record<string, symbol | unknown>}
+   * Computes priority from manual sampling tags if present.
    * Included for compatibility with {@link import('./standalone/tracesource_priority_sampler')._getPriorityFromTags}
-   * @param _context {DatadogSpanContext}
-   * @returns {SamplingPriority}
+   *
+   * @param {Record<string, unknown>} tags
+   * @param {DatadogSpanContext} _context
+   * @returns {SamplingPriority|undefined}
    */
   _getPriorityFromTags (tags, _context) {
     if (Object.hasOwn(tags, MANUAL_KEEP) && tags[MANUAL_KEEP] !== false) {
@@ -224,19 +234,23 @@ class PrioritySampler {
     } else if (Object.hasOwn(tags, MANUAL_DROP) && tags[MANUAL_DROP] !== false) {
       return USER_REJECT
     }
-    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
+    const rawPriority = tags[SAMPLING_PRIORITY]
+    if (rawPriority !== undefined) {
+      const priority = Number.parseInt(String(rawPriority), 10)
+
+      if (priority === 1 || priority === 2) {
+        return USER_KEEP
+      } else if (priority === 0 || priority === -1) {
+        return USER_REJECT
+      }
     }
   }
 
   /**
+   * Applies a matching rule and rate limit to compute the sampling priority.
    *
-   * @param context {DatadogSpanContext}
-   * @param rule {SamplingRule}
+   * @param {DatadogSpanContext} context
+   * @param {import('./sampling_rule')} rule
    * @returns {SamplingPriority}
    */
   #getPriorityByRule (context, rule) {
@@ -251,12 +265,14 @@ class PrioritySampler {
   }
 
   /**
+   * Checks if the rate limiter allows sampling for the current window and
+   * records the effective rate on the trace.
    *
-   * @param context {DatadogSpanContext}
+   * @param {DatadogSpanContext} context
    * @returns {boolean}
-   * @private
    */
   _isSampledByRateLimit (context) {
+    // TODO: Change underscored properties to private ones.
     const allowed = this._limiter.isAllowed()
 
     context._trace[SAMPLING_LIMIT_DECISION] = this._limiter.effectiveRate()
@@ -265,12 +281,14 @@ class PrioritySampler {
   }
 
   /**
+   * Computes priority using agent-provided sampling rates.
    *
-   * @param context {DatadogSpanContext}
+   * @param {DatadogSpanContext} context
    * @returns {SamplingPriority}
    */
   #getPriorityByAgent (context) {
     const key = `service:${context._tags[SERVICE_NAME]},env:${this._env}`
+    // TODO: Change underscored properties to private ones.
     const sampler = this._samplers[key] || this._samplers[DEFAULT_KEY]
 
     context._trace[SAMPLING_AGENT_DECISION] = sampler.rate()
@@ -281,8 +299,9 @@ class PrioritySampler {
   }
 
   /**
+   * Tags the trace with a decision maker when priority is keep, or removes it otherwise.
    *
-   * @param span {DatadogSpan}
+   * @param {DatadogSpan} span
    * @returns {void}
    */
   #addDecisionMaker (span) {
@@ -301,11 +320,13 @@ class PrioritySampler {
   }
 
   /**
-   * @param {Record<string, unknown>[] | Record<string, unknown>} rules - The sampling rules to normalize.
-   * @param {number} sampleRate
+   * Normalizes rule inputs to SamplingRule instances, applying defaults.
+   *
+   * @param {Array<SamplingRuleLike>|SamplingRuleLike} rules - Rules to normalize.
+   * @param {number|undefined} sampleRate
    * @param {number} rateLimit
-   * @param {string} provenance
-   * @returns {SamplingRule[]}
+   * @param {string|undefined} provenance
+   * @returns {Array<import('./sampling_rule')>}
    */
   #normalizeRules (rules, sampleRate, rateLimit, provenance) {
     rules = Array.isArray(rules) ? rules.flat() : [rules]
@@ -314,7 +335,7 @@ class PrioritySampler {
 
     const result = []
     for (const rule of rules) {
-      const sampleRate = Number.parseFloat(rule.sampleRate)
+      const sampleRate = Number.parseFloat(String(rule.sampleRate))
       // TODO(BridgeAR): Debug logging invalid rules fails our tests.
       // Should we definitely not know about these?
       if (!Number.isNaN(sampleRate)) {
@@ -325,11 +346,13 @@ class PrioritySampler {
   }
 
   /**
+   * Finds the first matching rule for the given span.
    *
-   * @param span {DatadogSpan}
-   * @returns {SamplingRule|undefined}
+   * @param {DatadogSpan} span
+   * @returns {import('./sampling_rule')|undefined}
    */
   #findRule (span) {
+    // TODO: Change underscored properties to private ones.
     for (const rule of this._rules) {
       // Rule is a special object with a .match() property.
       // It has nothing to do with a regular expression.
@@ -339,9 +362,10 @@ class PrioritySampler {
   }
 
   /**
+   * Convenience helper to keep a trace with an optional product mechanism.
    *
-   * @param span {DatadogSpan}
-   * @param product {import('./standalone/product')}
+   * @param {DatadogSpan} span
+   * @param {Product} [product]
    */
   static keepTrace (span, product) {
     span?._prioritySampler?.setPriority(span, USER_KEEP, product)

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

@@ -10,6 +10,8 @@ module.exports = {
   start: config => {
     const { service, version, env, url, hostname, port, tags, repositoryUrl, commitSHA, injectionEnabled } = config
     const { enabled, sourceMap, exporters } = config.profiling
+    const { heartbeatInterval } = config.telemetry
+
     const logger = {
       debug: (message) => log.debug(message),
       info: (message) => log.info(message),
@@ -39,7 +41,8 @@ module.exports = {
       repositoryUrl,
       commitSHA,
       libraryInjected,
-      activation
+      activation,
+      heartbeatInterval
     })
   },
 

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

@@ -1,9 +1,9 @@
 'use strict'
 
-const coalesce = require('koalas')
 const os = require('os')
 const path = require('path')
 const { URL, format, pathToFileURL } = require('url')
+const satisfies = require('semifies')
 const { AgentExporter } = require('./exporters/agent')
 const { FileExporter } = require('./exporters/file')
 const { ConsoleLogger } = require('./loggers/console')
@@ -16,6 +16,7 @@ const { tagger } = require('./tagger')
 const { isFalse, isTrue } = require('../util')
 const { getAzureTagsFromMetadata, getAzureAppMetadata } = require('../azure_metadata')
 const { getEnvironmentVariables } = require('../config-helper')
+const defaults = require('../config_defaults')
 
 class Config {
   constructor (options = {}) {
@@ -41,27 +42,26 @@ class Config {
       DD_PROFILING_TIMELINE_ENABLED,
       DD_PROFILING_UPLOAD_PERIOD,
       DD_PROFILING_UPLOAD_TIMEOUT,
+      DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED,
       DD_PROFILING_V8_PROFILER_BUG_WORKAROUND,
       DD_PROFILING_WALLTIME_ENABLED,
       DD_SERVICE,
       DD_TAGS,
       DD_TRACE_AGENT_PORT,
       DD_TRACE_AGENT_URL,
-      DD_VERSION
+      DD_VERSION,
+      NODE_OPTIONS
     } = getEnvironmentVariables()
 
-    const env = coalesce(options.env, DD_ENV)
+    const env = options.env ?? DD_ENV
     const service = options.service || DD_SERVICE || 'node'
     const host = os.hostname()
-    const version = coalesce(options.version, DD_VERSION)
+    const version = options.version ?? DD_VERSION
     // 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,
-      Number(DD_PROFILING_UPLOAD_TIMEOUT), 60 * 1000)
-    const sourceMap = coalesce(options.sourceMap,
-      DD_PROFILING_SOURCE_MAP, true)
-    const pprofPrefix = coalesce(options.pprofPrefix,
-      DD_PROFILING_PPROF_PREFIX, '')
+    const flushInterval = options.interval ?? (Number(DD_PROFILING_UPLOAD_PERIOD) * 1000 || 65 * 1000)
+    const uploadTimeout = options.uploadTimeout ?? (Number(DD_PROFILING_UPLOAD_TIMEOUT) || 60 * 1000)
+    const sourceMap = options.sourceMap ?? DD_PROFILING_SOURCE_MAP ?? true
+    const pprofPrefix = options.pprofPrefix ?? DD_PROFILING_PPROF_PREFIX ?? ''
 
     this.service = service
     this.env = env
@@ -104,21 +104,21 @@ class Config {
     this.flushInterval = flushInterval
     this.uploadTimeout = uploadTimeout
     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, samplingContextsAvailable))
+    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(coalesce(options.v8ProfilerBugWorkaround,
-      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND, true))
-    const hostname = coalesce(options.hostname, DD_AGENT_HOST) || 'localhost'
-    const port = coalesce(options.port, DD_TRACE_AGENT_PORT) || 8126
-    this.url = new URL(coalesce(options.url, DD_TRACE_AGENT_URL, format({
+    this.v8ProfilerBugWorkaroundEnabled = isTrue(options.v8ProfilerBugWorkaround ??
+      DD_PROFILING_V8_PROFILER_BUG_WORKAROUND ?? true)
+    const hostname = (options.hostname ?? DD_AGENT_HOST) || defaults.hostname
+    const port = (options.port ?? DD_TRACE_AGENT_PORT) || defaults.port
+    this.url = new URL(options.url ?? DD_TRACE_AGENT_URL ?? format({
       protocol: 'http:',
       hostname,
       port
-    })))
+    }))
 
     this.libraryInjected = options.libraryInjected
     this.activation = options.activation
@@ -129,17 +129,17 @@ class Config {
     // OOM monitoring does not work well on Windows, so it is disabled by default.
     const oomMonitoringSupported = process.platform !== 'win32'
 
-    const oomMonitoringEnabled = isTrue(coalesce(options.oomMonitoring,
-      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED, oomMonitoringSupported))
+    const oomMonitoringEnabled = isTrue(options.oomMonitoring ??
+      DD_PROFILING_EXPERIMENTAL_OOM_MONITORING_ENABLED ?? oomMonitoringSupported)
     checkOptionAllowed(oomMonitoringEnabled, 'OOM monitoring', oomMonitoringSupported)
 
-    const heapLimitExtensionSize = coalesce(options.oomHeapLimitExtensionSize,
-      Number(DD_PROFILING_EXPERIMENTAL_OOM_HEAP_LIMIT_EXTENSION_SIZE), 0)
-    const maxHeapExtensionCount = coalesce(options.oomMaxHeapExtensionCount,
-      Number(DD_PROFILING_EXPERIMENTAL_OOM_MAX_HEAP_EXTENSION_COUNT), 0)
+    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(coalesce(options.oomExportStrategies, DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES,
-        [oomExportStrategies.PROCESS]), this)
+      ? ensureOOMExportStrategies(options.oomExportStrategies ?? DD_PROFILING_EXPERIMENTAL_OOM_EXPORT_STRATEGIES ??
+        [oomExportStrategies.PROCESS], this)
       : []
     const exportCommand = oomMonitoringEnabled ? buildExportCommand(this) : undefined
     this.oomMonitoring = {
@@ -156,26 +156,29 @@ class Config {
       DD_PROFILING_PROFILERS
     })
 
-    this.timelineEnabled = isTrue(coalesce(options.timelineEnabled,
-      DD_PROFILING_TIMELINE_ENABLED, samplingContextsAvailable))
+    this.timelineEnabled = isTrue(
+      options.timelineEnabled ?? DD_PROFILING_TIMELINE_ENABLED ?? samplingContextsAvailable
+    )
     checkOptionWithSamplingContextAllowed(this.timelineEnabled, 'Timeline view')
-    this.timelineSamplingEnabled = isTrue(coalesce(options.timelineSamplingEnabled,
-      DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED, true))
+    this.timelineSamplingEnabled = isTrue(
+      options.timelineSamplingEnabled ?? DD_INTERNAL_PROFILING_TIMELINE_SAMPLING_ENABLED ?? true
+    )
 
-    this.codeHotspotsEnabled = isTrue(coalesce(options.codeHotspotsEnabled,
-      DD_PROFILING_CODEHOTSPOTS_ENABLED, samplingContextsAvailable))
+    this.codeHotspotsEnabled = isTrue(
+      options.codeHotspotsEnabled ?? DD_PROFILING_CODEHOTSPOTS_ENABLED ?? samplingContextsAvailable
+    )
     checkOptionWithSamplingContextAllowed(this.codeHotspotsEnabled, 'Code hotspots')
 
-    this.cpuProfilingEnabled = isTrue(coalesce(options.cpuProfilingEnabled,
-      DD_PROFILING_CPU_ENABLED,
-      samplingContextsAvailable))
+    this.cpuProfilingEnabled = isTrue(
+      options.cpuProfilingEnabled ?? DD_PROFILING_CPU_ENABLED ?? samplingContextsAvailable
+    )
     checkOptionWithSamplingContextAllowed(this.cpuProfilingEnabled, 'CPU profiling')
 
-    this.samplingInterval = coalesce(options.samplingInterval, 1e3 / 99) // 99hz in millis
+    this.samplingInterval = options.samplingInterval || 1e3 / 99 // 99hz in millis
 
-    this.heapSamplingInterval = coalesce(options.heapSamplingInterval,
-      Number(DD_PROFILING_HEAP_SAMPLING_INTERVAL))
-    const uploadCompression0 = coalesce(options.uploadCompression, DD_PROFILING_DEBUG_UPLOAD_COMPRESSION, 'on')
+    this.heapSamplingInterval = options.heapSamplingInterval ??
+      (Number(DD_PROFILING_HEAP_SAMPLING_INTERVAL) || 512 * 1024)
+    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".`)
@@ -209,6 +212,34 @@ class Config {
 
     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 hasExecArg = (arg) => process.execArgv.includes(arg) || String(NODE_OPTIONS).includes(arg)
+
+    this.asyncContextFrameEnabled = isTrue(options.useAsyncContextFrame ?? DD_PROFILING_ASYNC_CONTEXT_FRAME_ENABLED)
+    if (this.asyncContextFrameEnabled) {
+      if (satisfies(process.versions.node, '>=24.0.0')) {
+        if (hasExecArg('--no-async-context-frame')) {
+          turnOffAsyncContextFrame('with --no-async-context-frame')
+        }
+      } else if (satisfies(process.versions.node, '>=23.0.0')) {
+        if (!hasExecArg('--experimental-async-context-frame')) {
+          turnOffAsyncContextFrame('without --experimental-async-context-frame')
+        }
+      } else {
+        // NOTE: technically, this should work starting with 22.7.0 which is when
+        // AsyncContextFrame debuted, but it would require a change in pprof-nodejs too.
+        turnOffAsyncContextFrame('but it requires at least Node.js 23')
+      }
+    }
+
+    this.heartbeatInterval = options.heartbeatInterval || 60 * 1000 // 1 minute
+
     this.profilers = ensureProfilers(profilers, this)
   }
 }
@@ -220,7 +251,7 @@ function getProfilers ({
 }) {
   // First consider "legacy" DD_PROFILING_PROFILERS env variable, defaulting to wall + space
   // Use a Set to avoid duplicates
-  const profilers = new Set(coalesce(DD_PROFILING_PROFILERS, 'wall,space').split(','))
+  const profilers = new Set((DD_PROFILING_PROFILERS ?? 'wall,space').split(','))
 
   // Add/remove wall depending on the value of DD_PROFILING_WALLTIME_ENABLED
   if (DD_PROFILING_WALLTIME_ENABLED != null) {

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

@@ -110,11 +110,13 @@ class Profiler extends EventEmitter {
           }
           break
         case 'zstd':
-          if (typeof zlib.zstdCompress === 'function') {
+          if (typeof zlib.zstdCompress === 'function') { // eslint-disable-line n/no-unsupported-features/node-builtins
+            // eslint-disable-next-line n/no-unsupported-features/node-builtins
             this.#compressionFn = promisify(zlib.zstdCompress)
             if (clevel !== undefined) {
               this.#compressionOptions = {
                 params: {
+                  // eslint-disable-next-line n/no-unsupported-features/node-builtins
                   [zlib.constants.ZSTD_c_compressionLevel]: clevel
                 }
               }

package/packages/dd-trace/src/profiling/profilers/events.js

@@ -41,14 +41,9 @@ function labelFromStrStr (stringTable, keyStr, valStr) {
   return labelFromStr(stringTable, stringTable.dedup(keyStr), valStr)
 }
 
-function getSamplingIntervalMillis (options) {
-  return (options.samplingInterval || 1e3 / 99) // 99Hz
-}
-
 function getMaxSamples (options) {
-  const cpuSamplingInterval = getSamplingIntervalMillis(options)
-  const flushInterval = options.flushInterval || 65 * 1e3 // 60 seconds
-  const maxCpuSamples = flushInterval / cpuSamplingInterval
+  const flushInterval = options.flushInterval || 65 * 1e3 // 65 seconds
+  const maxCpuSamples = flushInterval / options.samplingInterval
 
   // The lesser of max parallelism and libuv thread pool size, plus one so we can detect
   // oversubscription on libuv thread pool, plus another one for GC.
@@ -399,7 +394,7 @@ class EventsProfiler {
 
     const eventHandler = event => this.#eventSerializer.addEvent(event)
     const eventFilter = options.timelineSamplingEnabled
-      ? createPoissonProcessSamplingFilter(getSamplingIntervalMillis(options))
+      ? createPoissonProcessSamplingFilter(options.samplingInterval)
       : () => true
     const filteringEventHandler = event => {
       if (eventFilter(event)) {