dd-trace 5.80.0 → 5.82.0

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

@@ -8,6 +8,7 @@ module.exports = function getDebuggerConfig (config) {
     hostname: config.hostname,
     logLevel: config.logLevel,
     port: config.port,
+    propagateProcessTags: config.propagateProcessTags,
     repositoryUrl: config.repositoryUrl,
     runtimeId: config.tags['runtime-id'],
     service: config.service,

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

@@ -1,6 +1,6 @@
 'use strict'
 
-const mutex = require('mutexify/promise')()
+const mutex = require('../../../../../vendor/dist/mutexify/promise')()
 const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile: compileCondition, compileSegments, templateRequiresEvaluation } = require('./condition')
@@ -64,8 +64,9 @@ async function addBreakpoint (probe) {
   const snapshotsPerSecond = probe.sampling?.snapshotsPerSecond ?? (probe.captureSnapshot
     ? MAX_SNAPSHOTS_PER_SECOND_PER_PROBE
     : MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE)
-  probe.nsBetweenSampling = BigInt(1 / snapshotsPerSecond * 1e9)
-  probe.lastCaptureNs = 0n
+  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
@@ -80,8 +81,17 @@ async function addBreakpoint (probe) {
     log.debug(
       '[debugger:devtools_client] Translating location using source map for %s:%d:%d (probe: %s, version: %d)',
       file, lineNumber, columnNumber, probe.id, probe.version
-    );
-    ({ line: lineNumber, column: columnNumber } = await getGeneratedPosition(url, source, lineNumber, sourceMapURL))
+    )
+    const position = await getGeneratedPosition(url, source, lineNumber, sourceMapURL)
+    if (position.line !== null && position.column !== null) {
+      lineNumber = position.line
+      columnNumber = position.column
+    } else {
+      throw new Error(
+        // eslint-disable-next-line @stylistic/max-len
+        `Could not find generated position for ${url}:${lineNumber}:${columnNumber} (probe: ${probe.id}, version: ${probe.version})`
+      )
+    }
   }
 
   try {

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

@@ -33,7 +33,7 @@ const reservedWords = new Set([
   // Future reserved words in strict mode
   'implements', 'interface', 'package', 'private', 'protected', 'public',
 
-  // Litterals
+  // Literals
   'NaN'
 ])
 

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

@@ -2,8 +2,8 @@
 
 const { workerData: { config: parentConfig, parentThreadId, configPort } } = require('node:worker_threads')
 const { format } = require('node:url')
-const log = require('./log')
 const defaults = require('../../config_defaults')
+const log = require('./log')
 
 const config = module.exports = {
   ...parentConfig,
@@ -24,4 +24,6 @@ function updateUrl (updates) {
     hostname: updates.hostname || defaults.hostname,
     port: updates.port
   })
+
+  config.dynamicInstrumentation.captureTimeoutNs = BigInt(updates.dynamicInstrumentation.captureTimeoutMs) * 1_000_000n
 }

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

@@ -1,17 +1,18 @@
 'use strict'
 
 const { randomUUID } = require('crypto')
+const { version } = require('../../../../../package.json')
+const { NODE_MAJOR } = require('../../../../../version')
+const processTags = require('../../process-tags')
 const { breakpointToProbes } = require('./state')
 const session = require('./session')
 const { getLocalStateForCallFrame } = require('./snapshot')
 const send = require('./send')
 const { getStackFromCallFrames } = require('./state')
 const { ackEmitting } = require('./status')
-const { parentThreadId } = require('./config')
+const config = require('./config')
 const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./defaults')
 const log = require('./log')
-const { version } = require('../../../../../package.json')
-const { NODE_MAJOR } = require('../../../../../version')
 
 require('./remote_config')
 
