dd-trace 5.53.0 → 5.54.0

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

@@ -62,9 +62,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 +110,7 @@ class PrioritySampler {
       return
     }
 
-    this.#_addDecisionMaker(root)
+    this.#addDecisionMaker(root)
   }
 
   /**
@@ -174,7 +174,7 @@ class PrioritySampler {
 
     log.trace(span, samplingPriority, mechanism)
 
-    this.#_addDecisionMaker(root)
+    this.#addDecisionMaker(root)
   }
 
   /**
@@ -193,11 +193,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)
   }
 
   /**
@@ -213,7 +213,7 @@ class PrioritySampler {
     } else if (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
@@ -229,13 +229,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
   }
@@ -260,17 +260,13 @@ class PrioritySampler {
    * @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
   }
@@ -281,7 +277,7 @@ class PrioritySampler {
    * @private
    * @returns {void}
    */
-  #_addDecisionMaker (span) {
+  #addDecisionMaker (span) {
     const context = span.context()
     const trace = context._trace
     const priority = context._sampling.priority
@@ -305,13 +301,14 @@ class PrioritySampler {
    * @returns {SamplingRule[]}
    * @private
    */
-  #_normalizeRules (rules, sampleRate, rateLimit, provenance) {
+  #normalizeRules (rules, sampleRate, rateLimit, provenance) {
     rules = [].concat(rules || [])
 
+    rules.push({ sampleRate, maxPerSecond: rateLimit, provenance })
+
     return rules
-      .concat({ sampleRate, maxPerSecond: rateLimit, provenance })
-      .map(rule => ({ ...rule, sampleRate: parseFloat(rule.sampleRate) }))
-      .filter(rule => !isNaN(rule.sampleRate))
+      .map(rule => ({ ...rule, sampleRate: Number.parseFloat(rule.sampleRate) }))
+      .filter(rule => !Number.isNaN(rule.sampleRate))
       .map(SamplingRule.from)
   }
 
@@ -321,8 +318,11 @@ class PrioritySampler {
    * @returns {SamplingRule}
    * @private
    */
-  #_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
     }
   }

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

