dd-trace 6.15.0 → 6.17.0

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

@@ -4,15 +4,19 @@ const { readFile } = require('fs')
 const { types } = require('util')
 const { join } = require('path')
 const { Worker, MessageChannel, threadId: parentThreadId } = require('worker_threads')
+const dc = require('dc-polyfill')
 const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
+const telemetryMetrics = require('../telemetry/metrics')
 const getDebuggerConfig = require('./config')
 const {
   DEBUGGER_DIAGNOSTICS_V1,
   DEBUGGER_INPUT_DIRECT,
   DEBUGGER_INPUT_V2,
+  GUARDRAIL_METRICS_FLUSH_INTERVAL_MS,
   INSPECT_SEGMENT_GLOBAL_PROPERTY,
 } = require('./constants')
+const { GuardrailMetrics, TELEMETRY_NAMESPACE } = require('./guardrail-metrics')
 const { installProbeSampler, uninstallProbeSampler } = require('./probe_sampler')
 
 /**
@@ -23,12 +27,20 @@ const { installProbeSampler, uninstallProbeSampler } = require('./probe_sampler'
  * @typedef {import('../remote_config')} RemoteConfig
  */
 
+// Published by telemetry right before it sends its final metrics on process exit. The flush interval timer is unref'ed
+// and the worker does not keep the process alive, so without this hook everything counted since the last tick would
+// be lost when the application exits on its own.
+const TELEMETRY_APP_CLOSING_CHANNEL = 'datadog:telemetry:app-closing'
+
 let worker = null
 let configChannel = null
 let ackId = 0
 let rcAckCallbacks = null
 let rc = null
 let inputPath = null
+/** @type {GuardrailMetrics | null} */
+let guardrailMetrics = null
+let guardrailMetricsTimer = null
 
 // eslint-disable-next-line eslint-rules/eslint-process-env
 const { NODE_OPTIONS, ...env } = process.env