@@ -33,8 +34,8 @@ const getDDTagsExpression = `(() => {
 
 // There doesn't seem to be an official standard for the content of these fields, so we're just populating them with
 // something that should be useful to a Node.js developer.
-const threadId = parentThreadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${parentThreadId}`
-const threadName = parentThreadId === 0 ? 'MainThread' : `WorkerThread:${parentThreadId}`
+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
@@ -46,6 +47,7 @@ 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?
@@ -165,13 +167,20 @@ session.on('Debugger.paused', async ({ params }) => {
   }
 
   // TODO: Create unique states for each affected probe based on that probes unique `capture` settings (DEBUG-2863)
-  const processLocalState = numberOfProbesWithSnapshots !== 0 && await getLocalStateForCallFrame(
-    params.callFrames[0],
-    { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength }
-  )
+  let processLocalState, captureErrors
+  if (numberOfProbesWithSnapshots !== 0) {
+    const opts = {
+      maxReferenceDepth,
+      maxCollectionSize,
+      maxFieldCount,
+      maxLength,
+      deadlineNs: start + config.dynamicInstrumentation.captureTimeoutNs
+    }
+    ;({ processLocalState, captureErrors } = await getLocalStateForCallFrame(params.callFrames[0], opts))
+  }
 
   await session.post('Debugger.resume')
-  const diff = process.hrtime.bigint() - start // TODO: Recored as telemetry (DEBUG-2858)
+  const diff = process.hrtime.bigint() - start // TODO: Recorded as telemetry (DEBUG-2858)
 
   // This doesn't measure the overhead of the CDP protocol. The actual pause time is slightly larger.
   // On my machine I'm seeing around 1.7ms of overhead.
@@ -207,15 +216,26 @@ session.on('Debugger.paused', async ({ params }) => {
       language: 'javascript'
     }
 
+    if (config.propagateProcessTags.enabled) {
+      snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
+    }
+
     if (probe.captureSnapshot) {
-      const state = processLocalState()
-      if (state instanceof Error) {
-        snapshot.captureError = state.message
-      } else if (state) {
-        snapshot.captures = {
-          lines: { [probe.location.lines[0]]: { locals: state } }
-        }
+      if (captureErrors?.length > 0) {
+        // There was an error collecting the snapshot for this probe, let's not try again
+        probe.captureSnapshot = false
+        probe.permanentEvaluationErrors = captureErrors.map(error => ({
+          expr: '',
+          message: error.message
+        }))
       }
+      snapshot.captures = {
+        lines: { [probe.location.lines[0]]: { locals: processLocalState() } }
+      }
+    }
+
+    if (probe.permanentEvaluationErrors !== undefined) {
+      snapshot.evaluationErrors = [...probe.permanentEvaluationErrors]
     }
 
     let message = ''

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

@@ -5,6 +5,7 @@
 const { builtinModules } = require('node:module')
 
 if (builtinModules.includes('inspector/promises')) {
+  // @ts-ignore - inspector/promises is available in Node.js 20+ but not in @types/node@18
   module.exports = require('node:inspector/promises')
 } else {
   const inspector = require('node:inspector')
@@ -12,6 +13,7 @@ if (builtinModules.includes('inspector/promises')) {
 
   // The rest of the code in this file is lifted from:
   // https://github.com/nodejs/node/blob/1d4d76ff3fb08f9a0c55a1d5530b46c4d5d550c7/lib/inspector/promises.js
+  // @ts-expect-error - We intentionally override 'post' with a promisified version, changing its signature
   class Session extends inspector.Session {
     constructor () { super() } // eslint-disable-line no-useless-constructor
   }

package/packages/dd-trace/src/debugger/devtools_client/json-buffer.js

@@ -1,34 +1,40 @@
 'use strict'
 
 class JSONBuffer {
+  #maxSize
+  #timeout
+  #onFlush
+  #timer
+  #partialJson
+
   constructor ({ size, timeout, onFlush }) {
-    this._maxSize = size
-    this._timeout = timeout
-    this._onFlush = onFlush
-    this._reset()
+    this.#maxSize = size
+    this.#timeout = timeout
+    this.#onFlush = onFlush
+    this.#reset()
   }
 
-  _reset () {
-    clearTimeout(this._timer)
-    this._timer = null
-    this._partialJson = null
+  #reset () {
+    clearTimeout(this.#timer)
+    this.#timer = undefined
+    this.#partialJson = undefined
   }
 
-  _flush () {
-    const json = `${this._partialJson}]`
-    this._reset()
-    this._onFlush(json)
+  #flush () {
+    const json = `${this.#partialJson}]`
+    this.#reset()
+    this.#onFlush(json)
   }
 
   write (str, size = Buffer.byteLength(str)) {
-    if (this._timer === null) {
-      this._partialJson = `[${str}`
-      this._timer = setTimeout(() => this._flush(), this._timeout)
-    } else if (Buffer.byteLength(this._partialJson) + size + 2 > this._maxSize) {
-      this._flush()
+    if (this.#timer === undefined) {
+      this.#partialJson = `[${str}`
+      this.#timer = setTimeout(() => this.#flush(), this.#timeout)
+    } else if (Buffer.byteLength(/** @type {string} */ (this.#partialJson)) + size + 2 > this.#maxSize) {
+      this.#flush()
       this.write(str, size)
     } else {
-      this._partialJson += `,${str}`
+      this.#partialJson += `,${str}`
     }
   }
 }

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

@@ -3,13 +3,14 @@
 const { hostname: getHostname } = require('os')
 const { stringify } = require('querystring')
 
-const config = require('./config')
-const JSONBuffer = require('./json-buffer')
 const request = require('../../exporters/common/request')
 const { GIT_COMMIT_SHA, GIT_REPOSITORY_URL } = require('../../plugins/util/tags')
-const log = require('./log')
 const { version } = require('../../../../../package.json')
 const { getEnvironmentVariable } = require('../../config-helper')
+const log = require('./log')
+const JSONBuffer = require('./json-buffer')
+const config = require('./config')
+const { pruneSnapshot } = require('./snapshot-pruner')
 
 module.exports = send
 
@@ -55,14 +56,23 @@ function send (message, logger, dd, snapshot) {
   let size = Buffer.byteLength(json)
 
   if (size > MAX_LOG_PAYLOAD_SIZE_BYTES) {
-    // TODO: This is a very crude way to handle large payloads. Proper pruning will be implemented later (DEBUG-2624)
-    delete payload.debugger.snapshot.captures
-    payload.debugger.snapshot.captureError =
-      `Snapshot was too large (max allowed size is ${MAX_LOG_PAYLOAD_SIZE_MB} MiB). ` +
-      'Consider reducing the capture depth or turn off "Capture Variables" completely, ' +
-      'and instead include the variables of interest directly in the message template.'
-    json = JSON.stringify(payload)
-    size = Buffer.byteLength(json)
+    let pruned
+    try {
+      pruned = pruneSnapshot(json, size, MAX_LOG_PAYLOAD_SIZE_BYTES)
+    } catch (err) {
+      log.error('[debugger:devtools_client] Error pruning snapshot', err)
+    }
+
+    if (pruned) {
+      json = pruned
+      size = Buffer.byteLength(json)
+    } else {
+      // Fallback if pruning fails
+      const line = Object.keys(snapshot.captures.lines)[0]
+      snapshot.captures.lines[line] = { pruned: true }
+      json = JSON.stringify(payload)
+      size = Buffer.byteLength(json)
+    }
   }
 
   jsonBuffer.write(json, size)

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

@@ -7,7 +7,7 @@ const inspector = require('./inspector_promises_polyfill')
  *   connect: () => void,
  *   connectToMainThread: () => void
  *   disconnect: () => void,
- *   post: (method: string, params?: object) => Promise<any>,
+ *   post: (method: string, params?: object) => Promise<unknown>,
  * }} CDPSession
  */
 const session = /** @type {CDPSession} */ (new inspector.Session())

package/packages/dd-trace/src/debugger/devtools_client/snapshot/collector.js

@@ -1,16 +1,42 @@
 'use strict'
 
-const { collectionSizeSym, fieldCountSym } = require('./symbols')
 const session = require('../session')
+const { collectionSizeSym, largeCollectionSkipThresholdSym, fieldCountSym, timeBudgetSym } = require('./symbols')
+const { LARGE_OBJECT_SKIP_THRESHOLD } = require('./constants')
 
 const LEAF_SUBTYPES = new Set(['date', 'regexp'])
 const ITERABLE_SUBTYPES = new Set(['map', 'set', 'weakmap', 'weakset'])
+const SIZE_IN_DESCRIPTION_SUBTYPES = new Set(['array', 'typedarray', 'arraybuffer', 'dataview', 'map', 'set'])
 
 module.exports = {
-  getRuntimeObject: getObject
+  collectObjectProperties
 }
 
-async function getObject (objectId, opts, depth = 0, collection = false) {
+/**
+ * @typedef {object} GetObjectOptions
+ * @property {object} maxReferenceDepth - The maximum depth of the object to traverse
+ * @property {number} maxCollectionSize - The maximum size of a collection to include in the snapshot
+ * @property {number} maxFieldCount - The maximum number of properties on an object to include in the snapshot
+ * @property {bigint} deadlineNs - The deadline in nanoseconds compared to `process.hrtime.bigint()`
+ * @property {object} ctx - A context object to track the state/progress of the snapshot collection.
+ * @property {boolean} ctx.deadlineReached - Will be set to `true` if the deadline has been reached.
+ * @property {Error[]} ctx.captureErrors - An array on which errors can be pushed if an issue is detected while
+ *   collecting the snapshot.
+ */
+
+/**
+ * Collect the properties of an object using the Chrome DevTools Protocol.
+ *
+ * @param {string} objectId - The ID of the object to get the properties of
+ * @param {GetObjectOptions} opts - The options for the snapshot. Also used to track the deadline and communicate the
+ *   deadline overrun to the caller using the `deadlineReached` flag.
+ * @param {number} [depth=0] - The depth of the object. Only used internally by this module to track the current depth
+ *   and should not be set by the caller.
+ * @param {boolean} [collection=false] - Whether the object is a collection. Only used internally by this module to
+ *   track the current object type and should not be set by the caller.
+ * @returns {Promise<object[]>} The properties of the object
+ */
+async function collectObjectProperties (objectId, opts, depth = 0, collection = false) {
   const { result, privateProperties } = await session.post('Runtime.getProperties', {
     objectId,
     ownProperties: true // exclude inherited properties
@@ -28,6 +54,13 @@ async function getObject (objectId, opts, depth = 0, collection = false) {
   } else if (result.length > opts.maxFieldCount) {
     // Trim the number of properties on the object if there's too many.
     const size = result.length
+    if (size > LARGE_OBJECT_SKIP_THRESHOLD) {
+      opts.ctx.captureErrors.push(new Error(
+        `An object with ${size} properties was detected while collecting a snapshot. ` +
+        `This exceeds the maximum number of allowed properties of ${LARGE_OBJECT_SKIP_THRESHOLD}. ` +
+        'Future snapshots for existing probes in this location will be skipped until the Node.js process is restarted'
+      ))
+    }
     result.length = opts.maxFieldCount
     result[fieldCountSym] = size
   } else if (privateProperties) {
@@ -43,32 +76,61 @@ async function traverseGetPropertiesResult (props, opts, depth) {
 
   if (depth >= opts.maxReferenceDepth) return props
 
-  const promises = []
+  const work = []
 
   for (const prop of props) {
     if (prop.value === undefined) continue
-    const { value: { type, objectId, subtype } } = prop
+    const { value: { type, objectId, subtype, description } } = prop
     if (type === 'object') {
       if (objectId === undefined) continue // if `subtype` is "null"
       if (LEAF_SUBTYPES.has(subtype)) continue // don't waste time with these subtypes
-      promises.push(getObjectProperties(subtype, objectId, opts, depth).then((properties) => {
-        prop.value.properties = properties
-      }))
+      const size = parseLengthFromDescription(description, subtype)
+      if (size !== null && size >= LARGE_OBJECT_SKIP_THRESHOLD) {
+        const empty = []
+        empty[largeCollectionSkipThresholdSym] = size
+        prop.value.properties = empty
+        continue
+      }
+      work.push([
+        prop.value,
+        () => collectPropertiesBySubtype(subtype, objectId, opts, depth).then((properties) => {
+          prop.value.properties = properties
+        })
+      ])
     } else if (type === 'function') {
-      promises.push(getFunctionProperties(objectId, opts, depth + 1).then((properties) => {
-        prop.value.properties = properties
-      }))
+      work.push([
+        prop.value,
+        () => getFunctionProperties(objectId, opts, depth + 1).then((properties) => {
+          prop.value.properties = properties
+        })
+      ])
     }
   }
 
-  if (promises.length) {
-    await Promise.all(promises)
+  if (work.length) {
+    // Iterate over the work in chunks of 2. The closer to 1, the less we'll overshoot the deadline, but the longer it
+    // takes to complete. `2` seems to be the best compromise.
+    // Anecdotally, on my machine, with no deadline, a concurrency of `1` takes twice as long as a concurrency of `2`.
+    // From thereon, there's no real measurable savings with a higher concurrency.
+    for (let i = 0; i < work.length; i += 2) {
+      if (overBudget(opts)) {
+        for (let j = i; j < work.length; j++) {
+          work[j][0][timeBudgetSym] = true
+        }
+        break
+      }
+      // eslint-disable-next-line no-await-in-loop
+      await Promise.all([
+        work[i][1](),
+        work[i + 1]?.[1]()
+      ])
+    }
   }
 
   return props
 }
 
-function getObjectProperties (subtype, objectId, opts, depth) {
+function collectPropertiesBySubtype (subtype, objectId, opts, depth) {
   if (ITERABLE_SUBTYPES.has(subtype)) {
     return getIterable(objectId, opts, depth)
   } else if (subtype === 'promise') {
@@ -78,7 +140,7 @@ function getObjectProperties (subtype, objectId, opts, depth) {
   } else if (subtype === 'arraybuffer') {
     return getArrayBuffer(objectId, opts, depth)
   }
-  return getObject(objectId, opts, depth + 1, subtype === 'array' || subtype === 'typedarray')
+  return collectObjectProperties(objectId, opts, depth + 1, subtype === 'array' || subtype === 'typedarray')
 }
 
 // TODO: The following extra information from `internalProperties` might be relevant to include for functions:
@@ -189,3 +251,29 @@ function removeNonEnumerableProperties (props) {
     }
   }
 }
+
+function parseLengthFromDescription (description, subtype) {
+  if (typeof description !== 'string') return null
+  if (!SIZE_IN_DESCRIPTION_SUBTYPES.has(subtype)) return null
+
+  const open = description.lastIndexOf('(')
+  if (open === -1) return null
+
+  const close = description.indexOf(')', open + 1)
+  if (close === -1) return null
+
+  const s = description.slice(open + 1, close)
+  if (s === '') return null
+
+  const n = Number(s)
+  if (!Number.isSafeInteger(n) || n < 0) return null
+  if (String(n) !== s) return null
+
+  return n
+}
+
+function overBudget (opts) {
+  if (opts.ctx.deadlineReached) return true
+  opts.ctx.deadlineReached = process.hrtime.bigint() >= opts.deadlineNs
+  return opts.ctx.deadlineReached
+}

package/packages/dd-trace/src/debugger/devtools_client/snapshot/constants.js

@@ -0,0 +1,25 @@
+'use strict'
+
+const { getEnvironmentVariable } = require('../../../config-helper')
+
+const largeObjectSkipThreshold = Number(
+  getEnvironmentVariable('_DD_DYNAMIC_INSTRUMENTATION_EXPERIMENTAL_LARGE_OBJECT_SKIP_THRESHOLD')
+)
+
+module.exports = {
+  /**
+   * When collecting a snapshot, this constant controls what happens when objects with a large number of properties or
+   * collections (arrays, maps, sets, etc.) with a large number of elements are detected:
+   *
+   * - If a collection is detected with more than this number of elements, none of its elements will be included in the
+   *   snapshot.
+   * - If an object is detected with more than this number of properties, it will be included in the snapshot, but
+   *   snapshotting will be turned off for that probe in the future, until the probe is either updated or the Node.js
+   *   process is restarted.
+   */
+  LARGE_OBJECT_SKIP_THRESHOLD: Number.isNaN(largeObjectSkipThreshold) ? 500 : largeObjectSkipThreshold,
+  DEFAULT_MAX_COLLECTION_SIZE: 100,
+  DEFAULT_MAX_FIELD_COUNT: 20,
+  DEFAULT_MAX_LENGTH: 255,
+  DEFAULT_MAX_REFERENCE_DEPTH: 3,
+}

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

@@ -1,52 +1,83 @@
 'use strict'
 
-const { getRuntimeObject } = require('./collector')
+const {
+  DEFAULT_MAX_REFERENCE_DEPTH,
+  DEFAULT_MAX_COLLECTION_SIZE,
+  DEFAULT_MAX_FIELD_COUNT,
+  DEFAULT_MAX_LENGTH
+} = require('./constants')
+const { collectObjectProperties } = require('./collector')
 const { processRawState } = require('./processor')
-const log = require('../log')
 
-const DEFAULT_MAX_REFERENCE_DEPTH = 3
-const DEFAULT_MAX_COLLECTION_SIZE = 100
-const DEFAULT_MAX_FIELD_COUNT = 20
-const DEFAULT_MAX_LENGTH = 255
+const BIGINT_MAX = (1n << 256n) - 1n
 
 module.exports = {
   getLocalStateForCallFrame
 }
 
-function returnError () {
-  return new Error('Error getting local state')
-}
+/**
+ * @typedef {object} GetLocalStateForCallFrameOptions
+ * @property {number} [maxReferenceDepth] - The maximum depth of the object to traverse. Defaults to
+ *   {@link DEFAULT_MAX_REFERENCE_DEPTH}.
+ * @property {number} [maxCollectionSize] - The maximum size of a collection to include in the snapshot. Defaults to
+ *   {@link DEFAULT_MAX_COLLECTION_SIZE}.
+ * @property {number} [maxFieldCount] - The maximum number of properties on an object to include in the snapshot.
+ *   Defaults to {@link DEFAULT_MAX_FIELD_COUNT}.
+ * @property {number} [maxLength] - The maximum length of a string to include in the snapshot. Defaults to
+ *   {@link DEFAULT_MAX_LENGTH}.
+ * @property {bigint} [deadlineNs] - The deadline in nanoseconds compared to `process.hrtime.bigint()`. Defaults to
+ *   {@link BIGINT_MAX}. If the deadline is reached, the snapshot will be truncated.
+ */
 
+/**
+ * Get the local state for a call frame.
+ *
+ * @param {import('inspector').Debugger.CallFrame} callFrame - The call frame to get the local state for
+ * @param {GetLocalStateForCallFrameOptions} [opts] - The options for the snapshot
+ * @returns {Promise<object>} The local state for the call frame
+ */
 async function getLocalStateForCallFrame (
   callFrame,
   {
     maxReferenceDepth = DEFAULT_MAX_REFERENCE_DEPTH,
     maxCollectionSize = DEFAULT_MAX_COLLECTION_SIZE,
     maxFieldCount = DEFAULT_MAX_FIELD_COUNT,
-    maxLength = DEFAULT_MAX_LENGTH
+    maxLength = DEFAULT_MAX_LENGTH,
+    deadlineNs = BIGINT_MAX
   } = {}
 ) {
+  /** @type {{ deadlineReached: boolean, captureErrors: Error[] }} */
+  const ctx = { deadlineReached: false, captureErrors: [] }
+  const opts = { maxReferenceDepth, maxCollectionSize, maxFieldCount, deadlineNs, ctx }
   const rawState = []
   let processedState = null
 
-  try {
-    await Promise.all(callFrame.scopeChain.map(async (scope) => {
-      if (scope.type === 'global') return // The global scope is too noisy
-      rawState.push(...await getRuntimeObject(
-        scope.object.objectId,
-        { maxReferenceDepth, maxCollectionSize, maxFieldCount }
+  for (const scope of callFrame.scopeChain) {
+    if (scope.type === 'global') continue // The global scope is too noisy
+    const { objectId } = scope.object
+    if (objectId === undefined) continue // I haven't seen this happen, but according to the types it's possible
+    try {
+      // The objectId for a scope points to a pseudo-object whose properties are the actual variables in the scope.
+      // This is why we can just call `collectObjectProperties` directly and expect it to return the in-scope variables
+      // as an array.
+      // eslint-disable-next-line no-await-in-loop
+      rawState.push(...await collectObjectProperties(objectId, opts))
+    } catch (err) {
+      ctx.captureErrors.push(new Error(
+        `Error getting local state for closure scope (type: ${scope.type}). ` +
+        'Future snapshots for existing probes in this location will be skipped until the Node.js process is restarted',
+        { cause: err } // TODO: The cause is not used by the backend
       ))
-    }))
-  } catch (err) {
-    // TODO: We might be able to get part of the scope chain.
-    // Consider if we could set errors just for the part of the scope chain that throws during collection.
-    log.error('[debugger:devtools_client] Error getting local state for call frame', err)
-    return returnError
+    }
+    if (ctx.deadlineReached === true) break // TODO: Bad UX; Variables in remaining scopes are silently dropped
   }
 
   // Delay calling `processRawState` so the caller gets a chance to resume the main thread before processing `rawState`
-  return () => {
-    processedState = processedState ?? processRawState(rawState, maxLength)
-    return processedState
+  return {
+    processLocalState () {
+      processedState = processedState ?? processRawState(rawState, maxLength)
+      return processedState
+    },
+    captureErrors: ctx.captureErrors
   }
 }