NestJS Logging Like a Pro: Pino, Correlation ID, and GCP Cloud Logging

Unleashing the Power of Professional Logging: Mastering NestJS with Pino, Correlation IDs, and GCP Cloud Logging

In the ever-evolving landscape of server-side development, NestJS has emerged as a formidable framework for building efficient and scalable applications with Node.js. Its out-of-the-box application architecture and extensibility have attracted a growing community of developers looking for ways to maximize their productivity while maintaining code quality.

However, no application, regardless of its architecture and design, is immune to bugs or performance issues. This is where logging comes into play — a critical part of any application development and maintenance cycle. A well-implemented logging strategy can be the guiding light in the murky waters of debugging, a benchmark of application health, and a window into user behaviour and application usage patterns.

In this article, we delve deep into the world of professional-grade logging in NestJS using three powerful tools: Pino for fast and low-overhead logging, Correlation IDs for maintaining traceability across services, and Google Cloud Platform (GCP) Cloud Logging for a centralized logging solution that scales with your application. Whether you are deploying microservices or monoliths, these tools combined will equip you with the resilience and introspection needed to log like a pro.

Why Good Logging Practice Is Essential

Photo by David Gabrić on Unsplash

The art of logging is often underestimated, occasionally reduced to scattered console.log statements intended for the eyes of developers alone. But in the grander vision of a robust application ecosystem, logs are akin to the black box of an aircraft—vital for post-mortem analysis, debugging real-time issues, and proactive performance tuning.

Debugging and Error Tracking: When things go wrong — and they inevitably do — logs provide the first line of defence. They can help you rapidly identify where and why a failure has occurred, which can be instrumental in a high-pressure scenario where time is of the essence.

Monitoring and Auditing: Logs play a pivotal role in monitoring the health of an application. They enable you to track usage patterns, user behaviour, and system performance over time. With the right tools, logs can trigger alerts when anomalies are detected, allowing you to act before minor issues escalate into major outages.

Performance Tuning: Detailed logs can provide insights into performance bottlenecks, enabling developers to optimize code and infrastructure. They can uncover slow-running queries, high latency operations, and other inefficiencies that would otherwise be difficult to isolate.

Despite these clear benefits, effective logging is more complex than outputting strings to a file. It requires careful consideration of what to log, how to log it, and where to store these logs. In the following sections, we will explore how NestJS can be configured to generate actionable logs with minimal performance impact, using Pino; how Correlation IDs can preserve context across asynchronous operations and service boundaries; and how GCP Cloud Logging can provide the storage, and search capabilities, and scalability needed to manage logs effectively.

Introduction to Pino: The Superior Logging Solution for NestJS

Photo by Jakub Pabis on Unsplash

As a Node.js developer, you’re likely familiar with console.log, the go-to method for adding quick print statements to your code. While this can be useful during development, relying on console.log for production logging comes with a host of problems:

• Performance Overhead: Unlike console.log, which is synchronous and blocks the event loop, Pino is an extraordinarily fast asynchronous logger with minimal overhead, ensuring your application performance remains optimal.
• Unstructured Output: console.log spits out plain text, making logs difficult to filter and analyze. Pino, on the other hand, produces structured JSON logs, which are incredibly valuable for parsing and automated processing.
• Lack of Log Levels: Pino supports multiple log levels (fatal, error, warn, info, debug, trace), whereas console.log lacks such granularity, making it harder to classify and manage log output.
• No Log Rotation: Pino can work with log management tools that support features like rotation and retention policies, whereas console.log relies on external solutions for such functionality.
• Centralized Logging: For applications distributed across multiple services, Pino makes centralized logging a breeze, unlike console.log, which does not cater to such architectures without custom implementations.
• Security and Compliance: Pino includes redaction features and allows the definition of custom serializers, preventing sensitive information from being logged accidentally — an area where console.log falls short.

Given these constraints of console.log, NestJS developers are increasingly turning to more capable logging solutions. Pino is one of the most compelling choices. It combines high-speed logging with the richness of structured data, all without sacrificing the flexibility developers need.

Getting Started with Pino

With NestJS’s modular system, setting up Pino is a streamlined process. Begin by adding the necessary pino and nestjs-pino packages to your project. Once installed, configuring your NestJS application to use Pino takes just a few lines of code, after which you're ready to enjoy structured, performant logging with the ability to configure log levels, serialization, and more.

Setting up Pino with NestJS can be done in a few steps:

1. Installation: First, install the necessary packages. pino for the logger itself, and nestjs-pino, which is an adapter for NestJS.

npm install pino nestjs-pino

Configuration in main.ts: After installation, Pino can be incorporated into your NestJS application through its module system and main.ts

import { Logger } from 'nestjs-pino';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    cors: true,
  });

  // configure logger
  app.useLogger(app.get(Logger));

}

