@devminister/applog-client 0.0.1 → 0.0.2

package/README.md

@@ -2,7 +2,7 @@
 
 Application log client for the **Monitoring** platform. Send structured business logs (auth, payments, orders, notifications) with buffered, batched delivery, retry, and duration tracking.
 
-Works as a **standalone Node.js client** or as a **NestJS module**.
+Works as a **standalone Node.js client** or as a **NestJS module** with automatic HTTP request logging.
 
 ## Install
 
@@ -53,7 +53,8 @@ process.on('SIGTERM', async () => {
 
 ```typescript
 // app.module.ts
-import { AppLogModule } from '@devminister/applog-client';
+import { AppLogModule, AppLogInterceptor } from '@devminister/applog-client';
+import { APP_INTERCEPTOR } from '@nestjs/core';
 
 @Module({
   imports: [
@@ -61,8 +62,19 @@ import { AppLogModule } from '@devminister/applog-client';
       apiUrl: process.env.MONITOR_API_URL,
       clientId: process.env.APPLOG_CLIENT_ID,
       clientSecret: process.env.APPLOG_CLIENT_SECRET,
+      // HTTP interceptor options
+      excludePaths: ['/api/health', '/api/health/system'],
+      logBodies: true,
+      logHeaders: true,
+      maxBodySize: 10240,
     }),
   ],
+  providers: [
+    {
+      provide: APP_INTERCEPTOR,
+      useClass: AppLogInterceptor,
+    },
+  ],
 })
 export class AppModule {}
 ```
@@ -78,6 +90,9 @@ AppLogModule.registerAsync({
     clientSecret: config.get('APPLOG_CLIENT_SECRET'),
     defaultCategory: 'my-service',
     defaultTags: ['production'],
+    excludePaths: ['/api/health'],
+    logBodies: true,
+    logHeaders: true,
   }),
 })
 ```
@@ -112,24 +127,39 @@ export class PaymentService {
 }
 ```
 
-#### Auto-log all HTTP requests (interceptor)
+## HTTP Interceptor
 
-```typescript
-import { AppLogInterceptor } from '@devminister/applog-client';
+The `AppLogInterceptor` automatically logs every HTTP request with full context:
 
-// app.module.ts
-@Module({
-  providers: [
-    {
-      provide: APP_INTERCEPTOR,
-      useClass: AppLogInterceptor,
-    },
-  ],
+- **Method, path, status code, duration**
+- **Request/response bodies** (with configurable size limit)
+- **Request headers** (content-type, user-agent, origin)
+- **Client IP and user-agent**
+- **Query parameters**
+- **Error messages and stack traces** (for failed requests)
+- **User ID** extracted from `request.user.id` or `request.user.sub`
+- **Controller and handler names** as context
+
+### Sensitive Field Redaction
+
+Request/response bodies are automatically sanitized. The following fields are redacted:
+
+`password`, `token`, `accessToken`, `refreshToken`, `authorization`, `secret`, `creditCard`, `cardNumber`, `cvv`, `ssn`
+
+### Path Exclusion
+
+Use `excludePaths` to skip logging for health checks or other noisy endpoints:
+
+```typescript
+AppLogModule.register({
+  // ...credentials
+  excludePaths: ['/api/health', '/metrics', '/api/docs'],
 })
