dd-trace 6.16.0 → 6.17.0

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

@@ -1,8 +1,10 @@
 'use strict'
 
+const { INCOMPLETE_REASON } = require('../../guardrail-metrics')
 const session = require('../session')
 const { collectObjectProperties } = require('./collector')
 const { processRawState, processRemoteObject } = require('./processor')
+const { fieldCountSym } = require('./symbols')
 
 const BIGINT_MAX = (1n << 256n) - 1n
 
@@ -26,8 +28,13 @@ module.exports = {
  * @param {CaptureLimits} limits - The capture limits
  * @param {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.
- * @returns {Promise<{ processLocalState: () => ReturnType<typeof processRawState>, fatalErrors: Error[] }>} The local
- *   state for the call frame
+ * @returns {Promise<{
+ *   processLocalState: () => ReturnType<typeof processRawState>,
+ *   fatalErrors: Error[],
+ *   incomplete: import('./processor').IncompleteCapture
+ * }>} The local state for the call frame. `incomplete` is only fully populated once `processLocalState` has run.
+ *   Not every fatal error is recorded as a runtime error: the collector also raises one when it hits its large object
+ *   safety threshold, which is reported as the field count limit it is.
  */
 async function getLocalStateForCallFrame (callFrame, limits, deadlineNs = BIGINT_MAX) {
   const { maxReferenceDepth, maxCollectionSize, maxFieldCount, maxLength } = limits
@@ -35,39 +42,63 @@ async function getLocalStateForCallFrame (callFrame, limits, deadlineNs = BIGINT
   const ctx = { deadlineReached: false, fatalErrors: [] }
   const opts = { maxReferenceDepth, maxCollectionSize, maxFieldCount, deadlineNs, ctx }
   const rawState = []
+  /** @type {import('./processor').IncompleteCapture} */
+  const incomplete = { reasons: 0 }
   /** @type {ReturnType<typeof processRawState> | null} */
   let processedState = null
 
-  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
+  const { scopeChain } = callFrame
+  for (const scope of scopeChain) {
+    if (!isCollectable(scope)) continue
+    const objectId = /** @type {string} */ (scope.object.objectId)
     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))
+      const variables = await collectObjectProperties(objectId, opts)
+      // A scope with more variables than the field count limit is trimmed like any other object, but since the scope
+      // itself is not part of the snapshot, the marker would be lost once its variables are spread into the state
+      if (variables[fieldCountSym] !== undefined) incomplete.reasons |= INCOMPLETE_REASON.FIELD_COUNT
+      rawState.push(...variables)
     } catch (err) {
+      incomplete.reasons |= INCOMPLETE_REASON.RUNTIME_ERROR
       ctx.fatalErrors.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 probes are re-applied',
         { cause: err } // TODO: The cause is not used by the backend
       ))
     }
-    if (ctx.deadlineReached === true) break // TODO: Bad UX; Variables in remaining scopes are silently dropped
+    if (ctx.deadlineReached === true) {
+      // Nodes skipped within this scope carry the timeout marker and are recorded when processed (unless they end up
+      // redacted), but the remaining scopes are dropped without any marker.
+      // TODO: Bad UX; Variables in remaining scopes are silently dropped
+      // @ts-expect-error - findLast is available in Node.js 18+ but TypeScript doesn't know about it without ES2023 lib
+      if (scope !== scopeChain.findLast(isCollectable)) incomplete.reasons |= INCOMPLETE_REASON.TIMEOUT
+      break
+    }
   }
 
   // Delay calling `processRawState` so caller can resume the main thread before processing `rawState`
   return {
     processLocalState () {
-      processedState ??= processRawState(rawState, maxLength)
+      processedState ??= processRawState(rawState, maxLength, incomplete)
       return processedState
     },
     fatalErrors: ctx.fatalErrors,
+    incomplete,
   }
 }
 
