Skip to content
Run some code when the process exits
Branch: master
Clone or download
Pull request Compare This branch is 72 commits ahead, 12 commits behind sindresorhus:master.
Type Name Latest commit message Commit time
Failed to load latest commit information.
test test: fix node 4 tests Aug 3, 2017
.editorconfig init Aug 31, 2014
.gitattributes init Aug 31, 2014
.gitignore chore: update dependencies, lint with xo Oct 13, 2016
.jshintrc init Aug 31, 2014
.travis.yml Add node 8 to Travis builds Aug 1, 2017 chore(release): 2.0.1 Aug 3, 2017
index.js style: upgrade to new xo style Aug 3, 2017
license init Aug 31, 2014
package-lock.json chore(release): 2.0.1 Aug 3, 2017
package.json chore(release): 2.0.1 Aug 3, 2017 docs(README): fix syntax error in example (#6) Apr 17, 2018


Build Status Coverage Status

Run some code when the process exits

The process.on('exit') event doesn't catch all the ways a process can exit. This module catches:

  • process SIGINT, SIGTERM and SIGHUP, SIGBREAK signals
  • process beforeExit and exit events
  • PM2 clustering process shutdown message (PM2 graceful reload)

Useful for cleaning up. You can also include async handlers, and add custom events to hook and exit on.

Forked and pretty much rewritten from exit-hook.


$ npm install --save async-exit-hook


Considerations and warning

On process.exit() and asynchronous code

If you use asynchronous exit hooks, DO NOT use process.exit() to exit. The exit event DOES NOT support asynchronous code.

['beforeExit' is not emitted for conditions causing explicit termination, such as process.exit()] (

Windows and process.kill(signal)

On windows process.kill(signal) immediately kills the process, and does not fire signal events, and as such, cannot be used to gracefully exit. See Clustering and child processes for a workaround when killing child processes. I'm planning to support gracefully exiting with async support on windows soon.

Clustering and child processes

If you use custom clustering / child processes, you can gracefully shutdown your child process by sending a shutdown message (childProc.send('shutdown')).


const exitHook = require('async-exit-hook');

exitHook(() => {

// you can add multiple hooks, even across files
exitHook(() => {
    console.log('exiting 2');

// you can add async hooks by accepting a callback
exitHook(callback => {
    setTimeout(() => {
        console.log('exiting 3');
    }, 1000);

// You can hook uncaught errors with uncaughtExceptionHandler(), consequently adding 
// async support to uncaught errors (normally uncaught errors result in a synchronous exit).
exitHook.uncaughtExceptionHandler(err => {

// You can hook unhandled rejections with unhandledRejectionHandler()
exitHook.unhandledRejectionHandler(err => {

// You can add multiple uncaught error handlers
// Add the second parameter (callback) to indicate async hooks
exitHook.uncaughtExceptionHandler((err, callback) => {
    sendErrorToCloudOrWhatever(err) // Returns promise
        .then(() => {
console.log('Sent err to cloud');
        .catch(sendError => {
console.error('Error sending to cloud: ', err.stack);
        .then(() => callback);

// Add exit hooks for a signal or custom message:

// Custom signal
// Arguments are `signal, exitCode` (SIGBREAK is already handled, this is an example)
exitHook.hookEvent('SIGBREAK', 21);

// process event: `message` with a filter
// filter gets all arguments passed to *handler*: `process.on(message, *handler*)`
// Exits on process event `message` with msg `customShutdownMessage` only
exitHook.hookEvent('message', 0, msg => msg !== 'customShutdownMessage');

// All async hooks will work with uncaught errors when you have specified an uncaughtExceptionHandler
throw new Error('awesome');

//=> // Sync uncaughtExcpetion hooks called and retun
//=> '[Error: awesome]'
//=> // Sync hooks called and retun
//=> 'exiting'
//=> 'exiting 2'
//=> // Async uncaughtException hooks return
//=> 'Sent error to cloud'
//=> // Sync uncaughtException hooks return
//=> 'exiting 3'


MIT © Tapani Moilanen
MIT © Sindre Sorhus

You can’t perform that action at this time.