dd-trace 5.52.0 → 5.54.0

package/packages/dd-trace/src/datastreams/processor.js

@@ -103,10 +103,8 @@ class StatsBucket {
   forBacklog (backlogData) {
     const backlog = new Backlog(backlogData)
     const existingBacklog = this._backlogs.get(backlog.hash)
-    if (existingBacklog !== undefined) {
-      if (existingBacklog.offset > backlog.offset) {
-        return existingBacklog
-      }
+    if (existingBacklog !== undefined && existingBacklog.offset > backlog.offset) {
+      return existingBacklog
     }
     this._backlogs.set(backlog.hash, backlog)
     return backlog
@@ -205,7 +203,9 @@ class DataStreamsProcessor {
     let parentHash = ENTRY_PARENT_HASH
     let closestOppositeDirectionHash = ENTRY_PARENT_HASH
     let closestOppositeDirectionEdgeStart = nowNs
-    if (ctx != null) {
+    if (ctx == null) {
+      log.debug(() => 'Setting DSM Checkpoint with empty parent context.')
+    } else {
       pathwayStartNs = ctx.pathwayStartNs
       edgeStartNs = ctx.edgeStartNs
       parentHash = ctx.hash
@@ -229,8 +229,6 @@ class DataStreamsProcessor {
       log.debug(
         () => `Setting DSM Checkpoint from extracted parent context with hash: ${parentHash} and edge tags: ${edgeTags}`
       )
-    } else {
-      log.debug(() => 'Setting DSM Checkpoint with empty parent context.')
     }
     const hash = computePathwayHash(this.service, this.env, edgeTags, parentHash)
     const edgeLatencyNs = nowNs - edgeStartNs

package/packages/dd-trace/src/datastreams/schemas/schema_builder.js

@@ -20,7 +20,7 @@ class SchemaBuilder {
   static getSchemaDefinition (schema) {
     const noNones = convertToJsonCompatible(schema)
     const definition = jsonStringify(noNones)
-    const id = fnv64(Buffer.from(definition, 'utf-8')).toString()
+    const id = fnv64(Buffer.from(definition, 'utf8')).toString()
     return new Schema(definition, id)
   }
 

package/packages/dd-trace/src/datastreams/schemas/schema_sampler.js

@@ -8,12 +8,10 @@ class SchemaSampler {
 
   trySample (currentTimeMs) {
     if (currentTimeMs >= this.lastSampleMs + SAMPLE_INTERVAL_MILLIS) {
-      if (currentTimeMs >= this.lastSampleMs + SAMPLE_INTERVAL_MILLIS) {
-        this.lastSampleMs = currentTimeMs
-        const weight = this.weight
-        this.weight = 0
-        return weight
-      }
+      this.lastSampleMs = currentTimeMs
+      const weight = this.weight
+      this.weight = 0
+      return weight
     }
     return 0
   }

package/packages/dd-trace/src/datastreams/size.js

@@ -4,7 +4,7 @@ const { types } = require('util')
 
 function getSizeOrZero (obj) {
   if (typeof obj === 'string') {
-    return Buffer.from(obj, 'utf-8').length
+    return Buffer.from(obj, 'utf8').length
   }
   if (types.isArrayBuffer(obj)) {
     return obj.byteLength

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

@@ -1,30 +1,57 @@
 'use strict'
 
-const lock = require('mutexify/promise')()
+const mutex = require('mutexify/promise')()
 const { getGeneratedPosition } = require('./source-maps')
 const session = require('./session')
 const { compile: compileCondition, compileSegments, templateRequiresEvaluation } = require('./condition')
 const { MAX_SNAPSHOTS_PER_SECOND_PER_PROBE, MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE } = require('./defaults')
-const { findScriptFromPartialPath, locationToBreakpoint, breakpointToProbes, probeToLocation } = require('./state')
+const {
+  findScriptFromPartialPath,
+  clearState,
+  locationToBreakpoint,
+  breakpointToProbes,
+  probeToLocation
+} = require('./state')
 const log = require('../../log')
 
 let sessionStarted = false
+const probes = new Map()
+let scriptLoadingStabilizedResolve
+const scriptLoadingStabilized = new Promise((resolve) => { scriptLoadingStabilizedResolve = resolve })
+
+// There's a race condition when a probe is first added, where the actual script that the probe is supposed to match
+// hasn't been loaded yet. This will result in either the probe not being added at all, or an incorrect script being
+// matched as the probe target.
+//
+// Therefore, once new scripts has been loaded, all probes are re-evaluated. If the matched `scriptId` has changed, we
+// simply remove the old probe (if it was added to the wrong script) and apply it again.
+session.on('scriptLoadingStabilized', () => {
+  log.debug('[debugger:devtools_client] Re-evaluating probes')
+  scriptLoadingStabilizedResolve()
+  for (const probe of probes.values()) {
+    reEvaluateProbe(probe).catch(err => {
+      log.error('[debugger:devtools_client] Error re-evaluating probe %s', probe.id, err)
+    })
+  }
+})
 
 module.exports = {
-  addBreakpoint,
-  removeBreakpoint
+  addBreakpoint: lock(addBreakpoint),
+  removeBreakpoint: lock(removeBreakpoint),
+  modifyBreakpoint: lock(modifyBreakpoint)
 }
 
 async function addBreakpoint (probe) {
   if (!sessionStarted) await start()
 
+  probes.set(probe.id, probe)
+
   const file = probe.where.sourceFile
   let lineNumber = Number(probe.where.lines[0]) // Tracer doesn't support multiple-line breakpoints
   let columnNumber = 0 // Probes do not contain/support column information
 
   // Optimize for sending data to /debugger/v1/input endpoint
   probe.location = { file, lines: [String(lineNumber)] }
-  delete probe.where
 
   // Optimize for fast calculations when probe is hit
   probe.templateRequiresEvaluation = templateRequiresEvaluation(probe.segments)
@@ -47,6 +74,8 @@ async function addBreakpoint (probe) {
   if (!script) throw new Error(`No loaded script found for ${file} (probe: ${probe.id}, version: ${probe.version})`)
   const { url, scriptId, sourceMapURL, source } = script
 
+  probe.scriptId = scriptId // Needed for detecting script changes during re-evaluation
+
   if (sourceMapURL) {
     log.debug(
       '[debugger:devtools_client] Translating location using source map for %s:%d:%d (probe: %s, version: %d)',
@@ -61,87 +90,84 @@ async function addBreakpoint (probe) {
     throw new Error(`Cannot compile expression: ${probe.when.dsl}`, { cause: err })
   }
 
-  const release = await lock()
+  const locationKey = generateLocationKey(scriptId, lineNumber, columnNumber)
+  const breakpoint = locationToBreakpoint.get(locationKey)
 
-  try {
-    const locationKey = generateLocationKey(scriptId, lineNumber, columnNumber)
-    const breakpoint = locationToBreakpoint.get(locationKey)
+  log.debug(
+    '[debugger:devtools_client] %s breakpoint at %s:%d:%d (probe: %s, version: %d)',
+    breakpoint ? 'Updating' : 'Adding', url, lineNumber, columnNumber, probe.id, probe.version
+  )
 
-    log.debug(
-      '[debugger:devtools_client] %s breakpoint at %s:%d:%d (probe: %s, version: %d)',
-      breakpoint ? 'Updating' : 'Adding', url, lineNumber, columnNumber, probe.id, probe.version
-    )
-
-    if (breakpoint) {
-      // A breakpoint already exists at this location, so we need to add the probe to the existing breakpoint
-      await updateBreakpoint(breakpoint, probe)
-    } else {
-      // No breakpoint exists at this location, so we need to create a new one
-      const location = {
-        scriptId,
-        lineNumber: lineNumber - 1, // Beware! lineNumber is zero-indexed
-        columnNumber
-      }
-      let result
-      try {
-        result = await session.post('Debugger.setBreakpoint', {
-          location,
-          condition: probe.condition
-        })
-      } catch (err) {
-        throw new Error(`Error setting breakpoint for probe ${probe.id}`, { cause: err })
-      }
-      probeToLocation.set(probe.id, locationKey)
-      locationToBreakpoint.set(locationKey, { id: result.breakpointId, location, locationKey })
-      breakpointToProbes.set(result.breakpointId, new Map([[probe.id, probe]]))
+  if (breakpoint) {
+    // A breakpoint already exists at this location, so we need to add the probe to the existing breakpoint
+    await updateBreakpointInternal(breakpoint, probe)
+  } else {
+    // No breakpoint exists at this location, so we need to create a new one
+    const location = {
+      scriptId,
+      lineNumber: lineNumber - 1, // Beware! lineNumber is zero-indexed
+      columnNumber
+    }
+    let result
+    try {
+      result = await session.post('Debugger.setBreakpoint', {
+        location,
+        condition: probe.condition
+      })
+    } catch (err) {
+      throw new Error(`Error setting breakpoint for probe ${probe.id}`, { cause: err })
     }
-  } finally {
-    release()
+    probeToLocation.set(probe.id, locationKey)
+    locationToBreakpoint.set(locationKey, { id: result.breakpointId, location, locationKey })
+    breakpointToProbes.set(result.breakpointId, new Map([[probe.id, probe]]))
   }
 }
 
 async function removeBreakpoint ({ id }) {
   if (!sessionStarted) {
     // We should not get in this state, but abort if we do, so the code doesn't fail unexpected
-    throw Error(`Cannot remove probe ${id}: Debugger not started`)
+    throw new Error(`Cannot remove probe ${id}: Debugger not started`)
   }
   if (!probeToLocation.has(id)) {
-    throw Error(`Unknown probe id: ${id}`)
+    throw new Error(`Unknown probe id: ${id}`)
   }
 
-  const release = await lock()
+  probes.delete(id)
 
-  try {
-    const locationKey = probeToLocation.get(id)
-    const breakpoint = locationToBreakpoint.get(locationKey)
-    const probesAtLocation = breakpointToProbes.get(breakpoint.id)
-
-    probesAtLocation.delete(id)
-    probeToLocation.delete(id)
-
-    if (probesAtLocation.size === 0) {
-      locationToBreakpoint.delete(locationKey)
-      breakpointToProbes.delete(breakpoint.id)
-      if (breakpointToProbes.size === 0) {
-        await stop() // TODO: Will this actually delete the breakpoint?
-      } else {
-        try {
-          await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
-        } catch (err) {
-          throw new Error(`Error removing breakpoint for probe ${id}`, { cause: err })
-        }
-      }
+  const locationKey = probeToLocation.get(id)
+  const breakpoint = locationToBreakpoint.get(locationKey)
+  const probesAtLocation = breakpointToProbes.get(breakpoint.id)
+
+  probesAtLocation.delete(id)
+  probeToLocation.delete(id)
+
+  if (probesAtLocation.size === 0) {
+    locationToBreakpoint.delete(locationKey)
+    breakpointToProbes.delete(breakpoint.id)
+    // TODO: If anything below in this if-block throws, the state is out of sync.
+    if (breakpointToProbes.size === 0) {
+      await stop() // This will also remove the breakpoint
     } else {
-      await updateBreakpoint(breakpoint)
+      try {
+        await session.post('Debugger.removeBreakpoint', { breakpointId: breakpoint.id })
+      } catch (err) {
+        throw new Error(`Error removing breakpoint for probe ${id}`, { cause: err })
+      }
     }
-  } finally {
-    release()
+  } else {
+    await updateBreakpointInternal(breakpoint)
   }
 }
 
-async function updateBreakpoint (breakpoint, probe) {
+// TODO: Modify existing probe instead of removing it (DEBUG-2817)
+async function modifyBreakpoint (probe) {
+  await removeBreakpoint(probe)
+  await addBreakpoint(probe)
+}
+
+async function updateBreakpointInternal (breakpoint, probe) {
   const probesAtLocation = breakpointToProbes.get(breakpoint.id)
-  const conditionBeforeNewProbe = compileCompoundCondition(Array.from(probesAtLocation.values()))
+  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 condtion of the breakpoint.
@@ -150,7 +176,7 @@ async function updateBreakpoint (breakpoint, probe) {
     probeToLocation.set(probe.id, breakpoint.locationKey)
   }
 
-  const condition = compileCompoundCondition(Array.from(probesAtLocation.values()))
+  const condition = compileCompoundCondition([...probesAtLocation.values()])
 
   if (condition || conditionBeforeNewProbe !== condition) {
     try {
@@ -173,25 +199,58 @@ async function updateBreakpoint (breakpoint, probe) {
   }
 }
 
-function start () {
+async function reEvaluateProbe (probe) {
+  const script = findScriptFromPartialPath(probe.where.sourceFile)
+  log.debug('[debugger:devtools_client] re-evaluating probe %s: %s => %s', probe.id, probe.scriptId, script?.scriptId)
+
+  if (probe.scriptId !== script?.scriptId) {
+    log.debug('[debugger:devtools_client] Better match found for probe %s, re-evaluating', probe.id)
+    if (probeToLocation.has(probe.id)) {
+      await removeBreakpoint(probe)
+    }
+    await addBreakpoint(probe)
+  }
+}
+
+async function start () {
   sessionStarted = true
   log.debug('[debugger:devtools_client] Starting debugger')
-  return session.post('Debugger.enable')
+  await session.post('Debugger.enable')
+
+  // Wait until there's a pause in script-loading to avoid accidentally adding probes to incorrect scripts. This is not
+  // a guarantee, but best effort.
+  log.debug('[debugger:devtools_client] Waiting for script-loading to stabilize')
+  await scriptLoadingStabilized
+  log.debug('[debugger:devtools_client] Script loading stabilized')
 }
 
 function stop () {
   sessionStarted = false
+  clearState()
   log.debug('[debugger:devtools_client] Stopping debugger')
   return session.post('Debugger.disable')
 }
 
+function lock (fn) {
+  return async function (...args) {
+    const release = await mutex()
+    try {
+      return await fn(...args)
+    } finally {
+      release()
+    }
+  }
+}
+
 // 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.
-// TODO: Handle errors - if there's 2 conditons, and one fails but the other returns true, we should still pause the
-// breakpoint
 function compileCompoundCondition (probes) {
+  if (probes.length === 1) return probes[0].condition
+
   return probes.every(p => p.condition)
-    ? probes.map(p => p.condition).filter(Boolean).join(' || ')
+    ? probes
+      .map((p) => `(() => { try { return ${p.condition} } catch { return false } })()`)
+      .join(' || ')
     : undefined
 }
 

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

@@ -51,9 +51,8 @@ function compileSegments (segments) {
   let result = '['
   for (let i = 0; i < segments.length; i++) {
     const { str, dsl, json } = segments[i]
-    result += str !== undefined
-      ? JSON.stringify(str)
-      : `(() => {
+    result += str === undefined
+      ? `(() => {
           try {
             const result = ${compile(json)}
             return typeof result === 'string' ? result : $dd_inspect(result, $dd_segmentInspectOptions)
@@ -61,6 +60,7 @@ function compileSegments (segments) {
             return { expr: ${JSON.stringify(dsl)}, message: \`\${e.name}: \${e.message}\` }
           }
         })()`
+      : JSON.stringify(str)
     if (i !== segments.length - 1) {
       result += ','
     }
@@ -95,11 +95,9 @@ function compile (node) {
       }
     })()`
   } else if (type === 'instanceof') {
-    if (isPrimitiveType(value[1])) {
-      return `(typeof ${compile(value[0])} === '${value[1]}')` // TODO: Is parenthesizing necessary?
-    } else {
-      return `Function.prototype[Symbol.hasInstance].call(${assertIdentifier(value[1])}, ${compile(value[0])})`
-    }
+    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'

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

@@ -3,5 +3,5 @@
 module.exports = {
   MAX_SNAPSHOTS_PER_SECOND_GLOBALLY: 25,
   MAX_SNAPSHOTS_PER_SECOND_PER_PROBE: 1,
-  MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE: 5_000
+  MAX_NON_SNAPSHOTS_PER_SECOND_PER_PROBE: 5000
 }

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

@@ -6,7 +6,7 @@ const session = require('./session')
 const { getLocalStateForCallFrame } = require('./snapshot')
 const send = require('./send')
 const { getStackFromCallFrames } = require('./state')
-const { ackEmitting, ackError } = require('./status')
+const { ackEmitting } = require('./status')
 const { parentThreadId } = require('./config')
 const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./defaults')
 const log = require('../../log')
@@ -36,7 +36,6 @@ const getDDTagsExpression = `(() => {
 const threadId = parentThreadId === 0 ? `pid:${process.pid}` : `pid:${process.pid};tid:${parentThreadId}`
 const threadName = parentThreadId === 0 ? 'MainThread' : `WorkerThread:${parentThreadId}`
 
-const SUPPORT_ITERATOR_METHODS = NODE_MAJOR >= 22
 const SUPPORT_ARRAY_BUFFER_RESIZE = NODE_MAJOR >= 20
 const oneSecondNs = 1_000_000_000n
 let globalSnapshotSamplingRateWindowStart = 0n
@@ -66,6 +65,12 @@ session.on('Debugger.paused', async ({ params }) => {
   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) {
@@ -77,14 +82,6 @@ session.on('Debugger.paused', async ({ params }) => {
       }
     }
 
-    // If all the probes have a condition, we know that it triggered. If at least one probe doesn't have a condition, we
-    // need to verify which conditions are met.
-    const shouldVerifyConditions = (
-      SUPPORT_ITERATOR_METHODS
-        ? probesAtLocation.values()
-        : Array.from(probesAtLocation.values())
-    ).some((probe) => probe.condition === undefined)
-
     for (const probe of probesAtLocation.values()) {
       if (start - probe.lastCaptureNs < probe.nsBetweenSampling) {
         continue
@@ -109,7 +106,7 @@ session.on('Debugger.paused', async ({ params }) => {
         maxLength = highestOrUndefined(probe.capture.maxLength, maxLength)
       }
 
-      if (shouldVerifyConditions && probe.condition !== undefined) {
+      if (probe.condition !== undefined) {
         // TODO: Bundle all conditions and evaluate them in a single call
         // TODO: Handle errors
         const { result } = await session.post('Debugger.evaluateOnCallFrame', {
@@ -153,27 +150,18 @@ session.on('Debugger.paused', async ({ params }) => {
     evalResults = result?.value ?? []
   }
 
-  let processLocalState
-  if (numberOfProbesWithSnapshots !== 0) {
-    try {
-      // TODO: Create unique states for each affected probe based on that probes unique `capture` settings (DEBUG-2863)
-      processLocalState = await getLocalStateForCallFrame(
-        params.callFrames[0],
-        { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength }
-      )
-    } catch (err) {
-      for (let i = 0; i < numberOfProbesWithSnapshots; i++) {
-        ackError(err, probes[snapshotProbeIndex[i]]) // TODO: Ok to continue after sending ackError?
-      }
-    }
-  }
+  // 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 }
+  )
 
   await session.post('Debugger.resume')
   const diff = process.hrtime.bigint() - start // TODO: Recored as telemetry (DEBUG-2858)
 
   log.debug(
     '[debugger:devtools_client] Finished processing breakpoints - main thread paused for: %d ms',
-    Number(diff) / 1000000
+    Number(diff) / 1_000_000
   )
 
   const logger = {
@@ -206,7 +194,9 @@ session.on('Debugger.paused', async ({ params }) => {
 
     if (probe.captureSnapshot) {
       const state = processLocalState()
-      if (state) {
+      if (state instanceof Error) {
+        snapshot.captureError = state.message
+      } else if (state) {
         snapshot.captures = {
           lines: { [probe.location.lines[0]]: { locals: state } }
         }

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

@@ -1,8 +1,7 @@
 'use strict'
 
 const { workerData: { rcPort } } = require('node:worker_threads')
-const lock = require('mutexify/promise')()
-const { addBreakpoint, removeBreakpoint } = require('./breakpoints')
+const { addBreakpoint, removeBreakpoint, modifyBreakpoint } = require('./breakpoints')
 const { ackReceived, ackInstalled, ackError } = require('./status')
 const log = require('../../log')
 
@@ -57,45 +56,26 @@ async function processMsg (action, probe) {
   }
   if (!probe.where.sourceFile && !probe.where.lines) {
     throw new Error(
-      // eslint-disable-next-line @stylistic/js/max-len
+      // eslint-disable-next-line @stylistic/max-len
       `Unsupported probe insertion point! Only line-based probes are supported (id: ${probe.id}, version: ${probe.version})`
     )
   }
 
-  // This lock is to ensure that we don't get the following race condition:
-  //
-  // When a breakpoint is being removed and there are no other breakpoints, we disable the debugger by calling
-  // `Debugger.disable` to free resources. However, if a new breakpoint is being added around the same time, we might
-  // have a race condition where the new breakpoint thinks that the debugger is already enabled because the removal of
-  // the other breakpoint hasn't had a chance to call `Debugger.disable` yet. Then once the code that's adding the new
-  // breakpoints tries to call `Debugger.setBreakpoint` it fails because in the meantime `Debugger.disable` was called.
-  //
-  // If the code is ever refactored to not tear down the debugger if there's no active breakpoints, we can safely remove
-  // this lock.
-  const release = await lock()
-
-  try {
-    switch (action) {
-      case 'unapply':
-        await removeBreakpoint(probe)
-        break
-      case 'apply':
-        await addBreakpoint(probe)
-        ackInstalled(probe)
-        break
-      case 'modify':
-        // TODO: Modify existing probe instead of removing it (DEBUG-2817)
-        await removeBreakpoint(probe)
-        await addBreakpoint(probe)
-        ackInstalled(probe) // TODO: Should we also send ackInstalled when modifying a probe?
-        break
-      default:
-        throw new Error(
-          // eslint-disable-next-line @stylistic/js/max-len
-          `Cannot process probe ${probe.id} (version: ${probe.version}) - unknown remote configuration action: ${action}`
-        )
-    }
-  } finally {
-    release()
+  switch (action) {
+    case 'unapply':
+      await removeBreakpoint(probe)
+      break
+    case 'apply':
+      await addBreakpoint(probe)
+      ackInstalled(probe)
+      break
+    case 'modify':
+      await modifyBreakpoint(probe)
+      ackInstalled(probe)
+      break
+    default:
+      throw new Error(
+        `Cannot process probe ${probe.id} (version: ${probe.version}) - unknown remote configuration action: ${action}`
+      )
   }
 }

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

@@ -13,7 +13,8 @@ const { version } = require('../../../../../package.json')
 module.exports = send
 
 const MAX_MESSAGE_LENGTH = 8 * 1024 // 8KB
-const MAX_LOG_PAYLOAD_SIZE = 1024 * 1024 // 1MB
+const MAX_LOG_PAYLOAD_SIZE_MB = 1
+const MAX_LOG_PAYLOAD_SIZE_BYTES = MAX_LOG_PAYLOAD_SIZE_MB * 1024 * 1024
 
 const ddsource = 'dd_debugger'
 const hostname = getHostname()
@@ -48,13 +49,13 @@ function send (message, logger, dd, snapshot) {
   let json = JSON.stringify(payload)
   let size = Buffer.byteLength(json)
 
-  if (size > MAX_LOG_PAYLOAD_SIZE) {
+  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)
-    const line = Object.values(payload.debugger.snapshot.captures.lines)[0]
-    line.locals = {
-      notCapturedReason: 'Snapshot was too large',
-      size: Object.keys(line.locals).length
-    }
+    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)
   }

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

@@ -2,6 +2,7 @@
 
 const { getRuntimeObject } = require('./collector')
 const { processRawState } = require('./processor')
+const log = require('../../../log')
 
 const DEFAULT_MAX_REFERENCE_DEPTH = 3
 const DEFAULT_MAX_COLLECTION_SIZE = 100
@@ -24,15 +25,22 @@ async function getLocalStateForCallFrame (
   const rawState = []
   let processedState = null
 
-  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 }
-    ))
-  }))
+  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 }
+      ))
+    }))
+  } 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 () => new Error('Error getting local state')
+  }
 
-  // Deplay calling `processRawState` so the caller gets a chance to resume the main thread before processing `rawState`
+  // 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