@@ -43,7 +55,6 @@ module.exports = {
 /**
  * Check if the Debugger worker is currently running
  *
- * @returns {boolean} True if the worker is started, false otherwise
  */
 function isStarted () {
   return worker !== null
@@ -77,7 +88,13 @@ function start (config, rcInstance) {
   debuggerGlobals.utilTypes = types
   debuggerGlobals[INSPECT_SEGMENT_GLOBAL_PROPERTY] = require('./inspect-segment')
 
-  const probeSamplerBuffer = installProbeSampler()
+  const guardrailMetricsBuffer = GuardrailMetrics.createBuffer()
+  guardrailMetrics = new GuardrailMetrics(guardrailMetricsBuffer)
+  guardrailMetricsTimer = setInterval(flushGuardrailMetrics, GUARDRAIL_METRICS_FLUSH_INTERVAL_MS)
+  guardrailMetricsTimer.unref?.()
+  dc.subscribe(TELEMETRY_APP_CLOSING_CHANNEL, flushGuardrailMetrics)
+
+  const probeSamplerBuffer = installProbeSampler(guardrailMetrics)
 
   readProbeFile(config.dynamicInstrumentation.probeFile, (probes) => {
     const action = 'apply'
@@ -125,6 +142,7 @@ function start (config, rcInstance) {
           logPort: logChannel.port1,
           configPort: configChannel.port1,
           probeSamplerBuffer,
+          guardrailMetricsBuffer,
         },
         transferList: [probeChannel.port1, logChannel.port1, configChannel.port1],
       }
@@ -137,6 +155,11 @@ function start (config, rcInstance) {
       )
     })
 
+    const threadPausedMetric = telemetryMetrics.manager.namespace(TELEMETRY_NAMESPACE)
+      .distribution('execution.pause.duration')
+    worker.on('message', (/** @type {{ type: string, durationMs: number }} */ { type, durationMs }) => {
+      if (type === 'thread-paused') threadPausedMetric.track(durationMs)
+    })
     worker.on('error', (err) => log.error('[debugger] worker thread error', err))
     worker.on('messageerror', (err) => log.error('[debugger] received "messageerror" from worker', err))
 
@@ -211,6 +234,20 @@ function cleanup (error) {
   configChannel = null
   inputPath = null
 
+  if (guardrailMetricsTimer !== null) {
+    clearInterval(guardrailMetricsTimer)
+    guardrailMetricsTimer = null
+  }
+  if (guardrailMetrics !== null) {
+    dc.unsubscribe(TELEMETRY_APP_CLOSING_CHANNEL, flushGuardrailMetrics)
+    // Report what the worker counted up until it was stopped. Known limitation: `Worker#terminate()` interrupts the
+    // worker asynchronously, so anything it counts between this drain and its actual termination is lost. That only
+    // concerns events still sitting in the worker's upload buffer, which die with the worker anyway, so it isn't worth
+    // deferring the drain until the worker has exited.
+    flushGuardrailMetrics()
+    guardrailMetrics = null
+  }
+
   // Call any pending ack callbacks
   // Pass error for unexpected exits, or undefined for graceful shutdown
   if (rcAckCallbacks) {
@@ -223,6 +260,17 @@ function cleanup (error) {
   }
 }
 
+/**
+ * Convert the guardrail counters accumulated by the probe sampler and the worker into telemetry metrics.
+ */
+function flushGuardrailMetrics () {
+  if (guardrailMetrics === null) return
+  const namespace = telemetryMetrics.manager.namespace(TELEMETRY_NAMESPACE)
+  guardrailMetrics.drain((metric, tags, count) => {
+    namespace.count(metric, tags).inc(count)
+  })
+}
+
 /**
  * Detect which debugger endpoint is available on the agent
  *

package/packages/dd-trace/src/debugger/inspect-segment.js

@@ -34,7 +34,6 @@ module.exports = inspectSegment
  * truncates objects before inspecting them.
  *
  * @param {unknown} value
- * @returns {string}
  */
 function inspectSegment (value) {
   if (value === null || (typeof value !== 'object' && typeof value !== 'function')) {
@@ -99,7 +98,6 @@ function inspectSegment (value) {
  *
  * @param {Collection} value
  * @param {boolean} isMap
- * @returns {string}
  */
 function inspectCollection (value, isMap) {
   if (NODE_MAJOR !== 18) return inspect(value, segmentInspectOptions)
@@ -137,7 +135,6 @@ function inspectCollection (value, isMap) {
  * Determine whether inspecting a value could invoke a proxy trap or toStringTag getter.
  *
  * @param {unknown} value
- * @returns {boolean}
  */
 function inspectionCanRunUserCode (value) {
   const type = typeof value

package/packages/dd-trace/src/debugger/probe_sampler.js

@@ -1,7 +1,13 @@
 'use strict'
 
+const { types } = require('node:util')
+
 const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./devtools_client/defaults')
+const { MAX_MESSAGE_LENGTH } = require('./constants')
+const { EVENT_TYPE, SKIPPED_REASON } = require('./guardrail-metrics')
 const {
+  CONDITION_ERROR_FLAG,
+  CONDITION_ERROR_THROTTLE_NS,
   DD_TRACE_SYMBOL,
   MAX_SAMPLED_PROBES_PER_PAUSE,
   PROBE_SAMPLER_SYMBOL,
@@ -22,12 +28,20 @@ module.exports = {
 /**
  * Install the runtime sampler in the debuggee context.
  *
+ * @param {import('./guardrail-metrics').GuardrailMetrics} guardrailMetrics - Counters for skipped probe hits.
  * @returns {SharedArrayBuffer} The shared sampler buffer to pass to the debugger worker.
  */
-function installProbeSampler () {
+function installProbeSampler (guardrailMetrics) {
   const buffer = createProbeSamplerBuffer()
 
   const lastCaptureNsByProbeId = new Map()
+  /**
+   * Probes whose condition recently failed to evaluate, keyed by probe id. The error is kept until the worker picks it
+   * up for the error result.
+   *
+   * @type {Map<string, { throttledUntilNs: bigint, error: string | undefined }>}
+   */
+  const conditionErrorByProbeId = new Map()
   const sampledProbeIndexes = new Int32Array(buffer)
   Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 0)
   Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 0)
@@ -44,27 +58,29 @@ function installProbeSampler () {
      * @param {string} probeId - The probe id.
      * @param {bigint} nsBetweenSampling - Minimum nanoseconds between samples for this probe.
      * @param {boolean} isSnapshotProducingProbe - Whether this probe counts toward the global snapshot sample limit.
-     * @returns {boolean} Whether this probe should make the breakpoint condition pause.
      */
     makeSampleDecision (probeIndex, probeId, nsBetweenSampling, isSnapshotProducingProbe) {
       const now = process.hrtime.bigint()
       const lastCaptureNs = lastCaptureNsByProbeId.get(probeId)
-      if (lastCaptureNs !== undefined && now - lastCaptureNs < nsBetweenSampling) return false
+      if (lastCaptureNs !== undefined && now - lastCaptureNs < nsBetweenSampling) {
+        guardrailMetrics.eventSkipped(
+          SKIPPED_REASON.RATE_LIMIT_PROBE,
+          isSnapshotProducingProbe === true ? EVENT_TYPE.SNAPSHOT : EVENT_TYPE.LOG
+        )
+        return false
+      }
 
       let shouldResetGlobalSnapshotRateWindow = false
       if (isSnapshotProducingProbe === true) {
         if (now - globalSnapshotSamplingRateWindowStart > oneSecondNs) {
           shouldResetGlobalSnapshotRateWindow = true
         } else if (snapshotsSampledWithinTheLastSecond >= MAX_SNAPSHOTS_PER_SECOND_GLOBALLY) {
+          guardrailMetrics.eventSkipped(SKIPPED_REASON.RATE_LIMIT_GLOBAL, EVENT_TYPE.SNAPSHOT)
           return false
         }
       }
 
-      const sampledProbeCount = Atomics.add(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 1)
-      if (sampledProbeCount >= MAX_SAMPLED_PROBES_PER_PAUSE) {
-        Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 1)
-        return false
-      }
+      if (!storeSampledProbeIndex(probeIndex)) return false
 
       if (isSnapshotProducingProbe === true) {
         if (shouldResetGlobalSnapshotRateWindow === true) {
@@ -76,10 +92,56 @@ function installProbeSampler () {
       }
 
       lastCaptureNsByProbeId.set(probeId, now)
-      Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_INDEXES_START + sampledProbeCount, probeIndex)
       return true
     },
 
+    /**
+     * Decide if a probe's condition should be evaluated, or skipped because a recent evaluation error throttled it.
+     *
+     * @param {string} probeId - The probe id.
+     */
+    shouldEvaluateCondition (probeId) {
+      const state = conditionErrorByProbeId.get(probeId)
+      if (state === undefined) return true
+      if (process.hrtime.bigint() < state.throttledUntilNs) return false
+      conditionErrorByProbeId.delete(probeId)
+      return true
+    },
+
+    /**
+     * Record that a probe's condition threw, throttle the probe, and request a pause if the error can be reported.
+     *
+     * Error results bypass the per-probe and global rate limits: they are rate limited by the throttle instead, which
+     * allows one error result per probe per window. If the shared buffer is full, the error is dropped but the throttle
+     * is retained.
+     *
+     * @param {number} probeIndex - The worker-side probe sampling index.
+     * @param {string} probeId - The probe id.
+     * @param {unknown} error - The value thrown by the condition.
+     */
+    conditionError (probeIndex, probeId, error) {
+      const stored = storeSampledProbeIndex(probeIndex | CONDITION_ERROR_FLAG)
+      conditionErrorByProbeId.set(probeId, {
+        throttledUntilNs: process.hrtime.bigint() + CONDITION_ERROR_THROTTLE_NS,
+        error: stored ? describeError(error) : undefined,
+      })
+      return stored
+    },
+
+    /**
+     * Hand over the recorded condition error for a probe to the worker. Called by the worker on the paused thread.
+     *
+     * @param {string} probeId - The probe id.
+     * @returns {string | undefined} The error description, if any.
+     */
+    takeConditionError (probeId) {
+      const state = conditionErrorByProbeId.get(probeId)
+      if (state === undefined) return
+      const { error } = state
+      state.error = undefined
+      return error
+    },
+
     /**
      * Remove cached sampling state for a probe.
      *
@@ -87,9 +149,25 @@ function installProbeSampler () {
      */
     remove (probeId) {
       lastCaptureNsByProbeId.delete(probeId)
+      conditionErrorByProbeId.delete(probeId)
     },
   }
 
+  /**
+   * Hand a sampled probe index over to the worker for the upcoming pause.
+   *
+   * @param {number} value - The probe sampling index, possibly with flags set.
+   */
+  function storeSampledProbeIndex (value) {
+    const sampledProbeCount = Atomics.add(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 1)
+    if (sampledProbeCount >= MAX_SAMPLED_PROBES_PER_PAUSE) {
+      Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 1)
+      return false
+    }
+    Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_INDEXES_START + sampledProbeCount, value)
+    return true
+  }
+
   return buffer
 }
 
@@ -100,6 +178,52 @@ function uninstallProbeSampler () {
   delete ddTraceGlobal[Symbol.for(PROBE_SAMPLER_SYMBOL)]
 }
 
+/**
+ * Describe a value thrown by a probe condition without invoking user code. Conditions can throw anything, including
+ * errors with accessors and proxies whose traps have side effects.
+ *
+ * @param {unknown} error - The thrown value.
+ */
+function describeError (error) {
+  if (typeof error === 'string') return truncateErrorDescription(error)
+  if (error === null || (typeof error !== 'object' && typeof error !== 'function')) {
+    return 'Unknown evaluation error'
+  }
+
+  const name = getErrorStringProperty(error, 'name')
+  const message = getErrorStringProperty(error, 'message')
+  if (name === undefined) return truncateErrorDescription(message ?? 'Unknown evaluation error')
+  if (message === undefined) return truncateErrorDescription(name)
+
+  return truncateErrorDescription(`${name}: ${message}`)
+}
+
+/**
+ * Bound an error description before retaining or transferring it.
+ *
+ * @param {string} description - The description to bound.
+ */
+function truncateErrorDescription (description) {
+  return description.length > MAX_MESSAGE_LENGTH
+    ? `${description.slice(0, MAX_MESSAGE_LENGTH)}…`
+    : description
+}
+
+/**
+ * Read a string-valued error property without invoking accessors or proxy traps.
+ *
+ * @param {object} error - The thrown object to inspect.
+ * @param {'name' | 'message'} property - The property to find.
+ */
+function getErrorStringProperty (error, property) {
+  while (error !== null) {
+    if (types.isProxy(error)) return
+    const descriptor = Object.getOwnPropertyDescriptor(error, property)
+    if (descriptor !== undefined) return typeof descriptor.value === 'string' ? descriptor.value : undefined
+    error = Object.getPrototypeOf(error)
+  }
+}
+
 /**
  * Create the shared buffer used to hand sampled probe indexes from breakpoint conditions to the debugger worker.
  *

package/packages/dd-trace/src/debugger/probe_sampler_constants.js

@@ -3,13 +3,43 @@
 const DD_TRACE_SYMBOL = 'dd-trace'
 const PROBE_SAMPLER_SYMBOL = 'dd-trace.debugger.probeSampler'
 
-// Shared sampler contract used by the main debugger bootstrap and the devtools worker.
+// Shared sampler contract used by the main debugger bootstrap and the devtools worker. The debuggee hands sampled
+// probes to the worker through a shared Int32Array, drained by the worker on every pause:
+//
+//            +----------+----------+----------+----------+- - - -+------------+
+//   slot     |    0     |    1     |    2     |    3     |       | 2+MAX-1    |
+//   holds    |  count   | overflow | value    | value    |  ...  | value      |
+//            +----------+----------+----------+----------+- - - -+------------+
+//             ^COUNT     ^OVERFLOW  ^INDEXES_START
 const MAX_SAMPLED_PROBES_PER_PAUSE = 256
 const SAMPLED_PROBE_COUNT_INDEX = 0
 const SAMPLED_PROBE_OVERFLOW_INDEX = 1
 const SAMPLED_PROBE_INDEXES_START = 2
 
+// Each value above is a probe sampling index, with this flag set in bit 30 when the pause is for reporting a
+// condition evaluation error instead of a probe result. Bit 31 stays unused because the array is signed:
+//
+//            +--------+------------+--------------------------------------------+
+//   bit      |   31   |     30     |                   29..0                    |
+//   means    | unused | CONDITION_ |                samplingIndex               |
+//            | (sign) | ERROR_FLAG |                                            |
+//            +--------+------------+--------------------------------------------+
+//
+//   0x0000_0007  probe #7 matched            -> worker captures as usual
+//   0x4000_0007  probe #7's condition threw  -> worker takes the recorded error, captures nothing
+//
+//   write: probeIndex | CONDITION_ERROR_FLAG
+//   read:  value & ~CONDITION_ERROR_FLAG  -> the sampling index
+//          value &  CONDITION_ERROR_FLAG  -> non-zero when the condition threw
+const CONDITION_ERROR_FLAG = 1 << 30
+
+// A probe whose condition failed to evaluate is not evaluated again for this long. One error result is reported per
+// window, so a probe with a broken condition stays visible without repeatedly paying for the failing evaluation.
+const CONDITION_ERROR_THROTTLE_NS = 5n * 60n * 1_000_000_000n // 5 minutes
+
 module.exports = {
+  CONDITION_ERROR_FLAG,
+  CONDITION_ERROR_THROTTLE_NS,
   DD_TRACE_SYMBOL,
   MAX_SAMPLED_PROBES_PER_PAUSE,
   PROBE_SAMPLER_SYMBOL,

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

@@ -207,7 +207,6 @@ class DogStatsDClient {
   /**
    * @param {boolean|(() => void)} [forceTelemetry] - Whether to ignore the telemetry interval, or completion callback
    * @param {() => void} [done] - Called after serverless deliveries complete
-   * @returns {void}
    */
   flush (forceTelemetry = false, done) {
     if (typeof forceTelemetry === 'function') {
@@ -238,7 +237,6 @@ class DogStatsDClient {
   /**
    * @param {boolean} force - Whether to ignore the telemetry interval
    * @param {((send: (done?: () => void) => void) => void)} [track] - Tracks a non-serverless delivery
-   * @returns {void}
    */
   #flushTelemetry (force, track) {
     const telemetry = this.telemetry
@@ -291,7 +289,6 @@ class DogStatsDClient {
    * @param {DogStatsDBufferState} state - Payload state to flush
    * @param {boolean} recordTelemetry - Whether to record the transport outcome
    * @param {((send: (done?: () => void) => void) => void)} [track] - Tracks a non-serverless delivery
-   * @returns {void}
    */
   #flush (state, recordTelemetry, track) {
     const queue = this._enqueue(state)
@@ -314,7 +311,6 @@ class DogStatsDClient {
 
   /**
    * @param {number} bytes - Number of bytes sent
-   * @returns {void}
    */
   #recordSent (bytes) {
     const telemetry = this.telemetry
@@ -326,7 +322,6 @@ class DogStatsDClient {
   /**
    * @param {number} bytes - Number of bytes dropped
    * @param {number} [packets] - Number of packets dropped
-   * @returns {void}
    */
   #recordDropped (bytes, packets = 1) {
     const telemetry = this.telemetry
@@ -341,7 +336,6 @@ class DogStatsDClient {
    * @param {Buffer[]} queue - The metrics to send
    * @param {boolean} recordTelemetry - Whether to record the transport outcome
    * @param {() => void} [done] - Called after delivery completes
-   * @returns {void}
    * @memberof DogStatsDClient
    */
   _sendHttp (queue, recordTelemetry, done) {
@@ -375,7 +369,6 @@ class DogStatsDClient {
    * @param {Buffer[]} queue - The metrics to send
    * @param {boolean} recordTelemetry - Whether to record the transport outcome
    * @param {() => void} [done] - Called after delivery completes
-   * @returns {void}
    * @memberof DogStatsDClient
    */
   _sendUdp (queue, recordTelemetry, done) {
@@ -411,7 +404,6 @@ class DogStatsDClient {
    * @param {number} family - The family of the address
    * @param {boolean} recordTelemetry - Whether to record the transport outcome
    * @param {() => void} [done] - Called after every packet completes
-   * @returns {void}
    * @memberof DogStatsDClient
    */
   _sendUdpFromQueue (queue, address, family, recordTelemetry, done) {
@@ -457,7 +449,6 @@ class DogStatsDClient {
    * @param {string[]} tags - The metric tags
    * @param {string} [tagsPrefix] - Serialized global tags
    * @param {DogStatsDBufferState} [state] - Payload state receiving the metric
-   * @returns {void}
    * @memberof DogStatsDClient
    */
   _add (stat, value, type, tags, tagsPrefix = this.#tagsPrefix, state = this.#metrics) {
@@ -482,7 +473,6 @@ class DogStatsDClient {
    * @param {string} stat - Telemetry metric name
    * @param {number} value - Telemetry metric value
    * @param {string} [typeLabel] - Submitted or aggregated metric type
-   * @returns {void}
    */
   #addTelemetry (stat, value, typeLabel) {
     const tags = typeLabel === undefined ? undefined : [`metrics_type:${typeLabel}`]
@@ -496,7 +486,6 @@ class DogStatsDClient {
    *
    * @param {string} message - The message to write
    * @param {DogStatsDBufferState} [state] - Payload state receiving the message
-   * @returns {void}
    * @memberof DogStatsDClient
    */
   _write (message, state = this.#metrics) {
@@ -605,7 +594,6 @@ class MetricsAggregationClient {
   /**
    * @param {boolean|(() => void)} [forceTelemetry] - Whether to ignore the telemetry interval, or completion callback
    * @param {() => void} [done] - Called after serverless deliveries complete
-   * @returns {void}
    */
   flush (forceTelemetry = false, done) {
     if (typeof forceTelemetry === 'function') {
@@ -680,9 +668,6 @@ class MetricsAggregationClient {
     this.count(name, -count, tags)
   }
 
-  /**
-   * @returns {number} Number of gauge contexts flushed
-   */
   _captureGauges () {
     let metrics = 0
     const contexts = this._captureTree(this._gauges, (node, name, tags) => {
@@ -696,9 +681,6 @@ class MetricsAggregationClient {
     return contexts
   }
 
-  /**
-   * @returns {number} Number of counter contexts flushed
-   */
   _captureCounters () {
     let metrics = 0
     const contexts = this._captureTree(this._counters, (node, name, tags) => {
@@ -712,9 +694,6 @@ class MetricsAggregationClient {
     return contexts
   }
 
-  /**
-   * @returns {number} Number of histogram contexts flushed
-   */
   _captureHistograms () {
     let metrics = 0
     const contexts = this._captureTree(this._histograms, (node, name, tags) => {
@@ -740,7 +719,6 @@ class MetricsAggregationClient {
   /**
    * @param {Map<string, MetricNode>} tree - Metric context tree
    * @param {CaptureMetric} fn - Called for every context with submissions
-   * @returns {number} Number of contexts with submissions
    */
   _captureTree (tree, fn) {
     let contexts = 0
@@ -757,7 +735,6 @@ class MetricsAggregationClient {
    * @param {string} name - Metric name
    * @param {string[]} tags - Current metric tags
    * @param {CaptureMetric} fn - Called for every context with submissions
-   * @returns {number} Number of contexts with submissions
    */
   _captureNode (node, name, tags, fn) {
     let contexts = 0

package/packages/dd-trace/src/encode/0.4-cross-payload.js

@@ -74,13 +74,11 @@ class CrossPayloadAgentEncoder extends AgentEncoder {
     return super.makePayload()
   }
 
-  /** @returns {void} */
   reset () {
     this.#prepareReset()
     super.reset()
   }
 
-  /** @returns {void} */
   #prepareReset () {
     const crossPayloadState = this.#crossPayloadState
     if (crossPayloadState !== undefined && !prepareCrossPayloadReset(crossPayloadState)) {
@@ -129,7 +127,6 @@ function markPayloadString (crossPayloadState, value) {
 
 /**
  * @param {ReturnType<typeof createCrossPayloadState>} crossPayloadState
- * @returns {boolean}
  */
 function prepareCrossPayloadReset (crossPayloadState) {
   const learning = crossPayloadState.learningPayloadCount < CROSS_PAYLOAD_LEARNING_PAYLOAD_LIMIT

package/packages/dd-trace/src/encode/0.4.js

@@ -136,7 +136,6 @@ function formatSpanWithLegacyEvents (span) {
  * replacer hooks).
  *
  * @param {Array<{ name: unknown, startTime: number, attributes?: object }>} spanEvents
- * @returns {string}
  */
 function stringifySpanEvents (spanEvents) {
   let result = '['
@@ -200,7 +199,6 @@ function stringifyAttributeValue (value) {
  * conversion (which is what `JSON.stringify` calls internally).
  *
  * @param {number} value
- * @returns {string}
  */
 function jsonNumber (value) {
   if (Number.isFinite(value)) return String(value)
@@ -215,7 +213,6 @@ function jsonNumber (value) {
  * lone surrogates, etc.).
  *
  * @param {string} value
- * @returns {string}
  */
 function escapeJsonString (value) {
   for (let index = 0; index < value.length; index++) {
@@ -649,7 +646,6 @@ class AgentEncoder {
    * @param {number} offset
    * @param {Buffer} keyPrefix Precomputed `[key, 0xCF]`.
    * @param {{ toBuffer: () => Uint8Array | number[] }} identifier
-   * @returns {number}
    */
   #writeIdAt (target, offset, keyPrefix, identifier) {
     target.set(keyPrefix, offset)
@@ -871,7 +867,6 @@ class AgentEncoder {
    * @param {MsgpackChunk} bytes
    * @param {string} key
    * @param {unknown} value
-   * @returns {boolean}
    */
   #emitAttribute (bytes, key, value) {
     if (typeof value === 'string') {
@@ -911,7 +906,6 @@ class AgentEncoder {
    * @param {MsgpackChunk} bytes
    * @param {string} key
    * @param {Array<unknown>} array
-   * @returns {boolean}
    */
   #emitArrayAttribute (bytes, key, array) {
     const sectionStart = bytes.length
@@ -946,7 +940,6 @@ class AgentEncoder {
    * @param {MsgpackChunk} bytes
    * @param {string} key
    * @param {unknown} value
-   * @returns {boolean}
    */
   #emitArrayItem (bytes, key, value) {
     if (typeof value === 'string') {

package/packages/dd-trace/src/encode/0.5.js

@@ -173,7 +173,6 @@ class AgentEncoder extends BaseEncoder {
    * @param {Uint8Array} target
    * @param {number} offset
    * @param {number} index
-   * @returns {number}
    */
   #writeIndexAt (target, offset, index) {
     target[offset] = 0xCE
@@ -192,7 +191,6 @@ class AgentEncoder extends BaseEncoder {
    * @param {Uint8Array} target
    * @param {number} offset
    * @param {{ toBuffer: () => Uint8Array | number[] }} identifier
-   * @returns {number}
    */
   #writeIdAt (target, offset, identifier) {
     target[offset] = 0xCF

package/packages/dd-trace/src/encode/tags-processors.js

@@ -53,7 +53,6 @@ function truncateSpanTestOpt (span) {
  * the formatter no longer reshapes events, it hands the raw array through.
  *
  * @param {{ startTime: number }} event
- * @returns {number}
  */
 function eventTimeNano (event) {
   return Math.round(event.startTime * 1e6)

package/packages/dd-trace/src/evp_proxy/discovery.js

@@ -2,8 +2,7 @@
 
 const { fetchAgentInfo } = require('../agent/info')
 const log = require('../log')
-
-const TRAILING_SLASHES = /\/+$/
+const { stripTrailingSlashes } = require('./path')
 
 /**
  * Receiver discovery contract
@@ -81,14 +80,14 @@ function selectEVPProxyPath (agentInfo, { supportedPaths, requiredHeaders = [] }
   const advertisedPaths = new Set()
   for (const endpoint of agentInfo.endpoints) {
     if (typeof endpoint === 'string') {
-      advertisedPaths.add(endpoint.replace(TRAILING_SLASHES, ''))
+      advertisedPaths.add(stripTrailingSlashes(endpoint))
     }
   }
 
   for (const supportedPath of supportedPaths) {
     if (typeof supportedPath !== 'string') continue
 
-    const normalizedPath = supportedPath.replace(TRAILING_SLASHES, '')
+    const normalizedPath = stripTrailingSlashes(supportedPath)
     if (advertisedPaths.has(normalizedPath)) {
       return normalizedPath
     }
@@ -107,7 +106,6 @@ function selectEVPProxyPath (agentInfo, { supportedPaths, requiredHeaders = [] }
  * @param {string[]} [options.requiredHeaders] - Headers that the proxy must forward unchanged to intake. Each
  * header must appear in `evp_proxy_allowed_headers`. Do not include routing headers that the Agent consumes.
  * @param {(error: Error|null, route?: {url: URL, basePath: string}) => void} callback - Result callback
- * @returns {void}
  */
 function discoverEVPProxy (url, options, callback) {
   fetchAgentInfo(url, (error, agentInfo) => {