@jmlq/logger 0.1.0-alpha.20 → 0.1.0-alpha.21

package/README.md

@@ -2,6 +2,56 @@
 
 Sistema de logging modular y extensible con **Arquitectura Limpia**. Soporta múltiples destinos (archivos, MongoDB, PostgreSQL) y enmascarado automático de datos sensibles (PII).
 
+Se encarga de:
+
+- Persistencia de logs en múltiples datasources
+- Enmascarado automático de datos sensibles (PII)
+- Filtros y búsquedas avanzadas
+- Arquitectura extensible y testeable
+
+## Componentes principales expuestos
+
+### Factory
+
+- **[`createLogger`](src/application/factory/logger.factory.ts)**  
+  Factory de alto nivel que construye un `ILogger` compatible con `@jmlq/logger`, resolviendo internamente:
+
+  - Configuración de datasources múltiples (fan-out)
+  - Inicialización del redactor PII
+  - Composición de casos de uso
+  - Nivel mínimo de logging
+
+  > Es el **único punto recomendado de entrada** para consumidores del paquete.
+
+---
+
+### Tipos de configuración
+
+- **[`ILoggerFactoryConfig`](src/application/types/logger-factory-config.type.ts)**  
+  Define la configuración necesaria:
+  - `datasources`: Uno o múltiples datasources donde persistir logs
+  - `minLevel`: Nivel mínimo de logging (por defecto INFO)
+  - `redactor`: Instancia personalizada de redactor PII
+  - `redactorOptions`: Configuración para redactor interno
+
+---
+
+## Contratos (Types / Ports)
+
+Estos tipos existen para **desacoplar el dominio y la aplicación**.  
+Son útiles para testing, extensiones avanzadas o integraciones personalizadas.
+
+- **[`ILogger`](src/domain/ports/logger.port.ts)**: Interfaz principal del logger con métodos por nivel
+- **[`ILogDatasource`](src/domain/ports/log-datasource.port.ts)**: Contrato para implementar datasources personalizados
+- **[`LogLevel`](src/domain/value-objects/log-level.vo.ts)**: Enumeración de niveles de logging
+- **[`LogFilterRequest`](src/domain/request/log-filter.request.ts)**: Filtros para consultas de logs
+- **[`ILogResponse`](src/domain/response/log.response.ts)**: Formato de respuesta de logs consultados
+- **[`PiiOptions`](src/domain/model/pii-options.model.ts)**: Configuración para enmascarado PII
+- **[`LogEntry`](src/domain/model/log-entry.model.ts)**: Modelo de entrada de log
+- **[`PiiRedactor`](src/domain/services/pii-redactor.service.ts)**: Servicio de enmascarado PII
+
+---
+
 ## 📦 Instalación
 
 ```bash
@@ -14,18 +64,406 @@ npm install @jmlq/logger-plugin-mongo     # Para MongoDB
 npm install @jmlq/logger-plugin-postgresql # Para PostgreSQL
 ```
 
-## 🚀 Uso Básico
+---
+
+## Configuración @jmlq/logger
 