@@ -25,6 +25,7 @@ class Config {
       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,
@@ -35,6 +36,7 @@ class Config {
       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,
@@ -163,13 +165,11 @@ 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,
@@ -191,6 +191,42 @@ class Config {
     logExperimentalVarDeprecation('CPU_ENABLED')
     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)) {
+      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}".`)
+        level = undefined
+      } else if (Number.isNaN(level)) {
+        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.`)
+        level = 1
+      } else {
+        const maxLevel = { gzip: 9, zstd: 22 }[uploadCompression]
+        if (level > maxLevel) {
+          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 +343,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/exporters/event_serializer.js

@@ -6,16 +6,16 @@ const libuvThreadPoolSize = (() => {
   const ss = process.env.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 +87,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/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)
     }
@@ -218,7 +249,11 @@ class Profiler extends EventEmitter {
       // encode and export asynchronously
       for (const { profiler, profile } of profiles) {
         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

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

@@ -1,10 +1,9 @@
 const { performance, constants, PerformanceObserver } = require('perf_hooks')
-const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL } = require('./shared')
+const { END_TIMESTAMP_LABEL, SPAN_ID_LABEL, LOCAL_ROOT_SPAN_ID_LABEL, encodeProfileAsync } = require('./shared')
 const { Function, Label, Line, Location, Profile, Sample, StringTable, ValueType } = require('pprof-format')
-const pprof = require('@datadog/pprof/')
 
 // perf_hooks uses millis, with fractional part representing nanos. We emit nanos into the pprof file.
-const MS_TO_NS = 1000000
+const MS_TO_NS = 1_000_000
 
 // While this is an "events profiler", meaning it emits a pprof file based on events observed as
 // perf_hooks events, the emitted pprof file uses the type "timeline".
@@ -50,10 +49,10 @@ class GCDecorator {
     // Create labels for all GC performance flags and kinds of GC
     for (const [key, value] of Object.entries(constants)) {
       if (key.startsWith('NODE_PERFORMANCE_GC_FLAGS_')) {
-        this.flagObj[key.substring(26).toLowerCase()] = value
+        this.flagObj[key.slice(26).toLowerCase()] = value
       } else if (key.startsWith('NODE_PERFORMANCE_GC_')) {
         // It's a constant for a kind of GC
-        const kind = key.substring(20).toLowerCase()
+        const kind = key.slice(20).toLowerCase()
         this.kindLabels[value] = labelFromStr(stringTable, kindLabelKey, kind)
       }
     }
@@ -258,6 +257,12 @@ class EventSerializer {
   }
 }
 
+function add (items) {
+  for (const item of items.getEntries()) {
+    this.eventHandler(item)
+  }
+}
+
 /**
  * Class that sources timeline events through Node.js performance measurement APIs.
  */
@@ -272,12 +277,6 @@ class NodeApiEventSource {
     // if already started, do nothing
     if (this.observer) return
 
-    function add (items) {
-      for (const item of items.getEntries()) {
-        this.eventHandler(item)
-      }
-    }
-
     this.observer = new PerformanceObserver(add.bind(this))
     this.observer.observe({ entryTypes: this.entryTypes })
   }
@@ -381,17 +380,15 @@ class EventsProfiler {
       }
     }
 
-    if (options.codeHotspotsEnabled) {
+    this.eventSource = options.codeHotspotsEnabled
       // Use Datadog instrumentation to collect events with span IDs. Still use
       // Node API for GC events.
-      this.eventSource = new CompositeEventSource([
+      ? new CompositeEventSource([
         new DatadogInstrumentationEventSource(eventHandler, eventFilter),
         new NodeApiEventSource(filteringEventHandler, ['gc'])
       ])
-    } else {
       // Use Node API instrumentation to collect events without span IDs
-      this.eventSource = new NodeApiEventSource(filteringEventHandler)
-    }
+      : new NodeApiEventSource(filteringEventHandler)
   }
 
   start () {
@@ -412,7 +409,7 @@ class EventsProfiler {
   }
 
   encode (profile) {
-    return pprof.encode(profile())
+    return encodeProfileAsync(profile())
   }
 }
 

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

@@ -36,6 +36,10 @@ function getNonJSThreadsLabels () {
   return { [THREAD_NAME_LABEL]: 'Non-JS threads', [THREAD_ID_LABEL]: 'NA', [OS_THREAD_ID_LABEL]: 'NA' }
 }
 
+function encodeProfileAsync (profile) {
+  return profile.encodeAsync().then(Buffer.from)
+}
+
 module.exports = {
   END_TIMESTAMP_LABEL,
   THREAD_NAME_LABEL,
@@ -46,5 +50,6 @@ module.exports = {
   threadNamePrefix,
   eventLoopThreadName,
   getNonJSThreadsLabels,
-  getThreadLabels: cacheThreadLabels()
+  getThreadLabels: cacheThreadLabels(),
+  encodeProfileAsync
 }

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

@@ -1,7 +1,7 @@
 'use strict'
 
 const { oomExportStrategies } = require('../constants')
-const { getThreadLabels } = require('./shared')
+const { encodeProfileAsync, getThreadLabels } = require('./shared')
 
 function strategiesToCallbackMode (strategies, callbackMode) {
   return strategies.includes(oomExportStrategies.ASYNC_CALLBACK) ? callbackMode.Async : 0
@@ -10,7 +10,7 @@ function strategiesToCallbackMode (strategies, callbackMode) {
 class NativeSpaceProfiler {
   constructor (options = {}) {
     this.type = 'space'
-    this._samplingInterval = options.samplingInterval || 512 * 1024
+    this._samplingInterval = options.heapSamplingInterval || 512 * 1024
     this._stackDepth = options.stackDepth || 64
     this._pprof = undefined
     this._oomMonitoring = options.oomMonitoring || {}
@@ -47,7 +47,7 @@ class NativeSpaceProfiler {
   }
 
   encode (profile) {
-    return this._pprof.encode(profile)
+    return encodeProfileAsync(profile)
   }
 
   stop () {

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

@@ -10,7 +10,8 @@ const {
   SPAN_ID_LABEL,
   LOCAL_ROOT_SPAN_ID_LABEL,
   getNonJSThreadsLabels,
-  getThreadLabels
+  getThreadLabels,
+  encodeProfileAsync
 } = require('./shared')
 
 const { isWebServerSpan, endpointNameFromTags, getStartedSpans } = require('../webspan-utils')
@@ -89,11 +90,9 @@ class NativeWallProfiler {
     this._pprof = undefined
 
     // Bind these to this so they can be used as callbacks
-    if (this._withContexts) {
-      if (this._captureSpanData) {
-        this._enter = this._enter.bind(this)
-        this._spanFinished = this._spanFinished.bind(this)
-      }
+    if (this._withContexts && this._captureSpanData) {
+      this._enter = this._enter.bind(this)
+      this._spanFinished = this._spanFinished.bind(this)
     }
     this._generateLabels = this._generateLabels.bind(this)
 
@@ -326,7 +325,7 @@ class NativeWallProfiler {
   }
 
   encode (profile) {
-    return this._pprof.encode(profile)
+    return encodeProfileAsync(profile)
   }
 
   stop () {

package/packages/dd-trace/src/profiling/ssi-heuristics.js

@@ -6,7 +6,7 @@ const dc = require('dc-polyfill')
 const log = require('../log')
 
 // If the process lives for at least 30 seconds, it's considered long-lived
-const DEFAULT_LONG_LIVED_THRESHOLD = 30000
+const DEFAULT_LONG_LIVED_THRESHOLD = 30_000
 
 /**
  * This class embodies the SSI profiler-triggering heuristics and also emits telemetry metrics about
@@ -107,10 +107,8 @@ class SSIHeuristics {
   }
 
   _maybeTriggered () {
-    if (!this.shortLived && !this.noSpan) {
-      if (typeof this.triggeredCallback === 'function') {
-        this.triggeredCallback.call(null)
-      }
+    if (!this.shortLived && !this.noSpan && typeof this.triggeredCallback === 'function') {
+      this.triggeredCallback.call(null)
     }
   }
 

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

@@ -6,8 +6,8 @@ const tagger = {
 
     switch (typeof tags) {
       case 'object':
-        if (Array.isArray(tags)) {
-          return tags.reduce((prev, next) => {
+        return Array.isArray(tags)
+          ? tags.reduce((prev, next) => {
             const parts = next.split(':')
             const key = parts.shift().trim()
             const value = parts.join(':').trim()
@@ -16,11 +16,9 @@ const tagger = {
 
             return Object.assign(prev, { [key]: value })
           }, {})
-        } else {
-          return tagger.parse(Object.keys(tags)
+          : tagger.parse(Object.keys(tags)
             .filter(key => tags[key] !== undefined && tags[key] !== null)
             .map(key => `${key}:${tags[key]}`))
-        }
       case 'string':
         return tagger.parse(tags.split(','))
       default:

package/packages/dd-trace/src/profiling/webspan-utils.js

@@ -9,7 +9,7 @@ function endpointNameFromTags (tags) {
   return tags[RESOURCE_NAME] || [
     tags[HTTP_METHOD],
     tags[HTTP_ROUTE]
-  ].filter(v => v).join(' ')
+  ].filter(Boolean).join(' ')
 }
 
 function getStartedSpans (context) {

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

@@ -189,15 +189,13 @@ class Tracer extends NoopProxy {
 
       this._modules.rewriter.enable(config)
 
-      if (config.tracing) {
-        if (config.isManualApiEnabled) {
-          const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
-          this._testApiManualPlugin = new TestApiManualPlugin(this)
-          // `shouldGetEnvironmentData` is passed as false so that we only lazily calculate it
-          // This is the only place where we need to do this because the rest of the plugins
-          // are lazily configured when the library is imported.
-          this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
-        }
+      if (config.tracing && config.isManualApiEnabled) {
+        const TestApiManualPlugin = require('./ci-visibility/test-api-manual/test-api-manual-plugin')
+        this._testApiManualPlugin = new TestApiManualPlugin(this)
+        // `shouldGetEnvironmentData` is passed as false so that we only lazily calculate it
+        // This is the only place where we need to do this because the rest of the plugins
+        // are lazily configured when the library is imported.
+        this._testApiManualPlugin.configure({ ...config, enabled: true }, false)
       }
       if (config.ciVisAgentlessLogSubmissionEnabled) {
         if (process.env.DD_API_KEY) {

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

@@ -0,0 +1,40 @@
+'use strict'
+
+/**
+ * `RandomSampler` determines whether or not to sample an operation based on random chance.
+ *
+ * Use this class **only** when the operation you are sampling does **not have access**
+ * to a `Span` or its `SpanContext`.
+ *
+ * If a `Span` or its `SpanContext` **is** available, use the `Sampler` class instead as
+ * it uses a deterministic sampling algorithm consistent across all languages.
+ */
+class RandomSampler {
+  /**
+   * @param {number} rate
+   */
+  constructor (rate) {
+    this._rate = rate
+  }
+
+  /**
+   * @returns {number}
+   */
+  rate () {
+    return this._rate
+  }
+
+  /**
+   * Determines whether an operation should be sampled based on the configured sampling rate.
+   *
+   * Returns `true` if the sampling decision passes (i.e., the operation should be sampled).
+   * This happens if the sampling rate is `1` (i.e., always sample) or if a random value falls below the rate.
+   *
+   * @returns {boolean} `true` if the operation should be sampled, otherwise `false`.
+   */
+  isSampled () {
+    return this._rate === 1 || Math.random() < this._rate
+  }
+}
+
+module.exports = RandomSampler

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

@@ -4,7 +4,7 @@ const limiter = require('limiter')
 
 class RateLimiter {
   constructor (rateLimit, interval = 'second') {
-    this._rateLimit = parseInt(rateLimit)
+    this._rateLimit = Number.parseInt(rateLimit)
     this._limiter = new limiter.RateLimiter(this._rateLimit, interval)
     this._tokensRequested = 0
     this._prevIntervalTokens = 0
@@ -16,12 +16,12 @@ class RateLimiter {
     const curIntervalTokens = this._limiter.tokensThisInterval
     const allowed = this._isAllowed()
 
-    if (curIntervalStart !== this._limiter.curIntervalStart) {
+    if (curIntervalStart === this._limiter.curIntervalStart) {
+      this._tokensRequested++
+    } else {
       this._prevIntervalTokens = curIntervalTokens
       this._prevTokensRequested = this._tokensRequested
       this._tokensRequested = 1
-    } else {
-      this._tokensRequested++
     }
 
     return allowed

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

@@ -61,13 +61,9 @@ function enable (config, appsec) {
 
 function enableOrDisableAppsec (action, rcConfig, config, appsec) {
   if (typeof rcConfig.asm?.enabled === 'boolean') {
-    let shouldEnable
-
-    if (action === 'apply' || action === 'modify') {
-      shouldEnable = rcConfig.asm.enabled // take control
-    } else {
-      shouldEnable = config.appsec.enabled // give back control to local config
-    }
+    const shouldEnable = action === 'apply' || action === 'modify'
+      ? rcConfig.asm.enabled // take control
+      : config.appsec.enabled // give back control to local config
 
     if (shouldEnable) {
       appsec.enable(config)