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/parallel/test-process-uncaught-exception-monitor.js

@@ -0,0 +1,35 @@
+'use strict';
+
+const common = require('../common');
+const assert = require('assert');
+
+const theErr = new Error('MyError');
+
+process.on(
+  process.uncaughtExceptionMonitor,
+  common.mustCall(function onUncaughtExceptionMonitor(err, origin) {
+    assert.strictEqual(err, theErr);
+    assert.strictEqual(origin, 'uncaughtException');
+  }, 2)
+);
+
+process.on('uncaughtException', common.mustCall(
+  function onUncaughtException(err, origin) {
+    assert.strictEqual(origin, 'uncaughtException');
+    assert.strictEqual(err, theErr);
+  })
+);
+
+process.nextTick(common.mustCall(
+  function withExceptionCaptureCallback() {
+    process.setUncaughtExceptionCaptureCallback(common.mustCall(
+      function uncaughtExceptionCaptureCallback(err) {
+        assert.strictEqual(err, theErr);
+      })
+    );
+
+    throw theErr;
+  })
+);
+
+throw theErr;