-Con esta configuración se busca:
+### Variables de entorno
+
+Ver cómo se configuran los adapters de `@jmlq/logger-plugin-fs`, `@jmlq/logger-plugin-mongo` y `@jmlq/logger-plugin-postgresql`.
+
+| Plugin                           | Descripción                | NPM                                                             |
+| -------------------------------- | -------------------------- | --------------------------------------------------------------- |
+| `@jmlq/logger-plugin-fs`         | Persistencia en archivos   | [npm](https://npmjs.com/package/@jmlq/logger-plugin-fs)         |
+| `@jmlq/logger-plugin-mongo`      | Persistencia en MongoDB    | [npm](https://npmjs.com/package/@jmlq/logger-plugin-mongo)      |
+| `@jmlq/logger-plugin-postgresql` | Persistencia en PostgreSQL | [npm](https://npmjs.com/package/@jmlq/logger-plugin-postgresql) |
+
+El paquete no gestiona variables de entorno internamente, pero puedes implementar tu propia capa de configuración. Estas son las variables de entorno que se usan para configurar todos los plugins.
+
+```ini
+# Settings @jmlq/logger
+# LOGGER Plugins Configuration
+# Nivel mínimo de logs
+# Valores: TRACE, DEBUG, INFO, WARN, ERROR, FATAL
+LOG_LEVEL=INFO
+# PII Protection
+LOGGER_PII_ENABLED=true
+LOGGER_PII_INCLUDE_DEFAULTS=false
+# FS Plugin Settings
+LOGGER_FS_PATH=./logs/
+# MongoDB Plugin Settings
+LOGGER_MONGO_DB_URL=mongodb://root:secret@localhost:27018/?authSource=admin
+LOGGER_MONGO_DB_NAME=logger_example_db
+LOGGER_MONGO_COLLECTION_NAME=logs_datasource_factory_example
+# PostgreSQL Plugin Settings
+LOGGER_PG_CONNECTION_STRING=postgres://admin:secret@localhost:5436/logger_tests
+LOGGER_PG_TABLE_NAME=logs_example_factory
+LOGGER_PG_SCHEMA=public
+```
 
-- Tener un **logger centralizado** basado en `@jmlq/logger`.
-- Enviar logs a uno o varios de estos destinos (**opcionales** y combinables):
-  - Sistema de archivos (`@jmlq/logger-plugin-fs`)
-  - MongoDB (`@jmlq/logger-plugin-mongo`)
-  - PostgreSQL (`@jmlq/logger-plugin-postgresql`)
-- Integrar el logger con:
-  - Express (por request) mediante un middleware (`req.logger` + `req.requestId`).
-  - El ciclo de vida de la app: arranque, apagado limpio y fallos no controlados.
+### Interfaz de configuración del paquete
+
+```ts
+// Path Ejemplo: src/infrastructure/logger/core/logger.bootstrap.options.ts
+
+import { LogLevel } from "@jmlq/logger";
+import { IFilesystemDatasourceOptions } from "@jmlq/logger-plugin-fs";
+import { IMongoDatasourceOptions } from "@jmlq/logger-plugin-mongo";
+import { IPostgresDatasourceOptions } from "@jmlq/logger-plugin-postgresql";
+
+export interface LoggerBootstrapOptions {
+  minLevel: LogLevel;
+  pii?: {
+    enabled?: boolean;
+    whitelistKeys?: string[];
+    blacklistKeys?: string[];
+    patterns?: any[];
+    deep?: boolean;
+    includeDefaults?: boolean;
+  };
+  adapters?: {
+    // NOTA: Opcional, depende de las necesidades del cliente
+    fs?: IFilesystemDatasourceOptions;
+    mongo?: IMongoDatasourceOptions;
+    pg?: IPostgresDatasourceOptions;
+  };
+}
+```
+
+### Implementación del Logger
+
+```ts
+// Path Ejemplo: src/infrastructure/logger/core/logger.bootstrap.ts
+
+import { type ILogDatasource, createLogger } from "@jmlq/logger";
+import { FsAdapter } from "../fs/fs.adapter";
+import { MongoAdapter } from "../mongo/mongo.adapter";
+import { PgAdapter } from "../pg/pg.adapter";
+import { LoggerBootstrapOptions } from "./logger.bootstrap.options";
+
+export class LoggerBootstrap {
+  private constructor(
+    private readonly _logger: ReturnType<typeof createLogger>
+  ) {}
+
+  static async create(opts: LoggerBootstrapOptions): Promise<LoggerBootstrap> {
+    const dsList: ILogDatasource[] = [];
+
+    // NOTA: Opcional, depende de las necesidades del cliente
+    if (opts.adapters?.fs) {
+      const fs = FsAdapter.create(opts.adapters.fs);
+      if (fs) dsList.push(fs.datasource);
+    }
+    if (opts.adapters?.mongo) {
+      const mongo = await MongoAdapter.create(opts.adapters.mongo);
+      if (mongo) dsList.push(mongo.datasource);
+    }
+    if (opts.adapters?.pg) {
+      const pg = await PgAdapter.create(opts.adapters.pg);
+      if (pg) dsList.push(pg.datasource);
+    }
+    //----
+
+    if (dsList.length === 0)
+      throw new Error("[logger] No hay datasources válidos.");
+
+    const logger = createLogger({
+      datasources: dsList,
+      minLevel: opts.minLevel,
+      redactorOptions: {
+        enabled: opts.pii?.enabled ?? false,
+        deep: opts.pii?.deep ?? true,
+        patterns: opts.pii?.patterns ?? [],
+      },
+    });
+
+    console.log("✅ Logger creado correctamente.\n");
+
+    return new LoggerBootstrap(logger);
+  }
+
+  get logger() {
+    return this._logger;
+  }
+
+  // Limpia buffers pendientes antes del cierre
+  async flush() {
+    const logs = this._logger as any;
+    if (typeof logs.flush === "function") await logs.flush();
+  }
+
+  // Cierra recursos (conexiones, handles, etc.)
+  async dispose() {
+    const logs = this._logger as any;
+    if (typeof logs.dispose === "function") await logs.dispose();
+  }
+}
+```
+
+### Inicializador del Logger
+
+```ts
+// Path Ejemplo: src/infrastructure/logger/index.ts
+
+import { envs } from "../../../../config/plugins";
+// NOTA: envs es un archivo donde se leen variables de entorno .env
+import { LoggerBootstrap } from "./core/logger.bootstrap";
+import { parseLogLevel } from "./helper";
+// NOTA: parseLogLevel hace un match con los valores del objeto LogLevel de @jmlq/logger
+
+declare global {
+  var __LOGGER_BOOT__: Promise<LoggerBootstrap> | undefined;
+}
+
+async function init() {
+  return LoggerBootstrap.create({
+    minLevel: parseLogLevel(envs.logger.LOGGER_LEVEL),
+    pii: {
+      enabled: envs.logger.LOGGER_PII_ENABLED,
+      includeDefaults: envs.logger.LOGGER_PII_INCLUDE_DEFAULTS,
+      deep: true,
+      patterns: [
+        {
+          pattern: "\\b\\d{4}-\\d{4}-\\d{4}-\\d{4}\\b",
+          replaceWith: "****-****-****-****",
+        },
+        {
+          pattern: "[\\w.-]+@[\\w.-]+",
+          replaceWith: "***@***",
+        },
+      ],
+    },
+    adapters: {
+      // NOTA: Opcional, depende de las necesidades del cliente
+      fs: envs.logger.LOGGER_FS_PATH
+        ? {
+            basePath: envs.logger.LOGGER_FS_PATH,
+            fileNamePattern: "app-{yyyy}{MM}{dd}.log",
+            rotation: { by: "day" },
+            mkdir: true,
+            onRotate: (oldPath, newPath) => {
+              console.log(
+                `   [Rotate] Rotación completada: ${oldPath.absolutePath} → ${newPath.absolutePath}`
+              );
+            },
+            onError: (err) => {
+              console.error("   [Error Handler]", err.message);
+            },
+          }
+        : undefined,
+      mongo: envs.logger.LOGGER_MONGO_DB_URL
+        ? ({
+            dbName: envs.logger.LOGGER_MONGO_DB_NAME ?? "logs",
+            collectionName:
+              envs.logger.LOGGER_MONGO_COLLECTION_NAME ?? "app_logs",
+            ensureIndexes: true,
+            retentionDays: 7,
+            extraIndexes: [{ key: { level: 1 } }],
+            createIfMissing: true,
+          } as any)
+        : undefined,
+      pg: envs.logger.LOGGER_PG_CONNECTION_STRING
+        ? ({
+            schema: envs.logger.LOGGER_PG_SCHEMA ?? "public",
+            table: envs.logger.LOGGER_PG_TABLE_NAME ?? "logs",
+            createIfMissing: true,
+            enablePrune: true,
+          } as any)
+        : undefined,
+    },
+  });
+}
+
+// 1. Es una promesa singleton de LoggerBootstrap
+// 2. Usa el operador nullish-coalescing (??) para: Reutilizar globalThis.__LOGGER_BOOT__ si ya existe.
+//    En caso contrario crea y memoriza (= init()) la promesa si no existe aún.
+// 3. Garantiza una sola inicialización global del sistema de logging (adapters, datasources, PII, etc.)
+//    aunque el módulo se importe múltiples veces
+export const bootReady: Promise<LoggerBootstrap> =
+  globalThis.__LOGGER_BOOT__ ?? (globalThis.__LOGGER_BOOT__ = init());
+
+// 1. Es una promesa que resuelve directamente al logger
+// 2. Hace un map de la promesa anterior: bootReady.then(b => b.logger).
+export const loggerReady = bootReady.then((b) => b.logger);
+
+// 1. Espera a bootReady y llama boot.flush(), que a su vez pide al logger/datasources
+//    que vacíen buffers pendientes (útil antes de apagar el proceso o en tests).
+export async function flushLogs() {
+  const boot = await bootReady;
+  await boot.flush();
+}
+
+// 1. Espera a bootReady y llama boot.dispose(), que cierra recursos
+//    (conexiones a MongoDB/Postgres, file handles, etc.)
+export async function disposeLogs() {
+  const boot = await bootReady;
+  await boot.dispose();
+}
+```
+
+---
+
+## Configuración en Frameworks
+
+**NOTA**: Se sugiere realizarlo en la capa `presentation` de la API que implementa `@jmlq/logger` y/o sus plugins.
+
+### Express
+
+#### Crear middleware (opcional):
+
+Se puede realizar de la forma que el usuario considere conveniente
+
+```ts
+// Path Ejemplo: src/presentation/middlewares/attach-logger.middleware.ts
+
+import { ILogger } from "@jmlq/logger";
+import { randomUUID } from "crypto";
+import { Request, Response, NextFunction } from "express";
+
+/**
+ * Middleware factory que adjunta contexto de logging al request.
+ *
+ * Responsabilidades:
+ * 1. Inyectar un logger base accesible desde cualquier controller/middleware.
+ * 2. Garantizar un requestId único para trazabilidad y correlación de logs.
+ *
+ * No configura el logger ni emite logs:
+ * solo prepara el contexto por request.
+ */
+export function attachLogger(base: ILogger) {
+  /**
+   * Middleware de Express ejecutado en cada request HTTP.
+   */
+  return async (req: Request, _res: Response, next: NextFunction) => {
+    /**
+     * Se adjunta el logger al objeto Request para evitar:
+     * - imports globales
+     * - singletons
+     * - acoplamiento directo en controllers
+     */
+    req.logger = base;
+
+    /**
+     * Se asigna un identificador único por request.
+     *
+     * - Si el cliente ya envía "x-request-id" (ej. API Gateway, Load Balancer),
+     *   se reutiliza para mantener trazabilidad entre servicios.
+     * - Si no existe, se genera un UUID local.
+     */
+    req.requestId = (req.headers["x-request-id"] as string) ?? randomUUID();
+
+    /**
+     * Continúa el pipeline normal de Express.
+     */
+    next();
+  };
+}
+```
+
+#### Adjuntar middleware en el servidor
+
+```ts
+// Path Ejemplo: src/presentation/server.ts
+
+import { ILogger } from "@jmlq/logger";
+import express from "express";
+import { attachLogger } from "./middlewares";
+
+export function createServer(base: ILogger) {
+  const app = express();
+  app.use(express.json()); // <-- necesario para POST JSON
+  app.use(attachLogger(base));
+
+  app.get("/health", (_req, res) => res.json({ ok: true }));
+
+  return app;
+}
+```
+
+#### Iniciar servidor
+
+**NOTA**: Esto se realiza en la raíz de la API
+
+```ts
+// Path Ejemplo: src/app.ts
+
+import { envs } from "./config/plugins";
+import { disposeLogs, flushLogs, loggerReady } from "./infrastructure/logger";
+import { createServer } from "./presentation/server";
+
+async function bootstrap() {
+  const logger = await loggerReady;
+
+  const app = createServer(logger);
+  const server = app.listen(envs.PORT, envs.HOST, () => {
+    console.log(`🚀 Server running at http://${envs.HOST}:${envs.PORT}`);
+    logger.info("http.start", { host: envs.HOST, port: envs.PORT });
+  });
+
+  server.on("error", async (err: any) => {
+    logger.error("http.listen.error", {
+      message: err?.message,
+      stack: err?.stack,
+    });
+    await flushLogs().catch(() => {});
+    await disposeLogs().catch(() => {});
+    process.exit(1);
+  });
+
+  // 3) Señales de apagado limpio
+  const shutdown = async (reason: string, code = 0) => {
+    logger.info("app.shutdown.begin", { reason });
+    server.close(async () => {
+      try {
+        await flushLogs();
+      } catch {}
+      try {
+        await disposeLogs();
+      } catch {}
+      logger.info("app.shutdown.end", { code });
+      process.exit(code);
+    });
+  };
+
+  process.on("SIGINT", () => shutdown("SIGINT"));
+  process.on("SIGTERM", () => shutdown("SIGTERM"));
+
+  // Fallos no controlados
+  process.on("unhandledRejection", async (err) => {
+    const e = err as any;
+    logger.error("unhandled.rejection", {
+      message: e?.message,
+      stack: e?.stack,
+    });
+    await shutdown("unhandledRejection", 1);
+  });
+
+  process.on("uncaughtException", async (err) => {
+    logger.error("uncaught.exception", {
+      message: err.message,
+      stack: err.stack,
+    });
+    await shutdown("uncaughtException", 1);
+  });
+}
+
+bootstrap().catch(async (err) => {
+  // Falla durante el bootstrap
+  const logger = await loggerReady.catch(() => null);
+  if (logger) {
+    logger.error("bootstrap.fatal", {
+      message: (err as Error)?.message,
+      stack: (err as Error)?.stack,
+    });
+    await flushLogs().catch(() => {});
+    await disposeLogs().catch(() => {});
+  } else {
+    // último recurso si el logger no llegó a inicializar
+    console.error("Fatal error (no logger):", err);
+  }
+  process.exit(1);
+});
+```
 
 ---
 
@@ -45,28 +483,26 @@ Con esta configuración se busca:
 El logger detecta y enmascara automáticamente datos sensibles utilizando patrones personalizados:
 
 ```js
