doing a cleanup action just before node.js exits


I want to tell node.js to always do something just before it exits, for whatever reason - Ctrl+C, exception, or any other reason.

I tried this:

process.on('exit', function (){

Started the process, killed it, and nothing happened; started again, pressed Ctrl+C, and still nothing happened...

Problem courtesy of: Erel Segal-Halevi



You can register a handler for process.on('exit') and in any other case(SIGINT or unhandled exception) to call process.exit()

process.stdin.resume();//so the program will not close instantly

function exitHandler(options, err) {
    if (options.cleanup) console.log('clean');
    if (err) console.log(err.stack);
    if (options.exit) process.exit();

//do something when app is closing
process.on('exit', exitHandler.bind(null,{cleanup:true}));

//catches ctrl+c event
process.on('SIGINT', exitHandler.bind(null, {exit:true}));

//catches uncaught exceptions
process.on('uncaughtException', exitHandler.bind(null, {exit:true}));
Solution courtesy of: Emil Condrea


"exit" is an event that gets triggered when node finish it's event loop internally, it's not triggered when you terminate the process externally.

What you're looking for is executing something on a SIGINT.

The docs at give an example:

Example of listening for SIGINT:

// Start reading from stdin so we don't exit.

process.on('SIGINT', function () {
  console.log('Got SIGINT.  Press Control-D to exit.');

Note: this seems to interrupt the sigint and you would need to call process.exit() when you finish with your code.

Discussion courtesy of: user1278519

Just wanted to mention death package here:


var ON_DEATH = require('death')({uncaughtException: true}); //this is intentionally ugly

ON_DEATH(function(signal, err) {
  //clean up code here
Discussion courtesy of: antongorodezkiy
var fs = require('fs');

function async(callback) {
    fs.writeFile('async.txt', 'bye!', callback);

function sync()
    for (var i = 0; i < 10; i++) {}
    return true;

function killProcess()
    if (process.exitTimeoutId){

    process.exitTimeoutId = setTimeout(process.exit, 5000);
    console.log('process will exit in 5 seconds');

    async(function() {
        console.log('async op. done', arguments);

    if (sync()) {
        console.log('sync op. done');

process.on('SIGTERM', killProcess);
process.on('SIGINT', killProcess);

process.on('uncaughtException', function(e)
    console.log('[uncaughtException] app will be terminated: ', e.stack);

     * @
     * 'uncaughtException' should be used to perform synchronous cleanup before shutting down the process. 
     * It is not safe to resume normal operation after 'uncaughtException'. 
     * If you do use it, restart your application after every unhandled exception!
     * You have been warned.

console.log('App is running...');
console.log('Try to press CTRL+C or SIGNAL the process with PID: ',;

// just for testing
Discussion courtesy of: Abdullah Aydın

io.js has an exit and a beforeExit event, which do what you want.

Discussion courtesy of: Golo Roden

In the case where the process was spawned by another node process, like:

var child = spawn('gulp', ['watch'], {
    stdio: 'inherit',

And you try to kill it later, via:


This is how you handle the event [on the child]:

process.on('SIGTERM', function() {
Discussion courtesy of: Jaime Gómez

The script below allows having a single handler for all exit conditions. It uses an app specific callback function to perform custom cleanup code.


// Object to capture process exits and call app specific cleanup function

function noOp() {};

exports.Cleanup = function Cleanup(callback) {

  // attach user callback to the process event emitter
  // if no callback, it will still exit gracefully on Ctrl-C
  callback = callback || noOp;

  // do app specific cleaning before exiting
  process.on('exit', function () {

  // catch ctrl+c event and exit normally
  process.on('SIGINT', function () {

  //catch uncaught exceptions, trace, then exit normally
  process.on('uncaughtException', function(e) {
    console.log('Uncaught Exception...');

This code intercepts uncaught exceptions, Ctrl-C and normal exit events. It then calls a single optional user cleanup callback function before exiting, handling all exit conditions with a single object.

The module simply extends the process object instead of defining another event emitter. Without an app specific callback the cleanup defaults to a no op function. This was sufficient for my use where child processes were left running when exiting by Ctrl-C.

You can easily add other exit events such as SIGHUP as desired. Note: per NodeJS manual, SIGKILL cannot have a listener. The test code below demonstrates various ways of using cleanup.js

// test cleanup.js on version 0.10.21

// loads module and registers app specific cleanup callback...
var cleanup = require('./cleanup').Cleanup(myCleanup);
//var cleanup = require('./cleanup').Cleanup(); // will call noOp

// defines app specific callback...
function myCleanup() {
  console.log('App specific cleanup code...');

// All of the following code is only needed for test demo

// Prevents the program from closing instantly

// Emits an uncaught exception when called because module does not exist
function error() {
  var x = require('');

// Try each of the following one at a time:

// Uncomment the next line to test exiting on an uncaught exception

// Uncomment the next line to test exiting normally
//setTimeout(function(){process.exit(3)}, 2000);

// Type Ctrl-C to test forced exit 
Discussion courtesy of: CanyonCasa

This recipe can be found in it's original form on Stack Over Flow.