@adatechnology/logger 0.0.8 → 0.0.10

package/dist/index.js

@@ -8999,9 +8999,11 @@ var require_operators = __commonJS({
 var index_exports = {};
 __export(index_exports, {
   DEFAULT_LOGGER_CONFIG: () => DEFAULT_LOGGER_CONFIG,
+  ExcludeHttpLogging: () => ExcludeHttpLogging,
   HTTP_LOGGING_INTERCEPTOR: () => HTTP_LOGGING_INTERCEPTOR,
   HTTP_LOGGING_INTERCEPTOR_CONTEXT: () => HTTP_LOGGING_INTERCEPTOR_CONTEXT,
   HttpLoggingInterceptor: () => HttpLoggingInterceptor,
+  LOGGER_CONFIG: () => LOGGER_CONFIG,
   LOGGER_PROVIDER: () => LOGGER_PROVIDER,
   LoggerModule: () => LoggerModule,
   RequestContextMiddleware: () => RequestContextMiddleware,
@@ -9011,7 +9013,7 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/logger.module.ts
-var import_common5 = require("@nestjs/common");
+var import_common6 = require("@nestjs/common");
 
 // src/logger.provider.ts
 var import_common = require("@nestjs/common");
@@ -9047,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([
@@ -9077,12 +9078,13 @@ LoggerProvider = _ts_decorate([
 
 // src/logger.token.ts
 var LOGGER_PROVIDER = "LOGGER_PROVIDER";
+var LOGGER_CONFIG = "LOGGER_CONFIG";
 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");
@@ -9098,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();
 }
@@ -9163,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;
@@ -9212,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);
@@ -9329,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");
@@ -9403,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({
@@ -9545,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);
   }
 };
@@ -9554,7 +9606,8 @@ WinstonImplementationModule = _ts_decorate3([
 ], WinstonImplementationModule);
 
 // src/interceptors/http-logging.interceptor.ts
-var import_common4 = require("@nestjs/common");
+var import_common5 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
 var import_operators = __toESM(require_operators());
 
 // src/interceptors/http-logging.interceptor.constant.ts
@@ -9564,6 +9617,11 @@ var HTTP_LOGGING_INTERCEPTOR_CONTEXT = {
   ON_ERROR: "HttpLoggingInterceptor.onError"
 };
 
+// src/interceptors/exclude-http-logging.decorator.ts
+var import_common4 = require("@nestjs/common");
+var EXCLUDE_HTTP_LOGGING_KEY = "EXCLUDE_HTTP_LOGGING";
+var ExcludeHttpLogging = /* @__PURE__ */ __name(() => (0, import_common4.SetMetadata)(EXCLUDE_HTTP_LOGGING_KEY, true), "ExcludeHttpLogging");
+
 // src/interceptors/http-logging.interceptor.ts
 function _ts_decorate4(decorators, target, key, desc) {
   var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
@@ -9587,14 +9645,38 @@ var HttpLoggingInterceptor = class {
     __name(this, "HttpLoggingInterceptor");
   }
   logger;
-  constructor(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;
+    this.excludedPaths = config?.interceptorExcludedPaths ?? [];
+  }
+  isExcluded(url) {
+    const normalized = url.replace(/^\/v\d+/, "");
+    return this.excludedPaths.some((path) => normalized === path || normalized.startsWith(path + "/"));
   }
   intercept(context, next) {
     const http = context.switchToHttp();
     const request = http.getRequest();
     const response = http.getResponse();
     const start = Date.now();
+    const isDecoratorExcluded = this.reflector.getAllAndOverride(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({
       message: "HTTP Request",
@@ -9642,7 +9724,7 @@ var HttpLoggingInterceptor = class {
             },
             response: {
               durationMs,
-              error: error instanceof Error ? error.message : String(error)
+              error: this.toErrorMessage(error)
             }
           }
         });
@@ -9651,11 +9733,15 @@ var HttpLoggingInterceptor = class {
   }
 };
 HttpLoggingInterceptor = _ts_decorate4([
-  (0, import_common4.Injectable)(),
-  _ts_param3(0, (0, import_common4.Inject)(LOGGER_PROVIDER)),
+  (0, import_common5.Injectable)(),
+  _ts_param3(0, (0, import_common5.Inject)(LOGGER_PROVIDER)),
+  _ts_param3(2, (0, import_common5.Optional)()),
+  _ts_param3(2, (0, import_common5.Inject)(LOGGER_CONFIG)),
   _ts_metadata3("design:type", Function),
   _ts_metadata3("design:paramtypes", [
-    typeof LoggerProviderInterface === "undefined" ? Object : LoggerProviderInterface
+    typeof LoggerProviderInterface === "undefined" ? Object : LoggerProviderInterface,
+    typeof import_core.Reflector === "undefined" ? Object : import_core.Reflector,
+    typeof LoggerConfig === "undefined" ? Object : LoggerConfig
   ])
 ], HttpLoggingInterceptor);
 
@@ -9682,7 +9768,7 @@ var LoggerModule = class _LoggerModule {
       useClass: LoggerProvider
     };
     if (config && config.requestScoped) {
-      loggerProvider.scope = import_common5.Scope.REQUEST;
+      loggerProvider.scope = import_common6.Scope.REQUEST;
     }
     return {
       module: _LoggerModule,
@@ -9690,11 +9776,16 @@ var LoggerModule = class _LoggerModule {
         implModule
       ],
       providers: [
+        {
+          provide: LOGGER_CONFIG,
+          useValue: config ?? {}
+        },
         loggerProvider,
         httpLoggingInterceptorProvider
       ],
       exports: [
         LOGGER_PROVIDER,
+        LOGGER_CONFIG,
         HTTP_LOGGING_INTERCEPTOR
       ]
     };
@@ -9707,6 +9798,11 @@ var LoggerModule = class _LoggerModule {
         WinstonImplementationModule.forRootAsync(options)
       ],
       providers: [
+        {
+          provide: LOGGER_CONFIG,
+          useFactory: options.useFactory,
+          inject: options.inject || []
+        },
         {
           provide: LOGGER_PROVIDER,
           useClass: LoggerProvider
@@ -9715,18 +9811,19 @@ var LoggerModule = class _LoggerModule {
       ],
       exports: [
         LOGGER_PROVIDER,
+        LOGGER_CONFIG,
         HTTP_LOGGING_INTERCEPTOR
       ]
     };
   }
 };
 LoggerModule = _ts_decorate5([
-  (0, import_common5.Global)(),
-  (0, import_common5.Module)({})
+  (0, import_common6.Global)(),
+  (0, import_common6.Module)({})
 ], LoggerModule);
 
 // src/middleware/request-context.middleware.ts
-var import_common6 = require("@nestjs/common");
+var import_common7 = require("@nestjs/common");
 var import_crypto = require("crypto");
 
 // src/request-id.constants.ts
@@ -9760,7 +9857,7 @@ var RequestContextMiddleware = class {
   }
 };
 RequestContextMiddleware = _ts_decorate6([
-  (0, import_common6.Injectable)()
+  (0, import_common7.Injectable)()
 ], RequestContextMiddleware);
 
 // src/logger.config.ts
@@ -9772,9 +9869,11 @@ var DEFAULT_LOGGER_CONFIG = {
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   DEFAULT_LOGGER_CONFIG,
+  ExcludeHttpLogging,
   HTTP_LOGGING_INTERCEPTOR,
   HTTP_LOGGING_INTERCEPTOR_CONTEXT,
   HttpLoggingInterceptor,
+  LOGGER_CONFIG,
   LOGGER_PROVIDER,
   LoggerModule,
   RequestContextMiddleware,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@adatechnology/logger",
-  "version": "0.0.8",
+  "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<