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

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

@@ -0,0 +1,414 @@
+"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 HttpLogQueryService_1;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HttpLogQueryService = void 0;
+const common_1 = require("@nestjs/common");
+const typeorm_1 = require("typeorm");
+const http_log_entity_1 = require("../entities/http-log.entity");
+let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
+    constructor(dataSource) {
+        this.dataSource = dataSource;
+        this.logger = new common_1.Logger(HttpLogQueryService_1.name);
+        this.logRepository = null;
+        this.initializeRepository();
+    }
+    findLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { page = 1, limit = 50, sortBy = 'createdAt', sortOrder = 'DESC', includeDetails = false, } = options;
+            const queryBuilder = this.buildQuery(options, includeDetails);
+            const offset = (page - 1) * limit;
+            queryBuilder.skip(offset).take(limit);
+            queryBuilder.orderBy(`log.${sortBy}`, sortOrder);
+            const [logs, total] = yield queryBuilder.getManyAndCount();
+            return {
+                logs,
+                total,
+                page,
+                limit,
+                totalPages: Math.ceil(total / limit),
+            };
+        });
+    }
+    findLogById(id_1) {
+        return __awaiter(this, arguments, void 0, function* (id, includeDetails = false) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const queryBuilder = this.logRepository.createQueryBuilder('log');
+            if (includeDetails) {
+                queryBuilder.leftJoinAndSelect('log.retryRecords', 'retryRecords');
+            }
+            return queryBuilder.where('log.id = :id', { id }).getOne();
+        });
+    }
+    findLogByRequestId(requestId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            return this.logRepository.findOne({
+                where: { requestId },
+                order: { createdAt: 'DESC' },
+            });
+        });
+    }
+    findErrorLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            const queryOptions = Object.assign(Object.assign({}, options), { success: false });
+            return this.findLogs(queryOptions);
+        });
+    }
+    findSlowRequests() {
+        return __awaiter(this, arguments, void 0, function* (minResponseTime = 5000, options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { page = 1, limit = 50 } = options;
+            const offset = (page - 1) * limit;
+            const [logs, total] = yield this.logRepository
+                .createQueryBuilder('log')
+                .where('log.responseTime >= :minResponseTime', { minResponseTime })
+                .orderBy('log.responseTime', 'DESC')
+                .skip(offset)
+                .take(limit)
+                .getManyAndCount();
+            return { logs, total };
+        });
+    }
+    findRetryLogs() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { minRetries = 1, page = 1, limit = 50 } = options;
+            const offset = (page - 1) * limit;
+            const queryBuilder = this.logRepository
+                .createQueryBuilder('log')
+                .where('log.attemptCount > :minRetries', { minRetries: minRetries - 1 })
+                .orderBy('log.attemptCount', 'DESC')
+                .addOrderBy('log.createdAt', 'DESC')
+                .skip(offset)
+                .take(limit);
+            const [logs, total] = yield queryBuilder.getManyAndCount();
+            return { logs, total };
+        });
+    }
+    getStats() {
+        return __awaiter(this, arguments, void 0, function* (options = {}) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const { startDate, endDate, userId, serviceName } = options;
+            const baseQuery = this.logRepository.createQueryBuilder('log');
+            if (startDate) {
+                baseQuery.andWhere('log.createdAt >= :startDate', { startDate });
+            }
+            if (endDate) {
+                baseQuery.andWhere('log.createdAt <= :endDate', { endDate });
+            }
+            if (userId) {
+                baseQuery.andWhere('log.userId = :userId', { userId });
+            }
+            if (serviceName) {
+                baseQuery.andWhere('log.serviceName = :serviceName', { serviceName });
+            }
+            const [total, successful, failed] = yield Promise.all([
+                baseQuery.getCount(),
+                baseQuery
+                    .clone()
+                    .andWhere('log.success = :success', { success: true })
+                    .getCount(),
+                baseQuery
+                    .clone()
+                    .andWhere('log.success = :success', { success: false })
+                    .getCount(),
+            ]);
+            const responseTimeStats = yield baseQuery
+                .select('AVG(log.responseTime)', 'avg')
+                .addSelect('MIN(log.responseTime)', 'min')
+                .addSelect('MAX(log.responseTime)', 'max')
+                .getRawOne();
+            const httpMethodStats = yield baseQuery
+                .select('log.method', 'method')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.method')
+                .getRawMany();
+            const statusStats = yield baseQuery
+                .select('log.statusCode', 'statusCode')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.statusCode')
+                .getRawMany();
+            const serviceStats = yield baseQuery
+                .select('log.serviceName', 'serviceName')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.serviceName')
+                .getRawMany();
+            const operationStats = yield baseQuery
+                .select('log.operationName', 'operationName')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.operationName')
+                .getRawMany();
+            const sourceStats = yield baseQuery
+                .select('log.source', 'source')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.source')
+                .getRawMany();
+            const errorStats = yield baseQuery
+                .clone()
+                .where('log.success = :success', { success: false })
+                .select('log.errorCode', 'errorCode')
+                .addSelect('COUNT(*)', 'count')
+                .groupBy('log.errorCode')
+                .getRawMany();
+            const retryStats = yield baseQuery
+                .select('AVG(log.attemptCount)', 'avgAttempts')
+                .addSelect('MAX(log.attemptCount)', 'maxAttempts')
+                .addSelect('SUM(log.attemptCount - 1)', 'totalRetries')
+                .addSelect('COUNT(*)', 'totalRequests')
+                .getRawOne();
+            const cacheStats = yield baseQuery
+                .select('SUM(CASE WHEN log.cacheHit = true THEN 1 ELSE 0 END)', 'cacheHits')
+                .addSelect('SUM(CASE WHEN log.cacheHit = false OR log.cacheHit IS NULL THEN 1 ELSE 0 END)', 'cacheMisses')
+                .addSelect('COUNT(*)', 'total')
+                .getRawOne();
+            const percentiles = yield this.calculatePercentiles(baseQuery);
+            return {
+                totalRequests: total,
+                successfulRequests: successful,
+                failedRequests: failed,
+                successRate: total > 0 ? (successful / total) * 100 : 0,
+                averageResponseTime: (responseTimeStats === null || responseTimeStats === void 0 ? void 0 : responseTimeStats.avg) || 0,
+                minResponseTime: (responseTimeStats === null || responseTimeStats === void 0 ? void 0 : responseTimeStats.min) || 0,
+                maxResponseTime: (responseTimeStats === null || responseTimeStats === void 0 ? void 0 : responseTimeStats.max) || 0,
+                p50ResponseTime: percentiles.p50,
+                p95ResponseTime: percentiles.p95,
+                p99ResponseTime: percentiles.p99,
+                requestsByMethod: this.formatStats(httpMethodStats, 'method', 'count'),
+                requestsByStatus: this.formatStats(statusStats, 'statusCode', 'count'),
+                requestsByService: this.formatStats(serviceStats, 'serviceName', 'count'),
+                requestsBySource: this.formatStats(sourceStats, 'source', 'count'),
+                errorsByCode: this.formatStats(errorStats, 'errorCode', 'count'),
+                retryStats: {
+                    totalRetries: (retryStats === null || retryStats === void 0 ? void 0 : retryStats.totalRetries) || 0,
+                    averageRetries: (retryStats === null || retryStats === void 0 ? void 0 : retryStats.avgAttempts)
+                        ? parseFloat(retryStats.avgAttempts) - 1
+                        : 0,
+                    maxRetries: (retryStats === null || retryStats === void 0 ? void 0 : retryStats.maxAttempts)
+                        ? parseInt(retryStats.maxAttempts) - 1
+                        : 0,
+                    retryRate: total > 0 ? (((retryStats === null || retryStats === void 0 ? void 0 : retryStats.totalRetries) || 0) / total) * 100 : 0,
+                },
+                cacheStats: {
+                    cacheHits: (cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.cacheHits) || 0,
+                    cacheMisses: (cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.cacheMisses) || 0,
+                    cacheHitRate: (cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.total) > 0
+                        ? (((cacheStats === null || cacheStats === void 0 ? void 0 : cacheStats.cacheHits) || 0) / cacheStats.total) * 100
+                        : 0,
+                },
+            };
+        });
+    }
+    deleteOldLogs() {
+        return __awaiter(this, arguments, void 0, function* (daysToKeep = 30) {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            const cutoffDate = new Date();
+            cutoffDate.setDate(cutoffDate.getDate() - daysToKeep);
+            const result = yield this.logRepository
+                .createQueryBuilder()
+                .delete()
+                .where('createdAt < :cutoffDate', { cutoffDate })
+                .execute();
+            this.logger.log(`Deleted ${result.affected} old HTTP logs (older than ${daysToKeep} days)`);
+            return result.affected || 0;
+        });
+    }
+    clearAllLogs() {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                throw new Error('HTTP log repository not available');
+            }
+            yield this.logRepository.clear();
+            this.logger.warn('Cleared all HTTP logs');
+            return 0;
+        });
+    }
+    initializeRepository() {
+        if (this.dataSource) {
+            try {
+                this.logRepository = this.dataSource.getRepository(http_log_entity_1.HttpLogEntity);
+                this.logger.log('HTTP log repository initialized');
+            }
+            catch (error) {
+                this.logger.error('Failed to initialize HTTP log repository', error);
+            }
+        }
+    }
+    calculatePercentiles(queryBuilder) {
+        return __awaiter(this, void 0, void 0, function* () {
+            try {
+                const results = yield queryBuilder
+                    .select('log.responseTime', 'responseTime')
+                    .where('log.responseTime IS NOT NULL')
+                    .orderBy('log.responseTime', 'ASC')
+                    .getRawMany();
+                if (results.length === 0) {
+                    return { p50: 0, p95: 0, p99: 0 };
+                }
+                const responseTimes = results
+                    .map((r) => r.responseTime)
+                    .sort((a, b) => a - b);
+                const total = responseTimes.length;
+                const getPercentile = (p) => {
+                    const index = Math.ceil((p / 100) * total) - 1;
+                    return responseTimes[Math.max(0, index)];
+                };
+                return {
+                    p50: getPercentile(50),
+                    p95: getPercentile(95),
+                    p99: getPercentile(99),
+                };
+            }
+            catch (error) {
+                this.logger.warn('Failed to calculate percentiles', error);
+                return { p50: 0, p95: 0, p99: 0 };
+            }
+        });
+    }
+    formatStats(stats, keyField, valueField) {
+        return stats.reduce((acc, item) => {
+            const key = item[keyField] || 'unknown';
+            const value = parseInt(item[valueField]) || 0;
+            acc[key] = value;
+            return acc;
+        }, {});
+    }
+    buildQuery(options, includeDetails = false) {
+        if (!this.logRepository) {
+            throw new Error('HTTP log repository not available');
+        }
+        const queryBuilder = this.logRepository.createQueryBuilder('log');
+        if (includeDetails) {
+            queryBuilder.leftJoinAndSelect('log.retryRecords', 'retryRecords');
+        }
+        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) {
+            if (Array.isArray(options.method)) {
+                queryBuilder.andWhere('log.method IN (:...methods)', {
+                    methods: options.method,
+                });
+            }
+            else {
+                queryBuilder.andWhere('log.method = :method', {
+                    method: options.method,
+                });
+            }
+        }
+        if (options.url) {
+            queryBuilder.andWhere('log.url LIKE :url', { url: `%${options.url}%` });
+        }
+        if (options.statusCode) {
+            if (Array.isArray(options.statusCode)) {
+                queryBuilder.andWhere('log.statusCode IN (:...statusCodes)', {
+                    statusCodes: options.statusCode,
+                });
+            }
+            else {
+                queryBuilder.andWhere('log.statusCode = :statusCode', {
+                    statusCode: options.statusCode,
+                });
+            }
+        }
+        if (options.success !== undefined) {
+            queryBuilder.andWhere('log.success = :success', {
+                success: options.success,
+            });
+        }
+        if (options.serviceName) {
+            queryBuilder.andWhere('log.serviceName = :serviceName', {
+                serviceName: options.serviceName,
+            });
+        }
+        if (options.operationName) {
+            queryBuilder.andWhere('log.operationName = :operationName', {
+                operationName: options.operationName,
+            });
+        }
+        if (options.clientIp) {
+            queryBuilder.andWhere('log.clientIp = :clientIp', {
+                clientIp: options.clientIp,
+            });
+        }
+        if (options.source) {
+            queryBuilder.andWhere('log.source = :source', { source: options.source });
+        }
+        if (options.tags && options.tags.length > 0) {
+            queryBuilder.andWhere('JSON_CONTAINS(log.tags, :tags)', {
+                tags: JSON.stringify(options.tags),
+            });
+        }
+        if (options.errorCode) {
+            queryBuilder.andWhere('log.errorCode = :errorCode', {
+                errorCode: options.errorCode,
+            });
+        }
+        if (options.minResponseTime) {
+            queryBuilder.andWhere('log.responseTime >= :minResponseTime', {
+                minResponseTime: options.minResponseTime,
+            });
+        }
+        if (options.maxResponseTime) {
+            queryBuilder.andWhere('log.responseTime <= :maxResponseTime', {
+                maxResponseTime: options.maxResponseTime,
+            });
+        }
+        if (options.startDate) {
+            queryBuilder.andWhere('log.createdAt >= :startDate', {
+                startDate: options.startDate,
+            });
+        }
+        if (options.endDate) {
+            queryBuilder.andWhere('log.createdAt <= :endDate', {
+                endDate: options.endDate,
+            });
+        }
+        if (options.keyword) {
+            queryBuilder.andWhere('(log.url LIKE :keyword OR log.errorMessage LIKE :keyword OR log.body LIKE :keyword)', { keyword: `%${options.keyword}%` });
+        }
+        return queryBuilder;
+    }
+};
+exports.HttpLogQueryService = HttpLogQueryService;
+exports.HttpLogQueryService = HttpLogQueryService = HttpLogQueryService_1 = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [typeorm_1.DataSource])
+], HttpLogQueryService);

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;
+}