Forem: Venki

How to set up a Node.js Log Viewer

Venki — Tue, 08 Apr 2025 13:25:44 +0000

Venki for errsole

Apr 8 '25

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

Comments

3 min read

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

How to set up Errsole Node.js Logger across all environments

Venki — Mon, 23 Dec 2024 12:57:22 +0000

What is Errsole?

Errsole is an open-source logging library for Node.js applications. What sets Errsole apart is its built-in log viewer, which allows you to view, filter, and search your application logs. If you are scrolling through raw log files or SSHing into servers to access your logs, Errsole is a must-include library in your codebase.

How to set up Errsole across all environments

In this setup, logs in the development environment are stored locally in an SQLite file. In the production environment, logs are stored in a centralized MongoDB database.

1. Install Errsole and the required storage modules

Run the following commands to install Errsole and its storage adapters:

npm install errsole errsole-sqlite errsole-mongodb

2. Create the logger file

Create a file named logger.js to handle Errsole’s initialization for all environments.

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

if (process.env.NODE_ENV === 'production') {
  // Production Environment: Centralized logging with MongoDB
  errsole.initialize({
    storage: new ErrsoleMongoDB('<Connection URL>', '<Collection Name>', { collectionPrefix: '<App Name>' }),
    appName: '<App Name>',
    environmentName: process.env.NODE_ENV,
  });
} else {
  // Development/Other Environments: Local logging with SQLite
  const logsFile = path.join(os.tmpdir(), '<App Name>.log.sqlite');
  errsole.initialize({
    storage: new ErrsoleSQLite(logsFile),
    appName: '<App Name>',
    environmentName: process.env.NODE_ENV,
  });
}

module.exports = errsole;

3. Use Errsole in your application

Include the logger in your application to start capturing logs.

const express = require('express');
const logger = require('./logger'); // Import Errsole logger

const app = express();

// Middleware to access Errsole log viewer
app.use('/errsole', logger.expressProxyMiddleware());

app.get('/', (req, res) => {
  logger.info('Home route accessed'); // Log an info message
  res.send('Hello, World!');
});

const port = 3000;
app.listen(port, () => {
  logger.info(`Server running on port ${port}`);
});

4. Access the Log Viewer

With the above configuration, you can access the Errsole Web Dashboard by visiting:

http://localhost:3000/errsole

Errsole with Other Storages

This guide uses MongoDB for centralized logging in production. However, Errsole supports other databases like MySQL and PostgreSQL. For detailed instructions, refer to the following documentation:

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: Venki

How to set up a Node.js Log Viewer

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

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

How to set up Errsole Node.js Logger across all environments

What is Errsole?

How to set up Errsole across all environments

1. Install Errsole and the required storage modules

2. Create the logger file

3. Use Errsole in your application

4. Access the Log Viewer

Errsole with Other Storages

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