@depup/dd-trace 5.90.0-depup.0

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

@@ -0,0 +1,294 @@
+'use strict'
+
+module.exports = {
+  compile,
+  compileSegments,
+  templateRequiresEvaluation,
+}
+
+const identifierRegex = /^[@a-zA-Z_$][\w$]*$/
+
+// The following identifiers have purposefully not been included in this list:
+// - The reserved words `this` and `super` as they can have valid use cases as `ref` values
+// - The literals `undefined` and `Infinity` as they can be useful as `ref` values, especially to check if a
+//   variable is `undefined`.
+// - The following future reserved words in older standards, as they can now be used safely:
+//   `abstract`, `boolean`, `byte`, `char`, `double`, `final`, `float`, `goto`, `int`, `long`, `native`, `short`,
+//   `synchronized`, `throws`, `transient`, `volatile`.
+const reservedWords = new Set([
+  // Reserved words
+  'break', 'case', 'catch', 'class', 'const', 'continue', 'debugger', 'default', 'delete', 'do', 'else', 'export',
+  'extends', 'false', 'finally', 'for', 'function', 'if', 'import', 'in', 'instanceof', 'new', 'null', 'return',
+  'switch', 'throw', 'true', 'try', 'typeof', 'var', 'void', 'while', 'with',
+
+  // Reserved in strict mode
+  'let', 'static', 'yield',
+
+  // Reserved in module code or async function bodies:
+  'await',
+
+  // Future reserved words
+  'enum',
+
+  // Future reserved words in strict mode
+  'implements', 'interface', 'package', 'private', 'protected', 'public',
+
+  // Literals
+  'NaN',
+])
+
+const PRIMITIVE_TYPES = new Set(['string', 'number', 'bigint', 'boolean', 'undefined', 'symbol', 'null'])
+
+function templateRequiresEvaluation (segments) {
+  if (segments === undefined) return false // There should always be segments, but just in case
+  for (const { str } of segments) {
+    if (str === undefined) return true
+  }
+  return false
+}
+
+function compileSegments (segments) {
+  let result = '['
+  for (let i = 0; i < segments.length; i++) {
+    const { str, dsl, json } = segments[i]
+    result += str === undefined
+      ? `(() => {
+          try {
+            const result = ${compile(json)}
+            return typeof result === 'string' ? result : $dd_inspect(result, $dd_segmentInspectOptions)
+          } catch (e) {
+            return { expr: ${JSON.stringify(dsl)}, message: \`\${e.name}: \${e.message}\` }
+          }
+        })()`
+      : JSON.stringify(str)
+    if (i !== segments.length - 1) {
+      result += ','
+    }
+  }
+  return `${result}]`
+}
+
+// TODO: Consider storing some of these functions that doesn't require closure access to the current scope on `process`
+// so they can be reused across probes
+function compile (node) {
+  if (node === null || typeof node === 'number' || typeof node === 'boolean') {
+    return node
+  } else if (typeof node === 'string') {
+    return JSON.stringify(node)
+  }
+
+  const [type, value] = Object.entries(node)[0]
+
+  if (type === 'not') {
+    return `!(${compile(value)})`
+  } else if (type === 'len' || type === 'count') {
+    return getSize(compile(value))
+  } else if (type === 'isEmpty') {
+    return `${getSize(compile(value))} === 0`
+  } else if (type === 'isDefined') {
+    return `(() => {
+      try {
+        ${compile(value)}
+        return true
+      } catch {
+        return false
+      }
+    })()`
+  } else if (type === 'instanceof') {
+    return isPrimitiveType(value[1])
+      ? `(typeof ${compile(value[0])} === '${value[1]}')` // TODO: Is parenthesizing necessary?
+      : `Function.prototype[Symbol.hasInstance].call(${assertIdentifier(value[1])}, ${compile(value[0])})`
+  } else if (type === 'ref') {
+    if (value === '@it') {
+      return '$dd_it'
+    } else if (value === '@key') {
+      return '$dd_key'
+    } else if (value === '@value') {
+      return '$dd_value'
+    }
+    return assertIdentifier(value)
+  } else if (Array.isArray(value)) {
+    const args = value.map(compile)
+    switch (type) {
+      case 'eq': return `(${args[0]}) === (${args[1]})`
+      case 'ne': return `(${args[0]}) !== (${args[1]})`
+      case 'gt': return `${guardAgainstCoercionSideEffects(args[0])} > ${guardAgainstCoercionSideEffects(args[1])}`
+      case 'ge': return `${guardAgainstCoercionSideEffects(args[0])} >= ${guardAgainstCoercionSideEffects(args[1])}`
+      case 'lt': return `${guardAgainstCoercionSideEffects(args[0])} < ${guardAgainstCoercionSideEffects(args[1])}`
+      case 'le': return `${guardAgainstCoercionSideEffects(args[0])} <= ${guardAgainstCoercionSideEffects(args[1])}`
+      case 'any': return iterateOn('some', ...args)
+      case 'all': return iterateOn('every', ...args)
+      case 'and': return `(${args.join(') && (')})`
+      case 'or': return `(${args.join(') || (')})`
+      case 'startsWith': return `String.prototype.startsWith.call(${assertString(args[0])}, ${assertString(args[1])})`
+      case 'endsWith': return `String.prototype.endsWith.call(${assertString(args[0])}, ${assertString(args[1])})`
+      case 'contains': return `((obj, elm) => {
+          if (${isString('obj')}) {
+            return String.prototype.includes.call(obj, elm)
+          } else if (Array.isArray(obj)) {
+            return Array.prototype.includes.call(obj, elm)
+          } else if (${isTypedArray('obj')}) {
+            return Object.getPrototypeOf(Int8Array.prototype).includes.call(obj, elm)
+          } else if (${isInstanceOfCoreType('Set', 'obj')}) {
+            return Set.prototype.has.call(obj, elm)
+          } else if (${isInstanceOfCoreType('WeakSet', 'obj')}) {
+            return WeakSet.prototype.has.call(obj, elm)
+          } else if (${isInstanceOfCoreType('Map', 'obj')}) {
+            return Map.prototype.has.call(obj, elm)
+          } else if (${isInstanceOfCoreType('WeakMap', 'obj')}) {
+            return WeakMap.prototype.has.call(obj, elm)
+          } else {
+            throw new TypeError('Variable does not support contains')
+          }
+        })(${args[0]}, ${args[1]})`
+      case 'matches': return `((str, regex) => {
+          if (${isString('str')}) {
+            const regexIsString = ${isString('regex')}
+            if (regexIsString || Object.getPrototypeOf(regex) === RegExp.prototype) {
+              return RegExp.prototype.test.call(regexIsString ? new RegExp(regex) : regex, str)
+            } else {
+              throw new TypeError('Regular expression must be either a string or an instance of RegExp')
+            }
+          } else {
+            throw new TypeError('Variable is not a string')
+          }
+        })(${args[0]}, ${args[1]})`
+      case 'filter': return `(($dd_var) => {
+          return ${isIterableCollection('$dd_var')}
+            ? Array.from($dd_var).filter(($dd_it) => ${args[1]})
+            : Object.entries($dd_var).reduce((acc, [$dd_key, $dd_value]) => {
+                if (${args[1]}) acc[$dd_key] = $dd_value
+                return acc
+              }, {})
+        })(${args[0]})`
+      case 'substring': return `((str) => {
+          if (${isString('str')}) {
+            return String.prototype.substring.call(str, ${args[1]}, ${args[2]})
+          } else {
+            throw new TypeError('Variable is not a string')
+          }
+        })(${args[0]})`
+      case 'getmember': return accessProperty(args[0], args[1], false)
+      case 'index': return accessProperty(args[0], args[1], true)
+    }
+  }
+
+  throw new TypeError(`Unknown AST node type: ${type}`)
+}
+
+function iterateOn (fnName, variable, callbackCode) {
+  return `(($dd_val) => {
+    return ${isIterableCollection('$dd_val')}
+      ? Array.from($dd_val).${fnName}(($dd_it) => ${callbackCode})
+      : Object.entries($dd_val).${fnName}(([$dd_key, $dd_value]) => ${callbackCode})
+  })(${variable})`
+}
+
+function isString (variable) {
+  return `(typeof ${variable} === 'string' || ${variable} instanceof String)`
+}
+
+function isPrimitiveType (type) {
+  return PRIMITIVE_TYPES.has(type)
+}
+
+function isIterableCollection (variable) {
+  return `(${isArrayOrTypedArray(variable)} || ${isInstanceOfCoreType('Set', variable)} || ` +
+    `${isInstanceOfCoreType('WeakSet', variable)})`
+}
+
+function isArrayOrTypedArray (variable) {
+  return `(Array.isArray(${variable}) || ${isTypedArray(variable)})`
+}
+
+function isTypedArray (variable) {
+  return isInstanceOfCoreType('TypedArray', variable, `${variable} instanceof Object.getPrototypeOf(Int8Array)`)
+}
+
+function isInstanceOfCoreType (type, variable, fallback = `${variable} instanceof ${type}`) {
+  return `(globalThis[Symbol.for('dd-trace')].utilTypes?.is${type}?.(${variable}) ?? ${fallback})`
+}
+
+function getSize (variable) {
+  return `((val) => {
+    if (${isString('val')} || ${isArrayOrTypedArray('val')}) {
+      return ${guardAgainstPropertyAccessSideEffects('val', '"length"')}
+    } else if (${isInstanceOfCoreType('Set', 'val')} || ${isInstanceOfCoreType('Map', 'val')}) {
+      return ${guardAgainstPropertyAccessSideEffects('val', '"size"')}
+    } else if (${isInstanceOfCoreType('WeakSet', 'val')} || ${isInstanceOfCoreType('WeakMap', 'val')}) {
+      throw new TypeError('Cannot get size of WeakSet or WeakMap')
+    } else if (typeof val === 'object' && val !== null) {
+      return Object.keys(val).length
+    } else {
+      throw new TypeError('Cannot get length of variable')
+    }
+  })(${variable})`
+}
+
+function accessProperty (variable, keyOrIndex, allowMapAccess) {
+  return `((val, key) => {
+    if (${isInstanceOfCoreType('Map', 'val')}) {
+      ${allowMapAccess
+        ? 'return Map.prototype.get.call(val, key)'
+        : 'throw new Error(\'Accessing a Map is not allowed\')'}
+    } else if (${isInstanceOfCoreType('WeakMap', 'val')}) {
+      ${allowMapAccess
+        ? 'return WeakMap.prototype.get.call(val, key)'
+        : 'throw new Error(\'Accessing a WeakMap is not allowed\')'}
+    } else if (${isInstanceOfCoreType('Set', 'val')} || ${isInstanceOfCoreType('WeakSet', 'val')}) {
+      throw new Error('Accessing a Set or WeakSet is not allowed')
+    } else {
+      return ${guardAgainstPropertyAccessSideEffects('val', 'key')}
+    }
+  })(${variable}, ${keyOrIndex})`
+}
+
+function guardAgainstPropertyAccessSideEffects (variable, propertyName) {
+  return `((val, key) => {
+    if (
+      ${isInstanceOfCoreType('Proxy', 'val', 'true')} ||
+      Object.getOwnPropertyDescriptor(val, key)?.get !== undefined
+    ) {
+      throw new Error('Possibility of side effect')
+    } else {
+      return val[key]
+    }
+  })(${variable}, ${propertyName})`
+}
+
+function guardAgainstCoercionSideEffects (variable) {
+  // shortcut if we're comparing number literals
+  if (typeof variable === 'number') return variable
+
+  return `((val) => {
+    if (
+      typeof val === 'object' && val !== null && (
+        ${isInstanceOfCoreType('Proxy', 'val', 'true')} ||
+        val[Symbol.toPrimitive] !== undefined ||
+        val.valueOf !== Object.prototype.valueOf ||
+        val.toString !== Object.prototype.toString
+      )
+    ) {
+      throw new Error('Possibility of side effect due to coercion methods')
+    } else {
+      return val
+    }
+  })(${variable})`
+}
+
+function assertString (variable) {
+  return `((val) => {
+    if (${isString('val')}) {
+      return val
+    } else {
+      throw new TypeError('Variable is not a string')
+    }
+  })(${variable})`
+}
+
+function assertIdentifier (value) {
+  if (!identifierRegex.test(value) || reservedWords.has(value)) {
+    throw new SyntaxError(`Illegal identifier: ${value}`)
+  }
+  return value
+}

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

