From 9039128251189fa2d4d6834ed7a48c1ad5ea54a7 Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Wed, 8 Jan 2020 10:22:00 +0100
Subject: [PATCH 01/10] process: allow monitoring uncaughtException

Installing an uncaughtException listener has a side effect that process
is not aborted. This is quite bad for monitoring/logging tools which
tend to be interested in errors but don't want to cause side effects
like swallow an exception or change the output on console.

There are some workarounds in the wild like monkey patching emit or
rethrow in the exception if monitoring tool detects that it is the only
listener but this is error prone and risky.

This PR allows to install a listener to monitor uncaughtException
without the side effect to consider the exception has handled. To avoid
conflicts with other events it exports a symbol on process which owns
this special meaning.
---
 doc/api/process.md                            | 28 +++++++++++++++
 lib/internal/bootstrap/node.js                |  9 ++++-
 lib/internal/process/execution.js             |  7 +++-
 ...test-process-uncaught-exception-monitor.js | 35 +++++++++++++++++++
 4 files changed, 77 insertions(+), 2 deletions(-)
 create mode 100644 test/parallel/test-process-uncaught-exception-monitor.js

diff --git a/doc/api/process.md b/doc/api/process.md
index a8ca1a641e85e1..60c94ceeff5fcb 100644
--- a/doc/api/process.md
+++ b/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
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index bb9a2b177c4304..5ac4773f3e65a5 100644
--- a/lib/internal/bootstrap/node.js
+++ b/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');
diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index d9567e643d7c85..6af688e8ccbc40 100644
--- a/lib/internal/process/execution.js
+++ b/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
 };
diff --git a/test/parallel/test-process-uncaught-exception-monitor.js b/test/parallel/test-process-uncaught-exception-monitor.js
new file mode 100644
index 00000000000000..c0fd56e7b0f7e0
--- /dev/null
+++ b/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;

From df03daaff4a346958fb884378080ba345c514fa0 Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Wed, 8 Jan 2020 12:40:50 +0100
Subject: [PATCH 02/10] fixup! crlf => lf

---
 ...test-process-uncaught-exception-monitor.js | 70 +++++++++----------
 1 file changed, 35 insertions(+), 35 deletions(-)

diff --git a/test/parallel/test-process-uncaught-exception-monitor.js b/test/parallel/test-process-uncaught-exception-monitor.js
index c0fd56e7b0f7e0..56c7eb35eb916b 100644
--- a/test/parallel/test-process-uncaught-exception-monitor.js
+++ b/test/parallel/test-process-uncaught-exception-monitor.js
@@ -1,35 +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;
+'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;

From b58dd7c8a7157794edacdd3a87ad67c6fade7943 Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Wed, 8 Jan 2020 13:22:58 +0100
Subject: [PATCH 03/10] use arrow functions

---
 ...test-process-uncaught-exception-monitor.js | 29 ++++++++-----------
 1 file changed, 12 insertions(+), 17 deletions(-)

