Every robust logging system consists of three key components: a Collector, a Storage, and a Visualizer. Popular Node.js logging modules like Winston and Pino function solely as log collectors. Errsole, however, offers a complete logging solution that includes:

Log Storage: Save logs in a file or your application’s database.
Built-in Dashboard: View, filter, and search logs using the built-in dashboard.
Alerts: Receive real-time notifications for critical errors.

Installing Errsole and its dependencies

To use Errsole, you need to install the Errsole module along with a storage module based on your chosen database. Here are the installation steps for different storage options:

File Storage:

npm install errsole errsole-sqlite

MongoDB:

npm install errsole errsole-mongodb

MySQL:

npm install errsole errsole-mysql

PostgreSQL:

npm install errsole errsole-postgres

Creating a Custom Logger File

In a real-life Node.js project, you will have multiple files. To use the Errsole Logger in every file of your project, create a logger.js file and initialize Errsole in it:

const errsole = require('errsole');
const ErrsoleSQLite = require('errsole-sqlite');

errsole.initialize({
  storage: new ErrsoleSQLite('/tmp/logs.sqlite')
});

module.exports = errsole;

Now, you can import the logger.js file in every file in your project and use it to log:

const logger = require('./logger');

// Example usage
logger.info('This is an informational message.');
logger.error('This is an error message.');

Understanding Log Levels in Errsole

Errsole Logger functions take the same arguments as console.log. You can provide one or more strings, objects, or variables separated by a comma. Additionally, you can attach metadata to your log messages using the meta function. This metadata can be any contextual information, such as HTTP requests or database query results.

logger.meta({ reqBody: req.body, queryResults: results }).error(err);
logger.meta({ email: req.body.email }).log('User logged in');

Errsole Logger provides functions for five log levels: alert, error, warn, info, and debug.

log / info: Use to log messages or information.

logger.log('Logging a message');
logger.log('Multiple', 'arguments', 'are supported');
logger.log('Logging with a variable:', var1);
logger.log(new Error('An error occurred'));
logger.log('Logging with an error object:', errorObject);

alert: Logs a message and sends a notification to configured channels, such as Email or Slack.

logger.alert('Alert! Something critical happened');

error: Specifically designed to log errors.

logger.error(new Error('An error occurred'));

warn: Logs warning messages.

logger.warn('This is a warning message');

debug: Logs debug information, typically used for troubleshooting during development.

logger.debug('Debugging information');

When to use `logger.alert` in your code

Whenever your Node.js application crashes, Errsole sends a real-time notification to your development team. This notification includes the error message, the app name, the environment name, and the server name.

To add critical errors to this notification list, use logger.alert in your code. However, avoid overusing it to prevent flooding your developers with notifications. Use it for critical errors like payment failures or database query failures. Put the error object in the alert function and add all contextual information in the meta function. This allows developers to easily debug critical errors.

logger.meta({ reqBody: req.body, queryResults: results }).alert(err);

Conclusion

Incorporating a complete logging solution into your Node.js application ensures robust log management and efficient debugging. Errsole provides log storage, a built-in dashboard, and real-time notifications, making it a complete logging tool.

To get started with Errsole, visit https://github.com/errsole/errsole.js.

Creating a Custom Logger for a Node.js Application using Errsole