@adatechnology/logger 0.0.7 → 0.0.9

package/package.json

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

package/src/index.ts

@@ -1,11 +1,14 @@
 export { LoggerModule } from "./logger.module";
-export { LOGGER_PROVIDER } from "./logger.token";
+export { LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR } from "./logger.token";
 export type {
   LoggerProviderInterface,
   LogPayload,
   LoggerLevel,
 } 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.constant.ts

@@ -0,0 +1,5 @@
+export const HTTP_LOGGING_INTERCEPTOR_CONTEXT = {
+  INTERCEPT: "HttpLoggingInterceptor.intercept",
+  ON_RESPONSE: "HttpLoggingInterceptor.onResponse",
+  ON_ERROR: "HttpLoggingInterceptor.onError",
+} as const;

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

@@ -0,0 +1,110 @@
+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, 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();
+    const request = http.getRequest<Record<string, any>>();
+    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({
+      message: "HTTP Request",
+      context: HTTP_LOGGING_INTERCEPTOR_CONTEXT.INTERCEPT,
+      meta: {
+        request: {
+          method,
+          path: url,
+          headers,
+          query: query && Object.keys(query).length ? query : undefined,
+          params: params && Object.keys(params).length ? params : undefined,
+          body: body && Object.keys(body).length ? body : undefined,
+        },
+      },
+    });
+
+    return next.handle().pipe(
+      tap({
+        next: (responseBody) => {
+          const durationMs = Date.now() - start;
+          const statusCode =
+            response?.statusCode ??
+            response?.raw?.statusCode ??
+            200;
+
+          this.logger.info({
+            message: "HTTP Response",
+            context: HTTP_LOGGING_INTERCEPTOR_CONTEXT.ON_RESPONSE,
+            meta: {
+              request: {
+                method,
+                path: url,
+              },
+              response: {
+                statusCode,
+                durationMs,
+                body: responseBody ?? undefined,
+              },
+            },
+          });
+        },
+        error: (error: unknown) => {
+          const durationMs = Date.now() - start;
+
+          this.logger.error({
+            message: "HTTP Response Error",
+            context: HTTP_LOGGING_INTERCEPTOR_CONTEXT.ON_ERROR,
+            meta: {
+              request: {
+                method,
+                path: url,
+              },
+              response: {
+                durationMs,
+                error: error instanceof Error ? error.message : String(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 = {

package/src/logger.module.ts

@@ -1,27 +1,37 @@
 import { DynamicModule, Module, Scope, Provider, Global } from "@nestjs/common";
 import { LoggerProvider } from "./logger.provider";
-import { LOGGER_PROVIDER } 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";
 
+const httpLoggingInterceptorProvider: Provider = {
+  provide: HTTP_LOGGING_INTERCEPTOR,
+  useClass: HttpLoggingInterceptor,
+};
+
 @Global()
 @Module({})
 export class LoggerModule {
   static forRoot(config?: LoggerConfig): DynamicModule {
     const implModule = WinstonImplementationModule.forRoot(config);
-    const provider: Provider = {
+    const loggerProvider: Provider = {
       provide: LOGGER_PROVIDER,
       useClass: LoggerProvider,
     };
     if (config && config.requestScoped) {
-      provider.scope = Scope.REQUEST;
+      loggerProvider.scope = Scope.REQUEST;
     }
 
     return {
       module: LoggerModule,
       imports: [implModule],
-      providers: [provider],
-      exports: [LOGGER_PROVIDER],
+      providers: [
+        { provide: LOGGER_CONFIG, useValue: config ?? {} },
+        loggerProvider,
+        httpLoggingInterceptorProvider,
+      ],
+      exports: [LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 
@@ -37,12 +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],
+      exports: [LOGGER_PROVIDER, LOGGER_CONFIG, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 }

package/src/logger.token.ts

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