Forem: errsole

How to set up a Node.js Log Viewer: a step-by-step guide

Venki — Tue, 08 Apr 2025 13:24:28 +0000

Errsole is an open-source logging library for Node.js applications. It comes with a built-in log viewer to view, filter, and search your application logs. If you are SSHing into servers or scrolling through raw log files to find errors or debug logs, Errsole simplifies the process for you.

Quick Setup

This guide sets up Errsole with SQLite. SQLite stores data in a file, so your logs will be saved directly on your server—ideal for quick and simple setups.

Note: Errsole supports multiple storage options for centralized logging. Explore all available options here.

1. Install the required modules

Run the following command to install Errsole and the SQLite storage module in your Node.js project:

npm install errsole errsole-sqlite

2. Configure the logger

Create a separate logger.js file to initialize and export the Errsole logger, so that you can use it across your project:

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

const logFile = path.join(os.tmpdir(), 'your-app-name.log.sqlite');
errsole.initialize({
  storage: new ErrsoleSQLite(logFile),
  appName: 'your-app-name'
});

module.exports = errsole;

Note: Replace your-app-name with the actual name of your app.

Now, you can include this logger in any file using:

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

3. Use the logger in your application code

To start logging, include the logger in your application code. Here is an example using Express:

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

const app = express();

app.get('/', (req, res) => {
  res.send('Hello World!');
});

const port = 3000;
app.listen(port, () => {
  errsole.log(`Hello World app is listening on port ${port}`);
});

Accessing the Log Viewer

After completing the setup, start your application and access the log viewer to view and manage your logs:

For Local Development
Visit http://localhost:8001/

For Remote Servers
Replace with your server IP or domain:
http://your-server-ip:8001/
http://your-domain:8001/

Optional: NGINX Configuration

If your application is behind NGINX, you can configure access to the log viewer by adding the following lines to your NGINX configuration file:

location = /your-app-name/logs {
  return 301 /your-app-name/logs/;
}
location /your-app-name/logs/ {
  proxy_pass http://localhost:8001/;
  proxy_http_version 1.1;
  proxy_set_header Upgrade $http_upgrade;
  proxy_set_header Connection "upgrade";
}

Note: Replace /your-app-name/logs and /your-app-name/logs/ with the desired URL path where you want the log viewer to be accessible.

After updating the configuration, reload NGINX to apply the changes:

sudo nginx -s reload

You can now access the log viewer through your domain:

For server IP access: http://your-server-ip/your-app-name/logs/
For domain access (HTTP): http://your-domain/your-app-name/logs/
For domain access (HTTPS): https://your-domain/your-app-name/logs/

Note: Replace /your-app-name/logs/ in the URLs above to match the path you configured in NGINX.

Conclusion

Errsole provides a fast and easy way to log and view errors in real time. While this guide uses SQLite for local logging, production environments can benefit from centralized logging using other supported storage backends.

Explore the full documentation here: https://github.com/errsole/errsole.js

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

Venki — Fri, 23 Aug 2024 13:25:34 +0000

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.

A new Node.js logger that does more than Winston and Pino

Venki — Fri, 07 Jun 2024 11:08:26 +0000

Popular Node.js loggers like Winston, Pino, and Bunyan are good for collecting logs, but that's pretty much all they do. They don't come with any built-in tools to visualize or search through the logs. Because of this, developers often need to set up Elastic Stack on dedicated servers or pay for a service to handle log storage and visualization.

From what I have gathered in conversations with many developers, a lot of them are just streaming logs to files. When an error occurs, they manually download and search through these logs to find the issue.

We have converted key features of Errsole Cloud to open source and released them under the MIT license.

Our Motive

Complete Logger: A single module should collect and store logs, as well as provide a web dashboard for viewing and searching the logs.
Easy Setup: The module should be easy to set up, without requiring dedicated servers or the installation of third-party software.

Features

Easy Setup: Just install and configure the module. That's it! Errsole handles the collection, storage, and visualization of logs within the module itself. No additional software installations or dedicated servers are required.

Complete Logger: One of the main issues with loggers like Winston and Pino is that they do not capture default console logs. When errors occur in dependency modules, these modules use console.error or console.warn to log the issues. Winston and Pino miss these logs entirely. To address this, we have decided to capture default console logs in addition to providing a custom logger with multiple log levels in Errsole.

Real-time Notifications: One of the essential features that developers often miss is receiving alerts for app crashes and critical errors. Typically, developers need to use a paid service for this, but it is a crucial requirement. To address this need, we have decided to add this feature to our open-source project. When an app crashes or encounters a critical error, Errsole Open Source will send a notification to developers via Email or Slack. This notification will include the error message, the app name, the environment, and the server name.

youtube.com

Conclusion

Errsole aims to provide a complete logging tool for Node.js applications, addressing the limitations of existing loggers and making it easier for developers to monitor and maintain their applications. Try Errsole and see how it can enhance your logging and monitoring workflow. We would love to hear your feedback!

https://github.com/errsole/errsole.js

Forem: errsole

How to set up a Node.js Log Viewer: a step-by-step guide

Quick Setup

1. Install the required modules

2. Configure the logger

3. Use the logger in your application code

Accessing the Log Viewer

Optional: NGINX Configuration

Conclusion

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

Installing Errsole and its dependencies

File Storage:

MongoDB:

MySQL:

PostgreSQL:

Creating a Custom Logger File

Understanding Log Levels in Errsole

When to use logger.alert in your code

Conclusion

A new Node.js logger that does more than Winston and Pino

Our Motive

Features

Conclusion

When to use `logger.alert` in your code