Add exitOn option

Author: ehmicky

README.md

@@ -39,6 +39,7 @@ logProcessErrors(options)
 - [`getMessage` `{function}`](#log-message)
 - [`colors` `{boolean}`](#log-message) (default: `false`)
 - [`skipEvent` `{function}`](#skipping-events)
+- [`exitOn` `{string[]}`](#process-exit) (default: `['uncaughtException']`)
 
 `logProcessErrors()` should be called as early as possible in the code.
 
@@ -56,6 +57,19 @@ the
 [`NODE_NO_WARNINGS=1`](https://nodejs.org/api/cli.html#cli_node_no_warnings_1)
 environment variable to prevent warnings being logged twice.
 
+# Process exit
+
+The `exitOn` option specifies which event should trigger `process.exit(1)`:
+
+- the default value is `['uncaughtException']`. Exiting is the default
+  behavior of Node.js. It's also recommended by the
+  [official documentation](https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly).
+- we recommend using `exitOn: ['uncaughtException', 'unhandledRejection']`
+  instead since this will be the [future default behavior of Node.js](https://nodejs.org/dist/latest-v8.x/docs/api/deprecations.html#deprecations_dep0018_unhandled_promise_rejections)
+- to prevent any `process.exit()`, use `exitOn: []`
+
+`process.exit(1)` will only be fired after successfully logging the event.
+
 # Custom logging
 
 By default events will be logged to the console (e.g. `console.error()`).
@@ -171,12 +185,6 @@ The following properties are also defined with the `getMessage` option:
 - `colors` `{object}`: [Chalk instance](https://github.com/chalk/chalk#api)
   to colorize strings (disabled if the option `colors` is `false`)
 
-# Uncaught exceptions
-
-`uncaughtException` events will fire `process.exit(1)` after being successfully
-logged. Exiting is the default behavior and is recommended by the
-[Node.js documentation](https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly).
-
 # Stop logging
 
 Logging can be stopped by firing the function returned by `logProcessErrors()`

src/default.js

@@ -10,6 +10,7 @@ const DEFAULT_OPTS = {
   getMessage: defaultGetMessage,
   log: defaultLog,
   colors: true,
+  exitOn: ['uncaughtException'],
 }
 
 module.exports = {

src/exit.js

@@ -0,0 +1,28 @@
+'use strict'
+
+const { exit } = require('process')
+const { promisify } = require('util')
+
+// Exit process according to `opts.exitOn` (default: ['uncaughtException']):
+//  - `uncaughtException`: default behavior of Node.js and recommended by https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly
+//  - `unhandledRejection`: possible future behavior and recommended by Node.js.
+//    See https://nodejs.org/dist/latest-v8.x/docs/api/deprecations.html#deprecations_dep0018_unhandled_promise_rejections
+// By default `unhandledRejection` is opt-in so that using this library does not
+// decrease stability (if the application does not restart on exit).
+const exitProcess = async function({ eventName, opts: { exitOn } }) {
+  if (!exitOn.includes(eventName)) {
+    return
+  }
+
+  // This is only needed as a safety measure
+  await promisify(setTimeout)(EXIT_TIMEOUT)
+
+  exit(EXIT_STATUS)
+}
+
+const EXIT_TIMEOUT = 3e3
+const EXIT_STATUS = 1
+
+module.exports = {
+  exitProcess,
+}

src/handle.js

@@ -1,12 +1,10 @@
 'use strict'
 
-const { exit } = require('process')
-const { promisify } = require('util')
-
 const { getInfo } = require('./info')
 const { getColors } = require('./colors')
 const { getLevel } = require('./level')
 const { getMessage } = require('./message')
+const { exitProcess } = require('./exit')
 
 // Generic event handler for all events.
 const handleEvent = async function({
@@ -35,32 +33,16 @@ const handleEvent = async function({
   const level = getLevel({ opts, info })
   const message = getMessage({ opts, info, level, colors })
 
-  // We need to `await` it in case we are logging an `uncaughtException` which
-  // will make the process exit.
+  // We need to `await` it in case `opts.exitOn` exits the process.
   // Without `await` Node.js would still wait until most async tasks (including
   // stream draining for logging libraries like Winston) have completed.
   // But there are some cases where it will not. In those cases, `opts.log()`
   // should be either synchronous or return a promise.
   await opts.log(message, level, info)
 
-  await exitProcess({ eventName })
-}
-
-// Exit process on `uncaughtException`
-// See https://nodejs.org/api/process.html#process_warning_using_uncaughtexception_correctly
-const exitProcess = async function({ eventName }) {
-  if (eventName !== 'uncaughtException') {
-    return
-  }
-
-  // This is only needed as a safety measure
-  await promisify(setTimeout)(EXIT_TIMEOUT)
-
-  exit(1)
+  await exitProcess({ eventName, opts })
 }
 
-const EXIT_TIMEOUT = 3e3
-
 module.exports = {
   handleEvent,
 }