@adatechnology/logger 0.0.8 → 0.0.10

package/src/implementations/winston/winston.logger.module.ts

@@ -1,6 +1,6 @@
 import { DynamicModule, Module, Provider } from "@nestjs/common";
 import { createLogger, format, transports, LoggerOptions } from "winston";
-import { inspect } from "util";
+import { inspect } from "node:util";
 import { WinstonLoggerProvider } from "./winston.logger.provider";
 import {
   WINSTON_LOGGER,
@@ -11,6 +11,227 @@ import type { LoggerConfig } from "../../logger.config";
 import { DEFAULT_LOG_LEVEL } from "./winston.logger.constants";
 import { buildDefaultObfuscator } from "../../obfuscator";
 
+type WritableLogInfo = Record<string, unknown> & {
+  level?: unknown;
+  message?: unknown;
+  timestamp?: unknown;
+  requestId?: unknown;
+  context?: unknown;
+  source?: unknown;
+  appName?: unknown;
+  appVersion?: unknown;
+  lib?: unknown;
+  libVersion?: unknown;
+  libMethod?: unknown;
+  stack?: unknown;
+  meta?: unknown;
+};
+
+type MetaLogContext = {
+  className?: unknown;
+  methodName?: unknown;
+};
+
+function asString(value: unknown): string | undefined {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return undefined;
+}
+
+function colorizeText(
+  useColors: boolean,
+  color: string,
+  reset: string,
+  text: string,
+): string {
+  return useColors ? `${color}${text}${reset}` : text;
+}
+
+function fillInfoFromMeta(info: WritableLogInfo): void {
+  if (!info.meta || typeof info.meta !== "object") return;
+
+  const meta = info.meta as Record<string, unknown>;
+  const metadataKeys = [
+    "requestId",
+    "context",
+    "source",
+    "lib",
+    "libVersion",
+    "libMethod",
+    "appName",
+    "appVersion",
+  ] as const;
+
+  for (const key of metadataKeys) {
+    if (meta[key] && !info[key]) {
+      info[key] = meta[key];
+      delete meta[key];
+    }
+  }
+
+  const logContext = meta.logContext as MetaLogContext | undefined;
+  if (!logContext || info.source) return;
+
+  const className = asString(logContext.className);
+  const methodName = asString(logContext.methodName);
+
+  if (className && methodName) {
+    info.source = `${className}.${methodName}`;
+  } else if (className) {
+    info.source = className;
+  } else if (methodName) {
+    info.source = methodName;
+  }
+}
+
+function applyDefaultInfoValues(
+  info: WritableLogInfo,
+  config?: LoggerConfig,
+): void {
+  info.requestId = info.requestId || "no-request-id";
+  info.context = info.context || config?.context || "App";
+  info.appName = info.appName || config?.appName;
+  info.appVersion = info.appVersion || config?.appVersion;
+  info.lib = info.lib || config?.lib;
+  info.libVersion = info.libVersion || config?.libVersion;
+}
+
+function buildMethodDisplays(params: {
+  context: string;
+  source?: string;
+  lib?: string;
+  libMethod?: string;
+  colorize: (text: string) => string;
+}): { sourceDisplay: string; libMethodDisplay: string } {
+  const { context, source, lib, libMethod, colorize } = params;
+
+  let sourceDisplay = "";
+  let libMethodDisplay = "";
+
+  if (source) {
+    sourceDisplay = `[${colorize(source)}]`;
+  }
+
+  if (lib) {
+    const methodPath = libMethod ? `${context}.${libMethod}` : context;
+    libMethodDisplay = `[${colorize(methodPath)}]`;
+    if (source === context || source === methodPath) {
+      sourceDisplay = "";
+    }
+    return { sourceDisplay, libMethodDisplay };
+  }
+
+  if (!source) {
+    libMethodDisplay = `[${colorize(context)}]`;
+    return { sourceDisplay, libMethodDisplay };
+  }
+
+  if (source.startsWith(`${context}.`) || source === context) {
+    libMethodDisplay = `[${colorize(source)}]`;
+    sourceDisplay = "";
+    return { sourceDisplay, libMethodDisplay };
+  }
+
+  libMethodDisplay = `[${colorize(context)}]`;
+  sourceDisplay = `[${colorize(source)}]`;
+  return { sourceDisplay, libMethodDisplay };
+}
+
+function formatDevelopmentLog(
+  infoInput: WritableLogInfo,
+  useColors: boolean,
+  levelColorizer: ReturnType<typeof format.colorize>,
+): string {
+  const info = infoInput;
+  const level = asString(info.level) ?? "info";
+  const message = asString(info.message) ?? "";
+  const timestamp = asString(info.timestamp) ?? "";
+  const requestId = asString(info.requestId) ?? "no-request-id";
+  const context = asString(info.context) ?? "App";
+  const source = asString(info.source);
+  const appName = asString(info.appName);
+  const appVersion = asString(info.appVersion);
+  const lib = asString(info.lib);
+  const libMethod = asString(info.libMethod);
+  const libVersion = asString(info.libVersion);
+  const stack = asString(info.stack);
+
+  const meta =
+    info.meta && typeof info.meta === "object"
+      ? (info.meta as Record<string, unknown>)
+      : undefined;
+
+  const colors = {
+    reset: "\x1b[0m",
+    gray: "\x1b[90m",
+    cyan: "\x1b[36m",
+    magenta: "\x1b[35m",
+    yellow: "\x1b[33m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+  };
+
+  const coloredLevel = useColors
+    ? levelColorizer.colorize(level, level.toUpperCase())
+    : level.toUpperCase();
+
+  const coloredTime = colorizeText(
+    useColors,
+    colors.gray,
+    colors.reset,
+    timestamp,
+  );
+  const coloredRequestId = colorizeText(
+    useColors,
+    colors.cyan,
+    colors.reset,
+    requestId,
+  );
+
+  let appDisplay = "";
+  if (appName) {
+    const appText = appVersion ? `${appName}@${appVersion}` : appName;
+    const appLabel = `App-${appText}`;
+    appDisplay = `[${colorizeText(useColors, colors.green, colors.reset, appLabel)}]`;
+  }
+
+  let libDisplay = "";
+  if (lib) {
+    const libText = libVersion ? `${lib}:${libVersion}` : lib;
+    libDisplay = `[${colorizeText(useColors, colors.yellow, colors.reset, libText)}]`;
+  }
+
+  const { sourceDisplay, libMethodDisplay } = buildMethodDisplays({
+    context,
+    source,
+    lib,
+    libMethod,
+    colorize: (text) =>
+      colorizeText(useColors, colors.magenta, colors.reset, text),
+  });
+
+  let output = `${appDisplay}${libDisplay}[${coloredRequestId}][${coloredTime}]${sourceDisplay}${libMethodDisplay}[${coloredLevel}] - ${message}`;
+
+  if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+    const inspectedMeta = inspect(meta, {
+      colors: useColors,
+      depth: null,
+      compact: true,
+      sorted: true,
+      breakLength: Infinity,
+    });
+    output += ` - ${inspectedMeta}`;
+  }
+
+  if (stack) {
+    output += `\n${colorizeText(useColors, colors.red, colors.reset, stack)}`;
+  }
+
+  return output;
+}
+
 @Module({})
 export class WinstonImplementationModule {
   static forRoot(config?: LoggerConfig): DynamicModule {
@@ -91,181 +312,17 @@ export class WinstonImplementationModule {
 
     // Standard fields we want to ensure are in the log object
     const standardFields = format((info) => {
-      // Extract requestId and context from meta if they exist there
-      const meta = info.meta as any;
-      if (meta) {
-        if (meta.requestId && !info.requestId) {
-          info.requestId = meta.requestId;
-          delete meta.requestId;
-        }
-        if (meta.context && !info.context) {
-          info.context = meta.context;
-          delete meta.context;
-        }
-
-        // Extract source (used for className.methodName)
-        if (meta.source && !info.source) {
-          info.source = meta.source;
-          delete meta.source;
-        }
-
-        // Support lib identification from metadata
-        if (meta.lib && !info.lib) {
-          info.lib = meta.lib;
-          delete meta.lib;
-        }
-
-        // Support lib version identification from metadata
-        if (meta.libVersion && !info.libVersion) {
-          info.libVersion = meta.libVersion;
-          delete meta.libVersion;
-        }
-
-        // Support lib method identification
-        if (meta.libMethod && !info.libMethod) {
-          info.libMethod = meta.libMethod;
-          delete meta.libMethod;
-        }
-
-        // Support app identification from metadata
-        if (meta.appName && !info.appName) {
-          info.appName = meta.appName;
-          delete meta.appName;
-        }
-
-        // Support app version identification from metadata
-        if (meta.appVersion && !info.appVersion) {
-          info.appVersion = meta.appVersion;
-          delete meta.appVersion;
-        }
-
-        // Support logContext object from some providers
-        if (meta.logContext && !info.source) {
-          const lc = meta.logContext;
-          if (lc.className && lc.methodName) {
-            info.source = `${lc.className}.${lc.methodName}`;
-          } else if (lc.className) {
-            info.source = lc.className;
-          } else if (lc.methodName) {
-            info.source = lc.methodName;
-          }
-        }
-      }
-
-      // Default values
-      info.requestId = info.requestId || "no-request-id";
-      info.context = info.context || config?.context || "App";
-      info.appName = info.appName || config?.appName;
-      info.appVersion = info.appVersion || config?.appVersion;
-      info.lib = info.lib || config?.lib;
-      info.libVersion = info.libVersion || config?.libVersion;
-      
-      return info;
+      const writableInfo = info as WritableLogInfo;
+      fillInfoFromMeta(writableInfo);
+      applyDefaultInfoValues(writableInfo, config);
+      return writableInfo;
     });
 
     const levelColorizer = format.colorize();
 
     // Custom format for development (colorful and intuitive)
-    const developmentFormat = format.printf(
-      (info) => {
-        const { 
-          level, message, timestamp, requestId, context, source, 
-          meta, stack, appName, appVersion, lib, libMethod, libVersion 
-        } = info;
-        
-        // Colors (using ANSI codes for precision)
-        const colors = {
-          reset: "\x1b[0m",
-          gray: "\x1b[90m",
-          cyan: "\x1b[36m",
-          magenta: "\x1b[35m",
-          yellow: "\x1b[33m",
-          red: "\x1b[31m",
-          green: "\x1b[32m",
-          bold: "\x1b[1m",
-        };
-
-        const colorize = (color: string, text: string) => 
-          useColors ? `${color}${text}${colors.reset}` : text;
-
-        // No trailing space for the level itself, but keep it uppercase
-        const coloredLevel = useColors 
-          ? levelColorizer.colorize(level, level.toUpperCase()) 
-          : level.toUpperCase();
-          
-        const coloredTime = colorize(colors.gray, timestamp);
-        const coloredRequestId = colorize(colors.cyan, requestId);
-        
-        // App identification: [App-example@0.0.3]
-        let appDisplay = "";
-        if (appName) {
-          const appText = appVersion ? `${appName}@${appVersion}` : appName;
-          appDisplay = `[${colorize(colors.green, `App-${appText}`)}]`;
-        }
-
-        // Lib identification: [@adatechnology/http-client:0.0.2]
-        let libDisplay = "";
-        if (lib) {
-          const libText = libVersion ? `${lib}:${libVersion}` : lib;
-          libDisplay = `[${colorize(colors.yellow, libText)}]`;
-        }
-
-        const mag = colors.magenta;
-
-        // Context formatting logic:
-        // [Source] (Magenta) - From the caller (e.g., HttpClientController.listPokemon)
-        // [Context.Method] (Magenta) - From the lib itself (e.g., HttpRedisClient.get)
-        let sourceDisplay = "";
-        let libMethodDisplay = "";
-
-        if (source) {
-          sourceDisplay = `[${colorize(mag, source)}]`;
-        }
-
-        if (lib) {
-          // Inside a library log
-          const methodPath = libMethod ? `${context}.${libMethod}` : context;
-          libMethodDisplay = `[${colorize(mag, methodPath)}]`;
-          
-          // If source is the same as context or methodPath, we can omit it to avoid duplication
-          if (source === context || source === methodPath) {
-            sourceDisplay = "";
-          }
-        } else if (!source) {
-          // App-only log without source: use context
-          libMethodDisplay = `[${colorize(mag, context)}]`;
-        } else if (source.startsWith(`${context}.`) || source === context) {
-          // App-only log where source is more specific than context: use source only
-          libMethodDisplay = `[${colorize(mag, source)}]`;
-          sourceDisplay = "";
-        } else {
-          // App-only log with different context and source
-          libMethodDisplay = `[${colorize(mag, context)}]`;
-          sourceDisplay = `[${colorize(mag, source)}]`;
-        }
-
-        // Header line: [App][Lib][requestId][timestamp][Source][LibMethod][LEVEL]
-        let output = `${appDisplay}${libDisplay}[${coloredRequestId}][${coloredTime}]${sourceDisplay}${libMethodDisplay}[${coloredLevel}] - ${message}`;
-
-        // Meta data (Pretty printed if not empty)
-        if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
-          const inspectedMeta = inspect(meta, {
-            colors: useColors,
-            depth: null,
-            compact: true,
-            sorted: true,
-            breakLength: Infinity,
-          });
-          output += ` - ${inspectedMeta}`;
-        }
-
-        // Error stack trace
-        if (stack) {
-          output += `\n${colorize(colors.red, stack)}`;
-        }
-
-        return output;
-      }
+    const developmentFormat = format.printf((info) =>
+      formatDevelopmentLog(info as WritableLogInfo, useColors, levelColorizer),
     );
 
     const formats = [
@@ -294,11 +351,9 @@ export class WinstonImplementationModule {
       transports: [consoleTransport],
     };
 
-    const mergedOptions: LoggerOptions = Object.assign(
-      {},
-      defaultOptions,
-      config?.loggerOptions || {},
-    );
+    const mergedOptions: LoggerOptions = config?.loggerOptions
+      ? { ...defaultOptions, ...config.loggerOptions }
+      : defaultOptions;
 
     return createLogger(mergedOptions);
   }

package/src/implementations/winston/winston.logger.provider.ts

@@ -1,10 +1,18 @@
 import { Injectable, Inject } from "@nestjs/common";
 import { Logger as WinstonLoggerType } from "winston";
 import {
-  type LogPayload,
+  type DebugParams,
+  type DebugResult,
+  type ErrorParams,
+  type ErrorResult,
+  type InfoParams,
+  type InfoResult,
   type LoggerProviderInterface,
   LoggerLevel,
-  type LogParams,
+  type WarnParams,
+  type WarnResult,
+  type WriteLogParams,
+  type WriteLogResult,
 } from "../../logger.interface";
 import type { Obfuscator } from "./winston.logger.types";
 import { getContext } from "../../context/async-context.service";
@@ -20,76 +28,67 @@ export class WinstonLoggerProvider implements LoggerProviderInterface {
     @Inject(WINSTON_OBFUSCATOR) private readonly obfuscator?: Obfuscator,
   ) {}
 
-  debug(payload: LogPayload): void;
-  debug(message: string, meta?: Record<string, unknown>, context?: string): void;
-  debug(messageOrPayload: string | LogPayload, meta?: Record<string, unknown>, context?: string): void {
-    this.handleLog(LoggerLevel.DEBUG, messageOrPayload, meta, context);
+  debug(payload: DebugParams): DebugResult {
+    this.log({
+      level: LoggerLevel.DEBUG,
+      payload: {
+        ...payload,
+        context: payload.context || this.context,
+      },
+    });
   }
 
-  info(payload: LogPayload): void;
-  info(message: string, meta?: Record<string, unknown>, context?: string): void;
-  info(messageOrPayload: string | LogPayload, meta?: Record<string, unknown>, context?: string): void {
-    this.handleLog(LoggerLevel.INFO, messageOrPayload, meta, context);
+  info(payload: InfoParams): InfoResult {
+    this.log({
+      level: LoggerLevel.INFO,
+      payload: {
+        ...payload,
+        context: payload.context || this.context,
+      },
+    });
   }
 
-  warn(payload: LogPayload): void;
-  warn(message: string, meta?: Record<string, unknown>, context?: string): void;
-  warn(messageOrPayload: string | LogPayload, meta?: Record<string, unknown>, context?: string): void {
-    this.handleLog(LoggerLevel.WARN, messageOrPayload, meta, context);
+  warn(payload: WarnParams): WarnResult {
+    this.log({
+      level: LoggerLevel.WARN,
+      payload: {
+        ...payload,
+        context: payload.context || this.context,
+      },
+    });
   }
 
-  error(payload: LogPayload): void;
-  error(message: string, meta?: Record<string, unknown>, context?: string): void;
-  error(messageOrPayload: string | LogPayload, meta?: Record<string, unknown>, context?: string): void {
-    this.handleLog(LoggerLevel.ERROR, messageOrPayload, meta, context);
+  error(payload: ErrorParams): ErrorResult {
+    this.log({
+      level: LoggerLevel.ERROR,
+      payload: {
+        ...payload,
+        context: payload.context || this.context,
+      },
+    });
   }
 
   setContext(context: string): void {
     this.context = context;
   }
 
-  private handleLog(
-    level: LoggerLevel,
-    messageOrPayload: string | LogPayload,
-    meta?: Record<string, unknown>,
-    context?: string,
-  ): void {
-    let payload: LogPayload;
-
-    if (typeof messageOrPayload === "string") {
-      payload = {
-        message: messageOrPayload,
-        meta,
-        context: context || this.context,
-      };
-    } else {
-      payload = {
-        ...messageOrPayload,
-        context: messageOrPayload.context || context || this.context,
-        meta: { ...messageOrPayload.meta, ...meta },
-      };
-    }
-
-    this.log({ level, payload });
-  }
-
-  private log(params: LogParams) {
+  private log(params: WriteLogParams): WriteLogResult {
     const { level, payload } = params;
     // Extract standard fields but keep the rest to pass to Winston
     const { message, context, meta, ...rest } = payload as any;
-    
+
     const messageText = message ?? EMPTY_STRING;
     const messageContext = context ?? this.context;
     const obfuscatedMeta = this.obfuscator ? this.obfuscator(meta) : meta;
 
     const requestContext = getContext();
-    const requestIdFromContext = (requestContext as Record<string, unknown> | undefined)?.requestId;
-    
+    const requestIdFromContext = requestContext?.requestId;
+
     // Merge everything into a flat info object for Winston
     const logInfo: Record<string, unknown> = {
       ...rest,
       context: messageContext,
-      requestId: requestIdFromContext || payload.requestId,
+      requestId: requestIdFromContext || rest.requestId,
       meta: obfuscatedMeta,
     };
 

package/src/index.ts

@@ -1,13 +1,25 @@
 export { LoggerModule } from "./logger.module";
-export { LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR } from "./logger.token";
+export { LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR } from "./logger.token";
 export type {
+  DebugParams,
+  DebugResult,
+  ErrorParams,
+  ErrorResult,
+  InfoParams,
+  InfoResult,
+  LogParams,
+  LogResult,
   LoggerProviderInterface,
-  LogPayload,
   LoggerLevel,
+  WarnParams,
+  WarnResult,
+  WriteLogParams,
+  WriteLogResult,
 } from "./logger.interface";
 export { RequestContextMiddleware } from "./middleware/request-context.middleware";
 export { HttpLoggingInterceptor } from "./interceptors/http-logging.interceptor";
 export { HTTP_LOGGING_INTERCEPTOR_CONTEXT } from "./interceptors/http-logging.interceptor.constant";
+export { ExcludeHttpLogging } from "./interceptors/exclude-http-logging.decorator";
 export { getContext, runWithContext } from "./context/async-context.service";
 export type { LoggerConfig } from "./logger.config";
 export { DEFAULT_LOGGER_CONFIG } from "./logger.config";

package/src/interceptors/exclude-http-logging.decorator.ts

@@ -0,0 +1,6 @@
+import { SetMetadata } from "@nestjs/common";
+
+export const EXCLUDE_HTTP_LOGGING_KEY = "EXCLUDE_HTTP_LOGGING";
+
+export const ExcludeHttpLogging = () =>
+  SetMetadata(EXCLUDE_HTTP_LOGGING_KEY, true);

package/src/interceptors/http-logging.interceptor.ts

@@ -1,16 +1,43 @@
-import { CallHandler, ExecutionContext, Inject, Injectable, NestInterceptor } from "@nestjs/common";
+import { CallHandler, ExecutionContext, Inject, Injectable, NestInterceptor, Optional } from "@nestjs/common";
+import { Reflector } from "@nestjs/core";
 import { Observable } from "rxjs";
 import { tap } from "rxjs/operators";
-import { LOGGER_PROVIDER } from "../logger.token";
+import { LOGGER_PROVIDER, LOGGER_CONFIG } from "../logger.token";
 import type { LoggerProviderInterface } from "../logger.interface";
+import type { LoggerConfig } from "../logger.config";
 import { HTTP_LOGGING_INTERCEPTOR_CONTEXT } from "./http-logging.interceptor.constant";
+import { EXCLUDE_HTTP_LOGGING_KEY } from "./exclude-http-logging.decorator";
 
 @Injectable()
 export class HttpLoggingInterceptor implements NestInterceptor {
+  private readonly excludedPaths: string[];
+
+  private toErrorMessage(error: unknown): string {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "string") return error;
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return "unknown error";
+    }
+  }
+
   constructor(
     @Inject(LOGGER_PROVIDER)
     private readonly logger: LoggerProviderInterface,
-  ) {}
+    private readonly reflector: Reflector,
+    @Optional() @Inject(LOGGER_CONFIG)
+    config?: LoggerConfig,
+  ) {
+    this.excludedPaths = config?.interceptorExcludedPaths ?? [];
+  }
+
+  private isExcluded(url: string): boolean {
+    const normalized = url.replace(/^\/v\d+/, "");
+    return this.excludedPaths.some(
+      (path) => normalized === path || normalized.startsWith(path + "/"),
+    );
+  }
 
   intercept(context: ExecutionContext, next: CallHandler): Observable<unknown> {
     const http = context.switchToHttp();
@@ -18,6 +45,15 @@ export class HttpLoggingInterceptor implements NestInterceptor {
     const response = http.getResponse<Record<string, any>>();
     const start = Date.now();
 
+    const isDecoratorExcluded = this.reflector.getAllAndOverride<boolean>(
+      EXCLUDE_HTTP_LOGGING_KEY,
+      [context.getHandler(), context.getClass()],
+    );
+
+    if (isDecoratorExcluded || this.isExcluded(request.url)) {
+      return next.handle();
+    }
+
     const { method, url, headers, body, query, params } = request;
 
     this.logger.info({
@@ -73,7 +109,7 @@ export class HttpLoggingInterceptor implements NestInterceptor {
               },
               response: {
                 durationMs,
-                error: error instanceof Error ? error.message : String(error),
+                error: this.toErrorMessage(error),
               },
             },
           });

package/src/logger.config.ts

@@ -46,6 +46,12 @@ export 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[];
 }
 
 export const DEFAULT_LOGGER_CONFIG: LoggerConfig = {