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

package/http-client/services/log-cleanup.service.js

@@ -0,0 +1,268 @@
+"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 HttpLogCleanupService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLogCleanupService = void 0;
+const common_1 = require("@nestjs/common");
+const schedule_1 = require("@nestjs/schedule");
+const http_log_query_service_1 = require("./http-log-query.service");
+const setup_1 = require("../../setup");
+let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupService {
+    constructor(logQueryService, config = {}) {
+        this.logQueryService = logQueryService;
+        this.logger = new common_1.Logger(HttpLogCleanupService_1.name);
+        this.defaultConfig = {
+            enabled: true,
+            strategy: 'retention',
+            retentionDays: 30,
+            maxRecords: 1000000,
+            schedule: schedule_1.CronExpression.EVERY_DAY_AT_2AM,
+            batchSize: 10000,
+            preserveErrorLogs: true,
+            errorLogRetentionDays: 90,
+            preserveImportantLogs: true,
+            importantLogRetentionDays: 60,
+            preserveSlowRequests: true,
+            slowRequestRetentionDays: 60,
+            slowRequestThreshold: 5000,
+        };
+        if (Object.keys(config).length > 0) {
+            Object.assign(this.defaultConfig, config);
+        }
+    }
+    get cleanupConfig() {
+        return this.defaultConfig;
+    }
+    onModuleInit() {
+        if (this.cleanupConfig.enabled) {
+            this.logger.log(`HTTP log cleanup enabled with strategy: ${this.cleanupConfig.strategy}`);
+            this.logger.log(`Schedule: ${this.cleanupConfig.schedule}`);
+        }
+        else {
+            this.logger.warn('HTTP log cleanup is disabled');
+        }
+    }
+    scheduledCleanup() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.cleanupConfig.enabled) {
+                return this.createCleanupStats('scheduled', 0, 0, 0, 0, []);
+            }
+            this.logger.log('Starting scheduled HTTP log cleanup...');
+            return this.performCleanup();
+        });
+    }
+    manualCleanup(options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = Object.assign(Object.assign({}, this.cleanupConfig), options);
+            if (!config.enabled) {
+                throw new Error('Log cleanup is disabled');
+            }
+            this.logger.log(`Starting manual HTTP log cleanup with strategy: ${config.strategy}`);
+            return this.performCleanup(config);
+        });
+    }
+    getConfig() {
+        return this.cleanupConfig;
+    }
+    updateConfig(config) {
+        Object.assign(this.defaultConfig, config);
+        this.logger.log('Cleanup configuration updated');
+    }
+    getCleanupStatus() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const config = this.cleanupConfig;
+            const stats = yield this.logQueryService.getStats();
+            const recommendations = [];
+            if (stats.totalRequests > (config.maxRecords || Infinity) * 0.9) {
+                recommendations.push('Current records approaching limit, consider adjusting retention policy');
+            }
+            if (stats.averageResponseTime > 1000) {
+                recommendations.push('High average response time detected, consider performance optimization');
+            }
+            if (stats.failedRequests / stats.totalRequests > 0.1) {
+                recommendations.push('High error rate detected, consider error handling improvements');
+            }
+            return {
+                enabled: config.enabled,
+                config,
+                currentStats: stats,
+                recommendations,
+            };
+        });
+    }
+    previewCleanup(config) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const finalConfig = Object.assign(Object.assign({}, this.cleanupConfig), config);
+            const stats = yield this.logQueryService.getStats();
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - finalConfig.retentionDays);
+            return {
+                strategy: finalConfig.strategy,
+                currentRecords: stats.totalRequests,
+                estimatedDeletion: Math.max(0, stats.totalRequests - finalConfig.maxRecords || Infinity),
+                estimatedAfterCount: Math.min(stats.totalRequests, finalConfig.maxRecords || Infinity),
+                cutoffDate,
+                breakdown: {
+                    normalLogs: Math.floor(stats.totalRequests * 0.7),
+                    errorLogs: Math.floor(stats.totalRequests * 0.2),
+                    slowRequests: Math.floor(stats.totalRequests * 0.05),
+                    importantLogs: Math.floor(stats.totalRequests * 0.05),
+                },
+            };
+        });
+    }
+    performCleanup() {
+        return __awaiter(this, arguments, void 0, function* (config = this.cleanupConfig) {
+            const startTime = Date.now();
+            const errors = [];
+            let deletedCount = 0;
+            const batchCount = 0;
+            try {
+                const beforeStats = yield this.logQueryService.getStats();
+                const beforeCount = beforeStats.totalRequests;
+                switch (config.strategy) {
+                    case 'retention':
+                        deletedCount = yield this.cleanupByRetention(config, errors);
+                        break;
+                    case 'size':
+                        deletedCount = yield this.cleanupBySize(config, errors);
+                        break;
+                    case 'combination':
+                        deletedCount = yield this.cleanupByCombination(config, errors);
+                        break;
+                    default:
+                        throw new Error(`Unknown cleanup strategy: ${config.strategy}`);
+                }
+                const afterStats = yield this.logQueryService.getStats();
+                const afterCount = afterStats.totalRequests;
+                const duration = Date.now() - startTime;
+                const stats = {
+                    cleanupTime: new Date(),
+                    strategy: config.strategy,
+                    beforeCount,
+                    afterCount,
+                    deletedCount,
+                    batchCount,
+                    duration,
+                    errors,
+                };
+                this.logger.log(`Cleanup completed: deleted ${deletedCount} records in ${duration}ms`);
+                if (errors.length > 0) {
+                    this.logger.warn(`Cleanup completed with ${errors.length} errors`, errors);
+                }
+                return stats;
+            }
+            catch (error) {
+                const duration = Date.now() - startTime;
+                this.logger.error(`Cleanup failed after ${duration}ms`, error);
+                throw error;
+            }
+        });
+    }
+    cleanupByRetention(config, errors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let totalDeleted = 0;
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - config.retentionDays);
+            try {
+                const normalDeleted = yield this.logQueryService.deleteOldLogs(config.retentionDays);
+                totalDeleted += normalDeleted;
+            }
+            catch (error) {
+                errors.push(`Retention cleanup failed: ${error.message}`);
+                return 0;
+            }
+            if (config.preserveErrorLogs &&
+                config.errorLogRetentionDays > config.retentionDays) {
+                this.logger.log(`Preserving error logs for ${config.errorLogRetentionDays} days`);
+            }
+            if (config.preserveSlowRequests &&
+                config.slowRequestRetentionDays > config.retentionDays) {
+                this.logger.log(`Preserving slow requests for ${config.slowRequestRetentionDays} days`);
+            }
+            return totalDeleted;
+        });
+    }
+    cleanupBySize(config, errors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!config.maxRecords) {
+                errors.push('Max records not configured for size-based cleanup');
+                return 0;
+            }
+            const stats = yield this.logQueryService.getStats();
+            if (stats.totalRequests <= config.maxRecords) {
+                this.logger.log(`Current records (${stats.totalRequests}) within limit (${config.maxRecords})`);
+                return 0;
+            }
+            const excessCount = stats.totalRequests - config.maxRecords;
+            const targetCutoffDate = new Date();
+            const averageDailyRecords = stats.totalRequests / 30;
+            const daysToDelete = Math.ceil(excessCount / averageDailyRecords);
+            targetCutoffDate.setDate(targetCutoffDate.getDate() - daysToDelete);
+            try {
+                const deleted = yield this.logQueryService.deleteOldLogs(Math.ceil((Date.now() - targetCutoffDate.getTime()) / (24 * 60 * 60 * 1000)));
+                this.logger.log(`Size-based cleanup: deleted ${deleted} records, cutoff date: ${targetCutoffDate.toISOString()}`);
+                return deleted;
+            }
+            catch (error) {
+                errors.push(`Size-based cleanup failed: ${error.message}`);
+                return 0;
+            }
+        });
+    }
+    cleanupByCombination(config, errors) {
+        return __awaiter(this, void 0, void 0, function* () {
+            let totalDeleted = 0;
+            const retentionDeleted = yield this.cleanupByRetention(config, errors);
+            totalDeleted += retentionDeleted;
+            if (config.maxRecords) {
+                const stats = yield this.logQueryService.getStats();
+                if (stats.totalRequests > config.maxRecords) {
+                    const sizeDeleted = yield this.cleanupBySize(config, errors);
+                    totalDeleted += sizeDeleted;
+                }
+            }
+            return totalDeleted;
+        });
+    }
+    createCleanupStats(strategy, beforeCount, afterCount, deletedCount, batchCount, errors) {
+        return {
+            cleanupTime: new Date(),
+            strategy,
+            beforeCount,
+            afterCount,
+            deletedCount,
+            batchCount,
+            duration: 0,
+            errors,
+        };
+    }
+};
+exports.HttpLogCleanupService = HttpLogCleanupService;
+__decorate([
+    (0, setup_1.WorkerCronSmart)(schedule_1.CronExpression.EVERY_DAY_AT_2AM),
+    __metadata("design:type", Function),
+    __metadata("design:paramtypes", []),
+    __metadata("design:returntype", Promise)
+], HttpLogCleanupService.prototype, "scheduledCleanup", null);
+exports.HttpLogCleanupService = HttpLogCleanupService = HttpLogCleanupService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_log_query_service_1.HttpLogQueryService, Object])
+], HttpLogCleanupService);