Configuration in Module: Import the LoggerModule from nestjs-pino and configure it within your application module.

import { Module } from '@nestjs/common';
import { LoggerModule } from 'nestjs-pino';

@Module({
  imports: [
    LoggerModule.forRootAsync({
      // Pino options go here
    }),
  ],
  // other modules, providers, controllers, etc.
})
export class AppModule {}

Usage: With the module configured, Pino’s logger instance can be injected into NestJS providers (services) or controllers using standard dependency injection. This keeps your codebase clean and testable.

import { Inject, Injectable, Logger } from '@nestjs/common';

@Injectable()
export class YourService {
  private readonly logger = new Logger(YourService.name);

yourMethod() {
    this.logger.info('This is an informational message');
  }
}

Generating and Using Correlation IDs

Photo by israel palacio on Unsplash

As our applications grow in complexity, especially when evolving into a microservices architecture, the ability to trace individual requests throughout the system becomes critical for effective debugging and performance monitoring. This is where Correlation IDs, also known as request IDs or transaction IDs, become invaluable. These unique identifiers track a request’s journey, providing comprehensive traceability through the network of services. In NestJS, integrating Correlation IDs into your logging with Pino can be streamlined with some configuration setup.

Understanding Correlation IDs

A Correlation ID is a unique identifier tied to a single action or transaction within your application. As this request or action passes through various parts of your system, having a consistent Correlation ID attached to each log entry allows you to correlate all activities related to that request. This facilitates a much more manageable debugging and monitoring process.

Advantages of Correlation IDs

The introduction of Correlation IDs into your logging strategy can exponentially improve your operational insight:

• Traceability: Correlation IDs allow tracking the entire lifecycle of a request across multiple services or components, which is invaluable for investigating issues and understanding system behavior.
• Enhanced Monitoring: By linking events and logs throughout your system with a common identifier, you can gain profound visibility into complex interactions and potentially uncover hidden inefficiencies.
• Streamlined Troubleshooting: A Correlation ID helps you filter log data to extract all relevant entries for a particular request, significantly speeding up the troubleshooting process.
• Context Preservation: In asynchronous and multi-threaded environments, Correlation IDs are critical for maintaining execution context across various tasks and callbacks.

Implementing Correlation IDs in NestJS with Pino

NestJS’s ecosystem allows for flexible and dynamic module imports, making it ideally suited to integrate Correlation IDs with Pino. Using LoggerModule.forRootAsync(), you can configure Pino to generate and attach a Correlation ID to each request:

import { Module } from '@nestjs/common';
import { LoggerModule } from 'nestjs-pino';
import { ConfigModule, ConfigService } from '@nestjs/config';
import { v4 as uuidv4 } from 'uuid';

@Module({
  imports: [
    LoggerModule.forRootAsync({
      imports: [ConfigModule],
      inject: [ConfigService],
      useFactory: async (config: ConfigService) => {
        await somePromise(); // Any initialization logic if needed
        return {
          pinoHttp: {
            level: config.get('LOG_LEVEL'), // Or any other config value
            genReqId: (request) => request.headers['x-correlation-id'] || uuidv4(),
          },
        };
      },
    }),
    // ... other modules
  ],
  // ...controllers, providers
})

export class AppModule {}

With the above configuration, a Correlation ID is either retrieved from the incoming request headers or generated using uuidv4() if it does not already exist. This ensures that every log stemming from a particular request can be traced back to it using this unique identifier.

Logging with Correlation IDs

When the configuration is in place, Pino automatically attaches the Correlation ID to every log message associated with the request. There’s no need for manual insertion; Pino enriches the logs with consistent and reliable identifiers for seamless tracking.

// Example log message with attached Correlation ID
this.logger.info('A log message from your service');

In practice, by utilizing Correlation IDs with Pino, you elevate the clarity and usefulness of your logs in NestJS. This approach aligns perfectly with practices embraced in modern distributed systems, enabling you to trace complex transactions and pinpoint issues with greater precision than ever before.

Integrating NestJS Logging with GCP Cloud Logging

Photo by Andreas Kind on Unsplash

With Correlation IDs enhancing the traceability and debugging experience within our NestJS application, our attention now turns to the challenge of log management at scale. As applications grow and the amount of log data increases, the need for a robust, scalable, and searchable log storage solution becomes critical. Google Cloud Platform (GCP) Cloud Logging offers an excellent service for centralized logging, allowing teams to store, search, and analyze log data seamlessly across all components of their infrastructure.

Why Use GCP Cloud Logging?

GCP Cloud Logging is part of Google Cloud’s suite of operations products, providing fully managed, real-time log management that is highly available and scalable. It aggregates logs from across your application, providing powerful search capabilities, alerting, and even machine learning-based insights. These features enable teams to quickly diagnose and respond to problems, thereby improving application reliability and performance.

