dd-trace 5.109.0 → 5.110.0

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

@@ -149,7 +149,140 @@ function validateAccess (name) {
   }
 }
 
+let configurationsTable
+let configDefaults
+
+// Lazy require to keep the `config -> helper` import direction acyclic: helper
+// must not pull `config/defaults` at module load. `config/defaults` defers its
+// own instrumented `dns` require until after it exports, so by the time any
+// caller resolves a value the table is fully populated.
+function loadConfigurationsTable () {
+  if (configurationsTable === undefined) {
+    const defaultsModule = require('./defaults')
+    configurationsTable = defaultsModule.configurationsTable
+    configDefaults = defaultsModule.defaults
+  }
+}
+
+/**
+ * Parses and transforms a raw environment value with the same parser and
+ * transformer Config applies when it reads environment sources, so callers
+ * receive the typed value instead of the raw string.
+ *
+ * @param {string} name Canonical or alias environment variable name.
+ * @param {string} value Raw value read from an environment source.
+ * @param {'env_var'|'fleet_stable_config'|'local_stable_config'} source Source the value was read from.
+ * @returns {string | number | boolean | object | undefined}
+ */
+function parseConfigurationValue (name, value, source) {
+  loadConfigurationsTable()
+  const canonical = aliasToCanonical[name] ?? name
+  const entry = configurationsTable[canonical]
+  const parsed = entry.parser(value, canonical, source)
+  return parsed !== undefined && entry.transformer ? entry.transformer(parsed, canonical, source) : parsed
+}
+
+/**
+ * Returns the registered default for a configuration — the same value Config
+ * resolves when no environment source sets it.
+ *
+ * @param {string} name Canonical or alias environment variable name.
+ * @returns {string | number | boolean | object | undefined}
+ */
+function getRegisteredDefault (name) {
+  loadConfigurationsTable()
+  const canonical = aliasToCanonical[name] ?? name
+  const entry = configurationsTable[canonical]
+  return configDefaults[entry.property ?? canonical]
+}
+
+/** @typedef {import('./generated-config-types').GeneratedEnvVarConfig} GeneratedEnvVarConfig */
+
+/**
+ * Returns the value stored at the given name, assumed to be in environment variable format,
+ * from the supported env sources (process.env, local stable config, fleet stable config).
+ * Falls back to aliases if the canonical name is not set.
+ *
+ * The raw value is parsed and transformed exactly as Config does when it reads environment
+ * sources, so the returned value is typed (boolean, number, array, map, ...) rather than the
+ * raw string. A literal supported name resolves to its specific configured type.
+ *
+ * When the name is not set in any source, the registered default is returned, so callers can
+ * use the value directly. Callers that must distinguish an explicitly configured value from the
+ * default (e.g. an OTel fallback that only applies when the option is unset) pass `skipDefault`
+ * to receive `undefined` for an unset value instead. All sources (process.env, local and fleet
+ * stable config) are read in both modes.
+ *
+ * @template {keyof GeneratedEnvVarConfig} TName
+ * @overload
+ * @param {TName} name Environment variable name
+ * @returns {GeneratedEnvVarConfig[TName]}
+ */
+/**
+ * @template {keyof GeneratedEnvVarConfig} TName
+ * @overload
+ * @param {TName} name Environment variable name
+ * @param {boolean} skipDefault Return `undefined` instead of the registered default when unset.
+ * @returns {GeneratedEnvVarConfig[TName] | undefined}
+ */
+/**
+ * @overload
+ * @param {string} name Environment variable name
+ * @param {boolean} [skipDefault] Return `undefined` instead of the registered default when unset.
+ * @returns {string | number | boolean | object | undefined}
+ */
+/**
+ * @param {string} name
+ * @param {boolean} [skipDefault]
+ * @throws {Error} if the configuration is not supported
+ */
+function getValueFromEnvSources (name, skipDefault) {
+  validateAccess(name)
+
+  if (!stableConfigLoaded) {
+    loadStableConfig()
+  }
+
+  // Sources are read in priority order (fleet > env > local). A value the parser
+  // or transformer rejects resolves to `undefined` and is ignored, falling
+  // through to the next source and finally the registered default — mirroring
+  // how Config applies env sources (`setAndTrack` skips such values). This keeps
+  // a malformed higher-priority value (e.g. a fleet-stable `DD_TRACE_DEBUG=maybe`)
+  // from masking a valid `DD_TRACE_DEBUG=true`.
+  if (fleetStableConfig !== undefined) {
+    const fromFleet = getValueFromSource(name, fleetStableConfig)
+    if (fromFleet !== undefined) {
+      const parsed = parseConfigurationValue(name, fromFleet, 'fleet_stable_config')
+      if (parsed !== undefined) {
+        return parsed
+      }
+    }
+  }
+
+  const fromEnv = getValueFromSource(name, process.env)
+  if (fromEnv !== undefined) {
+    const parsed = parseConfigurationValue(name, fromEnv, 'env_var')
+    if (parsed !== undefined) {
+      return parsed
+    }
+  }
+
+  if (localStableConfig !== undefined) {
+    const fromLocal = getValueFromSource(name, localStableConfig)
+    if (fromLocal !== undefined) {
+      const parsed = parseConfigurationValue(name, fromLocal, 'local_stable_config')
+      if (parsed !== undefined) {
+        return parsed
+      }
+    }
+  }
+
+  return skipDefault ? undefined : getRegisteredDefault(name)
+}
+
 module.exports = {
+  getValueFromEnvSources,
+
   /**
    * Expose raw stable config maps and warnings for consumers that need
    * per-source access (e.g. telemetry in Config).
@@ -209,39 +342,6 @@ module.exports = {
     return getValueFromSource(name, process.env)
   },
 
-  /**
-   * Returns the value stored at the given name, assumed to be in environment variable format,
-   * from the supported env sources (process.env, local stable config, fleet stable config).
-   * Falls back to aliases if the canonical name is not set.
-   *
-   * @param {string} name Environment variable name
-   * @returns {string|undefined}
-   * @throws {Error} if the configuration is not supported
-   */
-  getValueFromEnvSources (name) {
-    validateAccess(name)
-
-    if (!stableConfigLoaded) {
-      loadStableConfig()
-    }
-
-    if (fleetStableConfig !== undefined) {
-      const fromFleet = getValueFromSource(name, fleetStableConfig)
-      if (fromFleet !== undefined) {
-        return fromFleet
-      }
-    }
-
-    const fromEnv = getValueFromSource(name, process.env)
-    if (fromEnv !== undefined) {
-      return fromEnv
-    }
-
-    if (localStableConfig !== undefined) {
-      return getValueFromSource(name, localStableConfig)
-    }
-  },
-
   /**
    * Returns the actual environment variable name used for a supported configuration
    * from a specific environment-based source.

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

@@ -7,7 +7,7 @@ const { URL, format } = require('node:url')
 const rfdc = require('../../../../vendor/dist/rfdc')({ proto: false, circles: false })
 const uuid = require('../../../../vendor/dist/crypto-randomuuid') // we need to keep the old uuid dep because of cypress
 const set = require('../../../datadog-core/src/utils/src/set')
-const { DD_MAJOR } = require('../../../../version')
+const { DD_MAJOR, NODE_MAJOR } = require('../../../../version')
 const log = require('../log')
 const pkg = require('../pkg')
 const { isTrue } = require('../util')
@@ -361,6 +361,9 @@ class Config extends ConfigBase {
     if (this.telemetry.heartbeatInterval) {
       setAndTrack(this, 'telemetry.heartbeatInterval', Math.floor(this.telemetry.heartbeatInterval * 1000))
     }
+
+    // Allocation profiling needs a sampling hook only available on Node.js 26+.
+    setAndTrack(this, 'DD_PROFILING_ALLOCATION_ENABLED', NODE_MAJOR >= 26 && this.DD_PROFILING_ALLOCATION_ENABLED)
     if (this.telemetry.extendedHeartbeatInterval) {
       setAndTrack(this, 'telemetry.extendedHeartbeatInterval',
         Math.floor(this.telemetry.extendedHeartbeatInterval * 1000))

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

@@ -2,7 +2,7 @@
 
 const fs = require('fs')
 
-const { DD_MAJOR } = require('../../../../version')
+const { DD_MAJOR, NODE_MAJOR } = require('../../../../version')
 const tagger = require('../tagger')
 
 let warnInvalidValue
@@ -100,6 +100,24 @@ const transformers = {
     }
     return configValue
   },
+  /**
+   * Parses DD_PROFILING_DEBUG_UPLOAD_COMPRESSION ('on' | 'off' | 'gzip[-1..9]' | 'zstd[-1..22]')
+   * into the codec and level the profiler uploads with. The value's shape is already range-checked
+   * by the `allowed` pattern, so no validation is needed here.
+   *
+   * @param {string} value
+   * @returns {{ method: string, level: number | undefined }}
+   */
+  normalizeProfilingUploadCompression (value) {
+    let [method, level] = value.toLowerCase().split('-')
+    // Default "on" to zstd on Node.js 24+ and gzip earlier. zstd ships everywhere via a Rust
+    // compressor, but 24+ has a built-in that runs on libuv worker threads just as gzip does, so it
+    // is the least disruptive default.
+    if (method === 'on') {
+      method = NODE_MAJOR >= 24 ? 'zstd' : 'gzip'
+    }
+    return { method, level: level ? Number.parseInt(level, 10) : undefined }
+  },
   sampleRate (value, optionName, source) {
     const number = Number(value)
     if (Number.isNaN(number) || value === null) {

package/packages/dd-trace/src/config/supported-configurations.json

@@ -1238,6 +1238,16 @@
         "default": null
       }
     ],
+    "DD_LLMOBS_SAMPLE_RATE": [
+      {
+        "implementation": "A",
+        "type": "decimal",
+        "configurationNames": [
+          "llmobs.sampleRate"
+        ],
+        "default": "1.0"
+      }
+    ],
     "DD_LOGS_INJECTION": [
       {
         "implementation": "B",
@@ -1398,8 +1408,8 @@
         "implementation": "B",
         "type": "string",
         "default": "on",
-        "allowed": "on|off|(gzip|zstd)(-[1-9][0-9]?)?",
-        "transform": "toLowerCase"
+        "allowed": "on|off|gzip(-[1-9])?|zstd(-([1-9]|1[0-9]|2[0-2]))?",
+        "transform": "normalizeProfilingUploadCompression"
       }
     ],
     "DD_PROFILING_ENABLED": [
@@ -1486,7 +1496,8 @@
       {
         "implementation": "A",
         "type": "int",
-        "default": "524288"
+        "default": "524288",
+        "allowed": "[1-9]\\d*"
       }
     ],
     "DD_PROFILING_PPROF_PREFIX": [
@@ -3320,6 +3331,13 @@
         "default": "true"
       }
     ],
+    "DD_TRACE_OTEL_SEMANTICS_ENABLED": [
+      {
+        "implementation": "A",
+        "type": "boolean",
+        "default": "false"
+      }
+    ],
     "DD_TRACE_OTEL_ENABLED": [
       {
         "implementation": "A",

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')
   }