Logging

Cómo usar el Logger de Nest

NestJS incluye un sistema de logging integrado que facilita el registro de eventos, errores y información de depuración en nuestras aplicaciones. Este logger está disponible de forma nativa y se puede utilizar tanto en controladores como en servicios mediante inyección de dependencias.

El Logger de Nest proporciona diferentes niveles de logging (log, error, warn, debug, verbose) y permite personalizar el formato y destino de los mensajes. Su integración con el sistema de inyección de dependencias lo convierte en una herramienta esencial para el monitoreo y depuración de aplicaciones.

Inyección del Logger en servicios

Para utilizar el logger en un servicio, debemos inyectarlo como dependencia en el constructor. NestJS proporciona la clase Logger que podemos importar desde @nestjs/common:

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

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

  findAll() {
    this.logger.log('Obteniendo todos los productos');
    // Lógica del servicio
    return [];
  }

  create(product: any) {
    this.logger.log(`Creando producto: ${product.name}`);
    try {
      // Lógica de creación
      this.logger.log(`Producto creado exitosamente: ${product.id}`);
      return product;
    } catch (error) {
      this.logger.error(`Error al crear producto: ${error.message}`);
      throw error;
    }
  }
}

En este ejemplo, creamos una instancia privada del logger pasando el nombre de la clase como contexto. Esto nos permite identificar fácilmente qué servicio generó cada mensaje de log.

Uso del Logger en controladores

Los controladores también pueden utilizar el logger de la misma manera. Es especialmente útil para registrar peticiones HTTP y sus resultados:

import { Controller, Get, Post, Body, Logger } from '@nestjs/common';

@Controller('products')
export class ProductController {
  private readonly logger = new Logger(ProductController.name);

  constructor(private readonly productService: ProductService) {}

  @Get()
  findAll() {
    this.logger.log('GET /products - Solicitando lista de productos');
    const products = this.productService.findAll();
    this.logger.log(`GET /products - Devolviendo ${products.length} productos`);
    return products;
  }

  @Post()
  create(@Body() createProductDto: any) {
    this.logger.log('POST /products - Creando nuevo producto');
    const result = this.productService.create(createProductDto);
    this.logger.log(`POST /products - Producto creado con ID: ${result.id}`);
    return result;
  }
}

Niveles de logging disponibles

NestJS proporciona cinco niveles de logging diferentes, cada uno con un propósito específico:

1 - Log: Para información general del flujo de la aplicación

this.logger.log('Usuario autenticado correctamente');

2 - Error: Para registrar errores y excepciones

this.logger.error('Error de conexión a la base de datos', error.stack);

3 - Warn: Para advertencias que no detienen la ejecución

this.logger.warn('Límite de intentos de login alcanzado para el usuario');

4 - Debug: Para información detallada útil durante el desarrollo

this.logger.debug('Parámetros recibidos en la petición', { userId, filters });

5 - Verbose: Para información muy detallada del sistema

this.logger.verbose('Iniciando proceso de validación de datos');

Logger con contexto personalizado

Podemos personalizar el contexto del logger para proporcionar información más específica sobre el origen de los mensajes:

@Injectable()
export class UserService {
  private readonly logger = new Logger('UserService');

  async authenticateUser(email: string) {
    // Logger con contexto específico para esta operación
    const authLogger = new Logger('UserService:Authentication');
    
    authLogger.log(`Iniciando autenticación para: ${email}`);
    
    try {
      // Lógica de autenticación
      authLogger.log(`Autenticación exitosa para: ${email}`);
    } catch (error) {
      authLogger.error(`Fallo en autenticación para: ${email}`, error.stack);
      throw error;
    }
  }
}

Configuración global del Logger

También podemos configurar el logger globalmente en el archivo principal de la aplicación para establecer niveles de logging y personalizar su comportamiento:

import { NestFactory } from '@nestjs/core';
import { Logger } from '@nestjs/common';
import { AppModule } from './app.module';

async function bootstrap() {
  const app = await NestFactory.create(AppModule, {
    logger: ['error', 'warn', 'log'], // Niveles activos
  });
  
  const logger = new Logger('Bootstrap');
  logger.log('Aplicación iniciada correctamente');
  
  await app.listen(3000);
}
bootstrap();

Esta configuración permite controlar qué niveles de logging se muestran en la consola, lo cual es útil para diferentes entornos (desarrollo, producción, testing).