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

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

@@ -225,12 +225,6 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                 .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 {
@@ -259,13 +253,6 @@ let HttpLogQueryService = HttpLogQueryService_1 = class HttpLogQueryService {
                         : 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,
-                },
             };
         });
     }

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

@@ -1,7 +1,6 @@
 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

@@ -17,7 +17,6 @@ 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/logging.service.d.ts

@@ -1,15 +1,39 @@
-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';
+/**
+ * 异步日志配置
+ */
+interface AsyncLogConfig {
+    /** 批量大小 */
+    batchSize: number;
+    /** 刷新间隔（毫秒） */
+    flushIntervalMs: number;
+    /** 最大重试次数 */
+    maxRetries: number;
+    /** 是否启用异步日志 */
+    enabled: boolean;
+}
 /**
  * HTTP日志服务
  * 基于Spring Boot的请求日志记录机制，集成现有的ContextProvider
+ * 支持异步批量日志写入以提升性能
  */
-export declare class HttpLoggingService {
-    private readonly dataSource?;
+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>;
     /**
      * 记录请求开始
      */
@@ -17,11 +41,19 @@ export declare class HttpLoggingService {
     /**
      * 记录请求成功响应
      */
-    logRequestSuccess(response: AxiosResponse, startTime: number, requestId: string, loggingOptions: any, databaseLogging?: boolean, retryRecords?: any[], cacheHit?: boolean, circuitBreakerState?: string, decoratorContext?: any): Promise<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[], cacheHit?: boolean, circuitBreakerState?: string, decoratorContext?: any): 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;
     /**
      * 查询请求日志
      */
@@ -45,18 +77,48 @@ export declare class HttpLoggingService {
         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;
     /**
      * 转换请求体为字符串
      */
@@ -73,4 +135,11 @@ export declare class HttpLoggingService {
      * 递归清理对象中的敏感字段
      */
     private sanitizeObject;
+    /**
+     * 获取完整URL
+     * @param config Axios请求配置
+     * @returns 完整的URL字符串
+     */
+    private getFullUrl;
 }
+export {};

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

@@ -21,22 +21,53 @@ var HttpLoggingService_1;
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.HttpLoggingService = void 0;
 const common_1 = require("@nestjs/common");
-const typeorm_1 = require("typeorm");
 const http_log_entity_1 = require("../entities/http-log.entity");
 const request_id_util_1 = require("../utils/request-id.util");
 const context_extractor_util_1 = require("../utils/context-extractor.util");
 const call_stack_extractor_util_1 = require("../utils/call-stack-extractor.util");
+const transaction_1 = require("@nest-omni/transaction");
 /**
  * HTTP日志服务
  * 基于Spring Boot的请求日志记录机制，集成现有的ContextProvider
+ * 支持异步批量日志写入以提升性能
  */
 let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
-    constructor(dataSource) {
-        this.dataSource = dataSource;
+    constructor() {
         this.logger = new common_1.Logger(HttpLoggingService_1.name);
         this.logRepository = null;
-        if (dataSource) {
-            this.initializeDatabaseLogging();
+        /** 日志队列 */
+        this.logQueue = [];
+        /** 默认异步日志配置 */
+        this.asyncConfig = {
+            batchSize: 50, // 批量写入50条日志
+            flushIntervalMs: 5000, // 每5秒刷新一次
+            maxRetries: 3, // 失败后最多重试3次
+            enabled: true, // 默认启用异步日志
+        };
+        /** 处理中标志 */
+        this.isProcessing = false;
+        // 启动定期刷新任务
+        if (this.asyncConfig.enabled) {
+            this.startFlushTask();
+        }
+    }
+    onModuleDestroy() {
+        // 清理定时器
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        // 刷新剩余日志
+        this.flush();
+    }
+    initRepository(dataSource, tableName) {
+        try {
+            this.logRepository = (0, transaction_1.getDataSource)(dataSource).getRepository(http_log_entity_1.HttpLogEntity);
+            this.logger.log('Database logging initialized');
+            return this.logRepository;
+        }
+        catch (error) {
+            this.logger.error('Failed to initialize database logging', error);
+            throw error;
         }
     }
     /**
@@ -75,8 +106,8 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
      * 记录请求成功响应
      */
     logRequestSuccess(response_1, startTime_1, requestId_1, loggingOptions_1) {
-        return __awaiter(this, arguments, void 0, function* (response, startTime, requestId, loggingOptions, databaseLogging = false, retryRecords, cacheHit, circuitBreakerState, decoratorContext) {
-            var _a, _b;
+        return __awaiter(this, arguments, void 0, function* (response, startTime, requestId, loggingOptions, databaseLogging = false, retryRecords, circuitBreakerState, decoratorContext, clientName, callingContext) {
+            var _a, _b, _c, _d;
             const { logHeaders = true, logBody = true, sanitizeHeaders = [], } = loggingOptions || {};
             const responseTime = Date.now() - startTime;
             // 获取当前上下文信息
@@ -91,56 +122,63 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
                     : undefined,
                 body: logBody ? this.sanitizeBody(response.data) : undefined,
                 responseSize: JSON.stringify(response.data).length,
-                cacheHit,
                 circuitBreakerState,
             };
-            const logMessage = `HTTP Response [${requestId}]: ${response.status} (${responseTime}ms)${cacheHit ? ' [CACHE HIT]' : ''}`;
+            const logMessage = `HTTP Response [${requestId}]: ${response.status} (${responseTime}ms)`;
             switch ((loggingOptions || {}).logLevel) {
                 case 'debug':
                     this.logger.debug(logMessage, logData);
                     break;
-                    ``;
                 case 'info':
                 default:
                     this.logger.log(logMessage, logData);
                     break;
             }
-            if (!this.logRepository && this.dataSource) {
-                this.logRepository = this.dataSource.getRepository(loggingOptions.databaseLogging.tableName);
+            if (!this.logRepository) {
+                this.logger.debug('Initializing log repository', {
+                    dataSource: (_a = loggingOptions.databaseLogging) === null || _a === void 0 ? void 0 : _a.dataSource,
+                    tableName: (_b = loggingOptions.databaseLogging) === null || _b === void 0 ? void 0 : _b.tableName,
+                });
+                this.initRepository(loggingOptions.databaseLogging.dataSource, loggingOptions.databaseLogging.tableName);
             }
             // 数据库日志记录
+            if (databaseLogging && this.logRepository) {
+                this.logger.log('Database logging conditions met, saving to database');
+            }
+            else {
+                this.logger.warn(`Database logging conditions NOT met: databaseLogging=${databaseLogging}, hasRepository=${!!this.logRepository}, type=${typeof this.logRepository}`);
+            }
             if (databaseLogging && this.logRepository) {
                 // 提取调用信息
-                const callInfo = this.extractCallInfo(decoratorContext, response.config);
+                const callInfo = callingContext && callingContext.operationName
+                    ? callingContext
+                    : this.extractCallInfo(decoratorContext, response.config);
                 this.saveToDatabase({
                     id: requestId,
                     requestId,
                     userId: context.userId,
-                    method: ((_a = response.config.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'UNKNOWN',
-                    url: response.config.url || '',
+                    method: ((_c = response.config.method) === null || _c === void 0 ? void 0 : _c.toUpperCase()) || 'UNKNOWN',
+                    url: this.getFullUrl(response.config) || '',
                     headers: this.sanitizeHeaders(response.config.headers, sanitizeHeaders),
                     body: this.sanitizeBodyAsString(response.config.data),
                     params: response.config.params,
                     statusCode: response.status,
                     responseTime,
                     attemptCount: (retryRecords === null || retryRecords === void 0 ? void 0 : retryRecords.length)
-                        ? Math.max(...retryRecords.map((r) => r.attempt))
+                        ? Math.max(...retryRecords.map((r) => r.attempt)) + 1
                         : 1,
                     success: true,
                     responseHeaders: this.sanitizeHeaders(response.headers, sanitizeHeaders),
                     responseBody: logBody
                         ? this.sanitizeBodyAsString(response.data)
                         : undefined,
-                    responseSize: JSON.stringify(response.data).length,
-                    requestSize: JSON.stringify(response.config.data).length,
-                    serviceName: context.appId,
+                    serviceName: clientName || context.appId,
                     operationName: callInfo.operationName,
                     clientIp: context.clientIp,
-                    source: (_b = context.metadata) === null || _b === void 0 ? void 0 : _b.source,
+                    source: (_d = context.metadata) === null || _d === void 0 ? void 0 : _d.source,
                     tags: context.tags,
                     metadata: logData,
                     retryRecords,
-                    cacheHit,
                     circuitBreakerState,
                 });
             }
@@ -149,8 +187,8 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
     /**
      * 记录请求错误
      */
-    logRequestError(error, startTime, requestId, attemptCount, loggingOptions, databaseLogging = false, retryRecords, cacheHit, circuitBreakerState, decoratorContext) {
-        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l;
+    logRequestError(error, startTime, requestId, attemptCount, loggingOptions, databaseLogging = false, retryRecords, circuitBreakerState, decoratorContext, clientName, callingContext) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j;
         const { logHeaders = true, sanitizeHeaders = [] } = loggingOptions;
         const responseTime = Date.now() - startTime;
         // 获取当前上下文信息
@@ -184,37 +222,40 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
                 this.logger.error(logMessage, logData);
                 break;
         }
+        if (!this.logRepository) {
+            this.initRepository(loggingOptions.databaseLogging.dataSource, loggingOptions.databaseLogging.tableName);
+        }
         // 数据库日志记录
         if (databaseLogging && this.logRepository) {
             // 提取调用信息
-            const callInfo = this.extractCallInfo(decoratorContext, error.config);
+            const callInfo = callingContext && callingContext.operationName
+                ? callingContext
+                : this.extractCallInfo(decoratorContext, error.config);
             this.saveToDatabase({
                 id: requestId,
                 requestId,
                 userId: context.userId,
                 method: ((_d = (_c = error.config) === null || _c === void 0 ? void 0 : _c.method) === null || _d === void 0 ? void 0 : _d.toUpperCase()) || 'UNKNOWN',
-                url: ((_e = error.config) === null || _e === void 0 ? void 0 : _e.url) || '',
-                headers: ((_f = error.config) === null || _f === void 0 ? void 0 : _f.headers)
+                url: this.getFullUrl(error.config) || '',
+                headers: ((_e = error.config) === null || _e === void 0 ? void 0 : _e.headers)
                     ? this.sanitizeHeaders(error.config.headers, sanitizeHeaders)
                     : {},
-                body: this.sanitizeBodyAsString((_g = error.config) === null || _g === void 0 ? void 0 : _g.data),
-                params: (_h = error.config) === null || _h === void 0 ? void 0 : _h.params,
-                statusCode: (_j = error.response) === null || _j === void 0 ? void 0 : _j.status,
+                body: this.sanitizeBodyAsString((_f = error.config) === null || _f === void 0 ? void 0 : _f.data),
+                params: (_g = error.config) === null || _g === void 0 ? void 0 : _g.params,
+                statusCode: (_h = error.response) === null || _h === void 0 ? void 0 : _h.status,
                 responseTime,
                 attemptCount,
                 success: false,
                 errorMessage: error.message,
                 errorStack: error.stack,
                 errorCode: error.code,
-                requestSize: JSON.stringify(((_k = error.config) === null || _k === void 0 ? void 0 : _k.data) || {}).length,
-                serviceName: context.appId,
+                serviceName: clientName || context.appId,
                 operationName: callInfo.operationName,
                 clientIp: context.clientIp,
-                source: (_l = context.metadata) === null || _l === void 0 ? void 0 : _l.source,
+                source: (_j = context.metadata) === null || _j === void 0 ? void 0 : _j.source,
                 tags: context.tags,
                 metadata: logData,
                 retryRecords,
-                cacheHit,
                 circuitBreakerState,
             });
         }
@@ -335,20 +376,6 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
             };
         });
     }
-    /**
-     * 初始化数据库日志记录
-     */
-    initializeDatabaseLogging() {
-        return __awaiter(this, void 0, void 0, function* () {
-            try {
-                this.logRepository = this.dataSource.getRepository(http_log_entity_1.HttpLogEntity);
-                this.logger.log('Database logging initialized');
-            }
-            catch (error) {
-                this.logger.error('Failed to initialize database logging', error);
-            }
-        });
-    }
     /**
      * 提取调用信息
      */
@@ -392,20 +419,117 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
     }
     /**
      * 保存到数据库
+     * 如果启用异步日志，将日志项添加到队列中
+     * 否则同步保存到数据库
      */
     saveToDatabase(logEntity) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                this.logger.warn('Log repository not initialized, skipping database logging');
+                return;
+            }
+            if (this.asyncConfig.enabled) {
+                // 异步模式：添加到队列
+                this.logQueue.push({
+                    logEntity,
+                    attempt: 0,
+                });
+                // 如果队列达到批量大小，立即刷新
+                if (this.logQueue.length >= this.asyncConfig.batchSize) {
+                    setImmediate(() => this.flush());
+                }
+            }
+            else {
+                // 同步模式：直接保存
+                yield this.saveLogToDatabase(logEntity);
+            }
+        });
+    }
+    /**
+     * 启动定期刷新任务
+     */
+    startFlushTask() {
+        this.flushTimer = setInterval(() => {
+            this.flush();
+        }, this.asyncConfig.flushIntervalMs);
+        this.logger.log(`Async log flushing started (interval: ${this.asyncConfig.flushIntervalMs}ms, batchSize: ${this.asyncConfig.batchSize})`);
+    }
+    /**
+     * 刷新日志队列到数据库
+     */
+    flush() {
+        if (this.isProcessing || this.logQueue.length === 0) {
+            return;
+        }
+        this.isProcessing = true;
+        // 取出当前批次
+        const batch = this.logQueue.splice(0, this.asyncConfig.batchSize);
+        // 异步处理
+        setImmediate(() => __awaiter(this, void 0, void 0, function* () {
+            try {
+                // 批量保存
+                yield Promise.all(batch.map((item) => this.processLogItem(item)));
+                this.logger.debug(`Flushed ${batch.length} log entries to database`);
+                // 如果还有剩余日志，继续处理
+                if (this.logQueue.length > 0) {
+                    setImmediate(() => this.flush());
+                }
+            }
+            catch (error) {
+                this.logger.error('Error flushing log queue', error);
+                // 将失败的日志重新放回队列（如果还有重试机会）
+                batch.forEach((item) => {
+                    if (item.attempt < this.asyncConfig.maxRetries) {
+                        item.attempt++;
+                        this.logQueue.unshift(item); // 放回队列头部
+                    }
+                    else {
+                        this.logger.error(`Log entry exceeded max retries, discarding: ${item.logEntity.requestId}`);
+                    }
+                });
+            }
+            finally {
+                this.isProcessing = false;
+            }
+        }));
+    }
+    /**
+     * 处理单个日志项
+     */
+    processLogItem(item) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (!this.logRepository) {
+                return;
+            }
+            try {
+                yield this.logRepository.save(item.logEntity, { reload: false });
+            }
+            catch (error) {
+                this.logger.error(`Failed to save log entry: ${item.logEntity.requestId}`, error);
+                throw error; // 重新抛出错误以便重试
+            }
+        });
+    }
+    /**
+     * 同步保存日志到数据库（用于异步模式内部）
+     */
+    saveLogToDatabase(logEntity) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a;
             if (!this.logRepository) {
                 this.logger.warn('Log repository not initialized, skipping database logging');
                 return;
             }
             try {
-                this.logger.debug('Saving HTTP log to database', {
+                this.logger.log('Saving HTTP log to database', {
                     requestId: logEntity.requestId,
+                    circuitBreakerState: logEntity.circuitBreakerState,
+                    retryRecordsCount: ((_a = logEntity.retryRecords) === null || _a === void 0 ? void 0 : _a.length) || 0,
                 });
-                yield this.logRepository.save(logEntity);
-                this.logger.debug('Successfully saved HTTP log to database', {
+                yield this.logRepository.save(logEntity, { reload: false });
+                this.logger.log('Successfully saved HTTP log to database', {
                     requestId: logEntity.requestId,
+                    circuitBreakerState: logEntity.circuitBreakerState,
                 });
             }
             catch (error) {
@@ -414,6 +538,50 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
             }
         });
     }
+    /**
+     * 获取日志队列统计信息
+     */
+    getQueueStats() {
+        return {
+            queueSize: this.logQueue.length,
+            isProcessing: this.isProcessing,
+            config: Object.assign({}, this.asyncConfig),
+        };
+    }
+    /**
+     * 手动刷新日志队列
+     */
+    manualFlush() {
+        return __awaiter(this, void 0, void 0, function* () {
+            return new Promise((resolve) => {
+                const checkProcessing = () => {
+                    if (!this.isProcessing) {
+                        this.flush();
+                        // 等待刷新完成
+                        setTimeout(() => resolve(), 100);
+                    }
+                    else {
+                        setTimeout(checkProcessing, 50);
+                    }
+                };
+                checkProcessing();
+            });
+        });
+    }
+    /**
+     * 设置异步日志配置
+     */
+    setAsyncConfig(config) {
+        Object.assign(this.asyncConfig, config);
+        // 重启刷新任务
+        if (this.flushTimer) {
+            clearInterval(this.flushTimer);
+        }
+        if (this.asyncConfig.enabled) {
+            this.startFlushTask();
+        }
+        this.logger.log(`Async log config updated: ${JSON.stringify(this.asyncConfig)}`);
+    }
     /**
      * 转换请求体为字符串
      */
@@ -505,9 +673,36 @@ let HttpLoggingService = HttpLoggingService_1 = class HttpLoggingService {
             }
         }
     }
