dd-trace 5.109.0 → 5.111.0

package/packages/dd-trace/src/debugger/devtools_client/breakpoints.js

@@ -5,6 +5,7 @@ const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile, compileSegments, templateRequiresEvaluation } = require('./condition')
 const { MAX_SNAPSHOTS_PER_SECOND_PER_PROBE, MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE } = require('./defaults')
+const { compileBreakpointCondition, getRemoveProbeExpression } = require('./probe_sampler')
 const {
   DEFAULT_MAX_REFERENCE_DEPTH,
   DEFAULT_MAX_COLLECTION_SIZE,
@@ -17,6 +18,7 @@ const {
   locationToBreakpoint,
   breakpointToProbes,
   probeToLocation,
+  samplingIndexToProbe,
 } = require('./state')
 const log = require('./log')
 
@@ -26,6 +28,7 @@ const log = require('./log')
 
 let sessionStarted = false
 const probes = new Map()
+let nextSamplingIndex = 0
 let scriptLoadingStabilizedResolve
 const scriptLoadingStabilized = new Promise((resolve) => { scriptLoadingStabilizedResolve = resolve })
 
@@ -55,6 +58,8 @@ async function addBreakpoint (probe) {
   if (!sessionStarted) await start()
 
   probes.set(probe.id, probe)
+  probe.samplingIndex = nextSamplingIndex++
+  samplingIndexToProbe.set(probe.samplingIndex, probe)
 
   const file = probe.where.sourceFile
   let lineNumber = Number(probe.where.lines[0]) // Tracer doesn't support multiple-line breakpoints
@@ -75,8 +80,6 @@ async function addBreakpoint (probe) {
     ? MAX_SNAPSHOTS_PER_SECOND_PER_PROBE
     : MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE)
   probe.nsBetweenSampling = BigInt(Math.trunc(1 / snapshotsPerSecond * 1e9))
-  // Initialize to a large negative value to ensure first probe hit is always captured
-  probe.lastCaptureNs = BigInt(Number.MIN_SAFE_INTEGER)
 
   // Warning: The code below relies on undocumented behavior of the inspector!
   // It expects that `await session.post('Debugger.enable')` will wait for all loaded scripts to be emitted as
@@ -174,7 +177,7 @@ async function addBreakpoint (probe) {
     try {
       result = /** @type {SetBreakpointResponse} */ (await session.post('Debugger.setBreakpoint', {
         location,
-        condition: probe.condition,
+        condition: compileBreakpointCondition([probe]),
       }))
     } catch (err) {
       throw new Error(`Error setting breakpoint for probe ${probe.id} (version: ${probe.version})`, { cause: err })
@@ -195,11 +198,14 @@ async function removeBreakpoint ({ id }) {
   }
 
   probes.delete(id)
+  await removeProbeFromSampler(id)
 
   const locationKey = probeToLocation.get(id)
   const breakpoint = locationToBreakpoint.get(locationKey)
   const probesAtLocation = breakpointToProbes.get(breakpoint.id)
+  const probe = probesAtLocation.get(id)
 
+  samplingIndexToProbe.delete(probe.samplingIndex)
   probesAtLocation.delete(id)
   probeToLocation.delete(id)
 
@@ -229,35 +235,37 @@ async function modifyBreakpoint (probe) {
 
 async function updateBreakpointInternal (breakpoint, probe) {
   const probesAtLocation = breakpointToProbes.get(breakpoint.id)
-  const conditionBeforeNewProbe = compileCompoundCondition([...probesAtLocation.values()])
 
-  // If a probe is provided, add it to the breakpoint. If not, it's because we're removing a probe, but potentially
-  // need to update the condition of the breakpoint.
+  // If a probe is provided, add it to the breakpoint. If not, it's because we're removing a probe. In both cases the
+  // breakpoint condition must be rebuilt to match the remaining probes at the location.
   if (probe) {
     probesAtLocation.set(probe.id, probe)
     probeToLocation.set(probe.id, breakpoint.locationKey)
   }
 
-  const condition = compileCompoundCondition([...probesAtLocation.values()])
-
-  if (condition || conditionBeforeNewProbe !== condition) {
-    try {
-      await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
-    } catch (err) {
-      throw new Error(`Error removing breakpoint for probe ${probe.id}`, { cause: err })
-    }
-    breakpointToProbes.delete(breakpoint.id)
-    let result
-    try {
-      result = /** @type {SetBreakpointResponse} */ (await session.post('Debugger.setBreakpoint', {
-        location: breakpoint.location,
-        condition,
-      }))
-    } catch (err) {
-      throw new Error(`Error setting breakpoint for probe ${probe.id} (version: ${probe.version})`, { cause: err })
-    }
-    breakpointToProbes.set(result.breakpointId, probesAtLocation)
+  try {
+    await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
+  } catch (err) {
+    const message = probe
+      ? `Error replacing breakpoint while adding probe ${probe.id} (version: ${probe.version})`
+      : `Error replacing breakpoint after removing probe from ${breakpoint.locationKey}`
+    throw new Error(message, { cause: err })
+  }
+  breakpointToProbes.delete(breakpoint.id)
+  let result
+  try {
+    result = /** @type {SetBreakpointResponse} */ (await session.post('Debugger.setBreakpoint', {
+      location: breakpoint.location,
+      condition: compileBreakpointCondition([...probesAtLocation.values()]),
+    }))
+  } catch (err) {
+    const message = probe
+      ? `Error setting breakpoint while adding probe ${probe.id} (version: ${probe.version})`
+      : `Error setting breakpoint after removing probe from ${breakpoint.locationKey}`
+    throw new Error(message, { cause: err })
   }
+  breakpoint.id = result.breakpointId
+  breakpointToProbes.set(result.breakpointId, probesAtLocation)
 }
 
 async function reEvaluateProbe (probe) {
@@ -305,16 +313,20 @@ function lock (fn) {
   }
 }
 
-// Only if all probes have a condition can we use a compound condition.
-// Otherwise, we need to evaluate each probe individually once the breakpoint is hit.
-function compileCompoundCondition (probes) {
-  if (probes.length === 1) return probes[0].condition
-
-  return probes.every(p => p.condition)
-    ? probes
-      .map((p) => `(() => { try { return ${p.condition} } catch { return false } })()`)
-      .join(' || ')
-    : undefined
+/**
+ * Remove cached sampling state for a probe from the runtime sampler.
+ *
+ * @param {string} id - The probe id.
+ * @returns {Promise<void>}
+ */
+async function removeProbeFromSampler (id) {
+  try {
+    await session.post('Runtime.evaluate', {
+      expression: getRemoveProbeExpression(id),
+    })
+  } catch (err) {
+    log.error('[debugger:devtools_client] Error removing probe %s from sampler', id, err)
+  }
 }
 
 function generateLocationKey (scriptId, lineNumber, columnNumber) {

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

@@ -1,17 +1,22 @@
 'use strict'
 
 const { randomUUID } = require('crypto')
+const { workerData: { probeSamplerBuffer } } = require('worker_threads')
 const { version } = require('../../../../../package.json')
-const { NODE_MAJOR } = require('../../../../../version')
 const processTags = require('../../process-tags')
-const { breakpointToProbes } = require('./state')
+const {
+  MAX_SAMPLED_PROBES_PER_PAUSE,
+  SAMPLED_PROBE_COUNT_INDEX,
+  SAMPLED_PROBE_INDEXES_START,
+  SAMPLED_PROBE_OVERFLOW_INDEX,
+} = require('../probe_sampler_constants')
+const { breakpointToProbes, samplingIndexToProbe } = require('./state')
 const session = require('./session')
 const { getLocalStateForCallFrame, evaluateCaptureExpressions } = require('./snapshot')
 const send = require('./send')
 const { getStackFromCallFrames } = require('./state')
 const { ackEmitting } = require('./status')
 const config = require('./config')
-const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./defaults')
 const log = require('./log')
 
 require('./remote_config')
@@ -38,25 +43,7 @@ const getDDTagsExpression = `(() => {
 // something that should be useful to a Node.js developer.
 const threadId = config.parentThreadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${config.parentThreadId}`
 const threadName = config.parentThreadId === 0 ? 'MainThread' : `WorkerThread:${config.parentThreadId}`
-
-const SUPPORT_ARRAY_BUFFER_RESIZE = NODE_MAJOR >= 20
-const oneSecondNs = 1_000_000_000n
-let globalSnapshotSamplingRateWindowStart = 0n
-let snapshotsSampledWithinTheLastSecond = 0
-
-// TODO: Change to const once we drop support for Node.js 18
-let snapshotProbeIndexBuffer, snapshotProbeIndex
-
-if (SUPPORT_ARRAY_BUFFER_RESIZE) {
-  // TODO: Is a limit of 256 snapshots ever going to be a problem?
-  // @ts-ignore - ArrayBuffer constructor with maxByteLength is available in Node.js 20+ but not in @types/node@18
-  // eslint-disable-next-line n/no-unsupported-features/es-syntax
-  snapshotProbeIndexBuffer = new ArrayBuffer(1, { maxByteLength: 256 })
-  // TODO: Is a limit of 256 probes ever going to be a problem?
-  snapshotProbeIndex = new Uint8Array(snapshotProbeIndexBuffer)
-} else {
-  snapshotProbeIndex = new Uint8Array(1)
-}
+const sampledProbeIndexes = new Int32Array(probeSamplerBuffer)
 
 // WARNING: The code above the line `await session.post('Debugger.resume')` is highly optimized. Please edit with care!
 session.on('Debugger.paused', async ({ params }) => {
@@ -71,7 +58,6 @@ session.on('Debugger.paused', async ({ params }) => {
   let maxCollectionSize = 0
   let maxFieldCount = 0
   let maxLength = 0
-  let sampled = false
   let numberOfProbesWithSnapshots = 0
   let probesWithCaptureExpressions = false
   const probes = []
@@ -80,7 +66,15 @@ session.on('Debugger.paused', async ({ params }) => {
   // V8 doesn't allow setting more than one breakpoint at a specific location, however, it's possible to set two
   // breakpoints just next to each other that will "snap" to the same logical location, which in turn will be hit at the
   // same time. E.g. index.js:1:1 and index.js:1:2.
-  let numberOfProbesOnBreakpoint = params.hitBreakpoints.length
+  const numberOfSampledProbeIndexes = Math.min(
+    Atomics.exchange(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 0),
+    MAX_SAMPLED_PROBES_PER_PAUSE
+  )
+  if (Atomics.exchange(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 0) === 1) {
+    log.error(
+      '[debugger:devtools_client] Too many probes sampled at the same breakpoint location; skipping excess probes'
+    )
+  }
 
   // TODO: Investigate if it will improve performance to create a fast-path for when there's only a single breakpoint
   for (let i = 0; i < params.hitBreakpoints.length; i++) {
@@ -92,36 +86,23 @@ session.on('Debugger.paused', async ({ params }) => {
       continue
     }
 
-    if (probesAtLocation.size !== 1) {
-      numberOfProbesOnBreakpoint = numberOfProbesOnBreakpoint + probesAtLocation.size - 1
-      if (numberOfProbesOnBreakpoint > snapshotProbeIndex.length) {
-        if (SUPPORT_ARRAY_BUFFER_RESIZE) {
-          snapshotProbeIndexBuffer.resize(numberOfProbesOnBreakpoint)
-        } else {
-          snapshotProbeIndex = new Uint8Array(numberOfProbesOnBreakpoint)
-        }
-      }
-    }
+    for (let j = 0; j < numberOfSampledProbeIndexes; j++) {
+      const samplingIndex = Atomics.load(sampledProbeIndexes, SAMPLED_PROBE_INDEXES_START + j)
+      const probe = samplingIndexToProbe.get(samplingIndex)
 
-    for (const probe of probesAtLocation.values()) {
-      if (start - probe.lastCaptureNs < probe.nsBetweenSampling) {
+      if (probe === undefined) {
+        log.error('[debugger:devtools_client] No probe found for sampled probe index %d', samplingIndex)
+        continue
+      }
+      if (!probesAtLocation.has(probe.id)) {
+        log.error('[debugger:devtools_client] Sampled probe %s was not found at breakpoint %s',
+          probe.id, params.hitBreakpoints[i])
         continue
       }
 
       if (probe.captureSnapshot === true || probe.compiledCaptureExpressions !== undefined) {
-        // This algorithm to calculate number of sampled snapshots within the last second is not perfect, as it's not a
-        // sliding window. But it's quick and easy :)
-        if (i === 0 && start - globalSnapshotSamplingRateWindowStart > oneSecondNs) {
-          snapshotsSampledWithinTheLastSecond = 1
-          globalSnapshotSamplingRateWindowStart = start
-        } else if (snapshotsSampledWithinTheLastSecond >= MAX_SNAPSHOTS_PER_SECOND_GLOBALLY) {
-          continue
-        } else {
-          snapshotsSampledWithinTheLastSecond++
-        }
-
         if (probe.captureSnapshot === true) {
-          snapshotProbeIndex[numberOfProbesWithSnapshots++] = probes.length
+          numberOfProbesWithSnapshots++
           maxReferenceDepth = Math.max(probe.capture.maxReferenceDepth, maxReferenceDepth)
           maxCollectionSize = Math.max(probe.capture.maxCollectionSize, maxCollectionSize)
           maxFieldCount = Math.max(probe.capture.maxFieldCount, maxFieldCount)
@@ -131,23 +112,6 @@ session.on('Debugger.paused', async ({ params }) => {
         }
       }
 
-      if (probe.condition !== undefined) {
-        // TODO: Bundle all conditions and evaluate them in a single call
-        // TODO: Handle errors
-        const { result } = /** @type {EvaluateOnCallFrameResult} */ (
-          // eslint-disable-next-line no-await-in-loop
-          await session.post('Debugger.evaluateOnCallFrame', {
-            callFrameId: params.callFrames[0].callFrameId,
-            expression: probe.condition,
-            returnByValue: true,
-          })
-        )
-        if (result.value !== true) continue
-      }
-
-      sampled = true
-      probe.lastCaptureNs = start
-
       if (probe.templateRequiresEvaluation) {
         templateExpressions += `,${probe.template}`
       }
@@ -156,7 +120,8 @@ session.on('Debugger.paused', async ({ params }) => {
     }
   }
 
-  if (sampled === false) {
+  // This can happen if sampled probe indexes are inconsistent with the worker state. Those cases are logged above.
+  if (probes.length === 0) {
     return session.post('Debugger.resume')
   }
 

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

@@ -0,0 +1,83 @@
+'use strict'
+
+const { DD_TRACE_SYMBOL, PROBE_SAMPLER_SYMBOL } = require('../probe_sampler_constants')
+
+const SAMPLER_EXPRESSION = `globalThis[Symbol.for(${JSON.stringify(DD_TRACE_SYMBOL)})]?.` +
+  `[Symbol.for(${JSON.stringify(PROBE_SAMPLER_SYMBOL)})]`
+
+module.exports = {
+  compileBreakpointCondition,
+  getRemoveProbeExpression,
+}
+
+/**
+ * Build the expression that removes a probe from runtime sampler state. Called by the devtools worker and evaluated on
+ * the debuggee.
+ *
+ * @param {string} id - The probe id.
+ * @returns {string}
+ */
+function getRemoveProbeExpression (id) {
+  return `${SAMPLER_EXPRESSION}?.remove(${JSON.stringify(id)})`
+}
+
+/**
+ * Build a Chrome DevTools breakpoint condition that samples all matching probes at a location. Called by the devtools
+ * worker.
+ *
+ * @param {{
+ *   id: string,
+ *   samplingIndex: number,
+ *   nsBetweenSampling: bigint,
+ *   condition?: string,
+ *   captureSnapshot?: boolean,
+ *   compiledCaptureExpressions?: object[]
+ * }[]} probes - The probes at the breakpoint location.
+ * @returns {string}
+ */
+function compileBreakpointCondition (probes) {
+  const probeConditions = []
+  for (const probe of probes) {
+    probeConditions.push(compileProbeCondition(probe))
+  }
+
+  // NOTE: $dd_sampler is read from the realm-local `globalThis` where it was installed (the main
+  // realm). A probe whose code runs in a different V8 realm (e.g. a `vm.createContext` script with a
+  // file-path filename) won't see it and will silently never fire. Known limitation: a breakpoint
+  // condition has no realm-independent handle to reach, so we degrade rather than crash.
+  return `(() => {
+    const $dd_sampler = ${SAMPLER_EXPRESSION}
+    if ($dd_sampler === undefined) return false
+    let $dd_sampled = false
+    ${probeConditions.join('\n    ')}
+    return $dd_sampled
+  })()`
+}
+
+/**
+ * Build the condition fragment for a single probe. Called by the devtools worker while building breakpoint conditions.
+ *
+ * @param {{
+ *   id: string,
+ *   samplingIndex: number,
+ *   nsBetweenSampling: bigint,
+ *   condition?: string,
+ *   captureSnapshot?: boolean,
+ *   compiledCaptureExpressions?: object[]
+ * }} probe - The probe to sample.
+ * @returns {string}
+ */
+function compileProbeCondition (probe) {
+  const sample = `$dd_sampler.makeSampleDecision(${probe.samplingIndex}, ${JSON.stringify(probe.id)}, ` +
+    `${probe.nsBetweenSampling}n, ${probe.captureSnapshot === true || probe.compiledCaptureExpressions !== undefined})`
+
+  if (probe.condition === undefined) {
+    return `$dd_sampled = ${sample} || $dd_sampled`
+  }
+
+  return `try {
+      if ((${probe.condition}) === true) {
+        $dd_sampled = ${sample} || $dd_sampled
+      }
+    } catch {}`
+}

package/packages/dd-trace/src/debugger/devtools_client/state.js

@@ -33,6 +33,7 @@ module.exports = {
   locationToBreakpoint: new Map(),
   breakpointToProbes: new Map(),
   probeToLocation: new Map(),
+  samplingIndexToProbe: new Map(),
 
   _loadedScripts: loadedScripts, // Only exposed for testing
   _scriptUrls: scriptUrls, // Only exposed for testing

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

@@ -8,6 +8,7 @@ const log = require('../log')
 const { fetchAgentInfo } = require('../agent/info')
 const getDebuggerConfig = require('./config')
 const { DEBUGGER_DIAGNOSTICS_V1, DEBUGGER_INPUT_V2 } = require('./constants')
+const { installProbeSampler, uninstallProbeSampler } = require('./probe_sampler')
 
 /**
  * @typedef {ReturnType<import('../config')>} Config
@@ -65,6 +66,8 @@ function start (config, rcInstance) {
 
   globalThis[Symbol.for('dd-trace')].utilTypes = types
 
+  const probeSamplerBuffer = installProbeSampler()
+
   readProbeFile(config.dynamicInstrumentation.probeFile, (probes) => {
     const action = 'apply'
     for (const probe of probes) {
@@ -110,6 +113,7 @@ function start (config, rcInstance) {
           probePort: probeChannel.port1,
           logPort: logChannel.port1,
           configPort: configChannel.port1,
+          probeSamplerBuffer,
         },
         transferList: [probeChannel.port1, logChannel.port1, configChannel.port1],
       }
@@ -187,6 +191,7 @@ function cleanup (error) {
     worker.removeAllListeners()
     worker = null
   }
+  uninstallProbeSampler()
   configChannel = null
   inputPath = null
 

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

@@ -0,0 +1,112 @@
+'use strict'
+
+const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./devtools_client/defaults')
+const {
+  DD_TRACE_SYMBOL,
+  MAX_SAMPLED_PROBES_PER_PAUSE,
+  PROBE_SAMPLER_SYMBOL,
+  SAMPLED_PROBE_COUNT_INDEX,
+  SAMPLED_PROBE_INDEXES_START,
+  SAMPLED_PROBE_OVERFLOW_INDEX,
+} = require('./probe_sampler_constants')
+
+const ddTraceGlobal = /** @type {Record<symbol, SharedArrayBuffer | object | undefined>} */ (
+  /** @type {Record<symbol, unknown>} */ (globalThis)[Symbol.for(DD_TRACE_SYMBOL)]
+)
+
+module.exports = {
+  installProbeSampler,
+  uninstallProbeSampler,
+}
+
+/**
+ * Install the runtime sampler in the debuggee context.
+ *
+ * @returns {SharedArrayBuffer} The shared sampler buffer to pass to the debugger worker.
+ */
+function installProbeSampler () {
+  const buffer = createProbeSamplerBuffer()
+
+  const lastCaptureNsByProbeId = new Map()
+  const sampledProbeIndexes = new Int32Array(buffer)
+  Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_COUNT_INDEX, 0)
+  Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_OVERFLOW_INDEX, 0)
+
+  const oneSecondNs = 1_000_000_000n
+  let globalSnapshotSamplingRateWindowStart = 0n
+  let snapshotsSampledWithinTheLastSecond = 0
+
+  ddTraceGlobal[Symbol.for(PROBE_SAMPLER_SYMBOL)] = {
+    /**
+     * Decide if a probe should be sampled and store sampled probe indexes for the debugger worker.
+     *
+     * @param {number} probeIndex - The worker-side probe sampling index.
+     * @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
+
+      let shouldResetGlobalSnapshotRateWindow = false
+      if (isSnapshotProducingProbe === true) {
+        if (now - globalSnapshotSamplingRateWindowStart > oneSecondNs) {
+          shouldResetGlobalSnapshotRateWindow = true
+        } else if (snapshotsSampledWithinTheLastSecond >= MAX_SNAPSHOTS_PER_SECOND_GLOBALLY) {
+          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 (isSnapshotProducingProbe === true) {
+        if (shouldResetGlobalSnapshotRateWindow === true) {
+          snapshotsSampledWithinTheLastSecond = 1
+          globalSnapshotSamplingRateWindowStart = now
+        } else {
+          snapshotsSampledWithinTheLastSecond++
+        }
+      }
+
+      lastCaptureNsByProbeId.set(probeId, now)
+      Atomics.store(sampledProbeIndexes, SAMPLED_PROBE_INDEXES_START + sampledProbeCount, probeIndex)
+      return true
+    },
+
+    /**
+     * Remove cached sampling state for a probe.
+     *
+     * @param {string} probeId - The probe id.
+     */
+    remove (probeId) {
+      lastCaptureNsByProbeId.delete(probeId)
+    },
+  }
+
+  return buffer
+}
+
+/**
+ * Remove the runtime sampler from the debuggee context.
+ */
+function uninstallProbeSampler () {
+  delete ddTraceGlobal[Symbol.for(PROBE_SAMPLER_SYMBOL)]
+}
+
+/**
+ * Create the shared buffer used to hand sampled probe indexes from breakpoint conditions to the debugger worker.
+ *
+ * @returns {SharedArrayBuffer}
+ */
+function createProbeSamplerBuffer () {
+  return new SharedArrayBuffer(
+    (SAMPLED_PROBE_INDEXES_START + MAX_SAMPLED_PROBES_PER_PAUSE) * Int32Array.BYTES_PER_ELEMENT
+  )
+}

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

@@ -0,0 +1,19 @@
+'use strict'
+
+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.
+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
+
+module.exports = {
+  DD_TRACE_SYMBOL,
+  MAX_SAMPLED_PROBES_PER_PAUSE,
+  PROBE_SAMPLER_SYMBOL,
+  SAMPLED_PROBE_COUNT_INDEX,
+  SAMPLED_PROBE_INDEXES_START,
+  SAMPLED_PROBE_OVERFLOW_INDEX,
+}