Integrating NestJS with GCP Cloud Logging

To bridge the gap between NestJS logging powered by Pino and GCP Cloud Logging, we use the well-crafted pino-stackdriver package. This package provides a writable stream that formats logs according to Stackdriver's requirements and transmits them directly to the Cloud Logging service.

Here’s how you can implement it:

1. Install pino-stackdriver package: This package will allow us to stream NestJS logs directly to GCP Cloud Logging.

npm install pino-stackdriver

1. Modify NestJS AppModule with LoggerModule: Incorporate the pino-stackdriver writable stream into the LoggerModule.forRootAsync() configuration to enable GCP Cloud Logging integration.

import { Module } from '@nestjs/common';
import { LoggerModule } from 'nestjs-pino';
import { createWriteStream } from 'pino-stackdriver';
import { AppConfigModule, AppConfigService } from './config/app-config.module';
import { v4 as uuidv4 } from 'uuid';

@Module({
  imports: [
    LoggerModule.forRootAsync({
      imports: [AppConfigModule],
      useFactory: (configService: AppConfigService) => {
        const logName = `${configService.gcpCredentials.logName}-${configService.appEnvironment}`;
        
        const writeStream = createWriteStream({
          credentials: {
            client_email: configService.gcpCredentials.logging.email,
            private_key: configService.gcpCredentials.logging.privateKey,
          },
          projectId: configService.gcpCredentials.projectId,
          logName: logName,
          resource: {
            type: 'global',
          },
        });

        return {
          pinoHttp: {
            name: logName,
            stream: writeStream,
            redact: ['req.headers.authorization'], // Redact sensitive information
            genReqId: () => uuidv4(), // Generate Correlation IDs
          },
        };
      },
      inject: [AppConfigService],
    }),
    // ... other modules
  ],
  // ...controllers, providers
})

export class AppModule {}

In the configuration above, we utilize AppConfigService to fetch relevant settings such as the GCP project ID, credentials, and logging-specific configurations. The writable stream from pino-stackdriver is responsible for sending log entries to GCP Cloud Logging while ensuring they are in the correct format. Redaction is also configured to protect sensitive information from being exposed, and Correlation IDs are generated as part of the logging process.

Benefits of Combining NestJS, Pino, and GCP Cloud Logging

The integration of NestJS with Pino and GCP Cloud Logging promises not only to streamline log management but also to leverage the powerful features of Cloud Logging, such as:

• Scalability: Handle large volumes of log data without compromising on performance.
• Searchability: Use advanced search and filtering within the Cloud Logging to extract meaningful insights.
• Alerting and Monitoring: Set up alerts based on specific log criteria and monitor your application’s health in real-time.
• Machine Learning Insights: Tap into machine learning tools provided by GCP to uncover patterns and predict potential issues before they impact users.

Moving logs from a local or containerized environment to a cloud-based solution like GCP Cloud Logging represents a significant step forward in the maturity of an application’s logging strategy. With the Correlation ID in place and Pino providing high-performance logging, the addition of GCP Cloud Logging completes the triad, ensuring that you are well-equipped to manage your logs at any scale, maintain observability across your services, and, ultimately, deliver a more reliable and resilient application to your users.

Conclusion

Throughout this exploration of pro-level logging in NestJS with Pino, Correlation IDs, and GCP Cloud Logging, we have covered the essentials needed to elevate your logging strategy from rudimentary print statements to robust, traceable, and scalable logs. We’ve seen how the combination of these tools can revolutionize the way we handle logging in modern, distributed systems.

By moving away from the limitations of console.log, embracing structured logging with Pino, injecting traceability with Correlation IDs, and consolidating log management through GCP Cloud Logging, developers now have the power to diagnose and resolve issues with unprecedented efficiency and clarity.

Logging is not just about recording what happens. It’s about creating a narrative of your application that helps you understand its behavior, diagnose problems, and even anticipate future issues. With the techniques and strategies discussed in this article, you are now equipped to write your application’s story more effectively than ever before.

We hope this article serves as a valuable resource in your development journey, and we’re eager to hear how these practices impact your projects. If you have any questions, insights, or experiences you’d like to share, please leave a comment below. Happy logging, and may your applications run smoothly and your logs be ever informative!

If you’ve found this article informative and helpful, please give it some applause by clicking those claps 👏 — it helps more people see the article and I greatly appreciate your support! Don’t forget to share it with your friends, colleagues, or anyone you believe would benefit from these insights into pro-level logging with NestJS.

For more articles like this and updates on the latest in tech and software architecture, follow me here. I’m always excited to share knowledge and learn from this incredible community.

Also, feel free to connect with me and check out more content on my personal website at sagarvaghela.in or on GitHub

Stay tuned and keep coding! 🚀