@nest-omni/core 4.1.3-1 → 4.1.3-3

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

@@ -23,25 +23,39 @@ 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");
+/**
+ * HTTP请求重放服务
+ * 提供基于HTTP日志的请求重放功能，支持单个请求和批量请求重放
+ */
 let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
     constructor(httpClient, logQueryService) {
         this.httpClient = httpClient;
         this.logQueryService = logQueryService;
         this.logger = new common_1.Logger(HttpReplayService_1.name);
     }
+    /**
+     * 根据日志ID重放请求
+     * @param logId 日志ID
+     * @param options 重放选项
+     * @returns 重放结果
+     */
     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;
@@ -77,6 +91,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             }
         });
     }
+    /**
+     * 根据请求ID重放请求
+     * @param requestId 请求ID
+     * @param options 重放选项
+     * @returns 重放结果
+     */
     replayByRequestId(requestId_1) {
         return __awaiter(this, arguments, void 0, function* (requestId, options = {}) {
             const originalLog = yield this.logQueryService.findLogByRequestId(requestId);
@@ -86,10 +106,18 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             return this.replayByLogId(originalLog.id, options);
         });
     }
+    /**
+     * 批量重放请求
+     * @param logIds 日志ID数组
+     * @param options 重放选项
+     * @param concurrency 并发数
+     * @returns 批量重放结果
+     */
     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) {
@@ -114,6 +142,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
                 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);
@@ -131,9 +160,18 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             return batchResult;
         });
     }
+    /**
+     * 根据查询条件批量重放请求
+     * @param queryOptions 查询选项
+     * @param replayOptions 重放选项
+     * @param concurrency 并发数
+     * @returns 批量重放结果
+     */
     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) {
@@ -152,6 +190,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             return this.batchReplay(logIds, replayOptions, concurrency);
         });
     }
+    /**
+     * 重放请求并比较结果
+     * @param logId 日志ID
+     * @param options 重放选项
+     * @returns 包含原始和重放结果的比较
+     */
     replayAndCompare(logId_1) {
         return __awaiter(this, arguments, void 0, function* (logId, options = {}) {
             var _a, _b, _c;
@@ -160,6 +204,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
                 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,
@@ -173,6 +218,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             };
         });
     }
+    /**
+     * 构建重放配置
+     * @param log 原始日志
+     * @param options 重放选项
+     * @returns 请求配置
+     */
     buildReplayConfig(log, options) {
         const config = {
             method: log.method,
@@ -180,6 +231,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             headers: Object.assign({}, log.headers),
             params: Object.assign({}, log.params),
         };
+        // 处理请求体
         if (log.body) {
             try {
                 config.data =
@@ -189,6 +241,7 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
                 config.data = log.body;
             }
         }
+        // 应用覆盖选项
         if (options.overrideHeaders) {
             config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
         }
@@ -196,29 +249,49 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
             config.headers = Object.assign(Object.assign({}, config.headers), options.additionalHeaders);
         }
         if (options.overrideBody && options.additionalHeaders) {
+            // 如果有额外的body数据，在这里处理
         }
         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;
     }
+    /**
+     * 执行重放请求
+     * @param config 请求配置
+     * @param options 重放选项
+     * @returns 响应结果
+     */
     executeReplayRequest(config, options) {
         return __awaiter(this, void 0, void 0, function* () {
             try {
                 return yield this.httpClient.request(config);
             }
             catch (error) {
+                // 如果请求失败，重新抛出错误
                 throw error;
             }
         });
     }
+    /**
+     * 生成重放ID
+     * @returns 重放ID
+     */
     generateReplayId() {
         return `replay-${Date.now()}-${Math.random().toString(36).substring(2, 15)}`;
     }
+    /**
+     * 数组分块
+     * @param array 原始数组
+     * @param size 块大小
+     * @returns 分块后的数组
+     */
     chunkArray(array, size) {
         const chunks = [];
         for (let i = 0; i < array.length; i += size) {
@@ -226,7 +299,14 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
         }
         return chunks;
     }
+    /**
+     * 比较响应头
+     * @param original 原始响应头
+     * @param replay 重放响应头
+     * @returns 是否匹配
+     */
     compareHeaders(original, replay) {
+        // 简化比较：忽略时间相关的头部
         const ignoreHeaders = ['date', 'expires', 'last-modified', 'etag'];
         const originalFiltered = Object.keys(original)
             .filter((key) => !ignoreHeaders.includes(key.toLowerCase()))
@@ -242,6 +322,12 @@ let HttpReplayService = HttpReplayService_1 = class HttpReplayService {
         }, {});
         return JSON.stringify(originalFiltered) === JSON.stringify(replayFiltered);
     }
+    /**
+     * 比较响应体
+     * @param original 原始响应体
+     * @param replay 重放响应体
+     * @returns 是否匹配
+     */
     compareBodies(original, replay) {
         if (!original && !replay)
             return true;

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

@@ -1,31 +1,61 @@
 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[];
 }
+/**
+ * HTTP日志清理服务
+ */
 export declare class HttpLogCleanupService implements OnModuleInit {
     private readonly logQueryService;
     private readonly logger;
@@ -33,16 +63,34 @@ export declare class HttpLogCleanupService implements OnModuleInit {
     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;
@@ -56,9 +104,24 @@ export declare class HttpLogCleanupService implements OnModuleInit {
             importantLogs: number;
         };
     }>;
+    /**
+     * 执行清理操作
+     */
     private performCleanup;
+    /**
+     * 基于时间的清理策略
+     */
     private cleanupByRetention;
+    /**
+     * 基于数量的清理策略
+     */
     private cleanupBySize;
+    /**
+     * 组合清理策略
+     */
     private cleanupByCombination;
+    /**
+     * 创建清理统计
+     */
     private createCleanupStats;
 }

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,30 @@
 import { DataSource } from 'typeorm';
 import { AxiosError, AxiosRequestConfig, AxiosResponse } from 'axios';
 import { HttpLogEntity } from '../entities/http-log.entity';
+/**
+ * HTTP日志服务
+ * 基于Spring Boot的请求日志记录机制，集成现有的ContextProvider
+ */
 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;
@@ -21,16 +37,40 @@ 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 sanitizeBodyAsString;
+    /**
+     * 清理敏感头信息
+     */
     private sanitizeHeaders;
+    /**
+     * 清理敏感请求体信息
+     */
     private sanitizeBody;
+    /**
+     * 递归清理对象中的敏感字段
+     */
     private sanitizeObject;
 }