Handling Production Errors in Node.js: Best Practices and Tools

[SaiKumar2121]

Hello Node.js Community,

I'm initiating a discussion focused on the strategies and best practices for managing and handling production errors in Node.js applications. The ability to effectively manage errors in production is not only crucial for maintaining service reliability but also for ensuring a good user experience.

Topics I believe would be beneficial to cover include:

-Error Logging: What libraries or practices do you leverage for robust error logging?
-Monitoring: Which tools or services provide the best insights for Node.js applications in production?

• Graceful Error Handling: How do you ensure your application degrades gracefully in the face of errors?
• Auto-recovery: What strategies do you employ for service recovery in case of a crash?
• Error Tracking: Are there third-party services that you integrate for improved error tracking and analysis?
• Prevention: How do you proactively prevent errors from reaching production?

I would appreciate your input on these questions, along with any tools, middleware, or patterns you have found effective.

Let's share our experiences and learn from each other to improve our Node.js applications' robustness and reliability in production environments.

Thank you!

[CodeEventHorizon]

Hello,

• For error logging I have used pino and winston. I would say both are considered really good logging libraries, and both have their ups and downs, but pino is generally faster. The best practices for error logging: create a logger.js or logger.ts in utils/helpers and import it wherever you have error handling. Because we are talking about Node.js, you would probably be using it for creating APIs, so I would say, always log server error responses status 500-599. You could potentially log client error responses status 400-499 as well, in case you need to know if your front-end app is working as intended. Another useful thing would be, always include relevant information, like error message, stack trace and input data:

logger.error({
    error: error.message,
    stack: error.stack,
    inputData: inputData
})

another thing is log storage, depending on a size of your project/company. If your project is a startup, you could consider using slack webhooks or discord, to log errors to a specific channel. The downside is the lack of filtering. With that being said, there are other ways to store logs, such as AWS S3, where you can store a file of logs per day and then download it and use linux commands like grep to find something specific. You could also use AWS CloudWatch or self-managed solutions on a linux machine, such as AWS EC2 that uses ELB for storage, and I wouldn't recommend it, as there always would be a need for maintenance for growing the volume size.

• When we are talking about error logs, never forget about access logs, which are equally important and need to be stored as you can do a lot of data analysis and visualization, for instance geospatial mapping, to find out where the error could have occurred.
• There isn't such a thing as 'the best tool' for monitoring, it's really about what suits your needs, but there are tools like errsole, sentry, which are used primarily for error tracking. But there are also broader tools for log management, log aggregation and querying logs, such as: Elastic Search (Search & analytics engine), Kibana (Dashboard to visualize data), Grafana Loki (horizontally scalable, highly available, multi-tenant log aggregation system).
• For graceful error handling: use try/catch, log errors and store them, use custom error handling middleware right before where you do app.listen(port) and right after where you define your routes. Make sure error stack trace never reaches your client-side app, only friendly responses such as status 400-499 or status 500-599. Always include a useful custom message with status code responses. Use Event Emitter for event listening like so:

process.on('SIGTERM', () => {
  logger.error('Received SIGTERM signal. Exiting gracefully...');
  server.close(() => {
    logger.fatal('Server closed.');
    process.exit(1);
  });
});

process.on('unhandledRejection', (item) => {
  // logging & clean up tasks
});

process.on('uncaughtException', (item) => {
  // logging & clean up tasks
});

process.on('warning', (item) => {
  // logging
});

// etc...

write unit tests to ensure that your app behaves correctly when errors occur. Finally, always monitor errors, application health and setup alerts to be notified.

• For auto-recovery, you could use pm2 package for re-running the app in case it crashes or shuts down purposely. I believe that better solution would be containerization, by using docker and maybe even Kubernetes if your application generates enough money to sustain the use of Kubernetes and Microservices. In case of docker you can run the container like so and it will restart the app only if it exits with a non-zero exit code:

docker run --restart always -d my-node-app

or docker compose:

services:
  my-node-app:
    image: my-node-app-image
    restart: always

• As for preventing errors, I believe that if you employ the best practices, even then there's always something that can go wrong, because we aren't covered from unexpected outcomes, that's why a lot of running apps, need at least some maintenance and caressing.

Good luck! Please feel free to correct me or add something I have missed.

[WebMan2006]

Trust 👆this guy he knows what he saying 😁