@nest-omni/core 3.1.2-7 → 3.1.2-8

package/http-client/services/logging.service.js

@@ -0,0 +1,445 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var HttpLoggingService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLoggingService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const http_log_entity_1 = require("../entities/http-log.entity");
+const request_id_util_1 = require("../../../../http-client/src/utils/request-id.util");
+const context_extractor_util_1 = require("../utils/context-extractor.util");
+const call_stack_extractor_util_1 = require("../utils/call-stack-extractor.util");
+let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.logger = new common_1.Logger(HttpLoggingService_1.name);
+        this.logRepository = null;
+        if (dataSource) {
+            this.initializeDatabaseLogging();
+        }
+    }
+    logRequestStart(config, loggingOptions, requestId) {
+        const context = context_extractor_util_1.ContextExtractor.getHttpContext();
+        const actualRequestId = requestId || context.requestId || (0, request_id_util_1.generateRequestId)();
+        const { logHeaders = true, logBody = true, sanitizeHeaders = [], } = loggingOptions || {};
+        const logData = {
+            requestId: actualRequestId,
+            userId: context.userId,
+            method: config.method ? config.method.toUpperCase() : 'GET',
+            url: config.url,
+            headers: logHeaders
+                ? this.sanitizeHeaders(config.headers, sanitizeHeaders)
+                : undefined,
+            body: logBody ? this.sanitizeBody(config.data) : undefined,
+            clientIp: context.clientIp,
+            serviceName: context.appId,
+        };
+        const logMessage = `HTTP Request [${actualRequestId}]: ${logData.method} ${logData.url}`;
+        switch ((loggingOptions || {}).logLevel) {
+            case 'debug':
+                this.logger.debug(logMessage, logData);
+                break;
+            case 'info':
+            default:
+                this.logger.log(logMessage, logData);
+                break;
+        }
+        return actualRequestId;
+    }
+    logRequestSuccess(response, startTime, requestId, loggingOptions, databaseLogging = false, retryRecords, cacheHit, circuitBreakerState, decoratorContext) {
+        var _a, _b;
+        const { logHeaders = true, logBody = true, sanitizeHeaders = [], } = loggingOptions || {};
+        const responseTime = Date.now() - startTime;
+        const context = context_extractor_util_1.ContextExtractor.getHttpContext();
+        const logData = {
+            requestId,
+            userId: context.userId,
+            statusCode: response.status,
+            responseTime,
+            headers: logHeaders
+                ? this.sanitizeHeaders(response.headers, sanitizeHeaders)
+                : undefined,
+            body: logBody ? this.sanitizeBody(response.data) : undefined,
+            responseSize: JSON.stringify(response.data).length,
+            cacheHit,
+            circuitBreakerState,
+        };
+        const logMessage = `HTTP Response [${requestId}]: ${response.status} (${responseTime}ms)${cacheHit ? ' [CACHE HIT]' : ''}`;
+        switch ((loggingOptions || {}).logLevel) {
+            case 'debug':
+                this.logger.debug(logMessage, logData);
+                break;
+            case 'info':
+            default:
+                this.logger.log(logMessage, logData);
+                break;
+        }
+        if (databaseLogging && this.logRepository) {
+            const callInfo = this.extractCallInfo(decoratorContext, response.config);
+            this.saveToDatabase({
+                id: requestId,
+                requestId,
+                userId: context.userId,
+                method: ((_a = response.config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN',
+                url: response.config.url || '',
+                headers: this.sanitizeHeaders(response.config.headers, sanitizeHeaders),
+                body: this.sanitizeBodyAsString(response.config.data),
+                params: response.config.params,
+                statusCode: response.status,
+                responseTime,
+                attemptCount: (retryRecords === null || retryRecords === void 0 ? void 0 : retryRecords.length)
+                    ? Math.max(...retryRecords.map((r) => r.attempt))
+                    : 1,
+                success: true,
+                responseHeaders: this.sanitizeHeaders(response.headers, sanitizeHeaders),
+                responseBody: logBody
+                    ? this.sanitizeBodyAsString(response.data)
+                    : undefined,
+                responseSize: JSON.stringify(response.data).length,
+                requestSize: JSON.stringify(response.config.data).length,
+                serviceName: context.appId,
+                operationName: callInfo.operationName,
+                clientIp: context.clientIp,
+                source: (_b = context.metadata) === null || _b === void 0 ? void 0 : _b.source,
+                tags: context.tags,
+                metadata: logData,
+                retryRecords,
+                cacheHit,
+                circuitBreakerState,
+            });
+        }
+    }
+    logRequestError(error, startTime, requestId, attemptCount, loggingOptions, databaseLogging = false, retryRecords, cacheHit, circuitBreakerState, decoratorContext) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+        const { logHeaders = true, sanitizeHeaders = [] } = loggingOptions;
+        const responseTime = Date.now() - startTime;
+        const context = context_extractor_util_1.ContextExtractor.getHttpContext();
+        const logData = {
+            requestId,
+            userId: context.userId,
+            attemptCount,
+            responseTime,
+            message: error.message,
+            code: error.code,
+            errorCode: error.code,
+            statusCode: (_a = error.response) === null || _a === void 0 ? void 0 : _a.status,
+            headers: ((_b = error.config) === null || _b === void 0 ? void 0 : _b.headers) && logHeaders
+                ? this.sanitizeHeaders(error.config.headers, sanitizeHeaders)
+                : undefined,
+            circuitBreakerState,
+        };
+        const logMessage = `HTTP Error [${requestId}]: ${error.message} (${responseTime}ms)${circuitBreakerState ? ` [${circuitBreakerState}]` : ''}`;
+        switch ((loggingOptions || {}).logLevel) {
+            case 'debug':
+                this.logger.debug(logMessage, logData);
+                break;
+            case 'warn':
+                this.logger.warn(logMessage, logData);
+                break;
+            case 'error':
+                this.logger.error(logMessage, logData);
+                break;
+            default:
+                this.logger.error(logMessage, logData);
+                break;
+        }
+        if (databaseLogging && this.logRepository) {
+            const callInfo = this.extractCallInfo(decoratorContext, error.config);
+            this.saveToDatabase({
+                id: requestId,
+                requestId,
+                userId: context.userId,
+                method: ((_d = (_c = error.config) === null || _c === void 0 ? void 0 : _c.method) === null || _d === void 0 ? void 0 : _d.toUpperCase()) || 'UNKNOWN',
+                url: ((_e = error.config) === null || _e === void 0 ? void 0 : _e.url) || '',
+                headers: ((_f = error.config) === null || _f === void 0 ? void 0 : _f.headers)
+                    ? this.sanitizeHeaders(error.config.headers, sanitizeHeaders)
+                    : {},
+                body: this.sanitizeBodyAsString((_g = error.config) === null || _g === void 0 ? void 0 : _g.data),
+                params: (_h = error.config) === null || _h === void 0 ? void 0 : _h.params,
+                statusCode: (_j = error.response) === null || _j === void 0 ? void 0 : _j.status,
+                responseTime,
+                attemptCount,
+                success: false,
+                errorMessage: error.message,
+                errorStack: error.stack,
+                errorCode: error.code,
+                requestSize: JSON.stringify(((_k = error.config) === null || _k === void 0 ? void 0 : _k.data) || {}).length,
+                serviceName: context.appId,
+                operationName: callInfo.operationName,
+                clientIp: context.clientIp,
+                source: (_l = context.metadata) === null || _l === void 0 ? void 0 : _l.source,
+                tags: context.tags,
+                metadata: logData,
+                retryRecords,
+                cacheHit,
+                circuitBreakerState,
+            });
+        }
+    }
+    findLogs(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('Database logging not available');
+            }
+            const queryBuilder = this.logRepository.createQueryBuilder('log');
+            if (options.requestId) {
+                queryBuilder.andWhere('log.requestId = :requestId', {
+                    requestId: options.requestId,
+                });
+            }
+            if (options.userId) {
+                queryBuilder.andWhere('log.userId = :userId', { userId: options.userId });
+            }
+            if (options.method) {
+                queryBuilder.andWhere('log.method = :method', { method: options.method });
+            }
+            if (options.url) {
+                queryBuilder.andWhere('log.url LIKE :url', { url: `%${options.url}%` });
+            }
+            if (options.statusCode) {
+                queryBuilder.andWhere('log.statusCode = :statusCode', {
+                    statusCode: options.statusCode,
+                });
+            }
+            if (options.success !== undefined) {
+                queryBuilder.andWhere('log.success = :success', {
+                    success: options.success,
+                });
+            }
+            if (options.startDate) {
+                queryBuilder.andWhere('log.createdAt >= :startDate', {
+                    startDate: options.startDate,
+                });
+            }
+            if (options.endDate) {
+                queryBuilder.andWhere('log.createdAt <= :endDate', {
+                    endDate: options.endDate,
+                });
+            }
+            queryBuilder.orderBy('log.createdAt', 'DESC');
+            if (options.limit) {
+                queryBuilder.limit(options.limit);
+            }
+            if (options.offset) {
+                queryBuilder.offset(options.offset);
+            }
+            return queryBuilder.getMany();
+        });
+    }
+    getStatistics(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('Database logging not available');
+            }
+            const queryBuilder = this.logRepository.createQueryBuilder('log');
+            if (options.startDate) {
+                queryBuilder.andWhere('log.createdAt >= :startDate', {
+                    startDate: options.startDate,
+                });
+            }
+            if (options.endDate) {
+                queryBuilder.andWhere('log.createdAt <= :endDate', {
+                    endDate: options.endDate,
+                });
+            }
+            if (options.userId) {
+                queryBuilder.andWhere('log.userId = :userId', { userId: options.userId });
+            }
+            const total = yield queryBuilder.getCount();
+            const success = yield queryBuilder
+                .clone()
+                .andWhere('log.success = :success', { success: true })
+                .getCount();
+            const failed = total - success;
+            const avgResponseTime = yield queryBuilder
+                .clone()
+                .select('AVG(log.responseTime)', 'avg')
+                .getRawOne();
+            const statusStats = yield queryBuilder
+                .clone()
+                .select('log.statusCode', 'statusCode')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.statusCode')
+                .getRawMany();
+            const methodStats = yield queryBuilder
+                .clone()
+                .select('log.method', 'method')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.method')
+                .getRawMany();
+            return {
+                total,
+                success,
+                failed,
+                successRate: total > 0 ? (success / total) * 100 : 0,
+                averageResponseTime: (avgResponseTime === null || avgResponseTime === void 0 ? void 0 : avgResponseTime.avg) || 0,
+                statusStats: statusStats.reduce((acc, item) => {
+                    acc[item.statusCode] = parseInt(item.count);
+                    return acc;
+                }, {}),
+                methodStats: methodStats.reduce((acc, item) => {
+                    acc[item.method] = parseInt(item.count);
+                    return acc;
+                }, {}),
+            };
+        });
+    }
+    initializeDatabaseLogging() {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                this.logRepository = this.dataSource.getRepository(http_log_entity_1.HttpLogEntity);
+                this.logger.log('Database logging initialized');
+            }
+            catch (error) {
+                this.logger.error('Failed to initialize database logging', error);
+            }
+        });
+    }
+    extractCallInfo(decoratorContext, config) {
+        if (decoratorContext) {
+            const decoratorInfo = call_stack_extractor_util_1.CallStackExtractor.extractFromDecorator(decoratorContext.target, decoratorContext.propertyKey);
+            if (decoratorInfo.serviceClass && decoratorInfo.methodName) {
+                return {
+                    operationName: decoratorInfo.operationName,
+                };
+            }
+        }
+        const manualInfo = call_stack_extractor_util_1.CallStackExtractor.getManualCallInfo();
+        if (manualInfo) {
+            return {
+                operationName: manualInfo.operationName,
+            };
+        }
+        const stackInfo = call_stack_extractor_util_1.CallStackExtractor.getCallInfo();
+        if (stackInfo.serviceClass && stackInfo.methodName) {
+            return {
+                operationName: stackInfo.operationName,
+            };
+        }
+        if (config === null || config === void 0 ? void 0 : config.url) {
+            const pathParts = config.url
+                .split('/')
+                .filter((part) => part && !part.includes('{'));
+            if (pathParts.length > 0) {
+                const operation = pathParts[pathParts.length - 1];
+                return {
+                    operationName: operation,
+                };
+            }
+        }
+        return {};
+    }
+    saveToDatabase(logEntity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository)
+                return;
+            try {
+                yield this.logRepository.save(logEntity);
+            }
+            catch (error) {
+                this.logger.error('Failed to save HTTP log to database', error);
+            }
+        });
+    }
+    sanitizeBodyAsString(data) {
+        if (!data)
+            return undefined;
+        if (typeof data === 'string') {
+            return data.length > 5000 ? data.substring(0, 5000) + '...' : data;
+        }
+        const jsonString = JSON.stringify(data);
+        return jsonString.length > 5000
+            ? jsonString.substring(0, 5000) + '...'
+            : jsonString;
+    }
+    sanitizeHeaders(headers, sanitizeHeaders) {
+        if (!headers)
+            return {};
+        const sanitized = {};
+        const defaultSensitiveHeaders = [
+            'authorization',
+            'apikey',
+            'password',
+            'token',
+            'secret',
+            'cookie',
+            'set-cookie',
+            'x-api-key',
+            'x-auth-token',
+        ];
+        const headersToSanitize = [...defaultSensitiveHeaders, ...sanitizeHeaders];
+        Object.keys(headers).forEach((key) => {
+            if (headersToSanitize.some((sensitive) => key.toLowerCase().includes(sensitive.toLowerCase()))) {
+                sanitized[key] = '[FILTERED]';
+            }
+            else {
+                sanitized[key] = String(headers[key]);
+            }
+        });
+        return sanitized;
+    }
+    sanitizeBody(body) {
+        if (!body)
+            return undefined;
+        if (typeof body === 'string') {
+            try {
+                body = JSON.parse(body);
+            }
+            catch (_a) {
+                return body.length > 1000 ? body.substring(0, 1000) + '...' : body;
+            }
+        }
+        if (typeof body === 'object') {
+            const sanitized = Object.assign({}, body);
+            const sensitiveFields = [
+                'password',
+                'secret',
+                'token',
+                'key',
+                'authorization',
+                'credential',
+                'private',
+                'confidential',
+                'ssn',
+                'creditCard',
+            ];
+            this.sanitizeObject(sanitized, sensitiveFields);
+            return sanitized;
+        }
+        return body;
+    }
+    sanitizeObject(obj, sensitiveFields) {
+        if (typeof obj !== 'object' || obj === null)
+            return;
+        for (const key in obj) {
+            if (sensitiveFields.some((field) => key.toLowerCase().includes(field.toLowerCase()))) {
+                obj[key] = '[FILTERED]';
+            }
+            else if (typeof obj[key] === 'object') {
+                this.sanitizeObject(obj[key], sensitiveFields);
+            }
+        }
+    }
+};
+exports.HttpLoggingService = HttpLoggingService;
+exports.HttpLoggingService = HttpLoggingService = HttpLoggingService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], HttpLoggingService);

