@adatechnology/logger 0.0.9 → 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

@@ -21,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 {
     /**
@@ -109,6 +123,7 @@ declare class HttpLoggingInterceptor implements NestInterceptor {
     private readonly logger;
     private readonly reflector;
     private readonly excludedPaths;
+    private toErrorMessage;
     constructor(logger: LoggerProviderInterface, reflector: Reflector, config?: LoggerConfig);
     private isExcluded;
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
@@ -127,4 +142,4 @@ 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, ExcludeHttpLogging, HTTP_LOGGING_INTERCEPTOR, HTTP_LOGGING_INTERCEPTOR_CONTEXT, HttpLoggingInterceptor, LOGGER_CONFIG, 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 };

package/dist/index.js

@@ -9049,23 +9049,22 @@ var LoggerProvider = class {
   constructor(implementation) {
     this.implementation = implementation;
   }
-  debug(...args) {
-    return this.implementation.debug(...args);
+  debug(params) {
+    return this.implementation.debug(params);
   }
-  info(...args) {
-    return this.implementation.info(...args);
+  info(params) {
+    return this.implementation.info(params);
   }
-  warn(...args) {
-    return this.implementation.warn(...args);
+  warn(params) {
+    return this.implementation.warn(params);
   }
-  error(...args) {
-    return this.implementation.error(...args);
+  error(params) {
+    return this.implementation.error(params);
   }
   setContext(context) {
     if (typeof this.implementation.setContext === "function") {
       return this.implementation.setContext(context);
     }
-    return;
   }
 };
 LoggerProvider = _ts_decorate([
@@ -9085,7 +9084,7 @@ var HTTP_LOGGING_INTERCEPTOR = "HTTP_LOGGING_INTERCEPTOR";
 // src/implementations/winston/winston.logger.module.ts
 var import_common3 = require("@nestjs/common");
 var import_winston2 = require("winston");
-var import_util = require("util");
+var import_node_util = require("util");
 
 // src/implementations/winston/winston.logger.provider.ts
 var import_common2 = require("@nestjs/common");
@@ -9101,8 +9100,8 @@ var LoggerLevel = /* @__PURE__ */ (function(LoggerLevel2) {
 })({});
 
 // src/context/async-context.service.ts
-var import_async_hooks = require("async_hooks");
-var asyncLocalStorage = new import_async_hooks.AsyncLocalStorage();
+var import_node_async_hooks = require("async_hooks");
+var asyncLocalStorage = new import_node_async_hooks.AsyncLocalStorage();
 function getContext() {
   return asyncLocalStorage.getStore();
 }
@@ -9166,44 +9165,45 @@ var WinstonLoggerProvider = class {
     this.logger = logger;
     this.obfuscator = obfuscator;
   }
-  debug(messageOrPayload, meta, context) {
-    this.handleLog(LoggerLevel.DEBUG, messageOrPayload, meta, context);
+  debug(payload) {
+    this.log({
+      level: LoggerLevel.DEBUG,
+      payload: {
+        ...payload,
+        context: payload.context || this.context
+      }
+    });
   }
-  info(messageOrPayload, meta, context) {
-    this.handleLog(LoggerLevel.INFO, messageOrPayload, meta, context);
+  info(payload) {
+    this.log({
+      level: LoggerLevel.INFO,
+      payload: {
+        ...payload,
+        context: payload.context || this.context
+      }
+    });
   }
-  warn(messageOrPayload, meta, context) {
-    this.handleLog(LoggerLevel.WARN, messageOrPayload, meta, context);
+  warn(payload) {
+    this.log({
+      level: LoggerLevel.WARN,
+      payload: {
+        ...payload,
+        context: payload.context || this.context
+      }
+    });
   }
-  error(messageOrPayload, meta, context) {
-    this.handleLog(LoggerLevel.ERROR, messageOrPayload, meta, context);
+  error(payload) {
+    this.log({
+      level: LoggerLevel.ERROR,
+      payload: {
+        ...payload,
+        context: payload.context || this.context
+      }
+    });
   }
   setContext(context) {
     this.context = context;
   }
-  handleLog(level, messageOrPayload, meta, context) {
-    let payload;
-    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
-    });
-  }
   log(params) {
     const { level, payload } = params;
     const { message, context, meta, ...rest } = payload;
@@ -9215,7 +9215,7 @@ var WinstonLoggerProvider = class {
     const logInfo = {
       ...rest,
       context: messageContext,
-      requestId: requestIdFromContext || payload.requestId,
+      requestId: requestIdFromContext || rest.requestId,
       meta: obfuscatedMeta
     };
     this.logger.log(level, messageText, logInfo);
@@ -9332,6 +9332,163 @@ function _ts_decorate3(decorators, target, key, desc) {
   return c > 3 && r && Object.defineProperty(target, key, r), r;
 }
 __name(_ts_decorate3, "_ts_decorate");
+function asString(value) {
+  if (typeof value === "string") return value;
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  return void 0;
+}
+__name(asString, "asString");
+function colorizeText(useColors, color, reset, text) {
+  return useColors ? `${color}${text}${reset}` : text;
+}
+__name(colorizeText, "colorizeText");
+function fillInfoFromMeta(info) {
+  if (!info.meta || typeof info.meta !== "object") return;
+  const meta = info.meta;
+  const metadataKeys = [
+    "requestId",
+    "context",
+    "source",
+    "lib",
+    "libVersion",
+    "libMethod",
+    "appName",
+    "appVersion"
+  ];
+  for (const key of metadataKeys) {
+    if (meta[key] && !info[key]) {
+      info[key] = meta[key];
+      delete meta[key];
+    }
+  }
+  const logContext = meta.logContext;
+  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;
+  }
+}
+__name(fillInfoFromMeta, "fillInfoFromMeta");
+function applyDefaultInfoValues(info, config) {
+  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;
+}
+__name(applyDefaultInfoValues, "applyDefaultInfoValues");
+function buildMethodDisplays(params) {
+  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
+  };
+}
+__name(buildMethodDisplays, "buildMethodDisplays");
+function formatDevelopmentLog(infoInput, useColors, levelColorizer) {
+  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 : void 0;
+  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: /* @__PURE__ */ __name((text) => colorizeText(useColors, colors.magenta, colors.reset, text), "colorize")
+  });
+  let output = `${appDisplay}${libDisplay}[${coloredRequestId}][${coloredTime}]${sourceDisplay}${libMethodDisplay}[${coloredLevel}] - ${message}`;
+  if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
+    const inspectedMeta = (0, import_node_util.inspect)(meta, {
+      colors: useColors,
+      depth: null,
+      compact: true,
+      sorted: true,
+      breakLength: Infinity
+    });
+    output += ` - ${inspectedMeta}`;
+  }
+  if (stack) {
+    output += `
+${colorizeText(useColors, colors.red, colors.reset, stack)}`;
+  }
+  return output;
+}
+__name(formatDevelopmentLog, "formatDevelopmentLog");
 var WinstonImplementationModule = class _WinstonImplementationModule {
   static {
     __name(this, "WinstonImplementationModule");
@@ -9406,124 +9563,13 @@ var WinstonImplementationModule = class _WinstonImplementationModule {
     const isProduction = config?.isProduction ?? process.env.NODE_ENV === "production";
     const useColors = config?.colorize !== false;
     const standardFields = (0, import_winston2.format)((info) => {
-      const meta = info.meta;
-      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;
-        }
-        if (meta.source && !info.source) {
-          info.source = meta.source;
-          delete meta.source;
-        }
-        if (meta.lib && !info.lib) {
-          info.lib = meta.lib;
-          delete meta.lib;
-        }
-        if (meta.libVersion && !info.libVersion) {
-          info.libVersion = meta.libVersion;
-          delete meta.libVersion;
-        }
-        if (meta.libMethod && !info.libMethod) {
-          info.libMethod = meta.libMethod;
-          delete meta.libMethod;
-        }
-        if (meta.appName && !info.appName) {
-          info.appName = meta.appName;
-          delete meta.appName;
-        }
-        if (meta.appVersion && !info.appVersion) {
-          info.appVersion = meta.appVersion;
-          delete meta.appVersion;
-        }
-        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;
-          }
-        }
-      }
-      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;
+      fillInfoFromMeta(writableInfo);
+      applyDefaultInfoValues(writableInfo, config);
+      return writableInfo;
     });
     const levelColorizer = import_winston2.format.colorize();
