@adatechnology/logger 0.0.8 → 0.0.9

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 {
@@ -69,10 +71,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 +107,10 @@ declare class RequestContextMiddleware implements NestMiddleware {
 
 declare class HttpLoggingInterceptor implements NestInterceptor {
     private readonly logger;
-    constructor(logger: LoggerProviderInterface);
+    private readonly reflector;
+    private readonly excludedPaths;
+    constructor(logger: LoggerProviderInterface, reflector: Reflector, config?: LoggerConfig);
+    private isExcluded;
     intercept(context: ExecutionContext, next: CallHandler): Observable<unknown>;
 }
 
@@ -109,9 +120,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, ExcludeHttpLogging, HTTP_LOGGING_INTERCEPTOR, HTTP_LOGGING_INTERCEPTOR_CONTEXT, HttpLoggingInterceptor, LOGGER_CONFIG, LOGGER_PROVIDER, type LogPayload, type LoggerConfig, LoggerLevel, LoggerModule, type LoggerProviderInterface, RequestContextMiddleware, getContext, runWithContext };

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");
@@ -9077,6 +9079,7 @@ 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
@@ -9554,7 +9557,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 +9568,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 +9596,29 @@ var HttpLoggingInterceptor = class {
     __name(this, "HttpLoggingInterceptor");
   }
   logger;
-  constructor(logger) {
+  reflector;
+  excludedPaths;
+  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",
@@ -9651,11 +9675,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 +9710,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 +9718,16 @@ var LoggerModule = class _LoggerModule {
         implModule
       ],
       providers: [
+        {
+          provide: LOGGER_CONFIG,
+          useValue: config ?? {}
+        },
         loggerProvider,
         httpLoggingInterceptorProvider
       ],
       exports: [
         LOGGER_PROVIDER,
+        LOGGER_CONFIG,
         HTTP_LOGGING_INTERCEPTOR
       ]
     };
@@ -9707,6 +9740,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 +9753,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 +9799,7 @@ var RequestContextMiddleware = class {
   }
 };
 RequestContextMiddleware = _ts_decorate6([
-  (0, import_common6.Injectable)()
+  (0, import_common7.Injectable)()
 ], RequestContextMiddleware);
 
 // src/logger.config.ts
@@ -9772,9 +9811,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.9",
   "publishConfig": {
     "access": "public"
   },

package/src/index.ts

@@ -1,5 +1,5 @@
 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 {
   LoggerProviderInterface,
   LogPayload,
@@ -8,6 +8,7 @@ export type {
 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,33 @@
-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[];
+
   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 +35,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({

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 = {

package/src/logger.module.ts

@@ -1,6 +1,6 @@
 import { DynamicModule, Module, Scope, Provider, Global } from "@nestjs/common";
 import { LoggerProvider } from "./logger.provider";
-import { LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR } from "./logger.token";
+import { LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR } from "./logger.token";
 import { WinstonImplementationModule } from "./implementations/winston/winston.logger.module";
 import { HttpLoggingInterceptor } from "./interceptors/http-logging.interceptor";
 import type { LoggerConfig } from "./logger.config";
@@ -26,8 +26,12 @@ export class LoggerModule {
     return {
       module: LoggerModule,
       imports: [implModule],
-      providers: [loggerProvider, httpLoggingInterceptorProvider],
-      exports: [LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR],
+      providers: [
+        { provide: LOGGER_CONFIG, useValue: config ?? {} },
+        loggerProvider,
+        httpLoggingInterceptorProvider,
+      ],
+      exports: [LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 
@@ -43,13 +47,18 @@ export class LoggerModule {
         WinstonImplementationModule.forRootAsync(options),
       ],
       providers: [
+        {
+          provide: LOGGER_CONFIG,
+          useFactory: options.useFactory,
+          inject: options.inject || [],
+        },
         {
           provide: LOGGER_PROVIDER,
           useClass: LoggerProvider,
         },
         httpLoggingInterceptorProvider,
       ],
-      exports: [LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR],
+      exports: [LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 }

package/src/logger.token.ts

@@ -1,2 +1,3 @@
 export const LOGGER_PROVIDER = "LOGGER_PROVIDER";
+export const LOGGER_CONFIG = "LOGGER_CONFIG";
 export const HTTP_LOGGING_INTERCEPTOR = "HTTP_LOGGING_INTERCEPTOR";