Doing a cleanup action just before Node.js exits

In Node.js, performing cleanup operations before exit is a best practice to ensure resource release, state preservation, and other necessary cleanup tasks. Typically, this can be achieved by listening for process exit events. Here are the steps and examples for implementing this mechanism in Node.js:

Step 1: Listen for Exit Events

The process object in Node.js provides multiple hooks to listen for different types of exit events, such as exit, SIGINT, and uncaughtException. These events allow you to execute necessary cleanup logic before the process terminates.

Example Code

javascript
// Import necessary libraries  
const fs = require('fs');  
const server = require('http').createServer();  

// Server starts listening  
server.listen(3000);  

// Handling normal exit  
process.on('exit', (code) => {  
    console.log(`Exiting, exit code: ${code}`);  
    // Add cleanup code here, such as closing files or database connections  
});  

// User exits via Ctrl+C  
process.on('SIGINT', () => {  
    console.log('Received SIGINT, preparing to exit...');  
    server.close(() => {  
        console.log('Server closed');  
        process.exit(0);  
    });  
});  

// Exception handling  
process.on('uncaughtException', (err) => {  
    console.error('Uncaught exception:', err);  
    process.exit(1);  
});  

// Usage example: Simulate an error  
setTimeout(() => {  
    throw new Error('An error occurred!');  
}, 2000);  

// Save application state when needed  
function saveAppState() {  
    const state = { running: false };  
    fs.writeFileSync('./app-state.json', JSON.stringify(state));  
    console.log('Application state saved');  
}  

// Call the save state function before exit  
process.on('exit', saveAppState);  

Explanation

1. Listen for 'exit' event: Triggered when the Node.js process exits normally. Note that only synchronous code can be executed in this event.

2. Listen for 'SIGINT' event: Typically triggered when the user presses Ctrl+C. This is an asynchronous event that allows executing asynchronous operations such as closing the server or database connections.

3. Listen for 'uncaughtException': Triggered when an uncaught exception is thrown. Typically used to log error information and gracefully shut down the application.

Important Notes

• Asynchronous code cannot be executed in the exit event because the event loop stops at this point.

• Ensure all cleanup logic accounts for the asynchronous nature of the program.

• Different logic may be required for different exit reasons, such as manual user exit versus exception exit requiring distinct handling.

By implementing this approach, you can ensure Node.js applications perform cleanup operations correctly before exiting, reducing issues like resource leaks caused by abnormal process termination.