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
Why Should You Turbocharge Your Express.js App with HTTP/2?

Turbocharge Your Express.js App with HTTP/2's Cutting-Edge Features

Blog Image
Supercharge Your Node.js Projects: Master CI/CD with GitHub Actions and Jenkins

Node.js CI/CD pipelines automate testing, deployment, and quality checks. GitHub Actions and Jenkins streamline development, ensuring faster, more reliable releases. Best practices include security, error handling, and continuous improvement.

Blog Image
Mastering Node.js Security: Essential Tips for Bulletproof Applications

Node.js security: CSRF tokens, XSS prevention, SQL injection protection, HTTPS, rate limiting, secure sessions, input validation, error handling, JWT authentication, environment variables, and Content Security Policy.

Blog Image
How Do Graceful Shutdowns Keep Your Web App Running Smoothly?

Saying Goodbye Without Chaos: Elevate Your Server Shutdowns with http-terminator

Blog Image
JavaScript Accessibility: Building Web Apps That Work for Everyone

Learn to create inclusive web applications with our guide to JavaScript accessibility best practices. Discover essential techniques for keyboard navigation, focus management, and ARIA attributes to ensure your sites work for all users, regardless of abilities. Make the web better for everyone.

Blog Image
Harnessing ML Magic: How React Native Apps Become Smarter Every Swipe

Empowering Mobile Apps: React Native Meets Machine Learning for an Unforgettable User Experience