-    const developmentFormat = import_winston2.format.printf((info) => {
-      const { level, message, timestamp, requestId, context, source, meta, stack, appName, appVersion, lib, libMethod, libVersion } = info;
-      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 = /* @__PURE__ */ __name((color, text) => useColors ? `${color}${text}${colors.reset}` : text, "colorize");
-      const coloredLevel = useColors ? levelColorizer.colorize(level, level.toUpperCase()) : level.toUpperCase();
-      const coloredTime = colorize(colors.gray, timestamp);
-      const coloredRequestId = colorize(colors.cyan, requestId);
-      let appDisplay = "";
-      if (appName) {
-        const appText = appVersion ? `${appName}@${appVersion}` : appName;
-        appDisplay = `[${colorize(colors.green, `App-${appText}`)}]`;
-      }
-      let libDisplay = "";
-      if (lib) {
-        const libText = libVersion ? `${lib}:${libVersion}` : lib;
-        libDisplay = `[${colorize(colors.yellow, libText)}]`;
-      }
-      const mag = colors.magenta;
-      let sourceDisplay = "";
-      let libMethodDisplay = "";
-      if (source) {
-        sourceDisplay = `[${colorize(mag, source)}]`;
-      }
-      if (lib) {
-        const methodPath = libMethod ? `${context}.${libMethod}` : context;
-        libMethodDisplay = `[${colorize(mag, methodPath)}]`;
-        if (source === context || source === methodPath) {
-          sourceDisplay = "";
-        }
-      } else if (!source) {
-        libMethodDisplay = `[${colorize(mag, context)}]`;
-      } else if (source.startsWith(`${context}.`) || source === context) {
-        libMethodDisplay = `[${colorize(mag, source)}]`;
-        sourceDisplay = "";
-      } else {
-        libMethodDisplay = `[${colorize(mag, context)}]`;
-        sourceDisplay = `[${colorize(mag, source)}]`;
-      }
-      let output = `${appDisplay}${libDisplay}[${coloredRequestId}][${coloredTime}]${sourceDisplay}${libMethodDisplay}[${coloredLevel}] - ${message}`;
-      if (meta && typeof meta === "object" && Object.keys(meta).length > 0) {
-        const inspectedMeta = (0, import_util.inspect)(meta, {
-          colors: useColors,
-          depth: null,
-          compact: true,
-          sorted: true,
-          breakLength: Infinity
-        });
-        output += ` - ${inspectedMeta}`;
-      }
-      if (stack) {
-        output += `
-${colorize(colors.red, stack)}`;
-      }
-      return output;
-    });
+    const developmentFormat = import_winston2.format.printf((info) => formatDevelopmentLog(info, useColors, levelColorizer));
     const formats = [
       import_winston2.format.timestamp(),
       import_winston2.format.errors({
@@ -9548,7 +9594,10 @@ ${colorize(colors.red, stack)}`;
         consoleTransport
       ]
     };
-    const mergedOptions = Object.assign({}, defaultOptions, config?.loggerOptions || {});
+    const mergedOptions = config?.loggerOptions ? {
+      ...defaultOptions,
+      ...config.loggerOptions
+    } : defaultOptions;
     return (0, import_winston2.createLogger)(mergedOptions);
   }
 };
@@ -9598,6 +9647,15 @@ var HttpLoggingInterceptor = class {
   logger;
   reflector;
   excludedPaths;
+  toErrorMessage(error) {
+    if (error instanceof Error) return error.message;
+    if (typeof error === "string") return error;
+    try {
+      return JSON.stringify(error);
+    } catch {
+      return "unknown error";
+    }
+  }
   constructor(logger, reflector, config) {
     this.logger = logger;
     this.reflector = reflector;
@@ -9666,7 +9724,7 @@ var HttpLoggingInterceptor = class {
             },
             response: {
               durationMs,
-              error: error instanceof Error ? error.message : String(error)
+              error: this.toErrorMessage(error)
             }
           }
         });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adatechnology/logger",
-  "version": "0.0.9",
+  "version": "0.0.10",
   "publishConfig": {
     "access": "public"
   },

package/src/context/async-context.service.ts

@@ -1,4 +1,4 @@
-import { AsyncLocalStorage } from "async_hooks";
+import { AsyncLocalStorage } from "node:async_hooks";
 import { RequestContext } from "./async-context.types";
 
 export const asyncLocalStorage = new AsyncLocalStorage<

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,9 +1,20 @@
 export { LoggerModule } from "./logger.module";
 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";

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

@@ -12,6 +12,16 @@ import { EXCLUDE_HTTP_LOGGING_KEY } from "./exclude-http-logging.decorator";
 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,
@@ -99,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.interface.ts

@@ -5,21 +5,37 @@ export enum LoggerLevel {
   ERROR = "error",
 }
 
-export interface LogPayload {
+export type LogParams = {
   message: string;
   context?: string;
   meta?: Record<string, unknown>;
-}
+};
+
+export type LogResult = void;
+
+export type DebugParams = LogParams;
+export type DebugResult = LogResult;
+
+export type InfoParams = LogParams;
+export type InfoResult = LogResult;
+
+export type WarnParams = LogParams;
+export type WarnResult = LogResult;
+
+export type ErrorParams = LogParams;
+export type ErrorResult = LogResult;
 
 export 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;
 }
 
-export type LogParams = {
+export type WriteLogParams = {
   level: LoggerLevel;
-  payload: LogPayload;
+  payload: LogParams;
 };
+
+export type WriteLogResult = LogResult;

package/src/logger.provider.ts

@@ -1,5 +1,15 @@
 import { Injectable, Inject } from "@nestjs/common";
-import type { LoggerProviderInterface, LogPayload } from "./logger.interface";
+import type {
+  DebugParams,
+  DebugResult,
+  ErrorParams,
+  ErrorResult,
+  InfoParams,
+  InfoResult,
+  LoggerProviderInterface,
+  WarnParams,
+  WarnResult,
+} from "./logger.interface";
 import { WINSTON_LOGGER } from "./implementations/winston/winston.logger.token";
 
 @Injectable()
@@ -9,45 +19,24 @@ export class LoggerProvider implements LoggerProviderInterface {
     private readonly implementation: LoggerProviderInterface,
   ) {}
 
-  debug(payload: LogPayload): void;
-  debug(
-    message: string,
-    meta?: Record<string, unknown>,
-    context?: string,
-  ): void;
-  debug(...args: unknown[]): void {
-    // @ts-ignore - delegate to implementation which supports overloads
-    return this.implementation.debug(...(args as any));
+  debug(params: DebugParams): DebugResult {
+    return this.implementation.debug(params);
   }
 
-  info(payload: LogPayload): void;
-  info(message: string, meta?: Record<string, unknown>, context?: string): void;
-  info(...args: unknown[]): void {
-    // @ts-ignore
-    return this.implementation.info(...(args as any));
+  info(params: InfoParams): InfoResult {
+    return this.implementation.info(params);
   }
 
-  warn(payload: LogPayload): void;
-  warn(message: string, meta?: Record<string, unknown>, context?: string): void;
-  warn(...args: unknown[]): void {
-    // @ts-ignore
-    return this.implementation.warn(...(args as any));
+  warn(params: WarnParams): WarnResult {
+    return this.implementation.warn(params);
   }
 
-  error(payload: LogPayload): void;
-  error(
-    message: string,
-    meta?: Record<string, unknown>,
-    context?: string,
-  ): void;
-  error(...args: unknown[]): void {
-    // @ts-ignore
-    return this.implementation.error(...(args as any));
+  error(params: ErrorParams): ErrorResult {
+    return this.implementation.error(params);
   }
   setContext?(context: string): void {
     if (typeof this.implementation.setContext === "function") {
       return this.implementation.setContext(context);
     }
-    return;
   }
 }