@be-link/ecommerce-promotion-service-node-sdk 0.1.13 → 0.1.15

package/modules/BaseService.d.ts

@@ -8,7 +8,7 @@ export default abstract class BaseService {
     protected abstract prefixUrl: string;
     /** 子网域名 */
     protected readonly natDevHost = "http://192.168.3.168:8090/promotion";
-    protected readonly natProdHost = "http://192.168.87.191:8090/promotion";
+    protected readonly natProdHost = "http://10.1.0.97:8090/promotion";
     /** 公网域名 */
     protected readonly publicDevHost = "https://ecommerce-dev.wejourney.top/promotion";
     protected readonly publicProdHost = "";

package/modules/BaseService.js

@@ -13,7 +13,7 @@ class BaseService {
     constructor() {
         /** 子网域名 */
         this.natDevHost = 'http://192.168.3.168:8090/promotion';
-        this.natProdHost = 'http://192.168.87.191:8090/promotion';
+        this.natProdHost = 'http://10.1.0.97:8090/promotion';
         /** 公网域名 */
         this.publicDevHost = 'https://ecommerce-dev.wejourney.top/promotion';
         this.publicProdHost = '';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@be-link/ecommerce-promotion-service-node-sdk",
-  "version": "0.1.13",
+  "version": "0.1.15",
   "description": "EcommercePromotionService Node.js SDK",
   "main": "index.js",
   "types": "index.d.ts",

package/utils/http.d.ts

@@ -1,6 +1,6 @@
 declare module '@fastify/request-context' {
     interface RequestContextData {
-        requestId?: string;
+        requestId: string;
         traceMessageId?: string;
         pandoraUserId?: string;
         beLinkUserId?: string;
@@ -9,25 +9,11 @@ declare module '@fastify/request-context' {
     }
 }
 export declare function callApi<T extends (...args: any[]) => Promise<any>>(url: string, request?: Parameters<T>[0]): Promise<Awaited<ReturnType<T>>>;
-export declare function getConnectionStats(): {
+export declare function getHttpStats(): {
     activeRequests: number;
     totalRequests: number;
-    peakActiveRequests: number;
-    httpSockets: {
-        total: number;
-        hosts: number;
-        details: NodeJS.ReadOnlyDict<import("net").Socket[]>;
-    };
-    httpsSockets: {
-        total: number;
-        hosts: number;
-        details: NodeJS.ReadOnlyDict<import("net").Socket[]>;
-    };
-    config: {
-        maxSockets: number;
-        maxTotalSockets: number;
-        requestTimeout: number;
-        note: string;
-    };
+    errorCount: number;
+    timeoutCount: number;
+    errorRate: string;
+    timeoutRate: string;
 };
-export declare function resetPeakStats(): void;

package/utils/http.js

@@ -4,27 +4,24 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.callApi = callApi;
-exports.getConnectionStats = getConnectionStats;
-exports.resetPeakStats = resetPeakStats;
+exports.getHttpStats = getHttpStats;
 const axios_1 = __importDefault(require("axios"));
 const uuid_1 = require("uuid");
 const axios_retry_1 = __importDefault(require("axios-retry"));
 const request_context_1 = require("@fastify/request-context");
-const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
 const http_1 = __importDefault(require("http"));
 const https_1 = __importDefault(require("https"));
-// 针对高并发优化配置 - 支持高并发场景
+const safe_stable_stringify_1 = __importDefault(require("safe-stable-stringify"));
+// 针对高并发优化配置 - 极限性能模式
 const HTTP_CONFIG = {
-    maxSockets: 2000, // 每个主机的最大socket连接数（支持2000并发）
-    maxFreeSockets: 1000, // 空闲socket保留数（50%复用率，提高连接复用效率）
-    maxTotalSockets: 3000, // 所有主机总socket数（单后端场景优化）
-    keepAliveMsecs: 30000, // 保持连接30秒（平衡资源占用和连接复用）
-    timeout: 3000, // socket超时3秒（高并发场景快速失败）
-    requestTimeout: 3000, // 请求超时3秒（快速释放资源，避免慢请求占用连接）
-    retries: 1, // 重试1次（减少重试，避免高并发时加重后端压力）
-    retryBaseDelay: 100, // 基础重试延迟100ms（给服务恢复时间）
-    logThreshold: 1000, // 日志采样率（每1000个请求采样1次，降低日志开销）
-    monitorInterval: 5000, // 监控日志间隔（毫秒）
+    maxSockets: Infinity, // 不限制每个主机的socket连接数（极限并发模式）
+    maxFreeSockets: 2000, // 保留2000个空闲连接（减少连接重建开销）
+    maxTotalSockets: Infinity, // 不限制总socket数（避免连接池成为瓶颈）
+    keepAliveMsecs: 60000, // 保持连接60秒
+    timeout: 6000, // socket超时6秒（给予充足时间）
+    requestTimeout: 6000, // 请求超时6秒（避免正常请求超时）
+    retries: 0, // 不重试（失败直接返回）
+    retryBaseDelay: 200, // 基础重试延迟200ms
 };
 // 配置 HTTP/HTTPS Agent 以支持高并发连接池和 keepAlive
 const httpAgent = new http_1.default.Agent({
@@ -34,7 +31,7 @@ const httpAgent = new http_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'fifo', // 先进先出调度
+    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
 });
 const httpsAgent = new https_1.default.Agent({
     keepAlive: true,
@@ -43,7 +40,7 @@ const httpsAgent = new https_1.default.Agent({
     maxFreeSockets: HTTP_CONFIG.maxFreeSockets,
     maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
     timeout: HTTP_CONFIG.timeout,
-    scheduling: 'fifo',
+    scheduling: 'lifo', // 后进先出调度（优先复用热连接，提高连接复用效率）
 });
 // 配置 axios 默认使用这些 agent
 axios_1.default.defaults.httpAgent = httpAgent;
@@ -57,10 +54,16 @@ axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响
     retryCondition(error) {
         // 重试临时错误和特定的网络错误
         const status = error.response?.status;
-        const isNetworkError = error.code === 'ECONNRESET' || error.code === 'ETIMEDOUT';
+        const isNetworkError = error.code === 'ECONNRESET' ||
+            error.code === 'ETIMEDOUT' ||
+            error.code === 'ECONNREFUSED' ||
+            error.code === 'ENOTFOUND' ||
+            error.code === 'ENETUNREACH' ||
+            error.code === 'EAI_AGAIN';
         const isServerError = status === 502 || status === 503 || status === 504;
         const isRateLimited = status === 429;
-        return isNetworkError || isServerError || isRateLimited;
+        const isTimeout = error.code === 'ECONNABORTED' || error.message?.includes('timeout');
+        return isNetworkError || isServerError || isRateLimited || isTimeout;
     },
     retryDelay: (retryCount, error) => {
         // 指数退避 + 抖动
@@ -73,47 +76,33 @@ axios_1.default.defaults.maxContentLength = 50 * 1024 * 1024; // 50MB 最大响
             }
             return 1000 + Math.random() * 1000; // 1-2秒
         }
-        // 指数退避：100ms, 200ms, 400ms...
+        // 指数退避：200ms, 400ms, 800ms...
         const exponentialDelay = HTTP_CONFIG.retryBaseDelay * Math.pow(2, retryCount - 1);
-        const jitter = Math.random() * 50; // 0-50ms 抖动
-        return Math.min(exponentialDelay + jitter, 2000); // 最多延迟2秒
+        const jitter = Math.random() * 100; // 0-100ms 抖动
+        return Math.min(exponentialDelay + jitter, 3000); // 最多延迟3秒
     },
     shouldResetTimeout: true, // 重试时重置超时
 });
-// 连接池状态监控
-let requestCount = 0;
+// 性能监控变量
 let activeRequests = 0;
-let peakActiveRequests = 0; // 峰值并发
+let totalRequests = 0;
+let timeoutCount = 0;
+let errorCount = 0;
 async function callApi(url, request) {
-    // 不再等待应用层队列，直接发起请求，由底层socket连接池控制并发
-    const currentRequestId = ++requestCount;
-    activeRequests++;
-    // 记录峰值并发
-    if (activeRequests > peakActiveRequests) {
-        peakActiveRequests = activeRequests;
-    }
-    // 批量获取请求上下文，减少函数调用开销
+    // 获取请求上下文
     const ctx = request_context_1.requestContext.get('requestId') ? request_context_1.requestContext : null;
     const requestId = ctx?.get('requestId') || ctx?.get('traceMessageId') || (0, uuid_1.v4)();
     const pandoraUserId = ctx?.get('pandoraUserId') || '';
     const beLinkUserId = ctx?.get('beLinkUserId') || '';
     const pandoraRoleId = ctx?.get('pandoraRoleId') || '';
     const realIp = ctx?.get('realIp') || '';
-    // 采样日志决策（提前计算，避免重复判断）
-    const shouldLog = currentRequestId % HTTP_CONFIG.logThreshold === 0;
-    const startTime = shouldLog ? Date.now() : 0;
+    // 性能监控
+    const startTime = Date.now();
+    activeRequests++;
+    totalRequests++;
+    const currentRequestId = totalRequests;
     try {
-        if (shouldLog) {
-            console.log((0, safe_stable_stringify_1.default)({
-                message: '发起HTTP请求',
-                currentRequestId,
-                activeRequests,
-                requestId,
-                url,
-                type: 'http_request_start',
-            }));
-        }
-        const response = await axios_1.default.post(url, request || {}, {
+        const response = await axios_1.default.post(url, request, {
             headers: {
                 'x-request-id': requestId,
                 'x-belink-pandora-userid': pandoraUserId,
@@ -126,38 +115,51 @@ async function callApi(url, request) {
             httpAgent,
             httpsAgent,
         });
-        if (shouldLog) {
-            const duration = Date.now() - startTime;
-            if (duration > 3000) {
-                console.log((0, safe_stable_stringify_1.default)({
-                    message: '请求完成',
-                    currentRequestId,
-                    duration: `${duration}ms`,
-                    activeRequests,
-                    type: 'http_request_complete',
-                }));
-            }
+        const duration = Date.now() - startTime;
+        // 记录慢请求（超过3秒）
+        if (duration > 3000) {
+            console.log((0, safe_stable_stringify_1.default)({
+                message: '慢请求警告',
+                url,
+                duration,
+                activeRequests,
+                requestId: currentRequestId,
+                type: 'slow_request',
+            }));
         }
         const responseData = response.data;
         return responseData.data;
     }
     catch (error) {
         const axiosError = error;
-        const duration = startTime ? Date.now() - startTime : 0;
-        // 错误始终记录（但简化输出）
-        console.error((0, safe_stable_stringify_1.default)({
+        const duration = Date.now() - startTime;
+        errorCount++;
+        // 记录详细的错误信息用于诊断
+        const errorInfo = {
             message: '请求失败',
-            currentRequestId,
             url,
-            duration: `${duration}ms`,
+            duration,
             activeRequests,
+            totalRequests: currentRequestId,
             errorMessage: axiosError.message,
+            errorCode: axiosError.code,
             type: 'http_request_failed',
-        }));
+        };
+        // 添加超时相关信息
+        if (axiosError.code === 'ECONNABORTED' || axiosError.message?.includes('timeout')) {
+            errorInfo.isTimeout = true;
+            errorInfo.timeoutValue = HTTP_CONFIG.requestTimeout;
+            timeoutCount++;
+        }
+        // 添加重试信息
+        if (axiosError.config && 'axios-retry' in axiosError.config) {
+            errorInfo.retryCount = axiosError.config['axios-retry']?.retryCount || 0;
+        }
+        console.log((0, safe_stable_stringify_1.default)(errorInfo));
         if (axiosError.response) {
             const response = axiosError.response;
             const data = response.data;
-            console.error((0, safe_stable_stringify_1.default)({
+            console.log((0, safe_stable_stringify_1.default)({
                 message: '响应异常',
                 status: response.status,
                 errorMessage: data?.message || axiosError.message,
@@ -167,44 +169,30 @@ async function callApi(url, request) {
         throw error;
     }
     finally {
-        // 记录请求完成，减少活跃计数
         activeRequests--;
+        // 每1000个请求输出一次统计信息
+        if (totalRequests % 1000 === 0) {
+            console.log((0, safe_stable_stringify_1.default)({
+                message: 'HTTP客户端统计',
+                totalRequests,
+                activeRequests,
+                errorCount,
+                timeoutCount,
+                errorRate: ((errorCount / totalRequests) * 100).toFixed(2) + '%',
+                timeoutRate: ((timeoutCount / totalRequests) * 100).toFixed(2) + '%',
+                type: 'http_stats',
+            }));
+        }
     }
 }
-// 导出监控函数
-function getConnectionStats() {
-    const stats = {
-        // 当前状态
+// 获取当前统计信息
+function getHttpStats() {
+    return {
         activeRequests,
-        totalRequests: requestCount,
-        // 峰值指标
-        peakActiveRequests,
-        // Socket连接池状态（这是真正的并发控制点）
-        httpSockets: {
-            total: Object.keys(httpAgent.sockets).reduce((sum, host) => sum + (httpAgent.sockets[host]?.length || 0), 0),
-            hosts: Object.keys(httpAgent.sockets).length,
-            details: httpAgent.sockets,
-        },
-        httpsSockets: {
-            total: Object.keys(httpsAgent.sockets).reduce((sum, host) => sum + (httpsAgent.sockets[host]?.length || 0), 0),
-            hosts: Object.keys(httpsAgent.sockets).length,
-            details: httpsAgent.sockets,
-        },
-        // 配置信息
-        config: {
-            maxSockets: HTTP_CONFIG.maxSockets,
-            maxTotalSockets: HTTP_CONFIG.maxTotalSockets,
-            requestTimeout: HTTP_CONFIG.requestTimeout,
-            note: '已移除应用层并发队列限制，完全依赖socket连接池',
-        },
+        totalRequests,
+        errorCount,
+        timeoutCount,
+        errorRate: totalRequests > 0 ? ((errorCount / totalRequests) * 100).toFixed(2) + '%' : '0%',
+        timeoutRate: totalRequests > 0 ? ((timeoutCount / totalRequests) * 100).toFixed(2) + '%' : '0%',
     };
-    return stats;
-}
-// 重置峰值统计（可用于定期重置）
-function resetPeakStats() {
-    peakActiveRequests = activeRequests;
-    console.log((0, safe_stable_stringify_1.default)({
-        message: '峰值统计已重置',
-        type: 'stats_reset',
-    }));
 }