@adatechnology/logger 0.0.7 → 0.0.8

package/package.json

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

package/src/index.ts

@@ -1,11 +1,13 @@
 export { LoggerModule } from "./logger.module";
-export { LOGGER_PROVIDER } from "./logger.token";
+export { LOGGER_PROVIDER, 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 { getContext, runWithContext } from "./context/async-context.service";
 export type { LoggerConfig } from "./logger.config";
 export { DEFAULT_LOGGER_CONFIG } from "./logger.config";

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,84 @@
+import { CallHandler, ExecutionContext, Inject, Injectable, NestInterceptor } from "@nestjs/common";
+import { Observable } from "rxjs";
+import { tap } from "rxjs/operators";
+import { LOGGER_PROVIDER } from "../logger.token";
+import type { LoggerProviderInterface } from "../logger.interface";
+import { HTTP_LOGGING_INTERCEPTOR_CONTEXT } from "./http-logging.interceptor.constant";
+
+@Injectable()
+export class HttpLoggingInterceptor implements NestInterceptor {
+  constructor(
+    @Inject(LOGGER_PROVIDER)
+    private readonly logger: LoggerProviderInterface,
+  ) {}
+
+  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 { 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.module.ts

@@ -1,27 +1,33 @@
 import { DynamicModule, Module, Scope, Provider, Global } from "@nestjs/common";
 import { LoggerProvider } from "./logger.provider";
-import { LOGGER_PROVIDER } from "./logger.token";
+import { LOGGER_PROVIDER, 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: [loggerProvider, httpLoggingInterceptorProvider],
+      exports: [LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 
@@ -41,8 +47,9 @@ export class LoggerModule {
           provide: LOGGER_PROVIDER,
           useClass: LoggerProvider,
         },
+        httpLoggingInterceptorProvider,
       ],
-      exports: [LOGGER_PROVIDER],
+      exports: [LOGGER_PROVIDER, HTTP_LOGGING_INTERCEPTOR],
     };
   }
 }

package/src/logger.token.ts

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