+/**
+ * Returns whether the scope variables are collected into the snapshot.
+ * @param {import('inspector').Debugger.Scope} scope
+ */
+function isCollectable (scope) {
+  // The global scope is too noisy, and a scope without an object id is possible according to the types
+  return scope.type !== 'global' && scope.object.objectId !== undefined
+}
+
 /**
  * @typedef {object} CompiledCaptureExpression
  * @property {string} name - The name of the expression (used as key in snapshot)
@@ -82,6 +113,9 @@ async function getLocalStateForCallFrame (callFrame, limits, deadlineNs = BIGINT
  * @property {{ expr: string, message: string }[]} evaluationErrors - Transient errors from expression evaluation
  *   (safe to retry)
  * @property {Error[]} fatalErrors - Fatal errors that should disable capture expressions for this probe permanently
+ * @property {import('./processor').IncompleteCapture} incomplete - The capture limits enforced on the expressions,
+ *   including a runtime error for every expression that threw or could not be evaluated. Only fully populated once
+ *   `processCaptureExpressions` has run.
  */
 
 /**
@@ -108,6 +142,8 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
   const evaluationErrors = []
   /** @type {Error[]} */
   const fatalErrors = []
+  /** @type {import('./processor').IncompleteCapture} */
+  const incomplete = { reasons: 0 }
   /** @type {Record<string, ReturnType<typeof processRemoteObject>> | null} */
   let processedResult = null
 
@@ -126,6 +162,7 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
 
       // Handle evaluation exceptions (maybe transient - bad expression, undefined var, etc.)
       if (exceptionDetails) {
+        incomplete.reasons |= INCOMPLETE_REASON.RUNTIME_ERROR
         evaluationErrors.push({ expr: name, message: extractErrorMessage(exceptionDetails) })
         continue
       }
