process: allow monitoring uncaughtException

doc/api/process.md

@@ -262,6 +262,20 @@ nonexistentFunc();
 console.log('This will not run.');
 ```
 
+It is possible to monitor `'uncaughtException'` events without overriding the
+default behavior to exit the process by installing a listener using the symbol
+`uncaughtExceptionMonitor`.
+
+```js
+process.on(process.uncaughtExceptionMonitor, (err, origin) => {
+  MyMonitoringTool.logSync(err, origin);
+});
+
+// Intentionally cause an exception, but don't catch it.
+nonexistentFunc();
+// Still crashes Node.js
+```
+
 #### Warning: Using `'uncaughtException'` correctly
 
 `'uncaughtException'` is a crude mechanism for exception handling
@@ -2320,6 +2334,20 @@ documentation for the [`'warning'` event][process_warning] and the
 [`emitWarning()` method][process_emit_warning] for more information about this
 flag's behavior.
 
+## `process.uncaughtExceptionMonitor`
+<!-- YAML
+added: REPLACEME
+-->
+
+This symbol shall be used to install a listener for only monitoring
+`'uncaughtException'` events. Listeners installed using this symbol are called
+before the regular `'uncaughtException'` listeners and before a hook
+installed via [`process.setUncaughtExceptionCaptureCallback()`][].
+
+Installing a listener using this symbol does not change the behavior once an
+`'uncaughtException'` event is emitted, therefore the process will still crash
+if no regular `'uncaughtException'` listener is installed.
+
 ## `process.umask([mask])`
 <!-- YAML
 added: v0.1.19

lib/internal/bootstrap/node.js

@@ -206,7 +206,8 @@ ObjectDefineProperty(process, 'features', {
   const {
     onGlobalUncaughtException,
     setUncaughtExceptionCaptureCallback,
-    hasUncaughtExceptionCaptureCallback
+    hasUncaughtExceptionCaptureCallback,
+    kUncaughtExceptionMonitor
   } = require('internal/process/execution');
 
   // For legacy reasons this is still called `_fatalException`, even
@@ -220,6 +221,12 @@ ObjectDefineProperty(process, 'features', {
     setUncaughtExceptionCaptureCallback;
   process.hasUncaughtExceptionCaptureCallback =
     hasUncaughtExceptionCaptureCallback;
+  ObjectDefineProperty(process, 'uncaughtExceptionMonitor', {
+    value: kUncaughtExceptionMonitor,
+    writable: false,
+    configurable: true,
+    enumerable: true
+  });
 }
 
 const { emitWarning } = require('internal/process/warning');

lib/internal/process/execution.js

@@ -3,6 +3,7 @@
 const {
   JSONStringify,
   PromiseResolve,
+  Symbol,
 } = primordials;
 
 const path = require('path');
@@ -27,6 +28,8 @@ const {
 // communication with JS.
 const { shouldAbortOnUncaughtToggle } = internalBinding('util');
 
+const kUncaughtExceptionMonitor = Symbol('process.uncaughtExceptionMonitor');
+
 function tryGetCwd() {
   try {
     return process.cwd();
@@ -159,6 +162,7 @@ function createOnGlobalUncaughtException() {
     }
 
     const type = fromPromise ? 'unhandledRejection' : 'uncaughtException';
+    process.emit(kUncaughtExceptionMonitor, er, type);
     if (exceptionHandlerState.captureFn !== null) {
       exceptionHandlerState.captureFn(er);
     } else if (!process.emit('uncaughtException', er, type)) {
@@ -214,5 +218,6 @@ module.exports = {
   evalScript,
   onGlobalUncaughtException: createOnGlobalUncaughtException(),
   setUncaughtExceptionCaptureCallback,
-  hasUncaughtExceptionCaptureCallback
+  hasUncaughtExceptionCaptureCallback,
+  kUncaughtExceptionMonitor
 };

test/fixtures/uncaught-exceptions/uncaught-monitor.js

@@ -0,0 +1,7 @@
+'use strict';
+
+process.on(process.uncaughtExceptionMonitor, (err) => {
+	console.log(`Monitored: ${err.message}`);
+});
+
+throw new Error('Shall exit');

test/parallel/test-process-uncaught-exception-monitor.js

@@ -0,0 +1,49 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+const { execFile } = require('child_process');
+const fixtures = require('../common/fixtures');
+
+{
+  // Verify exit behavior is unchanged
+  const fixture = fixtures.path('uncaught-exceptions', 'uncaught-monitor.js');
+  execFile(
+    process.execPath,
+    [fixture],
+    common.mustCall((err, stdout, stderr) => {
+      assert.strictEqual(err.code, 1);
+      assert.strictEqual(Object.getPrototypeOf(err).name, 'Error');
+      assert.strictEqual(stdout, 'Monitored: Shall exit\n');
+      const errLines = stderr.trim().split(/[\r\n]+/);
+      const errLine = errLines.find((l) => /^Error/.exec(l));
+      assert.strictEqual(errLine, 'Error: Shall exit');
+    })
+  );
+}
+
+const theErr = new Error('MyError');
+
+process.on(
+  process.uncaughtExceptionMonitor,
+  common.mustCall((err, origin) => {
+    assert.strictEqual(err, theErr);
+    assert.strictEqual(origin, 'uncaughtException');
+  }, 2)
+);
+
+process.on('uncaughtException', common.mustCall((err, origin) => {
+  assert.strictEqual(origin, 'uncaughtException');
+  assert.strictEqual(err, theErr);
+}));
+
+process.nextTick(common.mustCall(() => {
+  // Test with uncaughtExceptionCaptureCallback installed
+  process.setUncaughtExceptionCaptureCallback(common.mustCall(
+    (err) => assert.strictEqual(err, theErr))
+  );
+
+  throw theErr;
+}));
+
+throw theErr;