package/http-client/services/logging.service.d.ts

@@ -0,0 +1,36 @@
+import { DataSource } from 'typeorm';
+import { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
+import { HttpLogEntity } from '../entities/http-log.entity';
+export declare class HttpLoggingService {
+    private readonly dataSource?;
+    private readonly logger;
+    private logRepository;
+    constructor(dataSource?: DataSource);
+    logRequestStart(config: AxiosRequestConfig, loggingOptions: any, requestId?: string): string;
+    logRequestSuccess(response: AxiosResponse, startTime: number, requestId: string, loggingOptions: any, databaseLogging?: boolean, retryRecords?: any[], cacheHit?: boolean, circuitBreakerState?: string, decoratorContext?: any): void;
+    logRequestError(error: AxiosError, startTime: number, requestId: string, attemptCount: number, loggingOptions: any, databaseLogging?: boolean, retryRecords?: any[], cacheHit?: boolean, circuitBreakerState?: string, decoratorContext?: any): void;
+    findLogs(options: {
+        requestId?: string;
+        userId?: string;
+        method?: string;
+        url?: string;
+        statusCode?: number;
+        success?: boolean;
+        startDate?: Date;
+        endDate?: Date;
+        limit?: number;
+        offset?: number;
+    }): Promise<HttpLogEntity[]>;
+    getStatistics(options: {
+        startDate?: Date;
+        endDate?: Date;
+        userId?: string;
+    }): Promise<any>;
+    private initializeDatabaseLogging;
+    private extractCallInfo;
+    private saveToDatabase;
+    private sanitizeBodyAsString;
+    private sanitizeHeaders;
+    private sanitizeBody;
+    private sanitizeObject;
+}