Logger

💡En Inlaze tenemos un desarrollo propio para el logging de aplicaciones, basado en un contexto, con un sistema muy completo que permite parametrizar los distintos tipos de log desde la base de datos. Para entender esta receta, es necesario conocer cómo funciona un logger por debajo, los niveles de log, los contextos de ejecución, etc.

Resumen

Esta receta proporciona una guía para configurar y utilizar el logger desarrollado por Inlaze en las aplicaciones. Este sistema permite parametrizar diferentes tipos de log desde la base de datos y admite múltiples contextos de ejecución. La configuración incluye la instalación de la librería @inlaze_techlead/inlaze-common y la creación de módulos específicos para gestionar la configuración de logs.

Descripción

El sistema de logging en Inlaze permite definir configuraciones personalizadas para distintos contextos de ejecución. Las configuraciones incluyen niveles de log, destinos como consola, archivos y webhooks (Slack, Teams, Google, etc.), y se pueden gestionar desde la base de datos. Este enfoque proporciona flexibilidad y centralización en la gestión de logs.

Prerrequisitos

• Node.js instalado

• NestJS instalado

• MongoDB configurado y funcionando

• Conocimientos básicos sobre el funcionamiento de un logger, niveles de log y contextos de ejecución

Casos de Uso

• Centralizar y parametrizar la configuración de logs para aplicaciones de Inlaze.

• Definir diferentes niveles de log y destinos según el contexto de ejecución.

• Integrar el envío de logs a servicios externos como Slack, Teams, etc.

Instrucciones Paso a Paso

1. Instalar la Librería de Logging

Instala la librería de backend @inlaze_techlead/inlaze-common que contiene los objetos de configuración y el servicio de logger:

pnpm i -E @inlaze_techlead/inlaze-common

2. Crear el Módulo de Configuración de Logger

Este módulo configura la conexión con la base de datos MongoDB para obtener las configuraciones del logger:

logger-config.module.ts

import { MongooseModule } from "@nestjs/mongoose";
import { Module } from "@nestjs/common";
import {
  LOGGER_CONFIG_REPOSITORY,
  LoggerConfigMongo,
  LoggerConfigMongoModel,
} from "@inlaze_techlead/inlaze-common";

@Module({
  imports: [MongooseModule.forFeature([LoggerConfigMongoModel])],
  providers: [
    {
      provide: LOGGER_CONFIG_REPOSITORY,
      useClass: LoggerConfigMongo,
    },
  ],
  exports: [LOGGER_CONFIG_REPOSITORY],
})
export class LoggerConfigModule {}

3. Crear el Módulo de Logger

Este módulo configura el servicio de logger y su integración con BullMQ para el manejo asincrónico de logs:

logger.module.ts

import {
  LOGGER_QUEUE_NAME,
  LOGGER_QUEUE_OPTIONS,
  LOGGER_TASK_NAME,
  LoggerConfigFinderService,
  LoggerService,
  TypeormLoggerService,
  loggerConfig,
  nodeConfig,
} from "@inlaze_techlead/inlaze-common";
import type { DynamicModule } from "@nestjs/common";
import { Module } from "@nestjs/common";
import type { ConfigType } from "@nestjs/config";
import { LoggerConfigModule } from "./logger-config.module";
import { BullModule, getQueueToken } from "@nestjs/bullmq";
import type { Queue } from "bullmq";

@Module({
  imports: [LoggerConfigModule, BullModule.registerQueue(LOGGER_QUEUE_OPTIONS)],
  providers: [
    LoggerConfigFinderService,
    {
      provide: LoggerService,
      useFactory(
        loggerEnvConfig: ConfigType<typeof loggerConfig>,
        nodeEnvConfig: ConfigType<typeof nodeConfig>,
        loggerConfigFinderService: LoggerConfigFinderService,
        loggerQueue: Queue,
      ): LoggerService {
        const service = new LoggerService(
          loggerEnvConfig,
          nodeEnvConfig,
          loggerConfigFinderService,
        );
        service.cb = (data, loggerConfig): undefined =>
          void loggerQueue.add(
            LOGGER_TASK_NAME,
            { data, loggerConfig },
            { removeOnComplete: true, removeOnFail: true },
          );
        return service;
      },
      inject: [
        loggerConfig.KEY,
        nodeConfig.KEY,
        LoggerConfigFinderService,
        getQueueToken(LOGGER_QUEUE_NAME),
      ],
    },
    TypeormLoggerService,
  ],
  exports: [LoggerService, TypeormLoggerService],
})
export class LoggerModule {
  public static register({ isGlobal }: { isGlobal: boolean }): DynamicModule {
    return {
      module: LoggerModule,
      global: isGlobal,
    };
  }
}

4. Importar los Módulos en el App Module

Importa los módulos de configuración y logger en el módulo principal de la aplicación para que la configuración sea global:

import { Module } from '@nestjs/common';
import { LoggerModule } from './logger.module';

@Module({
  imports: [
    LoggerModule.register({ isGlobal: true }),
    // Otros módulos...
  ],
})
export class AppModule {}

Validación

1. Verificar la Configuración: Asegúrate de que las configuraciones del logger se están cargando correctamente desde la base de datos.

2. Pruebas de Log: Genera logs en diferentes contextos y verifica que se registran correctamente en consola, archivos y webhooks configurados.

3. Revisar la Base de Datos: Confirma que las configuraciones en MongoDB se están utilizando para gestionar los logs según lo esperado.

Solución de Problemas

• Errores de Conexión: Verifica la configuración de MongoDB y asegúrate de que el servicio está funcionando correctamente.

• Logs No Aparecen: Asegúrate de que los contextos y niveles de log están correctamente definidos en la base de datos.

• Problemas con Webhooks: Verifica que las URLs de los webhooks están correctas y que los servicios externos (Slack, Teams, etc.) están configurados para recibir los logs.

Preguntas Frecuentes

• ¿Puedo utilizar otro tipo de base de datos en lugar de MongoDB?

  • Sí, puedes ajustar la implementación del repositorio para utilizar otra base de datos compatible.

• ¿Cómo configuro un nuevo contexto de log?

  • Añade una nueva configuración en la base de datos con el contexto deseado y define los niveles y destinos de log necesarios.

Recursos Adicionales

• Documentación de NestJS

• Documentación de Mongoose

• Documentación de BullMQ

Conclusión

Siguiendo esta receta, has configurado correctamente el sistema de logging en tu aplicación de Inlaze, permitiendo gestionar y parametrizar los logs de manera centralizada y flexible. Este sistema admite múltiples niveles y destinos de log, incluyendo consola, archivos y webhooks, lo que facilita el monitoreo y análisis de los logs en diferentes contextos de ejecución.