@adatechnology/logger 0.0.8 → 0.0.10

package/README.md

@@ -107,9 +107,7 @@ Ao realizar um log, você pode passar as seguintes propriedades para enriquecer
 - `libMethod`: O método interno da biblioteca sendo executado. Ex: `get`.
 - `meta`: Objeto com metadados adicionais (será exibido em uma única linha compacta).
 
-> ✅ **Padrão recomendado:** enviar payload estruturado em `meta`.
->
-> ⚠️ **Compatibilidade legada:** payload em `params` ainda é aceito e promovido para `meta` internamente para não quebrar serviços antigos.
+> ✅ **Padrão obrigatório:** enviar payload estruturado em `meta`.
 
 ### `meta` vs `params` (recomendação)
 
@@ -130,20 +128,7 @@ this.logger.error({
 });
 ```
 
-Exemplo legado (ainda funciona, mas evite em código novo):
-
-```ts
-this.logger.error({
-  message: "Exception caught in filter",
-  context: "HttpExceptionFilter.logResponse",
-  requestId,
-  params: {
-    request: { path, method, headers, params, query, body },
-    response: { status, headers, messages },
-    error: { type, message, status, body, details },
-  },
-});
-```
+Campos fora do contrato (`message`, `context`, `meta`) não são recomendados na API pública.
 
 ### Exemplo de Log de Biblioteca
 

package/agents/skills/SKILL.md

@@ -6,42 +6,52 @@ description: Patterns for @adatechnology/logger. Use when configuring Winston lo
 # 📝 Logger Standards
 
 ## 🚀 Setup Example
+
 ```typescript
 @Module({
   imports: [
     LoggerModule.forRoot({
-      level: 'info',
-      sensitiveKeys: ['password', 'token', 'clientSecret'],
+      level: "info",
+      sensitiveKeys: ["password", "token", "clientSecret"],
     }),
   ],
 })
 export class AppModule implements NestModule {
   configure(consumer: MiddlewareConsumer) {
     // Required to enable Request-ID tracking across async calls
-    consumer.apply(RequestContextMiddleware).forRoutes('*');
+    consumer.apply(RequestContextMiddleware).forRoutes("*");
   }
 }
 ```
 
 ## 🏗️ Usage Pattern
+
 ```typescript
 @Injectable()
 export class MyService {
   constructor(
-    @Inject(LOGGER_PROVIDER) private readonly logger: LoggerProviderInterface
+    @Inject(LOGGER_PROVIDER) private readonly logger: LoggerProviderInterface,
   ) {}
 
   doWork() {
-    this.logger.info('Action performed', { userId: '123' });
+    this.logger.info({
+      message: "Action performed",
+      context: MyService.name,
+      meta: { userId: "123" },
+    });
   }
 }
 ```
 
 ## 🔐 Obfuscation
+
 The logger automatically hides values for keys defined in `sensitiveKeys`.
+
 - **Default Keys**: `password`, `token`, `authorization`, `cookie`, `secret`.
 - **Custom Keys**: Add via `LoggerModule.forRoot()`.
 
 ## 🛠️ Internal Mechanics
+
 - **Async Context**: Uses `AsyncLocalStorage` to store the Request-ID.
 - **Context Access**: Use `getContext()` to retrieve the current request state anywhere in the call stack.
+- **Type naming**: aliases de tipagem com sufixo `Params`/`Result` devem usar **PascalCase** (ex.: `InfoParams`, `InfoResult`).

package/dist/index.d.ts

@@ -1,5 +1,7 @@
+import * as _nestjs_common from '@nestjs/common';
 import { DynamicModule, NestMiddleware, NestInterceptor, ExecutionContext, CallHandler } from '@nestjs/common';
 import { LoggerOptions } from 'winston';
+import { Reflector } from '@nestjs/core';
 import { Observable } from 'rxjs';
 
 interface ObfuscatorKey {
@@ -19,18 +21,32 @@ declare enum LoggerLevel {
     WARN = "warn",
     ERROR = "error"
 }
-interface LogPayload {
+type LogParams = {
     message: string;
     context?: string;
     meta?: Record<string, unknown>;
-}
+};
+type LogResult = void;
+type DebugParams = LogParams;
+type DebugResult = LogResult;
+type InfoParams = LogParams;
+type InfoResult = LogResult;
+type WarnParams = LogParams;
+type WarnResult = LogResult;
+type ErrorParams = LogParams;
+type ErrorResult = LogResult;
 interface LoggerProviderInterface {
-    debug(payload: LogPayload): void;
-    info(payload: LogPayload): void;
-    warn(payload: LogPayload): void;
-    error(payload: LogPayload): void;
+    debug(params: DebugParams): DebugResult;
+    info(params: InfoParams): InfoResult;
+    warn(params: WarnParams): WarnResult;
+    error(params: ErrorParams): ErrorResult;
     setContext?(context: string): void;
 }
+type WriteLogParams = {
+    level: LoggerLevel;
+    payload: LogParams;
+};
+type WriteLogResult = LogResult;
 
 interface LoggerConfig extends WinstonModuleConfig {
     /**
@@ -69,10 +85,16 @@ interface LoggerConfig extends WinstonModuleConfig {
      * Versão da biblioteca/módulo que está gerando o log
      */
     libVersion?: string;
+    /**
+     * Rotas excluídas do HttpLoggingInterceptor (ex.: ['/health'])
+     * Suporta prefixo exato ou parcial via startsWith
+     */
+    interceptorExcludedPaths?: string[];
 }
 declare const DEFAULT_LOGGER_CONFIG: LoggerConfig;
 
 declare const LOGGER_PROVIDER = "LOGGER_PROVIDER";
+declare const LOGGER_CONFIG = "LOGGER_CONFIG";
 declare const HTTP_LOGGING_INTERCEPTOR = "HTTP_LOGGING_INTERCEPTOR";
 
 declare class LoggerModule {
@@ -99,7 +121,11 @@ declare class RequestContextMiddleware implements NestMiddleware {
 
 declare class HttpLoggingInterceptor implements NestInterceptor {
     private readonly logger;
-    constructor(logger: LoggerProviderInterface);
+    private readonly reflector;
+    private readonly excludedPaths;
+    private toErrorMessage;
+    constructor(logger: LoggerProviderInterface, reflector: Reflector, config?: LoggerConfig);
+    private isExcluded;
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
 }
 
@@ -109,9 +135,11 @@ declare const HTTP_LOGGING_INTERCEPTOR_CONTEXT: {
     readonly ON_ERROR: "HttpLoggingInterceptor.onError";
 };
 
+declare const ExcludeHttpLogging: () => _nestjs_common.CustomDecorator<string>;
+
 type RequestContext = Record<string, unknown> | undefined;
 
 declare function getContext(): RequestContext;
 declare function runWithContext<T>(ctx: Record<string, unknown>, fn: () => T): T;
 
-export { DEFAULT_LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR, HTTP_LOGGING_INTERCEPTOR_CONTEXT, HttpLoggingInterceptor, LOGGER_PROVIDER, type LogPayload, type LoggerConfig, LoggerLevel, LoggerModule, type LoggerProviderInterface, RequestContextMiddleware, getContext, runWithContext };
+export { DEFAULT_LOGGER_CONFIG, type DebugParams, type DebugResult, type ErrorParams, type ErrorResult, ExcludeHttpLogging, HTTP_LOGGING_INTERCEPTOR, HTTP_LOGGING_INTERCEPTOR_CONTEXT, HttpLoggingInterceptor, type InfoParams, type InfoResult, LOGGER_CONFIG, LOGGER_PROVIDER, type LogParams, type LogResult, type LoggerConfig, LoggerLevel, LoggerModule, type LoggerProviderInterface, RequestContextMiddleware, type WarnParams, type WarnResult, type WriteLogParams, type WriteLogResult, getContext, runWithContext };