@nest-omni/core 4.1.3-2 → 4.1.3-20

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

@@ -24,6 +24,9 @@ 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");
+/**
+ * HTTP日志清理服务
+ */
 let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupService {
     constructor(logQueryService, config = {}) {
         this.logQueryService = logQueryService;
@@ -33,7 +36,7 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             strategy: 'retention',
             retentionDays: 30,
             maxRecords: 1000000,
-            schedule: schedule_1.CronExpression.EVERY_DAY_AT_2AM,
+            schedule: schedule_1.CronExpression.EVERY_DAY_AT_2AM, // 每天凌晨2点执行
             batchSize: 10000,
             preserveErrorLogs: true,
             errorLogRetentionDays: 90,
@@ -43,6 +46,7 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             slowRequestRetentionDays: 60,
             slowRequestThreshold: 5000,
         };
+        // Override defaults with provided config
         if (Object.keys(config).length > 0) {
             Object.assign(this.defaultConfig, config);
         }
@@ -59,6 +63,9 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             this.logger.warn('HTTP log cleanup is disabled');
         }
     }
+    /**
+     * 定时清理任务
+     */
     scheduledCleanup() {
         return __awaiter(this, void 0, void 0, function* () {
             if (!this.cleanupConfig.enabled) {
@@ -68,6 +75,9 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             return this.performCleanup();
         });
     }
+    /**
+     * 执行手动清理
+     */
     manualCleanup(options) {
         return __awaiter(this, void 0, void 0, function* () {
             const config = Object.assign(Object.assign({}, this.cleanupConfig), options);
@@ -78,18 +88,28 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             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');
             }
@@ -107,12 +127,17 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             };
         });
     }
+    /**
+     * 预览清理操作（不实际执行）
+     */
     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,
@@ -128,6 +153,9 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             };
         });
     }
+    /**
+     * 执行清理操作
+     */
     performCleanup() {
         return __awaiter(this, arguments, void 0, function* (config = this.cleanupConfig) {
             const startTime = Date.now();
@@ -135,6 +163,7 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             let deletedCount = 0;
             const batchCount = 0;
             try {
+                // 获取清理前的总记录数
                 const beforeStats = yield this.logQueryService.getStats();
                 const beforeCount = beforeStats.totalRequests;
                 switch (config.strategy) {
@@ -150,6 +179,7 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
                     default:
                         throw new Error(`Unknown cleanup strategy: ${config.strategy}`);
                 }
+                // 获取清理后的总记录数
                 const afterStats = yield this.logQueryService.getStats();
                 const afterCount = afterStats.totalRequests;
                 const duration = Date.now() - startTime;
@@ -176,12 +206,16 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             }
         });
     }
+    /**
+     * 基于时间的清理策略
+     */
     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;
             }
@@ -189,17 +223,25 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
                 errors.push(`Retention cleanup failed: ${error.message}`);
                 return 0;
             }
+            // 如果需要保留错误日志
             if (config.preserveErrorLogs &&
                 config.errorLogRetentionDays > config.retentionDays) {
+                // 保留错误日志的逻辑已经在deleteOldLogs中处理
                 this.logger.log(`Preserving error logs for ${config.errorLogRetentionDays} days`);
             }
+            // 清理慢请求日志（如果启用了较长的保留期）
             if (config.preserveSlowRequests &&
                 config.slowRequestRetentionDays > config.retentionDays) {
+                // 这里需要特殊的逻辑来保留慢请求
+                // 由于当前的deleteOldLogs不区分日志类型，我们需要实现特殊逻辑
                 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) {
@@ -213,10 +255,12 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             }
             const excessCount = stats.totalRequests - config.maxRecords;
             const targetCutoffDate = new Date();
-            const averageDailyRecords = stats.totalRequests / 30;
+            // 计算需要删除的记录对应的时间点
+            const averageDailyRecords = stats.totalRequests / 30; // 假设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;
@@ -227,11 +271,16 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             }
         });
     }
+    /**
+     * 组合清理策略
+     */
     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) {
@@ -242,6 +291,9 @@ let HttpLogCleanupService = HttpLogCleanupService_1 = class HttpLogCleanupServic
             return totalDeleted;
         });
     }
