javascript

Is Your Express App Ready for Pino, the Ferrari of Logging?

Embrace the Speed and Precision of Pino for Seamless Express Logging

Is Your Express App Ready for Pino, the Ferrari of Logging?

When diving into logging HTTP requests in Express applications, many developers lean towards Pino for its impressive speed and rich feature set. Pino is like the Ferrari of logging tools in the Node.js ecosystem – it’s fast, sleek, and reliable.

Why Go with Pino?

What sets Pino apart is its blazing speed. Time is crucial, especially for applications where performance is non-negotiable. Pino also boasts versatility, making it a great companion for various Node.js frameworks such as Express and Fastify.

Getting Started with Pino and Express

Let’s break it down on how you can set up Pino with an Express application.

First off, create a new directory for your project, then kick things off by initializing a new Node.js project.

mkdir pino-logging && cd pino-logging
npm init -y

Next, you’ll need to install Pino and pino-http, the latter being essential for HTTP request and response logging.

npm install pino pino-http --save

Now, you can roll up your sleeves and create your Express server. Here’s how you can integrate Pino logging into it:

const express = require('express');
const pino = require('pino');
const pinoHttp = require('pino-http');

const logger = pino();
const httpLogger = pinoHttp({ logger });

const app = express();

// Use Pino HTTP middleware
app.use(httpLogger);

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

app.get('/user/:id', (req, res) => {
  const userId = req.params.id;
  req.log.info({ userId }, 'User route accessed');
  res.send(`User ID: ${userId}`);
});

// Error handling middleware
app.use((err, req, res, next) => {
  req.log.error({ err }, 'Unhandled error');
  res.status(500).send('Something went wrong');
});

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

Logging HTTP Requests and Responses

When you make Pino log HTTP requests and responses, it gets pretty detailed – capturing HTTP methods, URLs, status codes, and response times.

Here’s what happens when a request hits your app. If someone does a GET request to the root URL, Pino generates a log entry that captures all these details.

{
  "level": 30,
  "time": 1720120558325,
  "pid": 18553,
  "hostname": "Anubhavs-MacBook-Air.local",
  "req": {
    "id": "req-1",
    "method": "GET",
    "url": "/",
    "headers": {
      "host": "localhost:3000",
      "connection": "keep-alive",
      // ...headers truncated for brevity
    },
    "remoteAddress": "::1",
    "remotePort": 64853
  },
  "res": {
    "statusCode": 200,
    "headers": {
      "content-type": "text/html; charset=utf-8",
      "content-length": "13",
      // ...headers truncated for brevity
    },
    "responseTime": 1.1204520016908646
  },
  "msg": "request completed"
}

You can even customize these logs to include any additional info you need, like logging user details when specific routes are accessed.

app.get('/user/:id', (req, res) => {
  const userId = req.params.id;
  req.log.info({ userId }, 'User route accessed');
  res.send(`User ID: ${userId}`);
});

Tailoring Pino Logging

Pino’s customization options allow you to mold the logging to fit your needs perfectly.

Log Levels: Adjust the verbosity by setting different log levels. For instance, setting the log level to info for production and debug during development.

const logger = pino({ level: 'info' });

Custom Serializers: Craft your own serializers to format log data precisely as you need it. This is useful for refining how request and response logs are shown.

const httpLogger = pinoHttp({
  logger,
  serializers: {
    req: (req) => ({ method: req.method, url: req.url }),
    res: (res) => ({ statusCode: res.statusCode }),
  },
});

Pretty Printing: If you’re all about readability, integrate pino-pretty for logs that are easy on the eyes.

const pretty = require('pino-pretty');
const logger = pino(pretty());

Performance and Benchmarks

Pino’s high performance is no joke. It’s built to handle high-traffic applications efficiently. Radiating speed and capability, Pino consistently outshines other popular logging libraries.

Here’s a snapshot of how Pino ranks in request rates compared to others:

express-bunyan-logger: 2702 req/sec
express-winston: 5953 req/sec
morgan: 8570 req/sec
pino-http: 9807 req/sec

Conclusion

Bringing Pino into your Express application is not only easy but can turbocharge how you monitor and debug. Pino’s high performance, customizable features, and seamless integration with Express make it a fantastic tool for any Node.js developer looking to up their logging game. With the guide laid out above, you’re set to create a solid logging system that keeps you on top of your application’s heartbeat.

And there you have it – a robust, efficient logging setup, ready to go. Time to code, log, and keep your app running smooth as butter. Cheers!

Keywords: Pino logging, express applications, Node.js logging tools, pino-http setup, high-performance logging, custom serializers, log levels in Node.js, integrating Pino, monitoring Express apps, pino-pretty readability



Similar Posts
Blog Image
Implementing Role-Based Access Control (RBAC) in Node.js for Secure APIs

RBAC in Node.js APIs controls access by assigning roles with specific permissions. It enhances security, scalability, and simplifies user management. Implement using middleware, JWT authentication, and role-based checks.

Blog Image
Mocking File System Interactions in Node.js Using Jest

Mocking file system in Node.js with Jest allows simulating file operations without touching the real system. It speeds up tests, improves reliability, and enables testing various scenarios, including error handling.

Blog Image
Supercharge Your React Native App: Unleash the Power of Hermes for Lightning-Fast Performance

Hermes optimizes React Native performance by precompiling JavaScript, improving startup times and memory usage. It's beneficial for complex apps on various devices, especially Android. Enable Hermes, optimize code, and use profiling tools for best results.

Blog Image
Are You Ready to Supercharge Your Web Apps with WebSockets?

WebSockets: Crafting a Seamless, Interactive Internet Experience

Blog Image
Unlock Node.js Power: Clustering for Scalable, Multi-Core Performance Boost

Node.js clustering enables multi-core utilization, improving performance and scalability. It distributes workload across worker processes, handles failures, facilitates inter-process communication, and allows custom load balancing for efficient resource use.

Blog Image
Why Should You Give Your TypeScript Code a Makeover?

Revitalize Your TypeScript Code: Refactor Like a Pro with These Game-Changing Techniques