+    /**
+     * 获取完整URL
+     * @param config Axios请求配置
+     * @returns 完整的URL字符串
+     */
+    getFullUrl(config) {
+        if (!config)
+            return '';
+        // 如果已经有完整的URL，直接返回
+        if (config.url && config.url.startsWith('http')) {
+            return config.url;
+        }
+        // 获取baseURL
+        const baseURL = config.baseURL || '';
+        // 获取URL路径
+        const urlPath = config.url || '';
+        // 如果baseURL为空，直接返回URL路径
+        if (!baseURL) {
+            return urlPath;
+        }
+        // 确保baseURL以/结尾，urlPath不以/开头（除非它是绝对路径）
+        const normalizedBaseURL = baseURL.endsWith('/') ? baseURL : baseURL + '/';
+        const normalizedUrlPath = urlPath.startsWith('/')
+            ? urlPath.substring(1)
+            : urlPath;
+        return normalizedBaseURL + normalizedUrlPath;
+    }
 };
 exports.HttpLoggingService = HttpLoggingService;
 exports.HttpLoggingService = HttpLoggingService = HttpLoggingService_1 = __decorate([
     (0, common_1.Injectable)(),
-    __metadata("design:paramtypes", [typeorm_1.DataSource])
+    __metadata("design:paramtypes", [])
 ], HttpLoggingService);

package/http-client/utils/call-stack-extractor.util.d.ts

@@ -3,6 +3,32 @@
  * 用于自动提取HTTP请求的调用服务和方法信息
  */
 export declare class CallStackExtractor {
+    /**
+     * 存储装饰器上下文（用于传递装饰器信息到HTTP客户端）
+     */
+    private static decoratorContext;
+    /**
+     * 装饰器上下文引用计数，用于处理多个装饰器嵌套的情况
+     */
+    private static decoratorContextDepth;
+    /**
+     * 设置装饰器上下文
+     */
+    static setDecoratorContext(context: {
+        target: any;
+        propertyKey: string;
+    }): void;
+    /**
+     * 获取装饰器上下文
+     */
+    static getDecoratorContext(): {
+        target: any;
+        propertyKey: string;
+    } | null;
+    /**
+     * 清除装饰器上下文
+     */
+    static clearDecoratorContext(): void;
     /**
      * 从调用栈中提取服务和方法信息
      */