+    /**
+     * 创建清理统计
+     */
     createCleanupStats(strategy, beforeCount, afterCount, deletedCount, batchCount, errors) {
         return {
             cleanupTime: new Date(),

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

@@ -1,14 +1,62 @@
-import { DataSource } from 'typeorm';
+import { OnModuleDestroy } from '@nestjs/common';
+import { Repository } from 'typeorm';
 import { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
 import { HttpLogEntity } from '../entities/http-log.entity';
-export declare class HttpLoggingService {
-    private readonly dataSource?;
+/**
+ * 异步日志配置
+ */
+interface AsyncLogConfig {
+    /** 批量大小 */
+    batchSize: number;
+    /** 刷新间隔（毫秒） */
+    flushIntervalMs: number;
+    /** 最大重试次数 */
+    maxRetries: number;
+    /** 是否启用异步日志 */
+    enabled: boolean;
+}
+/**
+ * HTTP日志服务
+ * 基于Spring Boot的请求日志记录机制，集成现有的ContextProvider
+ * 支持异步批量日志写入以提升性能
+ */
+export declare class HttpLoggingService implements OnModuleDestroy {
     private readonly logger;
     private logRepository;
-    constructor(dataSource?: DataSource);
+    /** 日志队列 */
+    private logQueue;
+    /** 定时器 */
+    private flushTimer?;
+    /** 默认异步日志配置 */
+    private readonly asyncConfig;
+    /** 处理中标志 */
+    private isProcessing;
+    constructor();
+    onModuleDestroy(): void;
+    initRepository(dataSource: string, tableName: string): Repository<HttpLogEntity>;
+    /**
+     * 记录请求开始
+     */
     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;
+    /**
+     * 记录请求成功响应
+     */
+    logRequestSuccess(response: AxiosResponse, startTime: number, requestId: string, loggingOptions: any, databaseLogging?: boolean, retryRecords?: any[], circuitBreakerState?: string, decoratorContext?: any, clientName?: string, callingContext?: {
+        serviceClass?: string;
+        methodName?: string;
+        operationName?: string;
+    }): Promise<void>;
+    /**
+     * 记录请求错误
+     */
+    logRequestError(error: AxiosError, startTime: number, requestId: string, attemptCount: number, loggingOptions: any, databaseLogging?: boolean, retryRecords?: any[], circuitBreakerState?: string, decoratorContext?: any, clientName?: string, callingContext?: {
+        serviceClass?: string;
+        methodName?: string;
+        operationName?: string;
+    }): void;
+    /**
+     * 查询请求日志
+     */
     findLogs(options: {
         requestId?: string;
         userId?: string;
@@ -21,16 +69,77 @@ export declare class HttpLoggingService {
         limit?: number;
         offset?: number;
     }): Promise<HttpLogEntity[]>;
+    /**
+     * 获取请求统计信息
+     */
     getStatistics(options: {
         startDate?: Date;
         endDate?: Date;
         userId?: string;
     }): Promise<any>;
-    private initializeDatabaseLogging;
+    /**
+     * 提取调用信息
+     */
     private extractCallInfo;
+    /**
+     * 保存到数据库
+     * 如果启用异步日志，将日志项添加到队列中
+     * 否则同步保存到数据库
+     */
     private saveToDatabase;
+    /**
+     * 启动定期刷新任务
+     */
+    private startFlushTask;
+    /**
+     * 刷新日志队列到数据库
+     */
+    private flush;
+    /**
+     * 处理单个日志项
+     */
+    private processLogItem;
+    /**
+     * 同步保存日志到数据库（用于异步模式内部）
+     */
+    private saveLogToDatabase;
+    /**
+     * 获取日志队列统计信息
+     */
+    getQueueStats(): {
+        queueSize: number;
+        isProcessing: boolean;
+        config: AsyncLogConfig;
+    };
+    /**
+     * 手动刷新日志队列
+     */
+    manualFlush(): Promise<void>;
+    /**
+     * 设置异步日志配置
+     */
+    setAsyncConfig(config: Partial<AsyncLogConfig>): void;
+    /**
+     * 转换请求体为字符串
+     */
     private sanitizeBodyAsString;
+    /**
+     * 清理敏感头信息
+     */
     private sanitizeHeaders;
+    /**
+     * 清理敏感请求体信息
+     */
     private sanitizeBody;
+    /**
+     * 递归清理对象中的敏感字段
+     */
     private sanitizeObject;
+    /**
+     * 获取完整URL
+     * @param config Axios请求配置
+     * @returns 完整的URL字符串
+     */
+    private getFullUrl;
 }
+export {};