diff --git a/test/parallel/test-process-uncaught-exception-monitor.js b/test/parallel/test-process-uncaught-exception-monitor.js
index 56c7eb35eb916b..d1a4d3571e569e 100644
--- a/test/parallel/test-process-uncaught-exception-monitor.js
+++ b/test/parallel/test-process-uncaught-exception-monitor.js
@@ -7,29 +7,24 @@ const theErr = new Error('MyError');
 
 process.on(
   process.uncaughtExceptionMonitor,
-  common.mustCall(function onUncaughtExceptionMonitor(err, origin) {
+  common.mustCall((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.on('uncaughtException', common.mustCall((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);
-      })
-    );
+// Test with uncaughtExceptionCaptureCallback installed
+process.nextTick(common.mustCall(() => {
+  process.setUncaughtExceptionCaptureCallback(common.mustCall(
+    (err) => assert.strictEqual(err, theErr))
+  );
 
-    throw theErr;
-  })
-);
+  throw theErr;
+}));
 
 throw theErr;

From 6f536956bc081de5ac017fb2ea3a180c86ed9ee3 Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Wed, 8 Jan 2020 13:59:32 +0100
Subject: [PATCH 04/10] add test to verify default exit behavior is unchanged

---
 .../uncaught-exceptions/uncaught-monitor.js   |  7 +++++++
 ...test-process-uncaught-exception-monitor.js | 21 ++++++++++++++++++-
 2 files changed, 27 insertions(+), 1 deletion(-)
 create mode 100644 test/fixtures/uncaught-exceptions/uncaught-monitor.js

diff --git a/test/fixtures/uncaught-exceptions/uncaught-monitor.js b/test/fixtures/uncaught-exceptions/uncaught-monitor.js
new file mode 100644
index 00000000000000..c2b454907ce521
--- /dev/null
+++ b/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');
diff --git a/test/parallel/test-process-uncaught-exception-monitor.js b/test/parallel/test-process-uncaught-exception-monitor.js
index d1a4d3571e569e..c5d599e960bc8f 100644
--- a/test/parallel/test-process-uncaught-exception-monitor.js
+++ b/test/parallel/test-process-uncaught-exception-monitor.js
@@ -2,6 +2,25 @@
 
 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');
 
@@ -18,8 +37,8 @@ process.on('uncaughtException', common.mustCall((err, origin) => {
   assert.strictEqual(err, theErr);
 }));
 
-// Test with uncaughtExceptionCaptureCallback installed
 process.nextTick(common.mustCall(() => {
+  // Test with uncaughtExceptionCaptureCallback installed
   process.setUncaughtExceptionCaptureCallback(common.mustCall(
     (err) => assert.strictEqual(err, theErr))
   );

From acee3de9411d75c3f24354e687458292c07c05f1 Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Wed, 8 Jan 2020 14:08:54 +0100
Subject: [PATCH 05/10] fixup! improve fixture

---
 test/fixtures/uncaught-exceptions/uncaught-monitor.js | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/test/fixtures/uncaught-exceptions/uncaught-monitor.js b/test/fixtures/uncaught-exceptions/uncaught-monitor.js
index c2b454907ce521..46df8e90fb6976 100644
--- a/test/fixtures/uncaught-exceptions/uncaught-monitor.js
+++ b/test/fixtures/uncaught-exceptions/uncaught-monitor.js
@@ -1,7 +1,10 @@
 'use strict';
 
+// Keep the event loop alive.
+setTimeout(() => {}, 1e6);
+
 process.on(process.uncaughtExceptionMonitor, (err) => {
-	console.log(`Monitored: ${err.message}`);
+  console.log(`Monitored: ${err.message}`);
 });
 
 throw new Error('Shall exit');

From 5daab4d8b5077acdec562cc1c6fbebf4c250bcda Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Fri, 10 Jan 2020 09:09:09 +0100
Subject: [PATCH 06/10] replace symbol uncaughtExceptionMonitor by a string

---
 doc/api/process.md                            | 56 ++++++++++---------
 lib/internal/bootstrap/node.js                |  9 +--
 lib/internal/process/execution.js             |  8 +--
 .../uncaught-exceptions/uncaught-monitor.js   |  2 +-
 ...test-process-uncaught-exception-monitor.js |  2 +-
 5 files changed, 35 insertions(+), 42 deletions(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index 60c94ceeff5fcb..a379455b20f322 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -263,18 +263,8 @@ 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
-```
+default behavior to exit the process by installing a
+`'uncaughtExceptionMonitor'` listener.
 
 #### Warning: Using `'uncaughtException'` correctly
 
@@ -303,6 +293,34 @@ To restart a crashed application in a more reliable way, whether
 in a separate process to detect application failures and recover or restart as
 needed.
 
+### Event: `'uncaughtExceptionMonitor'`
+<!-- YAML
+added: REPLACEME
+-->
+
+* `err` {Error} The uncaught exception.
+* `origin` {string} Indicates if the exception originates from an unhandled
+  rejection or from synchronous errors. Can either be `'uncaughtException'` or
+  `'unhandledRejection'`.
+
+The `'uncaughtExceptionMonitor'` event is emitted before an
+`'uncaughtException'` event is emitted or a hook installed via
+[`process.setUncaughtExceptionCaptureCallback()`][] is called.
+
+Installing a `'uncaughtExceptionMonitor'` listener does not change the behavior
+once an `'uncaughtException'` event is emitted, therefore the process will
+still crash if no regular `'uncaughtException'` listener is installed.
+
+```js
+process.on('uncaughtExceptionMonitor', (err, origin) => {
+  MyMonitoringTool.logSync(err, origin);
+});
+
+// Intentionally cause an exception, but don't catch it.
+nonexistentFunc();
+// Still crashes Node.js
+```
+
 ### Event: `'unhandledRejection'`
 <!-- YAML
 added: v1.4.1
@@ -2334,20 +2352,6 @@ 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
diff --git a/lib/internal/bootstrap/node.js b/lib/internal/bootstrap/node.js
index 5ac4773f3e65a5..bb9a2b177c4304 100644
--- a/lib/internal/bootstrap/node.js
+++ b/lib/internal/bootstrap/node.js
@@ -206,8 +206,7 @@ ObjectDefineProperty(process, 'features', {
   const {
     onGlobalUncaughtException,
     setUncaughtExceptionCaptureCallback,
-    hasUncaughtExceptionCaptureCallback,
-    kUncaughtExceptionMonitor
+    hasUncaughtExceptionCaptureCallback
   } = require('internal/process/execution');
 
   // For legacy reasons this is still called `_fatalException`, even
@@ -221,12 +220,6 @@ ObjectDefineProperty(process, 'features', {
     setUncaughtExceptionCaptureCallback;
   process.hasUncaughtExceptionCaptureCallback =
     hasUncaughtExceptionCaptureCallback;
-  ObjectDefineProperty(process, 'uncaughtExceptionMonitor', {
-    value: kUncaughtExceptionMonitor,
-    writable: false,
-    configurable: true,
-    enumerable: true
-  });
 }
 
 const { emitWarning } = require('internal/process/warning');
diff --git a/lib/internal/process/execution.js b/lib/internal/process/execution.js
index 6af688e8ccbc40..a6d6d2325a7f79 100644
--- a/lib/internal/process/execution.js
+++ b/lib/internal/process/execution.js
@@ -3,7 +3,6 @@
 const {
   JSONStringify,
   PromiseResolve,
-  Symbol,
 } = primordials;
 
 const path = require('path');
@@ -28,8 +27,6 @@ const {
 // communication with JS.
 const { shouldAbortOnUncaughtToggle } = internalBinding('util');
 
-const kUncaughtExceptionMonitor = Symbol('process.uncaughtExceptionMonitor');
-
 function tryGetCwd() {
   try {
     return process.cwd();
@@ -162,7 +159,7 @@ function createOnGlobalUncaughtException() {
     }
 
     const type = fromPromise ? 'unhandledRejection' : 'uncaughtException';
-    process.emit(kUncaughtExceptionMonitor, er, type);
+    process.emit('uncaughtExceptionMonitor', er, type);
     if (exceptionHandlerState.captureFn !== null) {
       exceptionHandlerState.captureFn(er);
     } else if (!process.emit('uncaughtException', er, type)) {
@@ -218,6 +215,5 @@ module.exports = {
   evalScript,
   onGlobalUncaughtException: createOnGlobalUncaughtException(),
   setUncaughtExceptionCaptureCallback,
-  hasUncaughtExceptionCaptureCallback,
-  kUncaughtExceptionMonitor
+  hasUncaughtExceptionCaptureCallback
 };
diff --git a/test/fixtures/uncaught-exceptions/uncaught-monitor.js b/test/fixtures/uncaught-exceptions/uncaught-monitor.js
index 46df8e90fb6976..9724539a253bc1 100644
--- a/test/fixtures/uncaught-exceptions/uncaught-monitor.js
+++ b/test/fixtures/uncaught-exceptions/uncaught-monitor.js
@@ -3,7 +3,7 @@
 // Keep the event loop alive.
 setTimeout(() => {}, 1e6);
 
-process.on(process.uncaughtExceptionMonitor, (err) => {
+process.on('uncaughtExceptionMonitor', (err) => {
   console.log(`Monitored: ${err.message}`);
 });
 
diff --git a/test/parallel/test-process-uncaught-exception-monitor.js b/test/parallel/test-process-uncaught-exception-monitor.js
index c5d599e960bc8f..37ffe43ccae9df 100644
--- a/test/parallel/test-process-uncaught-exception-monitor.js
+++ b/test/parallel/test-process-uncaught-exception-monitor.js
@@ -25,7 +25,7 @@ const fixtures = require('../common/fixtures');
 const theErr = new Error('MyError');
 
 process.on(
-  process.uncaughtExceptionMonitor,
+  'uncaughtExceptionMonitor',
   common.mustCall((err, origin) => {
     assert.strictEqual(err, theErr);
     assert.strictEqual(origin, 'uncaughtException');

From c3b5f2d9ade48fce728dd7934a535df71cbe8048 Mon Sep 17 00:00:00 2001
From: Gerhard Stoebich <18708370+Flarna@users.noreply.github.com>
Date: Fri, 10 Jan 2020 09:24:52 +0100
Subject: [PATCH 07/10] add test to verify that throwing in monitoring listener
 results in exit code 7

---
 ...caught-monitor.js => uncaught-monitor1.js} |  0
 .../uncaught-exceptions/uncaught-monitor2.js  | 11 ++++++++++
 ...test-process-uncaught-exception-monitor.js | 22 ++++++++++++++++++-
 3 files changed, 32 insertions(+), 1 deletion(-)
 rename test/fixtures/uncaught-exceptions/{uncaught-monitor.js => uncaught-monitor1.js} (100%)
 create mode 100644 test/fixtures/uncaught-exceptions/uncaught-monitor2.js

diff --git a/test/fixtures/uncaught-exceptions/uncaught-monitor.js b/test/fixtures/uncaught-exceptions/uncaught-monitor1.js
similarity index 100%
rename from test/fixtures/uncaught-exceptions/uncaught-monitor.js
rename to test/fixtures/uncaught-exceptions/uncaught-monitor1.js
diff --git a/test/fixtures/uncaught-exceptions/uncaught-monitor2.js b/test/fixtures/uncaught-exceptions/uncaught-monitor2.js
new file mode 100644
index 00000000000000..743a5611008ba2
--- /dev/null
+++ b/test/fixtures/uncaught-exceptions/uncaught-monitor2.js
@@ -0,0 +1,11 @@
+'use strict';
+
+// Keep the event loop alive.
+setTimeout(() => {}, 1e6);
+
+process.on('uncaughtExceptionMonitor', (err) => {
+  console.log(`Monitored: ${err.message}, will throw now`);
+  missingFunction();
+});
+
+throw new Error('Shall exit');
diff --git a/test/parallel/test-process-uncaught-exception-monitor.js b/test/parallel/test-process-uncaught-exception-monitor.js
index 37ffe43ccae9df..fc6c2637f6978e 100644
--- a/test/parallel/test-process-uncaught-exception-monitor.js
+++ b/test/parallel/test-process-uncaught-exception-monitor.js
@@ -7,7 +7,7 @@ const fixtures = require('../common/fixtures');
 
 {
   // Verify exit behavior is unchanged
-  const fixture = fixtures.path('uncaught-exceptions', 'uncaught-monitor.js');
+  const fixture = fixtures.path('uncaught-exceptions', 'uncaught-monitor1.js');
   execFile(
     process.execPath,
     [fixture],
@@ -22,6 +22,26 @@ const fixtures = require('../common/fixtures');
   );
 }
 
+{
+  // Verify exit behavior is unchanged
+  const fixture = fixtures.path('uncaught-exceptions', 'uncaught-monitor2.js');
+  execFile(
+    process.execPath,
+    [fixture],
+    common.mustCall((err, stdout, stderr) => {
+      assert.strictEqual(err.code, 7);
+      assert.strictEqual(Object.getPrototypeOf(err).name, 'Error');
+      assert.strictEqual(stdout, 'Monitored: Shall exit, will throw now\n');
+      const errLines = stderr.trim().split(/[\r\n]+/);
+      const errLine = errLines.find((l) => /^ReferenceError/.exec(l));
+      assert.strictEqual(
+        errLine,
+        'ReferenceError: missingFunction is not defined'
+      );
+    })
+  );
+}
+
 const theErr = new Error('MyError');
 
 process.on(

From 9db2da69240a73c649f43ea7338b38f86bb8ee0a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gerhard=20St=C3=B6bich?=
 <18708370+Flarna@users.noreply.github.com>
Date: Fri, 10 Jan 2020 19:38:07 +0100
Subject: [PATCH 08/10] Update doc/api/process.md

Co-Authored-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/process.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index a379455b20f322..99ca7fc2de9c05 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -307,7 +307,7 @@ The `'uncaughtExceptionMonitor'` event is emitted before an
 `'uncaughtException'` event is emitted or a hook installed via
 [`process.setUncaughtExceptionCaptureCallback()`][] is called.
 
-Installing a `'uncaughtExceptionMonitor'` listener does not change the behavior
+Installing an `'uncaughtExceptionMonitor'` listener does not change the behavior
 once an `'uncaughtException'` event is emitted, therefore the process will
 still crash if no regular `'uncaughtException'` listener is installed.
 

From 42060279ccffac360ab1894bcfd32e8cf78b557c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gerhard=20St=C3=B6bich?=
 <18708370+Flarna@users.noreply.github.com>
Date: Fri, 10 Jan 2020 19:39:40 +0100
Subject: [PATCH 09/10] Update doc/api/process.md

Co-Authored-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/process.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index 99ca7fc2de9c05..f6899569946582 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -308,7 +308,7 @@ The `'uncaughtExceptionMonitor'` event is emitted before an
 [`process.setUncaughtExceptionCaptureCallback()`][] is called.
 
 Installing an `'uncaughtExceptionMonitor'` listener does not change the behavior
-once an `'uncaughtException'` event is emitted, therefore the process will
+once an `'uncaughtException'` event is emitted. The process will
 still crash if no regular `'uncaughtException'` listener is installed.
 
 ```js

From efedbb56a3bad1ceb2e7053485a1509117415055 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Gerhard=20St=C3=B6bich?=
 <18708370+Flarna@users.noreply.github.com>
Date: Fri, 10 Jan 2020 19:39:58 +0100
Subject: [PATCH 10/10] Update doc/api/process.md

Co-Authored-By: Colin Ihrig <cjihrig@gmail.com>
---
 doc/api/process.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/doc/api/process.md b/doc/api/process.md
index f6899569946582..278fee680474dc 100644
--- a/doc/api/process.md
+++ b/doc/api/process.md
@@ -309,7 +309,7 @@ The `'uncaughtExceptionMonitor'` event is emitted before an
 
 Installing an `'uncaughtExceptionMonitor'` listener does not change the behavior
 once an `'uncaughtException'` event is emitted. The process will
-still crash if no regular `'uncaughtException'` listener is installed.
+still crash if no `'uncaughtException'` listener is installed.
 
 ```js
 process.on('uncaughtExceptionMonitor', (err, origin) => {