fix(debugger): abort on unknown Debugger.paused reason (#6901)

When the `Debugger.paused` event is emitted in the debugger
implementation, it's expected to be because a breakpoint is hit. In that
case the events `params.reason` will be set to `other`.

However, if the inspected thread experiences an OOM event,
`Debugger.paused` will also be emitted with `params.reason` set to `OOM`.
There might also be other situations where `params.reason` is different
from `other`. In all these situations we should abort and close the
debugger.

In the case of an OOM event in the inspected thread, exiting the
debugging thread, will also stop the debugging session, and this will
allow the inspected thread to properly exit with an OOM error. If we
didn't do this we would essentially swallow the OOM error.

Author: watson

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

@@ -58,6 +58,11 @@ if (SUPPORT_ARRAY_BUFFER_RESIZE) {
 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, maxCollectionSize, maxFieldCount, maxLength
   let sampled = false
   let numberOfProbesWithSnapshots = 0

packages/dd-trace/test/debugger/devtools_client/index.spec.js

@@ -16,16 +16,22 @@ const functionName = 'myFn'
 const parentThreadId = 'my-parent-thread-id'
 const event = {
   params: {
+    reason: 'other',
     hitBreakpoints: [breakpointId],
     callFrames: [{ functionName, location: { scriptId, lineNumber: breakpoint.line - 1, columnNumber: 0 } }]
   }
 }
 
 describe('onPause', function () {
-  let session, send, onPaused, ackReceived
+  let session, send, onPaused, ackReceived, log
 
   beforeEach(async function () {
     ackReceived = sinon.spy()
+    log = {
+      error: sinon.spy(),
+      debug: sinon.spy(),
+      '@noCallThru': true
+    }
 
     session = {
       on: sinon.spy((event, listener) => {
@@ -68,6 +74,7 @@ describe('onPause', function () {
       './session': session,
       './state': state,
       './snapshot': snapshot,
+      './log': log,
       './send': send,
       './status': { ackReceived },
       './remote_config': { '@noCallThru': true }
@@ -83,4 +90,27 @@ describe('onPause', function () {
     expect(ackReceived).to.not.have.been.called
     expect(send).to.not.have.been.called
   })
+
+  it('should throw if paused for an unknown reason', async function () {
+    const unknownReasonEvent = {
+      ...event,
+      params: {
+        ...event.params,
+        reason: 'OOM'
+      }
+    }
+
+    let thrown
+    try {
+      await onPaused(unknownReasonEvent)
+    } catch (err) {
+      thrown = err
+    }
+
+    expect(thrown).to.be.an('error')
+    expect(thrown.message).to.equal('Unexpected Debugger.paused reason: OOM')
+    expect(session.post).to.not.have.been.called
+    expect(ackReceived).to.not.have.been.called
+    expect(send).to.not.have.been.called
+  })
 })