report: skip report if uncaught exception is handled

If the exception is handled by the userland
process#uncaughtException, reports should not be generated
repetitively as the process may continue to run.

lib/internal/process/execution.js

@@ -151,34 +151,14 @@ function createOnGlobalUncaughtException() {
     // call that threw and was never cleared. So clear it now.
     clearDefaultTriggerAsyncId();
 
-    // If diagnostic reporting is enabled, call into its handler to see
-    // whether it is interested in handling the situation.
-    // Ignore if the error is scoped inside a domain.
-    // use == in the checks as we want to allow for null and undefined
-    if (er == null || er.domain == null) {
-      try {
-        const report = internalBinding('report');
-        if (report != null && report.shouldReportOnUncaughtException()) {
-          report.writeReport(
-            typeof er?.message === 'string' ?
-              er.message :
-              'Exception',
-            'Exception',
-            null,
-            er ?? {});
-        }
-      } catch {
-        // Ignore the exception. Diagnostic reporting is unavailable.
-      }
-    }
-
     const type = fromPromise ? 'unhandledRejection' : 'uncaughtException';
     process.emit('uncaughtExceptionMonitor', er, type);
     if (exceptionHandlerState.captureFn !== null) {
       exceptionHandlerState.captureFn(er);
     } else if (!process.emit('uncaughtException', er, type)) {
       // If someone handled it, then great. Otherwise, die in C++ land
       // since that means that we'll exit the process, emit the 'exit' event.
+
       try {
         if (!process._exiting) {
           process._exiting = true;

src/node_errors.cc

@@ -392,6 +392,7 @@ static void ReportFatalException(Environment* env,
   }
 
   node::Utf8Value trace(env->isolate(), stack_trace);
+  std::string report_message = "Exception";
 
   // range errors have a trace member set to undefined
   if (trace.length() > 0 && !stack_trace->IsUndefined()) {
@@ -424,6 +425,8 @@ static void ReportFatalException(Environment* env,
     } else {
       node::Utf8Value name_string(env->isolate(), name.ToLocalChecked());
       node::Utf8Value message_string(env->isolate(), message.ToLocalChecked());
+      // Update the report message if it is an object has message property.
+      report_message = message_string.ToString();
 
       if (arrow.IsEmpty() || !arrow->IsString() || decorated) {
         FPrintF(stderr, "%s: %s\n", name_string, message_string);
@@ -445,6 +448,11 @@ static void ReportFatalException(Environment* env,
     }
   }
 
+  if (env->isolate_data()->options()->report_uncaught_exception) {
+    report::TriggerNodeReport(
+        isolate, env, report_message.c_str(), "Exception", "", error);
+  }
+
   if (env->options()->trace_uncaught) {
     Local<StackTrace> trace = message->GetStackTrace();
     if (!trace.IsEmpty()) {

test/report/test-report-uncaught-exception-compat.js

@@ -1,5 +1,33 @@
-// Flags: --experimental-report --report-uncaught-exception --report-compact
 'use strict';
-// Test producing a compact report on uncaught exception.
-require('../common');
-require('./test-report-uncaught-exception.js');
+// Test producing a report on uncaught exception.
+const common = require('../common');
+const assert = require('assert');
+const childProcess = require('child_process');
+const helper = require('../common/report');
+const tmpdir = require('../common/tmpdir');
+
+if (process.argv[2] === 'child') {
+  process.report.directory = process.argv[3];
+
+  throw new Error('test error');
+}
+
+tmpdir.refresh();
+const child = childProcess.spawn(process.execPath, [
+  '--report-uncaught-exception',
+  '--report-compact',
+  __filename,
+  'child',
+  tmpdir.path,
+]);
+child.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 1);
+  const reports = helper.findReports(child.pid, tmpdir.path);
+  assert.strictEqual(reports.length, 1);
+
+  helper.validate(reports[0], [
+    ['header.event', 'Exception'],
+    ['header.trigger', 'Exception'],
+    ['javascriptStack.message', 'Error: test error'],
+  ]);
+}));

test/report/test-report-uncaught-exception-primitives.js

@@ -1,25 +1,33 @@
-// Flags: --report-uncaught-exception
 'use strict';
 // Test producing a report on uncaught exception.
 const common = require('../common');
 const assert = require('assert');
+const childProcess = require('child_process');
 const helper = require('../common/report');
 const tmpdir = require('../common/tmpdir');
 
-const exception = 1;
+if (process.argv[2] === 'child') {
+  process.report.directory = process.argv[3];
 
-tmpdir.refresh();
-process.report.directory = tmpdir.path;
+  // eslint-disable-next-line no-throw-literal
+  throw 1;
+}
 
-process.on('uncaughtException', common.mustCall((err) => {
-  assert.strictEqual(err, exception);
-  const reports = helper.findReports(process.pid, tmpdir.path);
+tmpdir.refresh();
+const child = childProcess.spawn(process.execPath, [
+  '--report-uncaught-exception',
+  __filename,
+  'child',
+  tmpdir.path,
+]);
+child.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 1);
+  const reports = helper.findReports(child.pid, tmpdir.path);
   assert.strictEqual(reports.length, 1);
 
   helper.validate(reports[0], [
     ['header.event', 'Exception'],
-    ['javascriptStack.message', `${exception}`],
+    ['header.trigger', 'Exception'],
+    ['javascriptStack.message', '1'],
   ]);
 }));
-
-throw exception;

test/report/test-report-uncaught-exception-symbols.js

@@ -1,25 +1,32 @@
-// Flags: --report-uncaught-exception
 'use strict';
 // Test producing a report on uncaught exception.
 const common = require('../common');
 const assert = require('assert');
+const childProcess = require('child_process');
 const helper = require('../common/report');
 const tmpdir = require('../common/tmpdir');
 
-const exception = Symbol('foobar');
+if (process.argv[2] === 'child') {
+  process.report.directory = process.argv[3];
 
-tmpdir.refresh();
-process.report.directory = tmpdir.path;
+  throw Symbol('foobar');
+}
 
-process.on('uncaughtException', common.mustCall((err) => {
-  assert.strictEqual(err, exception);
-  const reports = helper.findReports(process.pid, tmpdir.path);
+tmpdir.refresh();
+const child = childProcess.spawn(process.execPath, [
+  '--report-uncaught-exception',
+  __filename,
+  'child',
+  tmpdir.path,
+]);
+child.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 1);
+  const reports = helper.findReports(child.pid, tmpdir.path);
   assert.strictEqual(reports.length, 1);
 
   helper.validate(reports[0], [
     ['header.event', 'Exception'],
+    ['header.trigger', 'Exception'],
     ['javascriptStack.message', 'Symbol(foobar)'],
   ]);
 }));
-
-throw exception;

test/report/test-report-uncaught-exception.js

@@ -1,20 +1,32 @@
-// Flags: --report-uncaught-exception
 'use strict';
 // Test producing a report on uncaught exception.
 const common = require('../common');
 const assert = require('assert');
+const childProcess = require('child_process');
 const helper = require('../common/report');
 const tmpdir = require('../common/tmpdir');
-const error = new Error('test error');
 
-tmpdir.refresh();
-process.report.directory = tmpdir.path;
+if (process.argv[2] === 'child') {
+  process.report.directory = process.argv[3];
+
+  throw new Error('test error');
+}
 
-process.on('uncaughtException', common.mustCall((err) => {
-  assert.strictEqual(err, error);
-  const reports = helper.findReports(process.pid, tmpdir.path);
+tmpdir.refresh();
+const child = childProcess.spawn(process.execPath, [
+  '--report-uncaught-exception',
+  __filename,
+  'child',
+  tmpdir.path,
+]);
+child.on('exit', common.mustCall((code) => {
+  assert.strictEqual(code, 1);
+  const reports = helper.findReports(child.pid, tmpdir.path);
   assert.strictEqual(reports.length, 1);
-  helper.validate(reports[0]);
-}));
 
-throw error;
+  helper.validate(reports[0], [
+    ['header.event', 'Exception'],
+    ['header.trigger', 'Exception'],
+    ['javascriptStack.message', 'Error: test error'],
+  ]);
+}));