package/http-client/utils/call-stack-extractor.util.d.ts

@@ -0,0 +1,29 @@
+export declare class CallStackExtractor {
+    static extractCallInfo(): {
+        serviceClass?: string;
+        methodName?: string;
+        operationName?: string;
+    };
+    static setCallInfo(serviceClass: string, methodName: string, operationName?: string): void;
+    static getManualCallInfo(): {
+        serviceClass?: string;
+        methodName?: string;
+        operationName?: string;
+    } | null;
+    static clearCallInfo(): void;
+    static getCallInfo(): {
+        serviceClass?: string;
+        methodName?: string;
+        operationName?: string;
+    };
+    static extractFromDecorator(target: any, propertyKey: string): {
+        serviceClass?: string;
+        methodName?: string;
+        operationName?: string;
+    };
+    static generateOperationName(serviceClass?: string, methodName?: string, config?: any): string;
+    static formatServiceClass(serviceClass?: string): string;
+    static formatMethodName(methodName?: string): string;
+    private static parseStackLine;
+    private static isInternalCall;
+}

package/http-client/utils/call-stack-extractor.util.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CallStackExtractor = void 0;
+class CallStackExtractor {
+    static extractCallInfo() {
+        const stack = new Error().stack;
+        if (!stack) {
+            return {};
+        }
+        const lines = stack.split('\n');
+        const httpClientIndex = lines.findIndex((line) => line.includes('http-client.service.ts') ||
+            line.includes('HttpClientService'));
+        if (httpClientIndex === -1) {
+            return {};
+        }
+        for (let i = httpClientIndex + 1; i < lines.length; i++) {
+            const line = lines[i];
+            const callInfo = this.parseStackLine(line);
+            if (callInfo && !this.isInternalCall(callInfo.serviceClass)) {
+                return callInfo;
+            }
+        }
+        return {};
+    }
+    static setCallInfo(serviceClass, methodName, operationName) {
+        if (typeof global !== 'undefined') {
+            global.httpCallContext = {
+                serviceClass,
+                methodName,
+                operationName: operationName || `${serviceClass}.${methodName}`,
+                timestamp: Date.now(),
+            };
+        }
+    }
+    static getManualCallInfo() {
+        if (typeof global !== 'undefined' && global.httpCallContext) {
+            const context = global.httpCallContext;
+            if (Date.now() - context.timestamp < 1000) {
+                return {
+                    serviceClass: context.serviceClass,
+                    methodName: context.methodName,
+                    operationName: context.operationName,
+                };
+            }
+            delete global.httpCallContext;
+        }
+        return null;
+    }
+    static clearCallInfo() {
+        if (typeof global !== 'undefined' && global.httpCallContext) {
+            delete global.httpCallContext;
+        }
+    }
+    static getCallInfo() {
+        const manualInfo = this.getManualCallInfo();
+        if (manualInfo) {
+            return manualInfo;
+        }
+        return this.extractCallInfo();
+    }
+    static extractFromDecorator(target, propertyKey) {
+        var _a;
+        const serviceClass = (_a = target.constructor) === null || _a === void 0 ? void 0 : _a.name;
+        const methodName = propertyKey;
+        return {
+            serviceClass,
+            methodName,
+            operationName: serviceClass && methodName
+                ? `${serviceClass}.${methodName}`
+                : undefined,
+        };
+    }
+    static generateOperationName(serviceClass, methodName, config) {
+        if (!serviceClass || !methodName) {
+            return 'Unknown';
+        }
+        let operationName = `${serviceClass}.${methodName}`;
+        if (config === null || config === void 0 ? void 0 : config.url) {
+            const url = config.url;
+            const pathParts = url
+                .split('/')
+                .filter((part) => part && !part.includes('{'));
+            if (pathParts.length > 0) {
+                const lastPart = pathParts[pathParts.length - 1];
+                if (lastPart && lastPart !== 'api' && lastPart.length < 50) {
+                    operationName += `(${lastPart})`;
+                }
+            }
+        }
+        return operationName;
+    }
+    static formatServiceClass(serviceClass) {
+        if (!serviceClass)
+            return 'Unknown';
+        return serviceClass.replace(/Service|Controller|Provider|Handler$/, '');
+    }
+    static formatMethodName(methodName) {
+        if (!methodName)
+            return 'unknown';
+        return methodName
+            .replace(/([A-Z])/g, ' $1')
+            .replace(/^./, (str) => str.toUpperCase())
+            .trim();
+    }
+    static parseStackLine(line) {
+        const match = line.match(/at\s+([^.]+)\.([^(]+)\s*\(/);
+        if (!match) {
+            return null;
+        }
+        const [, serviceClass, methodName] = match;
+        return {
+            serviceClass,
+            methodName,
+            operationName: `${serviceClass}.${methodName}`,
+        };
+    }
+    static isInternalCall(serviceClass) {
+        if (!serviceClass)
+            return true;
+        const internalPatterns = [
+            /^Http/,
+            /^HttpClient/,
+            /^CircuitBreaker/,
+            /^Retry/,
+            /^Cache/,
+            /^Logger/,
+            /^Context/,
+            /Interceptor/,
+            /Middleware/,
+            /__/,
+            /^Array\./,
+            /^Object\./,
+            /^Function\./,
+        ];
+        return internalPatterns.some((pattern) => pattern.test(serviceClass));
+    }
+}
+exports.CallStackExtractor = CallStackExtractor;

package/http-client/utils/context-extractor.util.d.ts

@@ -0,0 +1,44 @@
+export declare class ContextExtractor {
+    static getHttpContext(): {
+        requestId?: string;
+        userId?: string;
+        clientIp?: string;
+        userAgent?: string;
+        appId?: string;
+        metadata?: Record<string, any>;
+        tags?: string[];
+    };
+    static getRequestId(): string | undefined;
+    static getUserId(): string | undefined;
+    static getClientIp(): string | undefined;
+    static getUserAgent(): string | undefined;
+    static getServiceName(): string | undefined;
+    static getMetadata(): Record<string, any> | undefined;
+    static getTags(): string[];
+    static addTag(tag: string): void;
+    static getContextSummary(): {
+        requestId?: string;
+        userId?: string;
+        service?: string;
+        clientIp?: string;
+        hasUser: boolean;
+        requestSource: string;
+    };
+    static getRequestSource(): {
+        source: 'internal' | 'external' | 'unknown';
+        ip?: string;
+        userAgent?: string;
+        service?: string;
+    };
+    static isInternalRequest(): boolean;
+    static getSecurityContext(): {
+        isAuthenticated: boolean;
+        userId?: string;
+        tenantId?: string;
+        role?: string;
+        permissions: string[];
+        securityLevel: 'low' | 'medium' | 'high';
+    };
+    private static generateSpanId;
+    private static isInternal172IP;
+}