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

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

@@ -0,0 +1,266 @@
+"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 HttpReplayService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpReplayService = void 0;
+const common_1 = require("@nestjs/common");
+const http_client_service_1 = require("./http-client.service");
+const http_log_query_service_1 = require("./http-log-query.service");
+let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
+    constructor(httpClient, logQueryService) {
+        this.httpClient = httpClient;
+        this.logQueryService = logQueryService;
+        this.logger = new common_1.Logger(HttpReplayService_1.name);
+    }
+    replayByLogId(logId_1) {
+        return __awaiter(this, arguments, void 0, function* (logId, options = {}) {
+            const startTime = Date.now();
+            const replayId = this.generateReplayId();
+            try {
+                const originalLog = yield this.logQueryService.findLogById(logId, true);
+                if (!originalLog) {
+                    throw new Error(`Log with ID ${logId} not found`);
+                }
+                const requestConfig = this.buildReplayConfig(originalLog, options);
+                if (options.logReplay !== false) {
+                    this.logger.log(`Starting replay for log ${logId} (replay ID: ${replayId})`);
+                }
+                const response = yield this.executeReplayRequest(requestConfig, options);
+                const endTime = Date.now();
+                const responseTime = endTime - startTime;
+                const result = {
+                    originalLog,
+                    requestConfig,
+                    response,
+                    responseTime,
+                    success: true,
+                    replayTimestamp: new Date().toISOString(),
+                    replayId,
+                };
+                if (options.logReplay !== false) {
+                    this.logger.log(`Replay completed for log ${logId} (replay ID: ${replayId}) in ${responseTime}ms`);
+                }
+                return result;
+            }
+            catch (error) {
+                const endTime = Date.now();
+                const responseTime = endTime - startTime;
+                const result = {
+                    originalLog: {},
+                    requestConfig: {},
+                    response: null,
+                    responseTime,
+                    success: false,
+                    error: error.message,
+                    replayTimestamp: new Date().toISOString(),
+                    replayId,
+                };
+                this.logger.error(`Replay failed for log ${logId} (replay ID: ${replayId}): ${error.message}`, error);
+                return result;
+            }
+        });
+    }
+    replayByRequestId(requestId_1) {
+        return __awaiter(this, arguments, void 0, function* (requestId, options = {}) {
+            const originalLog = yield this.logQueryService.findLogByRequestId(requestId);
+            if (!originalLog) {
+                throw new Error(`Log with requestId ${requestId} not found`);
+            }
+            return this.replayByLogId(originalLog.id, options);
+        });
+    }
+    batchReplay(logIds_1) {
+        return __awaiter(this, arguments, void 0, function* (logIds, options = {}, concurrency = 5) {
+            const startTime = Date.now();
+            this.logger.log(`Starting batch replay for ${logIds.length} logs`);
+            const results = [];
+            const chunks = this.chunkArray(logIds, concurrency);
+            for (const chunk of chunks) {
+                const chunkPromises = chunk.map((logId) => __awaiter(this, void 0, void 0, function* () {
+                    try {
+                        return yield this.replayByLogId(logId, options);
+                    }
+                    catch (error) {
+                        this.logger.error(`Failed to replay log ${logId}`, error);
+                        return {
+                            originalLog: {},
+                            requestConfig: {},
+                            response: null,
+                            responseTime: 0,
+                            success: false,
+                            error: error.message,
+                            replayTimestamp: new Date().toISOString(),
+                            replayId: this.generateReplayId(),
+                        };
+                    }
+                }));
+                const chunkResults = yield Promise.all(chunkPromises);
+                results.push(...chunkResults);
+            }
+            const successfulRequests = results.filter((r) => r.success).length;
+            const failedRequests = results.length - successfulRequests;
+            const totalResponseTime = results.reduce((sum, r) => sum + r.responseTime, 0);
+            const averageResponseTime = results.length > 0 ? totalResponseTime / results.length : 0;
+            const batchResult = {
+                totalRequests: results.length,
+                successfulRequests,
+                failedRequests,
+                successRate: results.length > 0 ? (successfulRequests / results.length) * 100 : 0,
+                totalResponseTime,
+                averageResponseTime,
+                results,
+            };
+            this.logger.log(`Batch replay completed: ${successfulRequests}/${results.length} successful in ${totalResponseTime}ms`);
+            return batchResult;
+        });
+    }
+    batchReplayByQuery() {
+        return __awaiter(this, arguments, void 0, function* (queryOptions = {}, replayOptions = {}, concurrency = 5) {
+            const limitedQueryOptions = Object.assign(Object.assign({}, queryOptions), { limit: Math.min(queryOptions.limit || 50, 100) });
+            const queryResult = yield this.logQueryService.findLogs(limitedQueryOptions);
+            const logIds = queryResult.logs.map((log) => log.id);
+            if (logIds.length === 0) {
+                this.logger.log('No logs found for replay query');
+                return {
+                    totalRequests: 0,
+                    successfulRequests: 0,
+                    failedRequests: 0,
+                    successRate: 0,
+                    totalResponseTime: 0,
+                    averageResponseTime: 0,
+                    results: [],
+                };
+            }
+            this.logger.log(`Found ${logIds.length} logs for batch replay`);
+            return this.batchReplay(logIds, replayOptions, concurrency);
+        });
+    }
+    replayAndCompare(logId_1) {
+        return __awaiter(this, arguments, void 0, function* (logId, options = {}) {
+            var _a, _b, _c;
+            const originalLog = yield this.logQueryService.findLogById(logId, true);
+            if (!originalLog) {
+                throw new Error(`Log with ID ${logId} not found`);
+            }
+            const replayResult = yield this.replayByLogId(logId, options);
+            const comparison = {
+                statusMatch: originalLog.statusCode === ((_a = replayResult.response) === null || _a === void 0 ? void 0 : _a.status),
+                responseTimeDifference: replayResult.responseTime - originalLog.responseTime,
+                headersMatch: this.compareHeaders(originalLog.responseHeaders || {}, ((_b = replayResult.response) === null || _b === void 0 ? void 0 : _b.headers) || {}),
+                bodyMatch: this.compareBodies(originalLog.responseBody, (_c = replayResult.response) === null || _c === void 0 ? void 0 : _c.data),
+            };
+            return {
+                original: originalLog,
+                replay: replayResult,
+                comparison,
+            };
+        });
+    }
+    buildReplayConfig(log, options) {
+        const config = {
+            method: log.method,
+            url: log.url,
+            headers: Object.assign({}, log.headers),
+            params: Object.assign({}, log.params),
+        };
+        if (log.body) {
+            try {
+                config.data =
+                    typeof log.body === 'string' ? JSON.parse(log.body) : log.body;
+            }
+            catch (_a) {
+                config.data = log.body;
+            }
+        }
+        if (options.overrideHeaders) {
+            config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
+        }
+        else if (options.additionalHeaders) {
+            config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
+        }
+        if (options.overrideBody && options.additionalHeaders) {
+        }
+        if (options.overrideParams && options.metadata) {
+            config.params = Object.assign(Object.assign({}, config.params), options.metadata);
+        }
+        if (options.timeout) {
+            config.timeout = options.timeout;
+        }
+        config.metadata = Object.assign({ originalLogId: log.id, originalRequestId: log.requestId, replayTimestamp: new Date().toISOString(), replayedBy: 'http-replay-service' }, options.metadata);
+        return config;
+    }
+    executeReplayRequest(config, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                return yield this.httpClient.request(config);
+            }
+            catch (error) {
+                throw error;
+            }
+        });
+    }
+    generateReplayId() {
+        return `replay-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
+    }
+    chunkArray(array, size) {
+        const chunks = [];
+        for (let i = 0; i < array.length; i += size) {
+            chunks.push(array.slice(i, i + size));
+        }
+        return chunks;
+    }
+    compareHeaders(original, replay) {
+        const ignoreHeaders = ['date', 'expires', 'last-modified', 'etag'];
+        const originalFiltered = Object.keys(original)
+            .filter((key) => !ignoreHeaders.includes(key.toLowerCase()))
+            .reduce((obj, key) => {
+            obj[key] = original[key];
+            return obj;
+        }, {});
+        const replayFiltered = Object.keys(replay)
+            .filter((key) => !ignoreHeaders.includes(key.toLowerCase()))
+            .reduce((obj, key) => {
+            obj[key] = replay[key];
+            return obj;
+        }, {});
+        return JSON.stringify(originalFiltered) === JSON.stringify(replayFiltered);
+    }
+    compareBodies(original, replay) {
+        if (!original && !replay)
+            return true;
+        if (!original || !replay)
+            return false;
+        try {
+            const originalParsed = typeof original === 'string' ? JSON.parse(original) : original;
+            const replayString = typeof replay === 'string' ? replay : JSON.stringify(replay);
+            const replayParsed = JSON.parse(replayString);
+            return JSON.stringify(originalParsed) === JSON.stringify(replayParsed);
+        }
+        catch (_a) {
+            return original === replay;
+        }
+    }
+};
+exports.HttpReplayService = HttpReplayService;
+exports.HttpReplayService = HttpReplayService = HttpReplayService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [http_client_service_1.HttpClientService,
+        http_log_query_service_1.HttpLogQueryService])
+], HttpReplayService);

package/http-client/services/index.d.ts

@@ -0,0 +1,7 @@
+export * from './http-client.service';
+export * from './circuit-breaker.service';
+export * from './logging.service';
+export * from './cache.service';
+export * from './http-log-query.service';
+export * from './log-cleanup.service';
+export * from './api-client-registry.service';

package/http-client/services/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./http-client.service"), exports);
+__exportStar(require("./circuit-breaker.service"), exports);
+__exportStar(require("./logging.service"), exports);
+__exportStar(require("./cache.service"), exports);
+__exportStar(require("./http-log-query.service"), exports);
+__exportStar(require("./log-cleanup.service"), exports);
+__exportStar(require("./api-client-registry.service"), exports);

package/http-client/services/log-cleanup.service.d.ts

@@ -0,0 +1,64 @@
+import { OnModuleInit } from '@nestjs/common';
+import { CronExpression } from '@nestjs/schedule';
+import { HttpLogQueryService } from './http-log-query.service';
+export interface LogCleanupConfig {
+    enabled: boolean;
+    strategy: 'retention' | 'size' | 'combination';
+    retentionDays: number;
+    maxRecords?: number;
+    schedule?: CronExpression;
+    batchSize?: number;
+    preserveErrorLogs?: boolean;
+    errorLogRetentionDays?: number;
+    preserveImportantLogs?: boolean;
+    importantLogRetentionDays?: number;
+    preserveSlowRequests?: boolean;
+    slowRequestRetentionDays?: number;
+    slowRequestThreshold?: number;
+}
+export interface CleanupStats {
+    cleanupTime: Date;
+    strategy: string;
+    beforeCount: number;
+    afterCount: number;
+    deletedCount: number;
+    batchCount: number;
+    duration: number;
+    errors: string[];
+}
+export declare class HttpLogCleanupService implements OnModuleInit {
+    private readonly logQueryService;
+    private readonly logger;
+    private readonly defaultConfig;
+    constructor(logQueryService: HttpLogQueryService, config?: Partial<LogCleanupConfig>);
+    private get cleanupConfig();
+    onModuleInit(): void;
+    scheduledCleanup(): Promise<CleanupStats>;
+    manualCleanup(options?: Partial<LogCleanupConfig>): Promise<CleanupStats>;
+    getConfig(): LogCleanupConfig;
+    updateConfig(config: Partial<LogCleanupConfig>): void;
+    getCleanupStatus(): Promise<{
+        enabled: boolean;
+        config: LogCleanupConfig;
+        currentStats: any;
+        recommendations: string[];
+    }>;
+    previewCleanup(config?: Partial<LogCleanupConfig>): Promise<{
+        strategy: string;
+        currentRecords: number;
+        estimatedDeletion: number;
+        estimatedAfterCount: number;
+        cutoffDate: Date;
+        breakdown: {
+            normalLogs: number;
+            errorLogs: number;
+            slowRequests: number;
+            importantLogs: number;
+        };
+    }>;
+    private performCleanup;
+    private cleanupByRetention;
+    private cleanupBySize;
+    private cleanupByCombination;
+    private createCleanupStats;
+}

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 schedule_decorator_1 = require("../../setup/schedule.decorator");
+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, schedule_decorator_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;
+}