@@ -156,9 +193,11 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
         }
 
         if (ctx.deadlineReached) {
-          // Add the current expression (properties may be incomplete due to timeout)
+          // Add the current expression (properties may be incomplete due to timeout). Those carry the timeout marker
+          // and are recorded when processed, unless they end up redacted.
           rawResults.push({ name, remoteObject: result, maxLength })
-          // Add stub entries for remaining uncaptured expressions
+          // Add stub entries for remaining uncaptured expressions. The stubs are used as-is, so record them here.
+          if (i + 1 < expressions.length) incomplete.reasons |= INCOMPLETE_REASON.TIMEOUT
           for (let j = i + 1; j < expressions.length; j++) {
             rawResults.push({
               name: expressions[j].name,
@@ -172,6 +211,7 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
 
       rawResults.push({ name, remoteObject: result, maxLength })
     } catch (err) {
+      incomplete.reasons |= INCOMPLETE_REASON.RUNTIME_ERROR
       fatalErrors.push(new Error(
         `Error capturing expression "${name}". ` +
         'Capture expressions for this probe will be skipped until the probe is re-applied',
@@ -189,7 +229,7 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
       for (const { name, remoteObject, maxLength } of rawResults) {
         // If the remote object has notCapturedReason (e.g., timeout), use it as-is without processing
         processedResult[name] = remoteObject.notCapturedReason === undefined
-          ? processRemoteObject(remoteObject, maxLength)
+          ? processRemoteObject(remoteObject, maxLength, incomplete)
           : remoteObject
       }
 
@@ -197,6 +237,7 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
     },
     evaluationErrors,
     fatalErrors,
+    incomplete,
   }
 }
 
@@ -204,7 +245,6 @@ async function evaluateCaptureExpressions (callFrame, expressions, deadlineNs =
  * Extract the error message from the exception details.
  *
  * @param {import('inspector').Runtime.ExceptionDetails} exceptionDetails - The exception details
- * @returns {string} The error message
  */
 function extractErrorMessage (exceptionDetails) {
   const description = exceptionDetails.exception?.description

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

@@ -1,5 +1,6 @@
 'use strict'
 
+const { INCOMPLETE_REASON } = require('../../guardrail-metrics')
 const { LARGE_OBJECT_SKIP_THRESHOLD } = require('./constants')
 const { collectionSizeSym, largeCollectionSkipThresholdSym, fieldCountSym, timeBudgetSym } = require('./symbols')
 const { normalizeName, REDACTED_IDENTIFIERS } = require('./redaction')
@@ -15,15 +16,24 @@ module.exports = {
  * @typedef {import('inspector').Runtime.RemoteObject & { properties?: object[] }} RemoteObjectWithProperties
  */
 
+/**
+ * Accumulates which capture limits were enforced while processing a single event, so they can be reported once per
+ * event instead of once per affected node.
+ *
+ * @typedef {object} IncompleteCapture
+ * @property {number} reasons - Bitmask of {@link INCOMPLETE_REASON} flags
+ */
+
 /**
  * Process a RemoteObject into the snapshot format.
  *
  * @param {RemoteObjectWithProperties} remoteObject
  * @param {number} maxLength - Maximum string length
+ * @param {IncompleteCapture} incomplete - Receives the capture limits enforced on the object
  * @returns {object} The processed value in snapshot format
  */
-function processRemoteObject (remoteObject, maxLength) {
-  return getPropertyValueRaw({ value: remoteObject }, maxLength)
+function processRemoteObject (remoteObject, maxLength, incomplete) {
+  return getPropertyValueRaw({ value: remoteObject }, maxLength, incomplete)
 }
 
 // Matches classes in source code, no matter how it's written:
@@ -33,7 +43,15 @@ function processRemoteObject (remoteObject, maxLength) {
 // - Anonymous, with odd whitespace: class\n{}
 const CLASS_REGEX = /^class\s([^{]*)/
 
-function processProperties (props, maxLength) {
+/**
+ * Process the collected properties of an object into the snapshot format.
+ *
+ * @param {object[]} props - The collected property descriptors
+ * @param {number} maxLength - Maximum string length
+ * @param {IncompleteCapture} incomplete - Receives the capture limits enforced on the properties
+ * @returns {Record<string, object>} The processed properties in snapshot format
+ */
+function processProperties (props, maxLength, incomplete) {
   const result = {}
 
   for (const prop of props) {
@@ -42,20 +60,26 @@ function processProperties (props, maxLength) {
     if (name.includes('.')) {
       name = name.replaceAll('.', '_')
     }
-    result[name] = getPropertyValue(prop, maxLength)
+    result[name] = getPropertyValue(prop, maxLength, incomplete)
   }
 
   return result
 }
 
+// Capture limits enforced while processing a value that ends up redacted never make it into the snapshot, so they are
+// not recorded as incomplete capture reasons either
+const discardedIncomplete = { reasons: 0 }
+
 // TODO: Improve performance of redaction algorithm.
 // This algorithm is probably slower than if we embedded the redaction logic inside the functions below.
 // That way we didn't have to traverse objects that will just be redacted anyway.
-function getPropertyValue (prop, maxLength) {
-  return redact(prop, getPropertyValueRaw(prop, maxLength))
+function getPropertyValue (prop, maxLength, incomplete) {
+  return shouldRedactProperty(prop)
+    ? notCapturedRedacted(getPropertyValueRaw(prop, maxLength, discardedIncomplete).type)
+    : getPropertyValueRaw(prop, maxLength, incomplete)
 }
 
-function getPropertyValueRaw (prop, maxLength) {
+function getPropertyValueRaw (prop, maxLength, incomplete) {
   // Special case for getters and setters which does not have a value property
   if (prop.get) {
     const hasGet = prop.get.type !== 'undefined'
@@ -69,15 +93,15 @@ function getPropertyValueRaw (prop, maxLength) {
 
   switch (prop.value?.type) {
     case 'object':
-      return getObjectValue(prop.value, maxLength)
+      return getObjectValue(prop.value, maxLength, incomplete)
     case 'string':
-      return toString(prop.value.value, maxLength)
+      return toString(prop.value.value, maxLength, incomplete)
     case 'number':
       return { type: 'number', value: prop.value.description } // use `description` to get it as string
     case 'boolean':
       return { type: 'boolean', value: prop.value.value === true ? 'true' : 'false' }
     case 'function':
-      return toFunctionOrClass(prop.value, maxLength)
+      return toFunctionOrClass(prop.value, maxLength, incomplete)
     case undefined: // TODO: Add test for when a prop has no value. I think it's if it's defined after the breakpoint?
     case 'undefined':
       return { type: 'undefined' }
@@ -88,18 +112,19 @@ function getPropertyValueRaw (prop, maxLength) {
     default:
       // As of this writing, the Chrome DevTools Protocol doesn't allow any other types than the ones listed above, but
       // in the future new ones might be added.
+      incomplete.reasons |= INCOMPLETE_REASON.OTHER
       return { type: prop.value.type, notCapturedReason: 'Unsupported property type' }
   }
 }
 
-function getObjectValue (obj, maxLength) {
+function getObjectValue (obj, maxLength, incomplete) {
   const timeBudgetReached = obj[timeBudgetSym] === true
 
   switch (obj.subtype) {
     case undefined:
-      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'array':
-      return toArray(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toArray(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'null':
       return { type: 'null', isNull: true }
     // case 'node': // TODO: What does this subtype represent?
@@ -113,28 +138,28 @@ function getObjectValue (obj, maxLength) {
       return { type: obj.className, value }
     }
     case 'map':
-      return toMap(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toMap(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'set':
-      return toSet(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toSet(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'error':
       // TODO: Convert stack trace to array to avoid string truncation or disable truncation in this case?
-      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'proxy':
       // Use `description` instead of `className` as the `type` to get type of target object (`Proxy(Error)` vs `proxy`)
-      return toObject(obj.description, obj.properties, maxLength, timeBudgetReached)
+      return toObject(obj.description, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'promise':
-      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toObject(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'typedarray':
-      return toArray(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toArray(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'generator':
       // Use `subtype` instead of `className` to make it obvious it's a generator
-      return toObject(obj.subtype, obj.properties, maxLength, timeBudgetReached)
+      return toObject(obj.subtype, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'arraybuffer':
-      return toArrayBuffer(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toArrayBuffer(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'weakmap':
-      return toMap(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toMap(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     case 'weakset':
-      return toSet(obj.className, obj.properties, maxLength, timeBudgetReached)
+      return toSet(obj.className, obj.properties, maxLength, timeBudgetReached, incomplete)
     // case 'iterator': // TODO: I've not been able to trigger this subtype
     // case 'dataview': // TODO: Looks like the internal ArrayBuffer is only accessible via the `buffer` getter
     // case 'webassemblymemory': // TODO: Looks like the internal ArrayBuffer is only accessible via the `buffer` getter
@@ -142,31 +167,34 @@ function getObjectValue (obj, maxLength) {
     default:
       // As of this writing, the Chrome DevTools Protocol doesn't allow any other subtypes than the ones listed above,
       // but in the future new ones might be added.
+      incomplete.reasons |= INCOMPLETE_REASON.OTHER
       return { type: obj.subtype, notCapturedReason: 'Unsupported object type' }
   }
 }
 
-function toFunctionOrClass (value, maxLength) {
+function toFunctionOrClass (value, maxLength, incomplete) {
   const classMatch = value.description.match(CLASS_REGEX)
 
   if (classMatch === null) {
     // This is a function
     const timeBudgetReached = value[timeBudgetSym] === true
     // TODO: Would it make sense to detect if it's an arrow function or not?
-    return toObject(value.className, value.properties, maxLength, timeBudgetReached)
+    return toObject(value.className, value.properties, maxLength, timeBudgetReached, incomplete)
   }
   // This is a class
   const className = classMatch[1].trim()
   return { type: className ? `class ${className}` : 'class' }
 }
 
-function toString (str, maxLength) {
+function toString (str, maxLength, incomplete) {
   const size = str.length
 
   if (size <= maxLength) {
     return { type: 'string', value: str }
   }
 
+  incomplete.reasons |= INCOMPLETE_REASON.STRING_LENGTH
+
   return {
     type: 'string',
     value: str.slice(0, maxLength),
@@ -175,16 +203,17 @@ function toString (str, maxLength) {
   }
 }
 
-function toObject (type, props, maxLength, timeBudgetReached) {
-  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
-  if (props === undefined) return notCapturedDepth(type)
+function toObject (type, props, maxLength, timeBudgetReached, incomplete) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type, incomplete)
+  if (props === undefined) return notCapturedDepth(type, incomplete)
 
   const result = {
     type,
-    fields: processProperties(props, maxLength),
+    fields: processProperties(props, maxLength, incomplete),
   }
 
   if (props[fieldCountSym] !== undefined) {
+    incomplete.reasons |= INCOMPLETE_REASON.FIELD_COUNT
     result.notCapturedReason = 'fieldCount'
     result.size = props[fieldCountSym]
   }
@@ -192,27 +221,29 @@ function toObject (type, props, maxLength, timeBudgetReached) {
   return result
 }
 
-function toArray (type, elements, maxLength, timeBudgetReached) {
-  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
-  if (elements === undefined) return notCapturedDepth(type)
+function toArray (type, elements, maxLength, timeBudgetReached, incomplete) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type, incomplete)
+  if (elements === undefined) return notCapturedDepth(type, incomplete)
 
   const result = {
     type,
     elements: elements.map((element) => {
-      return getPropertyValue(element, maxLength)
+      return getPropertyValue(element, maxLength, incomplete)
     }),
   }
 
-  setNotCaptureReasonOnCollection(result, elements)
-  setNotCaptureReasonOnTooLargeCollection(result, elements)
+  setNotCaptureReasonOnCollection(result, elements, incomplete)
+  setNotCaptureReasonOnTooLargeCollection(result, elements, incomplete)
 
   return result
 }
 
-function toMap (type, pairs, maxLength, timeBudgetReached) {
-  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
-  if (pairs === undefined) return notCapturedDepth(type)
-  if (pairs.length > 0 && pairs.every(({ value }) => value[timeBudgetSym] === true)) return notCapturedTimeBudget(type)
+function toMap (type, pairs, maxLength, timeBudgetReached, incomplete) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type, incomplete)
+  if (pairs === undefined) return notCapturedDepth(type, incomplete)
+  if (pairs.length > 0 && pairs.every(({ value }) => value[timeBudgetSym] === true)) {
+    return notCapturedTimeBudget(type, incomplete)
+  }
 
   const result = {
     type,
@@ -227,32 +258,34 @@ function toMap (type, pairs, maxLength, timeBudgetReached) {
       // second containing the value of this entry of the Map.
 
       if (value[timeBudgetSym] === true) {
+        incomplete.reasons |= INCOMPLETE_REASON.TIMEOUT
         return [{ notCapturedReason: 'timeout' }, { notCapturedReason: 'timeout' }]
       }
       if (value.properties === undefined) {
+        incomplete.reasons |= INCOMPLETE_REASON.OTHER
         return [{ notCapturedReason: 'unknown' }, { notCapturedReason: 'unknown' }]
       }
 
       const shouldRedact = shouldRedactMapValue(value.properties[0])
-      const key = getPropertyValue(value.properties[0], maxLength)
+      const key = getPropertyValue(value.properties[0], maxLength, incomplete)
       const val = shouldRedact
         ? notCapturedRedacted(value.properties[1].value.type)
-        : getPropertyValue(value.properties[1], maxLength)
+        : getPropertyValue(value.properties[1], maxLength, incomplete)
       return [key, val]
     }),
   }
 
-  setNotCaptureReasonOnCollection(result, pairs)
-  setNotCaptureReasonOnTooLargeCollection(result, pairs)
+  setNotCaptureReasonOnCollection(result, pairs, incomplete)
+  setNotCaptureReasonOnTooLargeCollection(result, pairs, incomplete)
 
   return result
 }
 
-function toSet (type, values, maxLength, timeBudgetReached) {
-  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
-  if (values === undefined) return notCapturedDepth(type)
+function toSet (type, values, maxLength, timeBudgetReached, incomplete) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type, incomplete)
+  if (values === undefined) return notCapturedDepth(type, incomplete)
   if (values.length > 0 && values.every(({ value }) => value[timeBudgetSym] === true)) {
-    return notCapturedTimeBudget(type)
+    return notCapturedTimeBudget(type, incomplete)
   }
 
   const result = {
@@ -267,33 +300,42 @@ function toSet (type, values, maxLength, timeBudgetReached) {
       // children, of which there will always be exactly one, which contain the
       // actual value in this entry of the Set.
 
-      if (value[timeBudgetSym] === true) return { notCapturedReason: 'timeout' }
-      if (value.properties === undefined) return { notCapturedReason: 'unknown' }
+      if (value[timeBudgetSym] === true) {
+        incomplete.reasons |= INCOMPLETE_REASON.TIMEOUT
+        return { notCapturedReason: 'timeout' }
+      }
+      if (value.properties === undefined) {
+        incomplete.reasons |= INCOMPLETE_REASON.OTHER
+        return { notCapturedReason: 'unknown' }
+      }
 
-      return getPropertyValue(value.properties[0], maxLength)
+      return getPropertyValue(value.properties[0], maxLength, incomplete)
     }),
   }
 
-  setNotCaptureReasonOnCollection(result, values)
-  setNotCaptureReasonOnTooLargeCollection(result, values)
+  setNotCaptureReasonOnCollection(result, values, incomplete)
+  setNotCaptureReasonOnTooLargeCollection(result, values, incomplete)
 
   return result
 }
 
-function toArrayBuffer (type, bytes, maxLength, timeBudgetReached) {
-  if (timeBudgetReached === true) return notCapturedTimeBudget(type)
-  if (bytes === undefined) return notCapturedDepth(type)
+function toArrayBuffer (type, bytes, maxLength, timeBudgetReached, incomplete) {
+  if (timeBudgetReached === true) return notCapturedTimeBudget(type, incomplete)
+  if (bytes === undefined) return notCapturedDepth(type, incomplete)
 
   const size = bytes.length
 
-  return size > maxLength
-    ? {
-        type,
-        value: arrayBufferToString(bytes, maxLength),
-        truncated: true,
-        size: bytes.length,
-      }
-    : { type, value: arrayBufferToString(bytes, size) }
+  if (size > maxLength) {
+    incomplete.reasons |= INCOMPLETE_REASON.STRING_LENGTH
+    return {
+      type,
+      value: arrayBufferToString(bytes, maxLength),
+      truncated: true,
+      size: bytes.length,
+    }
+  }
+
+  return { type, value: arrayBufferToString(bytes, size) }
 }
 
 function arrayBufferToString (bytes, size) {
@@ -304,9 +346,8 @@ function arrayBufferToString (bytes, size) {
   return buf.toString()
 }
 
-function redact (prop, obj) {
-  const name = getNormalizedNameFromProp(prop)
-  return REDACTED_IDENTIFIERS.has(name) ? notCapturedRedacted(obj.type) : obj
+function shouldRedactProperty (prop) {
+  return REDACTED_IDENTIFIERS.has(getNormalizedNameFromProp(prop))
 }
 
 function shouldRedactMapValue (key) {
@@ -323,15 +364,19 @@ function getNormalizedNameFromProp (prop) {
   return normalizeName(prop.name, prop.symbol !== undefined)
 }
 
-function setNotCaptureReasonOnCollection (result, collection) {
+function setNotCaptureReasonOnCollection (result, collection, incomplete) {
   if (collection[collectionSizeSym] !== undefined) {
+    incomplete.reasons |= INCOMPLETE_REASON.COLLECTION_SIZE
     result.notCapturedReason = 'collectionSize'
     result.size = collection[collectionSizeSym]
   }
 }
 
-function setNotCaptureReasonOnTooLargeCollection (result, collection) {
+function setNotCaptureReasonOnTooLargeCollection (result, collection, incomplete) {
   if (collection[largeCollectionSkipThresholdSym] !== undefined) {
+    // The collection was skipped entirely because it exceeded the skip threshold, which is a different limit than the
+    // `maxCollectionSize` limit that `collectionSize` represents
+    incomplete.reasons |= INCOMPLETE_REASON.OTHER
     result.notCapturedReason = `Large collection with too many elements (skip threshold: ${
       LARGE_OBJECT_SKIP_THRESHOLD
     })`
@@ -339,7 +384,8 @@ function setNotCaptureReasonOnTooLargeCollection (result, collection) {
   }
 }
 
-function notCapturedDepth (type) {
+function notCapturedDepth (type, incomplete) {
+  incomplete.reasons |= INCOMPLETE_REASON.DEPTH
   return { type, notCapturedReason: 'depth' }
 }
 
@@ -347,6 +393,7 @@ function notCapturedRedacted (type) {
   return { type, notCapturedReason: 'redactedIdent' }
 }
 
-function notCapturedTimeBudget (type) {
+function notCapturedTimeBudget (type, incomplete) {
+  incomplete.reasons |= INCOMPLETE_REASON.TIMEOUT
   return { type, notCapturedReason: 'timeout' }
 }

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

@@ -143,7 +143,6 @@ class PriorityQueue {
    *
    * @param {TreeNode} a - First node to compare
    * @param {TreeNode} b - Second node to compare
-   * @returns {number} - > 0 if a has higher priority, < 0 if b has higher priority, 0 if equal
    */
   #compare (a, b) {
     const keyA = a.priorityKey
@@ -243,7 +242,6 @@ function parseJsonToTree (json) {
  *
  * @param {string} json - The JSON string to skip
  * @param {number} startIndex - The index to start skipping from
- * @returns {number} The index of the closing quote
  */
 function skipString (json, startIndex) {
   let index = startIndex + 1 // Skip opening quote
@@ -353,7 +351,6 @@ function selectNodesToPrune (root, bytesToRemove) {
  *
  * @param {string} json - The JSON string to rebuild
  * @param {Set<TreeNode>} prunedNodes - The set of nodes to replace with {"pruned":true}
- * @returns {string} The rebuilt JSON string
  */
 function rebuildJson (json, prunedNodes) {
   // Convert set to array and sort by start position (descending)