Send errors as evaluationErrors instead of diagnostics

Author: watson

integration-tests/debugger/snapshot-time-budget.spec.js

@@ -38,38 +38,27 @@ describe('Dynamic Instrumentation', function () {
           'should timeout first, then disable subsequent snapshots and emit error diagnostics',
           async function () {
             const breakpoint = t.breakpoints[1]
+            const expectedEvaluationErrors = [{
+              expr: '',
+              message: 'An object with 1000000 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'
+            }]
 
             // Listen for the first snapshot payload (should contain notCapturedReason: "timeout")
-            const firstPayloadReceived = new Promise((resolve) => {
-              t.agent.once('debugger-input', ({ payload: [{ debugger: { snapshot: { captures } } }] }) => {
-                const { locals } = captures.lines[breakpoint.line]
-                resolve(locals)
+            const firstPayloadReceived = new Promise(/** @type {() => void} */ (resolve) => {
+              t.agent.once('debugger-input', ({ payload: [{ debugger: { snapshot } }] }) => {
+                const { locals } = snapshot.captures.lines[breakpoint.line]
+                assert.strictEqual(
+                  containsTimeBudget(locals),
+                  true,
+                  'expected at least one field/element to be marked with notCapturedReason: "timeout"'
+                )
+                assert.deepStrictEqual(snapshot.evaluationErrors, expectedEvaluationErrors)
+                resolve()
               })
             })
 
-            // Prepare to assert that an ERROR diagnostics event with exception details is emitted
-            const errorDiagnosticsReceived = new Promise((/** @type {(value?: unknown) => void} */ resolve, reject) => {
-              const handler = ({ payload }) => {
-                payload.forEach(({ debugger: { diagnostics } }) => {
-                  if (diagnostics.status !== 'ERROR') return
-                  try {
-                    assert.strictEqual(
-                      diagnostics.exception.message,
-                      'An object with 1000000 properties was detected while collecting a snapshot. This exceeds the ' +
-                      'maximum number of allowed properties of 500. Future snapshots for existing probes in this ' +
-                      'location will be skipped until the Node.js process is restarted'
-                    )
-                    resolve()
-                  } catch (e) {
-                    reject(e)
-                  } finally {
-                    t.agent.off('debugger-diagnostics', handler)
-                  }
-                })
-              }
-              t.agent.on('debugger-diagnostics', handler)
-            })
-
             // Install probe with snapshot capture enabled
             t.agent.addRemoteConfig(breakpoint.generateRemoteConfig({
               captureSnapshot: true,
@@ -82,18 +71,14 @@ describe('Dynamic Instrumentation', function () {
               result1.data.paused >= 1_000,
               `expected thread to be paused for at least 1 second, but was paused for ~${result1.data.paused}ms`
             )
-            const locals = await firstPayloadReceived
-            assert.strictEqual(
-              containsTimeBudget(locals),
-              true,
-              'expected at least one field/element to be marked with notCapturedReason: "timeout"'
-            )
-            await errorDiagnosticsReceived
+
+            await firstPayloadReceived
 
             // Prepare to assert that no snapshot is produced on a subsequent trigger
-            const noSnapshotAfterSecondTrigger = new Promise((/** @type {(value?: unknown) => void} */ resolve) => {
-              t.agent.once('debugger-input', ({ payload: [{ debugger: { snapshot: { captures } } }] }) => {
-                assert.strictEqual(captures, undefined)
+            const secondPayloadReceived = new Promise(/** @type {() => void} */ (resolve) => {
+              t.agent.once('debugger-input', ({ payload: [{ debugger: { snapshot } }] }) => {
+                assert.ok(!Object.hasOwn(snapshot, 'captures'))
+                assert.deepStrictEqual(snapshot.evaluationErrors, expectedEvaluationErrors)
                 resolve()
               })
             })
@@ -105,7 +90,7 @@ describe('Dynamic Instrumentation', function () {
               `expected thread to be paused <=5ms, but was paused for ~${result2.data.paused}ms`
             )
 
-            await noSnapshotAfterSecondTrigger
+            await secondPayloadReceived
           }
         )
       })

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 config = require('./config')
 const { MAX_SNAPSHOTS_PER_SECOND_GLOBALLY } = require('./defaults')
 const log = require('./log')
@@ -219,15 +219,20 @@ session.on('Debugger.paused', async ({ params }) => {
       if (captureErrors.length > 0) {
         // There was an error collecting the snapshot for this probe, let's not try again
         probe.captureSnapshot = false
-        for (const error of captureErrors) {
-          ackError(error, probe)
-        }
+        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 = ''
     if (probe.templateRequiresEvaluation) {
       const results = evalResults[messageIndex++]