Log System

Ecosistema completo para organización y gestión de contenido con interfaces espaciales

Librería Log System (Core)

Prioridad: Muy Alta

Propósito: Sistema de logging con diferentes destinos para registrar eventos y métricas del sistema, fundamental para la observabilidad y debugging de toda la plataforma GoGrab.

Especificación funcional

Esta librería debe proporcionar:

Modelos principales:

Servicios core:

Utilidades:

Decorators:

Integraciones previstas:

Appenders/Destinos:

Estado actual

API pública actual

Estructura del paquete

Comandos de mantenimiento

Dependencias identificadas

Esta librería será dependencia fundamental para:

Nota de implementación: Actualmente no existen servicios ni modelos implementados; al agregarlos, garantizar pruebas, tipado estricto y exportación desde src/index.ts.

Importancia en el ecosistema GoGrab

Esta librería es foundational para toda la plataforma, siendo requerida por prácticamente todos los módulos del sistema:

Sin un sistema de logging robusto, el diagnóstico y mantenimiento de la plataforma sería extremadamente complejo.

Diseño y alcance

Modelo de dominio (tipos clave)

Servicios y API

Appenders previstos

Formatters

Decorators

Integraciones

Configuración e inicialización (Angular)

Esta librería es 100% standalone: no expone NgModule y no usa forRoot. La configuración se realiza mediante providers en bootstrapApplication, ApplicationConfig, rutas o componentes standalone.

import { provideLogSystem } from '@libs-core/log-system';

bootstrapApplication(AppComponent, {
  providers: [
    provideLogSystem({
      level: 'info',
      appenders: [new ConsoleAppender()],
      formatter: new JsonFormatter(),
      defaultContext: { source: 'gograb-space' },
      queue: { maxSize: 1000, flushIntervalMs: 2000 },
      redact: { keys: ['password', 'token'] },
    }),
  ],
});

Alternativa con ApplicationConfig (p. ej. en app.config.ts):

import { ApplicationConfig } from '@angular/core';
import { provideLogSystem } from '@libs-core/log-system';

export const appConfig: ApplicationConfig = {
  providers: [
    provideLogSystem(() => ({
      level: 'info',
      appenders: [new ConsoleAppender()],
    })),
  ],
};

Proveer a nivel de ruta (feature aislada):

export const routes: Routes = [
  {
    path: 'admin',
    loadComponent: () => import('./admin.component').then((m) => m.AdminComponent),
    providers: [provideLogSystem(() => ({ level: 'warn', appenders: [new ConsoleAppender()] }))],
  },
];

Ajuste de contexto por componente standalone (sin redefinir el logger):

import { Component } from '@angular/core';
import { LOG_CONTEXT } from '@libs-core/log-system';

@Component({
  standalone: true,
  selector: 'feature-x',
  template: '...',
  providers: [{ provide: LOG_CONTEXT, useValue: { source: 'feature-x' } }],
})
export class FeatureXComponent {}

Uso en código:

constructor(private logger: LoggerService) {}

save(item: Item) {
  this.logger.info('Guardando item', { id: item.id });
}

Decorators:

class PaymentService {
  @performance({ thresholdMs: 300 })
  @logError()
  async charge(payload: ChargeRequest) {
    // ...
  }
}

Notas standalone:

Multi-tenant y trazabilidad

Seguridad y cumplimiento

Rendimiento y resiliencia

Manejo de errores

Testing y calidad

API pública prevista (exportar desde src/index.ts)

Estructura propuesta

libs/core/log-system/src/
  index.ts
  lib/
    config/
      logger-config.ts
    models/
      log-entry.ts
      log-level.ts
      log-context.ts
      appender.ts
      formatter.ts
    services/
      logger.service.ts
      provider.ts
    appenders/
      console-appender.ts
      remote-appender.ts
    formatters/
      json-formatter.ts
      text-formatter.ts
    decorators/
      loggable.ts
      log-error.ts
      performance.ts

Roadmap de implementación

Fase 1 - MVP Crítico (Prioridad: Muy Alta)

Objetivo: Funcionalidad básica requerida por otros módulos core

Fase 2 - Funcionalidad avanzada

Objetivo: Preparación para producción

Fase 3 - Integraciones y observabilidad

Objetivo: Ecosistema completo

Próximos pasos críticos

Implementación inmediata requerida

  1. Completar Fase 1 - Sin esta librería, otros módulos core no pueden avanzar
  2. Coordinación con EventSystem - Ambos se necesitan mutuamente, implementar en paralelo
  3. Testing exhaustivo - Al ser dependencia de tantos módulos, la estabilidad es crítica

Dependencias bloqueantes

Módulos bloqueados sin esta librería

Estado recomendado: Implementar inmediatamente después de Utilities y en paralelo con EventSystem.