-export class AppModule {}
 ```
 
-This will automatically log every request with controller name, handler, method, path, status code, duration, and userId.
+### Disabled Mode
+
+When `disabled: true`, the interceptor still logs to the NestJS console (method, path, status, duration) but does not send logs to the monitoring API.
 
 ## API
 
@@ -145,13 +175,18 @@ appLog.fatal(category, action, options?)
 
 ### Options
 
-| Field      | Type     | Description                              |
-|------------|----------|------------------------------------------|
-| `message`  | string   | Human-readable log message               |
-| `metadata` | object   | Any structured data (JSON)               |
-| `userId`   | string   | User identifier                          |
-| `duration` | number   | Duration in milliseconds                 |
-| `tags`     | string[] | Searchable tags                          |
+| Field        | Type     | Description                              |
+|--------------|----------|------------------------------------------|
+| `message`    | string   | Human-readable log message               |
+| `metadata`   | object   | Any structured data (JSON)               |
+| `userId`     | string   | User identifier                          |
+| `duration`   | number   | Duration in milliseconds                 |
+| `tags`       | string[] | Searchable tags                          |
+| `method`     | string   | HTTP method (GET, POST, etc.)            |
+| `path`       | string   | Request path / URL                       |
+| `statusCode` | number   | HTTP status code                         |
+| `context`    | string   | Log context (e.g. controller name)       |
+| `pid`        | number   | Process ID                               |
 
 ### Timer
 
@@ -184,13 +219,18 @@ appLog.bufferSize        // Current buffer length
 | `maxRetries`       | number   | `3`     | Retry attempts with exponential backoff          |
 | `defaultCategory`  | string   | —       | Default category when none specified             |
 | `defaultTags`      | string[] | `[]`    | Tags added to every log                          |
-| `disabled`         | boolean  | `false` | Disable all logging                              |
+| `disabled`         | boolean  | `false` | Disable API logging (console logging still works)|
 | `logger`           | object   | console | Custom logger `{ debug, warn, error }`           |
+| `excludePaths`     | string[] | `[]`    | Paths to skip in the HTTP interceptor            |
+| `logBodies`        | boolean  | `true`  | Capture request/response bodies                  |
+| `logHeaders`       | boolean  | `true`  | Capture request headers                          |
+| `maxBodySize`      | number   | `10240` | Max body size to capture (characters)            |
 
 ## Category & Action Conventions
 
 | Category       | Example Actions                                              |
 |----------------|--------------------------------------------------------------|
+| `http`         | `Controller.handler` (auto-logged by interceptor)             |
 | `auth`         | `user.login`, `user.logout`, `user.register`, `token.refresh` |
 | `payment`      | `payment.charge`, `payment.refund`, `subscription.create`     |
 | `order`        | `order.create`, `order.update`, `order.cancel`, `order.ship`  |

package/dist/applog.interceptor.d.ts

@@ -4,21 +4,17 @@ import { AppLogNestService } from './applog-nestjs.service';
 /**
  * NestJS interceptor that automatically logs every HTTP request as an app log.
  *
- * Captures: controller name, handler name, method, path, status, duration, userId.
- * Errors are logged at level 'error', successful requests at 'info'.
+ * Captures: method, path, status, duration, headers, body, IP, user-agent,
+ * error stack, query params. Supports path exclusion, sensitive field redaction,
+ * and body truncation.
  *
  * @example
  * // Global interceptor
- * app.useGlobalInterceptors(app.get(AppLogInterceptor));
- *
- * // Or via module providers
  * { provide: APP_INTERCEPTOR, useClass: AppLogInterceptor }
- *
- * // Or per-controller
- * @UseInterceptors(AppLogInterceptor)
  */
 export declare class AppLogInterceptor implements NestInterceptor {
     private readonly appLog;
+    private readonly logger;
     constructor(appLog: AppLogNestService);
     intercept(context: ExecutionContext, next: CallHandler): Observable<any>;
 }

package/dist/applog.interceptor.js

@@ -14,61 +14,166 @@ const common_1 = require("@nestjs/common");
 const rxjs_1 = require("rxjs");
 const operators_1 = require("rxjs/operators");
 const applog_nestjs_service_1 = require("./applog-nestjs.service");
+// ─── Sensitive Field Redaction ──────────────────────────
+const SENSITIVE_FIELDS = new Set([
+    'password',
+    'token',
+    'accesstoken',
+    'refreshtoken',
+    'authorization',
+    'secret',
+    'creditcard',
+    'cardnumber',
+    'cvv',
+    'ssn',
+]);
+function sanitize(obj, depth = 0) {
+    if (!obj || typeof obj !== 'object' || depth > 5)
+        return obj;
+    if (Array.isArray(obj))
+        return obj.map((item) => sanitize(item, depth + 1));
+    const cleaned = {};
+    for (const [key, value] of Object.entries(obj)) {
+        if (SENSITIVE_FIELDS.has(key.toLowerCase())) {
+            cleaned[key] = '[REDACTED]';
+        }
+        else if (typeof value === 'object' && value !== null) {
+            cleaned[key] = sanitize(value, depth + 1);
+        }
+        else {
+            cleaned[key] = value;
+        }
+    }
+    return cleaned;
+}
+function truncate(obj, maxSize) {
+    if (!obj)
+        return obj;
+    const str = typeof obj === 'string' ? obj : JSON.stringify(obj);
+    if (str.length <= maxSize)
+        return obj;
+    return typeof obj === 'string'
+        ? str.slice(0, maxSize) + '...[truncated]'
+        : undefined;
+}
 /**
  * NestJS interceptor that automatically logs every HTTP request as an app log.
  *
- * Captures: controller name, handler name, method, path, status, duration, userId.
- * Errors are logged at level 'error', successful requests at 'info'.
+ * Captures: method, path, status, duration, headers, body, IP, user-agent,
+ * error stack, query params. Supports path exclusion, sensitive field redaction,
+ * and body truncation.
  *
  * @example
  * // Global interceptor
- * app.useGlobalInterceptors(app.get(AppLogInterceptor));
- *
- * // Or via module providers
  * { provide: APP_INTERCEPTOR, useClass: AppLogInterceptor }
- *
- * // Or per-controller
- * @UseInterceptors(AppLogInterceptor)
  */
 let AppLogInterceptor = class AppLogInterceptor {
     constructor(appLog) {
         this.appLog = appLog;
+        this.logger = new common_1.Logger('HTTP');
     }
     intercept(context, next) {
-        if (this.appLog.getConfig().disabled)
-            return next.handle();
+        const config = this.appLog.getConfig();
         const ctx = context.switchToHttp();
         const request = ctx.getRequest();
+        const startTime = Date.now();
+        // When disabled, still log to console
+        if (config.disabled) {
+            return next.handle().pipe((0, operators_1.tap)(() => {
+                const response = ctx.getResponse();
+                this.logger.log(`${request.method} ${request.path} ${response.statusCode} - ${Date.now() - startTime}ms`);
+            }), (0, operators_1.catchError)((error) => {
+                const statusCode = error instanceof common_1.HttpException
+                    ? error.getStatus()
+                    : common_1.HttpStatus.INTERNAL_SERVER_ERROR;
+                const msg = `${request.method} ${request.path} ${statusCode} - ${Date.now() - startTime}ms`;
+                statusCode >= 500 ? this.logger.error(msg) : this.logger.warn(msg);
+                return (0, rxjs_1.throwError)(() => error);
+            }));
+        }
+        // Path exclusion
+        const excludePaths = config.excludePaths ?? [];
+        const isExcluded = excludePaths.some((p) => request.path?.startsWith(p));
+        // Config defaults
+        const maxBodySize = config.maxBodySize ?? 10240;
+        const logBodies = config.logBodies !== false;
+        const logHeaders = config.logHeaders !== false;
+        // Extract context
         const controller = context.getClass().name;
         const handler = context.getHandler().name;
-        const start = Date.now();
         const userId = request.user?.id || request.user?.sub || undefined;
-        return next.handle().pipe((0, operators_1.tap)(() => {
+        // Extract HTTP details
+        const ip = (request.headers?.['x-forwarded-for']?.toString().split(',')[0] ||
+            request.ip ||
+            request.socket?.remoteAddress ||
+            '').substring(0, 45);
+        const userAgent = (request.headers?.['user-agent'] || '').substring(0, 500);
+        const query = request.query && Object.keys(request.query).length > 0 ? request.query : undefined;
+        const requestHeaders = logHeaders
+            ? sanitize({
+                'content-type': request.headers?.['content-type'],
+                'user-agent': request.headers?.['user-agent'],
+                origin: request.headers?.['origin'],
+            })
+            : undefined;
+        const requestBody = logBodies
+            ? truncate(sanitize(request.body), maxBodySize)
+            : undefined;
+        return next.handle().pipe((0, operators_1.tap)((responseBody) => {
             const response = ctx.getResponse();
-            this.appLog.info('api', `${controller}.${handler}`, {
-                userId,
-                duration: Date.now() - start,
-                metadata: {
+            const duration = Date.now() - startTime;
+            const statusCode = response.statusCode;
+            // Console log
+            this.logger.log(`${request.method} ${request.path} ${statusCode} - ${duration}ms`);
+            // Push to app log (skip excluded paths)
+            if (!isExcluded) {
+                this.appLog.info('http', `${controller}.${handler}`, {
+                    userId,
+                    duration,
                     method: request.method,
                     path: request.url,
-                    statusCode: response.statusCode,
-                },
-            });
+                    statusCode,
+                    context: controller,
+                    metadata: {
+                        ip,
+                        userAgent,
+                        ...(query ? { query } : {}),
+                        ...(requestHeaders ? { requestHeaders } : {}),
+                        ...(requestBody ? { requestBody } : {}),
+                        ...(logBodies && responseBody
+                            ? { responseBody: truncate(sanitize(responseBody), maxBodySize) }
+                            : {}),
+                    },
+                });
+            }
         }), (0, operators_1.catchError)((error) => {
+            const duration = Date.now() - startTime;
             const statusCode = error instanceof common_1.HttpException
                 ? error.getStatus()
                 : common_1.HttpStatus.INTERNAL_SERVER_ERROR;
-            this.appLog.error('api', `${controller}.${handler}`, {
-                message: error.message,
-                userId,
-                duration: Date.now() - start,
-                metadata: {
+            const msg = `${request.method} ${request.path} ${statusCode} - ${duration}ms`;
+            statusCode >= 500 ? this.logger.error(msg) : this.logger.warn(msg);
+            // Push to app log (skip excluded paths)
+            if (!isExcluded) {
+                this.appLog.error('http', `${controller}.${handler}`, {
+                    message: error.message,
+                    userId,
+                    duration,
                     method: request.method,
                     path: request.url,
                     statusCode,
-                    error: error.message,
-                },
-            });
+                    context: controller,
+                    metadata: {
+                        ip,
+                        userAgent,
+                        ...(query ? { query } : {}),
+                        ...(requestHeaders ? { requestHeaders } : {}),
+                        ...(requestBody ? { requestBody } : {}),
+                        errorMessage: error.message,
+                        errorStack: error.stack,
+                    },
+                });
+            }
             return (0, rxjs_1.throwError)(() => error);
         }));
     }

package/dist/applog.service.d.ts

@@ -10,6 +10,11 @@ export interface AppLogPayload {
     duration?: number;
     tags?: string[];
     createdAt?: string;
+    method?: string;
+    path?: string;
+    statusCode?: number;
+    context?: string;
+    pid?: number;
 }
 export interface AppLogOptions {
     message?: string;
@@ -17,6 +22,10 @@ export interface AppLogOptions {
     userId?: string;
     duration?: number;
     tags?: string[];
+    method?: string;
+    path?: string;
+    statusCode?: number;
+    context?: string;
 }
 export declare class AppLogClientService {
     private readonly config;

package/dist/interfaces/applog-config.interface.d.ts

@@ -27,5 +27,13 @@ export interface AppLogClientConfig {
         warn?: (msg: string) => void;
         error?: (msg: string) => void;
     };
+    /** Paths to exclude from HTTP request logging (e.g. ['/health', '/api/health']) */
+    excludePaths?: string[];
+    /** Whether to log request/response bodies (default: true) */
+    logBodies?: boolean;
+    /** Whether to log request headers (default: true) */
+    logHeaders?: boolean;
+    /** Max body size to capture in characters (default: 10240) */
+    maxBodySize?: number;
 }
 export declare const APPLOG_CLIENT_CONFIG = "APPLOG_CLIENT_CONFIG";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@devminister/applog-client",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "description": "Application log client for the Monitoring platform. Buffered, batched delivery with retry. Works standalone or as a NestJS module.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -31,9 +31,15 @@
     "rxjs": "^7.0.0"
   },
   "peerDependenciesMeta": {
-    "@nestjs/common": { "optional": true },
-    "@nestjs/core": { "optional": true },
-    "rxjs": { "optional": true }
+    "@nestjs/common": {
+      "optional": true
+    },
+    "@nestjs/core": {
+      "optional": true
+    },
+    "rxjs": {
+      "optional": true
+    }
   },
   "devDependencies": {
     "@nestjs/common": "^11.1.3",