dd-trace 5.54.0 → 5.56.0

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

@@ -421,7 +421,7 @@ function addAllowHeaders (req, res, headers) {
   ]
 
   for (const header of contextHeaders) {
-    if (~requestHeaders.indexOf(header)) {
+    if (requestHeaders.includes(header)) {
       allowHeaders.push(header)
     }
   }
@@ -530,10 +530,9 @@ function extractURL (req) {
 
   if (req.stream) {
     return `${headers[HTTP2_HEADER_SCHEME]}://${headers[HTTP2_HEADER_AUTHORITY]}${headers[HTTP2_HEADER_PATH]}`
-  } else {
-    const protocol = getProtocol(req)
-    return `${protocol}://${req.headers.host}${req.originalUrl || req.url}`
   }
+  const protocol = getProtocol(req)
+  return `${protocol}://${req.headers.host}${req.originalUrl || req.url}`
 }
 
 function getProtocol (req) {

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, 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)
@@ -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
@@ -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 = Number.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
     }
   }
 
@@ -258,7 +268,6 @@ class PrioritySampler {
    *
    * @param context {DatadogSpanContext}
    * @returns {SamplingPriority}
-   * @private
    */
   #getPriorityByAgent (context) {
     const key = `service:${context._tags[SERVICE_NAME]},env:${this._env}`
@@ -274,7 +283,6 @@ class PrioritySampler {
   /**
    *
    * @param span {DatadogSpan}
-   * @private
    * @returns {void}
    */
   #addDecisionMaker (span) {
@@ -293,30 +301,33 @@ 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 || [])
+    rules = Array.isArray(rules) ? rules.flat() : [rules]
 
     rules.push({ sampleRate, maxPerSecond: rateLimit, provenance })
 
-    return rules
-      .map(rule => ({ ...rule, sampleRate: Number.parseFloat(rule.sampleRate) }))
-      .filter(rule => !Number.isNaN(rule.sampleRate))
-      .map(SamplingRule.from)
+    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) {
     for (const rule of this._rules) {
@@ -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,10 +15,12 @@ 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
@@ -27,14 +29,10 @@ class Config {
       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,
@@ -50,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,
@@ -86,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.
@@ -119,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
@@ -172,23 +157,18 @@ class Config {
     })
 
     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,
@@ -196,25 +176,25 @@ class Config {
     const uploadCompression0 = coalesce(options.uploadCompression, DD_PROFILING_DEBUG_UPLOAD_COMPRESSION, 'on')
     let [uploadCompression, level0] = uploadCompression0.split('-')
     if (!['on', 'off', 'gzip', 'zstd'].includes(uploadCompression)) {
-      logger.warn(`Invalid profile upload compression method "${uploadCompression0}". Will use "on".`)
+      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)) {
-        logger.warn(`Compression levels are not supported for "${uploadCompression}".`)
+        this.logger.warn(`Compression levels are not supported for "${uploadCompression}".`)
         level = undefined
       } else if (Number.isNaN(level)) {
-        logger.warn(
+        this.logger.warn(
           `Invalid compression level "${level0}". Will use default level.`)
         level = undefined
       } else if (level < 1) {
-        logger.warn(`Invalid compression level ${level}. Will use 1.`)
+        this.logger.warn(`Invalid compression level ${level}. Will use 1.`)
         level = 1
       } else {
         const maxLevel = { gzip: 9, zstd: 22 }[uploadCompression]
         if (level > maxLevel) {
-          logger.warn(`Invalid compression level ${level}. Will use ${maxLevel}.`)
+          this.logger.warn(`Invalid compression level ${level}. Will use ${maxLevel}.`)
           level = maxLevel
         }
       }

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,9 +1,10 @@
 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

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

@@ -226,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.')
       }
 
@@ -246,8 +246,10 @@ 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 {
           const encoded = await profiler.encode(profile)
           const compressed = encoded instanceof Buffer && this._compressionFn !== undefined
@@ -260,14 +262,15 @@ class Profiler extends EventEmitter {
             })
             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')

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

@@ -291,8 +291,16 @@ class NodeApiEventSource {
 
 class DatadogInstrumentationEventSource {
   constructor (eventHandler, eventFilter) {
-    this.plugins = ['dns_lookup', 'dns_lookupservice', 'dns_resolve', 'dns_reverse', 'fs', 'net'].map(m => {
-      const Plugin = require(`./event_plugins/${m}`)
+    // List all entries explicitly for bundlers to pick up the require calls correctly.
+    const plugins = [
+      require('./event_plugins/dns_lookup'),
+      require('./event_plugins/dns_lookupservice'),
+      require('./event_plugins/dns_resolve'),
+      require('./event_plugins/dns_reverse'),
+      require('./event_plugins/fs'),
+      require('./event_plugins/net')
+    ]
+    this.plugins = plugins.map((Plugin) => {
       return new Plugin(eventHandler, eventFilter)
     })
 

package/packages/dd-trace/src/profiling/ssi-telemetry-mock-profiler.js

@@ -3,7 +3,9 @@
 const dc = require('dc-polyfill')
 const coalesce = require('koalas')
 const profileSubmittedChannel = dc.channel('datadog:profiling:mock-profile-submitted')
-const { DD_PROFILING_UPLOAD_PERIOD } = process.env
+const { getEnvironmentVariable } = require('../config-helper')
+
+const DD_PROFILING_UPLOAD_PERIOD = getEnvironmentVariable('DD_PROFILING_UPLOAD_PERIOD')
 
 let timerId
 

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

@@ -5,20 +5,30 @@ const tagger = {
     if (!tags) return {}
 
     switch (typeof tags) {
-      case 'object':
-        return Array.isArray(tags)
-          ? tags.reduce((prev, next) => {
-            const parts = next.split(':')
-            const key = parts.shift().trim()
-            const value = parts.join(':').trim()
+      case 'object': {
+        if (Array.isArray(tags)) {
+          const tagObject = {}
+          for (const tag of tags) {
+            const colon = tag.indexOf(':')
+            if (colon === -1) continue
+            const key = tag.slice(0, colon).trim()
+            const value = tag.slice(colon + 1).trim()
+            if (key.length !== 0 && value.length !== 0) {
+              tagObject[key] = value
+            }
+          }
+          return tagObject
+        }
 
-            if (!key || !value) return prev
+        const tagsArray = []
+        for (const [key, value] of Object.entries(tags)) {
+          if (value != null) {
+            tagsArray.push(`${key}:${value}`)
+          }
+        }
 
-            return Object.assign(prev, { [key]: value })
-          }, {})
-          : tagger.parse(Object.keys(tags)
-            .filter(key => tags[key] !== undefined && tags[key] !== null)
-            .map(key => `${key}:${tags[key]}`))
+        return tagger.parse(tagsArray)
+      }
       case 'string':
         return tagger.parse(tags.split(','))
       default:

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

@@ -10,6 +10,7 @@ const telemetry = require('./telemetry')
 const nomenclature = require('./service-naming')
 const PluginManager = require('./plugin_manager')
 const NoopDogStatsDClient = require('./noop/dogstatsd')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 const {
   setBaggageItem,
   getBaggageItem,
@@ -198,7 +199,7 @@ class Tracer extends NoopProxy {
         this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
       }
       if (config.ciVisAgentlessLogSubmissionEnabled) {
-        if (process.env.DD_API_KEY) {
+        if (getEnvironmentVariable('DD_API_KEY')) {
           const LogSubmissionPlugin = require('./ci-visibility/log-submission/log-submission-plugin')
           const automaticLogPlugin = new LogSubmissionPlugin(this)
           automaticLogPlugin.configure({ ...config, enabled: true })

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

@@ -4,6 +4,7 @@ const path = require('path')
 const Module = require('module')
 const parse = require('module-details-from-path')
 const dc = require('dc-polyfill')
+const { getEnvironmentVariable } = require('../../dd-trace/src/config-helper')
 
 const origRequire = Module.prototype.require
 
@@ -82,9 +83,8 @@ function Hook (modules, options, onrequire) {
     if (patched) {
       // If it's already patched, just return it as-is.
       return origRequire.apply(this, arguments)
-    } else {
-      patching[filename] = true
     }
+    patching[filename] = true
 
     const payload = {
       filename,
@@ -110,8 +110,8 @@ function Hook (modules, options, onrequire) {
       if (!hooks) return exports // abort if module name isn't on whitelist
       name = filename
     } else {
-      const inAWSLambda = process.env.AWS_LAMBDA_FUNCTION_NAME !== undefined
-      const hasLambdaHandler = process.env.DD_LAMBDA_HANDLER !== undefined
+      const inAWSLambda = getEnvironmentVariable('AWS_LAMBDA_FUNCTION_NAME') !== undefined
+      const hasLambdaHandler = getEnvironmentVariable('DD_LAMBDA_HANDLER') !== undefined
       const segments = filename.split(path.sep)
       const filenameFromNodeModule = segments.includes('node_modules')
       // decide how to assign the stat

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

@@ -8,9 +8,10 @@ const { DogStatsDClient, MetricsAggregationClient } = require('../dogstatsd')
 const log = require('../log')
 const Histogram = require('../histogram')
 const { performance, PerformanceObserver } = require('perf_hooks')
+const { getEnvironmentVariable } = require('../config-helper')
 
 const { NODE_MAJOR, NODE_MINOR } = require('../../../../version')
-const { DD_RUNTIME_METRICS_FLUSH_INTERVAL = '10000' } = process.env
+const DD_RUNTIME_METRICS_FLUSH_INTERVAL = getEnvironmentVariable('DD_RUNTIME_METRICS_FLUSH_INTERVAL') ?? '10000'
 const INTERVAL = Number.parseInt(DD_RUNTIME_METRICS_FLUSH_INTERVAL, 10)
 
 // Node >=16 has PerformanceObserver with `gc` type, but <16.7 had a critical bug.
@@ -202,7 +203,7 @@ function captureGCMetrics () {
   const pause = {}
 
   for (const stat of profile.statistics) {
-    const type = stat.gcType.replace(/([a-z])([A-Z])/g, '$1_$2').toLowerCase()
+    const type = stat.gcType.replaceAll(/([a-z])([A-Z])/g, '$1_$2').toLowerCase()
 
     pause[type] = pause[type] || new Histogram()
     pause[type].record(stat.cost)

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

@@ -16,12 +16,16 @@ const SAMPLING_KNUTH_FACTOR = 1_111_111_111_111_111_111n
  * This class uses a deterministic sampling algorithm that is consistent across all languages.
  */
 class Sampler {
+  #threshold = 0n
+
   /**
    * @param {number} rate
    */
   constructor (rate) {
+    // TODO: Should this be moved up to the calling parts?
+    rate = Math.min(Math.max(rate, 0), 1)
     this._rate = rate
-    this._threshold = BigInt(Math.floor(rate * MAX_TRACE_ID))
+    this.#threshold = BigInt(Math.floor(rate * MAX_TRACE_ID))
   }
 
   /**
@@ -31,6 +35,10 @@ class Sampler {
     return this._rate
   }
 
+  get threshold () {
+    return this.#threshold
+  }
+
   /**
    * Determines whether a trace/span should be sampled based on the configured sampling rate.
    *
@@ -48,7 +56,7 @@ class Sampler {
 
     span = typeof span.context === 'function' ? span.context() : span
 
-    return (span._traceId.toBigInt() * SAMPLING_KNUTH_FACTOR) % UINT64_MODULO <= this._threshold
+    return (span._traceId.toBigInt() * SAMPLING_KNUTH_FACTOR) % UINT64_MODULO <= this.#threshold
   }
 }