-
-      patterns: [
-      // Tarjetas de crédito
-      {
-        pattern: "\\b\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b",
-        replaceWith: "****-****-****-****",
-      },
-      // Números de cuenta bancaria
-      {
-        pattern: "\\b\\d{10,20}\\b",
-        replaceWith: "****ACCOUNT****",
-      },
-      // Tokens JWT
-      {
-        pattern: "eyJ[A-Za-z0-9-_=]+\\.[A-Za-z0-9-_=]+\\.?[A-Za-z0-9-_.+/=]*",
-        replaceWith: "****JWT****",
-      },
-    ],
-
+patterns: [
+  // Tarjetas de crédito
+  {
+    pattern: "\\b\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}[-\\s]?\\d{4}\\b",
+    replaceWith: "****-****-****-****",
+  },
+  // Números de cuenta bancaria
+  {
+    pattern: "\\b\\d{10,20}\\b",
+    replaceWith: "****ACCOUNT****",
+  },
+  // Tokens JWT
+  {
+    pattern: "eyJ[A-Za-z0-9-_=]+\\.[A-Za-z0-9-_=]+\\.?[A-Za-z0-9-_.+/=]*",
+    replaceWith: "****JWT****",
+  },
+],
 ```
 
-Por ejemplo se tiene la siguiente información:
+Por ejemplo, si se tiene la siguiente información:
 
 ```js
 [
@@ -87,7 +523,7 @@ Por ejemplo se tiene la siguiente información:
 
 Los logs registrarán lo siguiente:
 
-> - **File .log** (`@jmlq/logger-plugin-fs`)
+> - **Archivo .log** (`@jmlq/logger-plugin-fs`)
 
 ```js
 {
@@ -117,15 +553,15 @@ Los logs registrarán lo siguiente:
 
 > - **MongoDB** (`@jmlq/logger-plugin-mongo`)
 
-![MongoDB log](./assets/mongo-log.png)
+![MongoDB log](assets/mongo-log.png)
 
-> - **MongoDB** (`@jmlq/logger-plugin-mongo`)
+> - **PostgreSQL** (`@jmlq/logger-plugin-postgresql`)
 
-![Postgresql log](./assets/pg-log.png)
+![PostgreSQL log](assets/pg-log.png)
 
 ### Filtros y Consultas
 
-#### 1. Obtener todos los logs de nivel WARN o superior (en este caso retorna WARN, ERROR y FATAL)
+#### 1. Obtener todos los logs de nivel WARN o superior (retorna WARN, ERROR y FATAL)
 
 ```ts
 const errors = await _req.logger?.getLogs({
@@ -138,8 +574,6 @@ Resultado:
 ```ini
 [2025-12-10T21:19:58.804Z] [50] app.error {"name":"AppError","code":"INTERNAL","message":"Unhandled exception","retryable":false,"meta":null,"cause":{"cause":{}},"stack":"AppError: Unhandled exception\n    at AppError.internal (D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\shared\\errors\\app-error.js:61:16)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\presentation\\middlewares\\http\\error.middleware.js:36:40\n    at Layer.handleError (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\lib\\layer.js:116:17)\n
    at trimPrefix (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:340:13)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:297:9\n    at processParams (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:582:12)\n    at Immediate.next (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:291:5)\n    at Immediate._onImmediate (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:688:15)\n    at process.processImmediate (node:internal/timers:485:21)"}
-[2025-12-10T21:19:58.804Z] [50] app.error {"code":"INTERNAL","name":"AppError","cause":{"cause":{}},"stack":"AppError: Unhandled exception\n    at AppError.internal (D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\shared\\errors\\app-error.js:61:16)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\presentation\\middlewares\\http\\error.middleware.js:36:40\n    at Layer.handleError (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\lib\\layer.js:116:17)\n    at trimPrefix (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:340:13)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:297:9\n    at processParams (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:582:12)\n    at Immediate.next (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:291:5)\n    at Immediate._onImmediate (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:688:15)\n    at process.processImmediate (node:internal/timers:485:21)","message":"Unhandled exception","retryable":false}
-
 ```
 
 **NOTA**: `parseLogLevel` es un helper para convertir un `string` a `LogLevel`.
@@ -158,9 +592,8 @@ Resultado:
 
 ```ini
 [2025-12-10T22:21:58.500Z] [30] app.shutdown.begin {"reason":"SIGINT"}
-[2025-12-10T21:12:59.216Z] [50] app.error {"name":"AppError","code":"INTERNAL","message":"Unhandled exception","retryable":false,"meta":null,"cause":{"cause":{}},"stack":"AppError: Unhandled exception\n    at AppError.internal (D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\shared\\errors\\app-error.js:61:16)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\presentation\\middlewares\\http\\error.middleware.js:36:40\n    at Layer.handleError (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\lib\\layer.js:116:17)\n    at trimPrefix (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:340:13)\n    at D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:297:9\n    at processParams (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:582:12)\n    at Immediate.next (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:291:5)\n    at Immediate._onImmediate (D:\\Fuentes\\Core\\ml-dev-rest-api\\node_modules\\router\\index.js:688:15)\n    at process.processImmediate (node:internal/timers:485:21)"}
+[2025-12-10T21:12:59.216Z] [50] app.error {"name":"AppError","code":"INTERNAL","message":"Unhandled exception","retryable":false,"meta":null,"cause":{"cause":{}},"stack":"AppError: Unhandled exception\n    at AppError.internal (D:\\Fuentes\\Core\\ml-dev-rest-api\\dist\\shared\\errors\\app-error.js:61:16)"}
 [2025-12-10T21:04:21.565Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","name":"John Doe","email":"***@***","card":"****-****-****-****"},{"id":"2","name":"Jane Doe","email":"***@***","card":"****-****-****-****"}]}
-[2025-12-10T21:04:21.565Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","card":"****-****-****-****","name":"John Doe","email":"***@***"},{"id":"2","card":"****-****-****-****","name":"Jane Doe","email":"***@***"}]}
 [2025-12-10T21:03:32.910Z] [30] http.start {"host":"127.0.0.1","port":3000}
 ```
 
@@ -197,50 +630,9 @@ Resultado:
 [2025-12-10T22:58:09.874Z] [30] Users listed successfully {"count":2,"result":[{"id":"1","name":"John Doe","email":"***@***","card":"****-****-****-****"},{"id":"2","name":"Jane Doe","email":"***@***","card":"****-****-****-****"}]}
 ```
 
-## 🏗️ Arquitectura
-
-El paquete sigue **Arquitectura Limpia**:
-
-```
-src/
-├─ domain/           # Reglas de negocio puras
-│  ├─ entities/
-│  ├─ value-objects/ # LogLevel
-│  ├─ services/      # PiiRedactor, MessageNormalizer
-│  ├─ ports/         # Interfaces/contratos
-│  └─ types/
-├─ application/      # Casos de uso
-│  ├─ use-cases/     # SaveLog, GetLogs, FlushBuffers
-│  └─ factory/       # LoggerFactory
-└─ infrastructure/   # Implementaciones concretas
-   └─ services/      # DataSourceService (composite)
-```
-
-### Casos de Uso Principales
-
-- **[`SaveLogUseCase`](src/application/use-cases/save-log.use-case.ts)** - Guarda logs aplicando filtros de nivel y PII
-- **[`GetLogsUseCase`](src/application/use-cases/get-logs.use-case.ts)** - Recupera logs con filtros
-- **[`FlushBuffersUseCase`](src/application/use-cases/flush-buffers.use-case.ts)** - Vacía buffers de datasources
-
-### Servicios de Dominio
-
-- **[`PiiRedactor`](src/domain/services/pii-redactor.service.ts)** - Enmascara datos sensibles
-- **[`MessageNormalizer`](src/domain/services/message-normalizer.service.ts)** - Normaliza mensajes de log
-- **[`LogLevelService`](src/domain/services/log-level.service.ts)** - Maneja niveles de log
-
-## 🔌 Plugins Disponibles
-
-| Plugin                           | Descripción                | NPM                                                             |
-| -------------------------------- | -------------------------- | --------------------------------------------------------------- |
-| `@jmlq/logger-plugin-fs`         | Persistencia en archivos   | [npm](https://npmjs.com/package/@jmlq/logger-plugin-fs)         |
-| `@jmlq/logger-plugin-mongo`      | Persistencia en MongoDB    | [npm](https://npmjs.com/package/@jmlq/logger-plugin-mongo)      |
-| `@jmlq/logger-plugin-postgresql` | Persistencia en PostgreSQL | [npm](https://npmjs.com/package/@jmlq/logger-plugin-postgresql) |
-
 ## 📄 Más Información
 
 - **[Arquitectura Detallada](./architecture.md)** - Documentación técnica completa
-- **[Guía de Instalación](./install.md)** - Configuración paso a paso
-- **[Ejemplos](./examples/)** - Códigos de ejemplo funcionales
 
 ## 📝 Licencia