@@ -0,0 +1,23 @@
+'use strict'
+
+const { workerData: { config: parentConfig, parentThreadId, configPort } } = require('node:worker_threads')
+const { getAgentUrl } = require('../../agent/url')
+const log = require('./log')
+
+const config = module.exports = {
+  ...parentConfig,
+  parentThreadId,
+  maxTotalPayloadSize: 5 * 1024 * 1024, // 5MB
+}
+
+updateConfig(parentConfig)
+
+configPort.on('message', updateConfig)
+configPort.on('messageerror', (err) =>
+  log.error('[debugger:devtools_client] received "messageerror" on config port', err)
+)
+
+function updateConfig (updates) {
+  config.url = getAgentUrl(updates)
+  config.dynamicInstrumentation.captureTimeoutNs = BigInt(updates.dynamicInstrumentation.captureTimeoutMs) * 1_000_000n
+}

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

@@ -0,0 +1,7 @@
+'use strict'
+
+module.exports = {
+  MAX_SNAPSHOTS_PER_SECOND_GLOBALLY: 25,
+  MAX_SNAPSHOTS_PER_SECOND_PER_PROBE: 1,
+  MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE: 5000,
+}

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

@@ -0,0 +1,336 @@
+'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, 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')
+
+/** @typedef {import('node:inspector').Debugger.EvaluateOnCallFrameReturnType} EvaluateOnCallFrameResult */
+
+// Expression to run on a call frame of the paused thread to get its active trace and span id.
+const templateExpressionSetupCode = `
+  const $dd_inspect = global.require('node:util').inspect;
+  const $dd_segmentInspectOptions = {
+    depth: 0,
+    customInspect: false,
+    maxArrayLength: 3,
+    maxStringLength: 8 * 1024,
+    breakLength: Infinity
+  };
+`
+const getDDTagsExpression = `(() => {
+  const context = global.require('dd-trace').scope().active()?.context();
+  return { trace_id: context?.toTraceId(), span_id: context?.toSpanId() }
+})()`
+
+// 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 = 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)
+}
+
+// WARNING: The code above the line `await session.post('Debugger.resume')` is highly optimized. Please edit with care!
+session.on('Debugger.paused', async ({ params }) => {
+  const start = process.hrtime.bigint()
+
+  if (params.reason !== 'other') {
+    // This error should not be caught, and should exit the worker thread, effectively stopping the debugging session
+    throw new Error(`Unexpected Debugger.paused reason: ${params.reason}`)
+  }
+
+  let maxReferenceDepth = 0
+  let maxCollectionSize = 0
+  let maxFieldCount = 0
+  let maxLength = 0
+  let sampled = false
+  let numberOfProbesWithSnapshots = 0
+  let probesWithCaptureExpressions = false
+  const probes = []
+  let templateExpressions = ''
+
+  // 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
+
+  // 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++) {
+    const probesAtLocation = breakpointToProbes.get(params.hitBreakpoints[i])
+
+    if (probesAtLocation === undefined) {
+      // This might happen due to a race condition where the breakpoint is in the process of being removed
+      log.error('[debugger:devtools_client] No probes found for breakpoint %s', params.hitBreakpoints[i])
+      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 (const probe of probesAtLocation.values()) {
+      if (start - probe.lastCaptureNs < probe.nsBetweenSampling) {
+        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
+          maxReferenceDepth = Math.max(probe.capture.maxReferenceDepth, maxReferenceDepth)
+          maxCollectionSize = Math.max(probe.capture.maxCollectionSize, maxCollectionSize)
+          maxFieldCount = Math.max(probe.capture.maxFieldCount, maxFieldCount)
+          maxLength = Math.max(probe.capture.maxLength, maxLength)
+        } else {
+          probesWithCaptureExpressions = true
+        }
+      }
+
+      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}`
+      }
+
+      probes.push(probe)
+    }
+  }
+
+  if (sampled === false) {
+    return session.post('Debugger.resume')
+  }
+
+  const timestamp = Date.now()
+
+  let evalResults
+  const { result } = /** @type {EvaluateOnCallFrameResult} */ (
+    await session.post('Debugger.evaluateOnCallFrame', {
+      callFrameId: params.callFrames[0].callFrameId,
+      expression: templateExpressions.length === 0
+        ? `[${getDDTagsExpression}]`
+        : `${templateExpressionSetupCode}[${getDDTagsExpression}${templateExpressions}]`,
+      returnByValue: true,
+      includeCommandLineAPI: true,
+    })
+  )
+  if (result?.subtype === 'error') {
+    log.error('[debugger:devtools_client] Error evaluating code on call frame: %s', result?.description)
+    evalResults = []
+  } else {
+    evalResults = result?.value ?? []
+  }
+
+  // TODO: Create unique states for each affected probe based on that probes unique `capture` settings (DEBUG-2863)
+  let processLocalState
+  /** @type {Error[] | undefined} */
+  let fatalSnapshotErrors
+  if (numberOfProbesWithSnapshots !== 0) {
+    const result = await getLocalStateForCallFrame(
+      params.callFrames[0],
+      { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength },
+      start + config.dynamicInstrumentation.captureTimeoutNs
+    )
+    processLocalState = result.processLocalState
+    fatalSnapshotErrors = result.fatalErrors
+  }
+
+  // Evaluate capture expressions for probes that have them
+  let captureExpressionResults = null
+  if (probesWithCaptureExpressions === true) {
+    captureExpressionResults = new Map()
+    for (const probe of probes) {
+      if (probe.compiledCaptureExpressions === undefined) continue
+      // eslint-disable-next-line no-await-in-loop
+      captureExpressionResults.set(probe.id, await evaluateCaptureExpressions(
+        params.callFrames[0],
+        probe.compiledCaptureExpressions,
+        start + config.dynamicInstrumentation.captureTimeoutNs
+      ))
+    }
+  }
+
+  await session.post('Debugger.resume')
+  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.
+  // eslint-disable-next-line eslint-rules/eslint-log-printf-style
+  log.debug(() => `[debugger:devtools_client] Finished processing breakpoints - main thread paused for: ~${
+    Number(diff) / 1_000_000
+  } ms`)
+
+  const logger = {
+    // We can safely use `location.file` from the first probe in the array, since all probes hit by `hitBreakpoints`
+    // must exist in the same file since the debugger can only pause the main thread in one location.
+    name: probes[0].location.file, // name of the class/type/file emitting the snapshot
+    method: params.callFrames[0].functionName, // name of the method/function emitting the snapshot
+    version,
+    thread_id: threadId,
+    thread_name: threadName,
+  }
+
+  const stack = await getStackFromCallFrames(params.callFrames)
+  const dd = processDD(evalResults[0]) // the first result is the dd tags, the rest are the probe template results
+  let messageIndex = 1
+
+  // TODO: Send multiple probes in one HTTP request as an array (DEBUG-2848)
+  for (const probe of probes) {
+    const snapshot = {
+      id: randomUUID(),
+      timestamp,
+      probe: {
+        id: probe.id,
+        version: probe.version,
+        location: probe.location,
+      },
+      stack,
+      language: 'javascript',
+    }
+
+    if (config.propagateProcessTags.enabled) {
+      snapshot[processTags.DYNAMIC_INSTRUMENTATION_FIELD_NAME] = processTags.tagsObject
+    }
+
+    if (probe.captureSnapshot) {
+      if (fatalSnapshotErrors && fatalSnapshotErrors.length > 0) {
+        // There was an error collecting the snapshot for this probe, let's not try again
+        probe.captureSnapshot = false
+        probe.permanentEvaluationErrors = fatalSnapshotErrors.map(error => ({
+          expr: '',
+          message: error.message,
+        }))
+      }
+      snapshot.captures = {
+        lines: { [probe.location.lines[0]]: { locals: /** @type {Function} */ (processLocalState)() } },
+      }
+    } else if (probe.compiledCaptureExpressions !== undefined) {
+      const expressionResult = /** @type {Map} */ (captureExpressionResults).get(probe.id)
+      if (expressionResult) {
+        // Handle fatal capture errors - disable capture expressions for this probe permanently
+        if (expressionResult.fatalErrors?.length > 0) {
+          probe.compiledCaptureExpressions = undefined
+          probe.permanentEvaluationErrors = expressionResult.fatalErrors.map(error => ({
+            expr: '',
+            message: error.message,
+          }))
+        }
+
+        snapshot.captures = {
+          lines: { [probe.location.lines[0]]: { captureExpressions: expressionResult.processCaptureExpressions() } },
+        }
+
+        // Handle transient evaluation errors - include in snapshot for this capture
+        if (expressionResult.evaluationErrors?.length > 0) {
+          if (snapshot.evaluationErrors === undefined) {
+            snapshot.evaluationErrors = expressionResult.evaluationErrors
+          } else {
+            snapshot.evaluationErrors.push(...expressionResult.evaluationErrors)
+          }
+        }
+      } else {
+        log.error('[debugger:devtools_client] Missing capture expression results for probe %s (version: %s)',
+          probe.id, probe.version)
+        snapshot.evaluationErrors = [{
+          expr: '',
+          message: 'Internal error: capture expression results not found',
+        }]
+      }
+    }
+
+    if (probe.permanentEvaluationErrors !== undefined) {
+      snapshot.evaluationErrors = [...probe.permanentEvaluationErrors]
+    }
+
+    let message = ''
+    if (probe.templateRequiresEvaluation) {
+      const results = evalResults[messageIndex++]
+      if (results === undefined) {
+        log.error('[debugger:devtools_client] No evaluation results for probe %s', probe.id)
+      } else {
+        for (const result of results) {
+          if (typeof result === 'string') {
+            message += result
+          } else {
+            // If `result` isn't a string, it's an evaluation error object
+            if (snapshot.evaluationErrors === undefined) {
+              snapshot.evaluationErrors = [result]
+            } else {
+              snapshot.evaluationErrors.push(result)
+            }
+            message += `{${result.message}}`
+          }
+        }
+      }
+    } else {
+      message = probe.template
+    }
+
+    ackEmitting(probe)
+
+    send(message, logger, dd, snapshot)
+  }
+})
+
+function processDD (result) {
+  return result?.trace_id === undefined ? undefined : result
+}

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

@@ -0,0 +1,27 @@
+'use strict'
+
+/* eslint n/no-unsupported-features/node-builtins: ['error', { ignores: ['inspector/promises'] }] */
+
+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')
+  const { promisify } = require('node:util')
+
+  // 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
+  }
+
+  Session.prototype.post = promisify(inspector.Session.prototype.post)
+
+  module.exports = {
+    ...inspector,
+    Session,
+  }
+}