amqplib-init 1.3.0 → 1.3.2

package/CHANGELOG.md

@@ -1,5 +1,21 @@
 # Changelog
 
+## [1.3.2] - 2026-01-24
+
+### 🐛 修复
+- **修复 ES Module 导入**: 调整 `exports` 配置,`default` 指向 ESM 文件
+- 确保 `"type": "module"` 项目能正确导入 ESM 格式
+
+---
+
+## [1.3.1] - 2026-01-24
+
+### 🐛 修复
+- **修复发布配置**: 移除 `module/` 和 `index.js` 源码文件，只发布混淆后的 `dist/` 目录
+- 确保源码不会被暴露到 npm 包中
+
+---
+
 ## [1.3.0] - 2026-01-24
 
 ### 🔥 Breaking Changes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "amqplib-init",
-  "version": "1.3.0",
+  "version": "1.3.2",
   "description": "消息队列初始化 - 移除PM2依赖,改用Supervisor管理 (支持15分钟长任务)",
   "main": "dist/amqplib-init.cjs.js",
   "module": "dist/amqplib-init.esm.js",
@@ -8,15 +8,13 @@
   "types": "index.d.ts",
   "exports": {
     ".": {
-      "require": "./dist/amqplib-init.cjs.js",
       "import": "./dist/amqplib-init.esm.js",
-      "default": "./dist/amqplib-init.cjs.js"
+      "require": "./dist/amqplib-init.cjs.js",
+      "default": "./dist/amqplib-init.esm.js"
     }
   },
   "files": [
     "dist",
-    "module",
-    "index.js",
     "index.d.ts",
     "README.md",
     "CHANGELOG.md"

package/index.js

@@ -1,153 +0,0 @@
-const ConfigResolver = require('./module/ConfigResolver');
-const ConnectionManager = require('./module/ConnectionManager');
-const MessageProcessor = require('./module/MessageProcessor');
-const AutoReloader = require('./module/AutoReloader');
-const log = require('chalk-style');
-
-/**
- * AMQP初始化器主类
- * 协调各个模块完成RabbitMQ的初始化和消息处理
- */
-class AMQPInitializer {
-  constructor() {
-    this.configResolver = new ConfigResolver();
-    this.connectionManager = null;
-    this.messageProcessor = null;
-    this.autoReloader = null;
-    this.config = null;
-  }
-
-  /**
-   * 初始化AMQP连接和消息处理
-   * @param {Object} options - 配置选项
-   * @returns {Promise<void>}
-   */
-  async init(options = {}) {
-    try {
-      // 1. 解析配置
-      this.config = this.configResolver.resolveConfig(options);
-      log.log('配置解析完成');
-
-      // 2. 解析连接地址
-      const amqpLink = await this.configResolver.resolveAmqpLink(
-        this.config.amqpAutoLink,
-        this.config.amqpLink
-      );
-
-      // 3. 初始化各个模块
-      this.connectionManager = new ConnectionManager(this.config);
-      this.messageProcessor = new MessageProcessor(this.config);
-      this.autoReloader = new AutoReloader(this.config);
-
-      // 4. 设置连接地址并初始化连接
-      this.connectionManager.setAmqpLink(amqpLink);
-      const channel = await this.connectionManager.initialize();
-
-      // 5. 重新定义重连逻辑，确保重连后重新启动消息处理和自动重载
-      this._setupReconnectHandler();
-
-      // 6. 启动消息处理
-      await this.messageProcessor.startConsuming(channel);
-      log.log('消息处理器已启动');
-
-      // 7. 启动自动重载监控
-      this.autoReloader.start(channel);
-
-      // 8. 执行初始化完成回调
-      this.config.finish();
-      
-      log.log('AMQP初始化完成');
-    } catch (error) {
-      log.error('AMQP初始化失败:', error.message);
-      throw error;
-    }
-  }
-
-  /**
-   * 设置重连处理器
-   * 确保重连后各个模块能够正确重新启动
-   * @private
-   */
-  _setupReconnectHandler() {
-    const originalReconnect = this.connectionManager.reconnect.bind(this.connectionManager);
-    
-    this.connectionManager.reconnect = async () => {
-      try {
-        // 执行原始重连逻辑
-        const newChannel = await originalReconnect();
-        
-        // 重连后重新启动消息处理
-        this.messageProcessor.clearProcessingMessages();
-        await this.messageProcessor.startConsuming(newChannel);
-        log.log('重连后消息处理器已重新启动');
-        
-        // 重连后重新启动自动重载监控
-        this.autoReloader.restart(newChannel);
-        log.log('重连后自动重载监控已重新启动');
-        
-        return newChannel;
-      } catch (error) {
-        log.error('重连处理失败:', error.message);
-        throw error;
-      }
-    };
-  }
-
-  /**
-   * 获取当前状态信息
-   * @returns {Object} 状态信息
-   */
-  getStatus() {
-    return {
-      isConnected: this.connectionManager ? this.connectionManager.isConnected() : false,
-      processingCount: this.messageProcessor ? this.messageProcessor.getProcessingCount() : 0,
-      autoReloaderActive: this.autoReloader ? this.autoReloader.isActive() : false,
-      channelName: this.config ? this.config.channelName : null
-    };
-  }
-
-  /**
-   * 优雅关闭
-   * @returns {Promise<void>}
-   */
-  async shutdown() {
-    try {
-      log.log('开始优雅关闭AMQP连接...');
-      
-      // 停止自动重载监控
-      if (this.autoReloader) {
-        this.autoReloader.stop();
-      }
-      
-      // 清理消息处理状态
-      if (this.messageProcessor) {
-        this.messageProcessor.clearProcessingMessages();
-      }
-      
-      // 关闭连接
-      if (this.connectionManager) {
-        await this.connectionManager.close();
-      }
-      
-      log.log('AMQP连接已优雅关闭');
-    } catch (error) {
-      log.error('关闭AMQP连接时出错:', error.message);
-    }
-  }
-}
-
-// 导出兼容的API
-module.exports = {
-  /**
-   * 初始化函数 - 保持向后兼容
-   * @param {Object} options - 配置选项
-   * @returns {Promise<void>}
-   */
-  async init(options) {
-    const initializer = new AMQPInitializer();
-    return await initializer.init(options);
-  },
-
-  // 导出类，供需要更多控制的用户使用
-  AMQPInitializer
-};

package/module/AutoReloader.js

@@ -1,109 +0,0 @@
-const log = require('chalk-style');
-
-/**
- * 自动重载器模块
- * 负责监控队列状态（已移除 PM2 重启功能，改用 Supervisor 管理）
- */
-class AutoReloader {
-  constructor(config) {
-    this.config = config;
-    this.intervalId = null;
-    this.isRunning = false;
-  }
-
-  /**
-   * 启动自动重载监控
-   * @param {Object} channel - RabbitMQ频道
-   */
-  start(channel) {
-    const { autoReload, channelName, queryHook } = this.config;
-    
-    if (autoReload <= 0) {
-      log.log('自动重载功能未启用');
-      return;
-    }
-
-    if (this.isRunning) {
-      log.log('自动重载监控已在运行中');
-      return;
-    }
-
-    this.isRunning = true;
-    log.log(`启动队列监控，间隔: ${autoReload}ms`);
-
-    this.intervalId = setInterval(async () => {
-      try {
-        await this._checkQueueStatus(channel, channelName, queryHook);
-      } catch (error) {
-        log.error('队列状态检查时出错:', error.message);
-      }
-    }, autoReload);
-  }
-
-  /**
-   * 停止自动重载监控
-   */
-  stop() {
-    if (this.intervalId) {
-      clearInterval(this.intervalId);
-      this.intervalId = null;
-      this.isRunning = false;
-      log.log('自动重载监控已停止');
-    }
-  }
-
-  /**
-   * 重启自动重载监控（用于重连后）
-   * @param {Object} channel - 新的RabbitMQ频道
-   */
-  restart(channel) {
-    this.stop();
-    this.start(channel);
-  }
-
-  /**
-   * 获取监控状态
-   * @returns {boolean} 是否正在运行
-   */
-  isActive() {
-    return this.isRunning;
-  }
-
-  /**
-   * 检查队列状态（仅监控，不执行重启）
-   * @param {Object} channel - RabbitMQ频道
-   * @param {string} channelName - 频道名称
-   * @param {Function} queryHook - 查询钩子函数
-   * @private
-   */
-  async _checkQueueStatus(channel, channelName, queryHook) {
-    try {
-      // 检查队列中的消息数量
-      const { messageCount } = await channel.checkQueue(channelName);
-      
-      // 执行查询钩子
-      const hookResult = await queryHook();
-      
-      log.log(`队列 ${channelName} 中有 ${messageCount} 条消息，钩子状态: ${hookResult ? 1 : 0}`);
-      
-      // 注意: 已移除自动重启功能
-      // 如需重启服务，请使用 Supervisor: supervisorctl restart <service-name>
-    } catch (error) {
-      log.error('检查队列状态时出错:', error.message);
-    }
-  }
-
-  /**
-   * 获取当前配置信息
-   * @returns {Object} 配置信息
-   */
-  getConfig() {
-    return {
-      autoReload: this.config.autoReload,
-      isRunning: this.isRunning,
-      intervalId: this.intervalId !== null
-    };
-  }
-}
-
-module.exports = AutoReloader; 

package/module/ConfigResolver.js

@@ -1,86 +0,0 @@
-const axios = require('axios');
-const log = require('chalk-style');
-
-/**
- * 配置解析器模块
- * 负责处理配置参数和自动获取RabbitMQ连接信息
- */
-class ConfigResolver {
-  constructor() {
-    this.defaultConfig = {
-      channelName: 'node-test-channel',
-      prefetch: 1,
-      callback: () => {},
-      finish: () => {},
-      amqpLink: '',
-      amqpAutoLink: '',
-      heartbeat: 60,         // 增加心跳间隔到60秒，避免长时间处理时连接断开
-      timeout: 300000,       // 增加连接超时到5分钟（300秒）
-      delay: 0,
-      autoReload: 0,
-      queryHook: () => {},
-      initHook: () => {},
-      durable: true,
-      // 新增配置项 - 支持15分钟长任务
-      messageTimeout: 900000,  // 消息处理超时15分钟（900秒）
-      reconnectDelay: 5000,    // 重连延迟5秒
-      maxReconnectAttempts: 10 // 最大重连次数
-    };
-  }
-
-  /**
-   * 解析和合并配置参数
-   * @param {Object} options - 用户传入的配置选项
-   * @returns {Object} 合并后的完整配置
-   */
-  resolveConfig(options = {}) {
-    return { ...this.defaultConfig, ...options };
-  }
-
-  /**
-   * 自动获取RabbitMQ连接信息
-   * @param {string} amqpAutoLink - 自动获取连接信息的HTTPS链接
-   * @param {string} fallbackAmqpLink - 备用连接地址
-   * @returns {Promise<string>} 最终使用的连接地址
-   */
-  async resolveAmqpLink(amqpAutoLink, fallbackAmqpLink) {
-    if (!amqpAutoLink) {
-      return fallbackAmqpLink;
-    }
-
-    try {
-      log.log(`正在从 ${amqpAutoLink} 获取连接信息...`);
-      const response = await axios.post(amqpAutoLink);
-      const { info } = response.data;
-      
-      if (this._validateConnectionInfo(info)) {
-        const finalAmqpLink = `amqp://${info.AMQPLIB_USER}:${info.AMQPLIB_PWD}@${info.AMQPLIB_PUB}:${info.AMQPLIB_PORT}`;
-        log.log(`✅ 自动获取连接信息成功: ${finalAmqpLink}`);
-        return finalAmqpLink;
-      } else {
-        log.error('❌ 获取的连接信息不完整，使用默认连接地址');
-        return fallbackAmqpLink;
-      }
-    } catch (error) {
-      log.error('❌ 获取连接信息失败:', error.message);
-      log.log('使用默认连接地址继续...');
-      return fallbackAmqpLink;
-    }
-  }
-
-  /**
-   * 验证连接信息的完整性
-   * @param {Object} info - 连接信息对象
-   * @returns {boolean} 是否包含所有必要字段
-   * @private
-   */
-  _validateConnectionInfo(info) {
-    return info && 
-           info.AMQPLIB_USER && 
-           info.AMQPLIB_PWD && 
-           info.AMQPLIB_PUB && 
-           info.AMQPLIB_PORT;
-  }
-}
-
-module.exports = ConfigResolver; 

package/module/ConnectionManager.js

@@ -1,214 +0,0 @@
-const amqp = require('amqplib');
-const log = require('chalk-style');
-const happy = require('happy-help');
-
-/**
- * 连接管理器模块
- * 负责RabbitMQ连接管理、重连逻辑、频道管理
- */
-class ConnectionManager {
-  constructor(config) {
-    this.config = config;
-    this.connection = null;
-    this.channel = null;
-    this.amqpLink = '';
-    this.reconnectInProgress = false; // 防止重复重连
-    this.reconnectAttempts = 0; // 重连计数器
-    this.maxReconnectAttempts = config.maxReconnectAttempts || 10; // 最大重连次数
-  }
-
-  /**
-   * 设置AMQP连接地址
-   * @param {string} amqpLink - RabbitMQ连接地址
-   */
-  setAmqpLink(amqpLink) {
-    this.amqpLink = amqpLink;
-  }
-
-  /**
-   * 初始化连接和频道
-   * @returns {Promise<Object>} 返回频道对象
-   */
-  async initialize() {
-    const { channelName, durable, prefetch, heartbeat, timeout, initHook, reconnectDelay } = this.config;
-    
-    try {
-      // 建立连接
-      this.connection = await amqp.connect(this.amqpLink, { heartbeat, timeout });
-      
-      // 创建频道
-      this.channel = await this.connection.createChannel();
-      
-      // 设置队列和预取
-      await this.channel.assertQueue(channelName, { durable });
-      await this.channel.prefetch(prefetch);
-      
-      // 执行初始化钩子
-      await initHook({ channel: this.channel, connection: this.connection });
-      
-      log.log(`已连接到RabbitMQ，频道: ${channelName}`);
-      
-      // 设置连接事件监听
-      this._setupConnectionEvents();
-      
-      return this.channel;
-    } catch (error) {
-      log.error('初始化RabbitMQ连接时出错:', error);
-      throw error;
-    }
-  }
-
-  /**
-   * 重连逻辑
-   * @returns {Promise<Object>} 返回新的频道对象
-   */
-  async reconnect() {
-    if (this.reconnectInProgress) {
-      log.log('重连已在进行中，跳过此次重连请求');
-      return this.channel;
-    }
-
-    // 检查是否达到最大重连次数
-    if (this.reconnectAttempts >= this.maxReconnectAttempts) {
-      log.error(`❌ 已达到最大重连次数 ${this.maxReconnectAttempts}，停止重连`);
-      log.error('请检查 RabbitMQ 服务状态或网络连接');
-      return null;
-    }
-
-    this.reconnectInProgress = true;
-    this.reconnectAttempts++;
-    
-    try {
-      log.error(`🔄 连接丢失，正在尝试第 ${this.reconnectAttempts}/${this.maxReconnectAttempts} 次重连...`);
-      
-      // 清理旧的channel状态
-      await this._cleanupOldChannel();
-      
-      // 等待重连间隔，使用配置的延迟时间
-      const delaySeconds = (this.config.reconnectDelay || 5000) / 1000;
-      await happy.sleep(delaySeconds);
-      
-      // 重新初始化连接
-      await this.initialize();
-      
-      // 重连成功，重置计数器
-      this.reconnectAttempts = 0;
-      log.log(`✅ 已重新连接到RabbitMQ，频道: ${this.config.channelName}`);
-      
-      return this.channel;
-    } catch (error) {
-      log.error(`❌ 第 ${this.reconnectAttempts} 次重连失败:`, error.message);
-      
-      // 如果未达到最大次数，继续重试
-      if (this.reconnectAttempts < this.maxReconnectAttempts) {
-        const retryDelay = this.config.reconnectDelay || 5000;
-        setTimeout(() => {
-          this.reconnectInProgress = false;
-          this.reconnect();
-        }, retryDelay);
-      } else {
-        log.error('❌ 已达到最大重连次数，停止重连');
-      }
-      
-      throw error;
-    } finally {
-      this.reconnectInProgress = false;
-    }
-  }
-
-  /**
-   * 获取当前频道
-   * @returns {Object|null} 当前频道对象
-   */
-  getChannel() {
-    return this.channel;
-  }
-
-  /**
-   * 获取当前连接
-   * @returns {Object|null} 当前连接对象
-   */
-  getConnection() {
-    return this.connection;
-  }
-
-  /**
-   * 检查连接是否正常
-   * @returns {boolean} 连接状态
-   */
-  isConnected() {
-    return this.connection && this.channel && !this.connection.connection.destroyed;
-  }
-
-  /**
-   * 关闭连接
-   * @returns {Promise<void>}
-   */
-  async close() {
-    try {
-      if (this.channel) {
-        await this.channel.close();
-        this.channel = null;
-      }
-      if (this.connection) {
-        await this.connection.close();
-        this.connection = null;
-      }
-      log.log('RabbitMQ连接已关闭');
-    } catch (error) {
-      log.error('关闭连接时出错:', error.message);
-    }
-  }
-
-  /**
-   * 设置连接事件监听
-   * @private
-   */
-  _setupConnectionEvents() {
-    // 连接错误处理
-    this.connection.on('error', (err) => {
-      log.error('连接错误:', err.message);
-      this.reconnect().catch(error => {
-        log.error('重连失败:', error.message);
-      });
-    });
-
-    // 连接关闭处理
-    this.connection.on('close', () => {
-      log.error('与RabbitMQ的连接已关闭');
-      this.reconnect().catch(error => {
-        log.error('重连失败:', error.message);
-      });
-    });
-  }
-
-  /**
-   * 清理旧的频道状态
-   * @private
-   */
-  async _cleanupOldChannel() {
-    if (this.channel) {
-      try {
-        await this.channel.close();
-      } catch (e) {
-        log.log('关闭旧channel时出错:', e.message);
-      }
-      this.channel = null;
-    }
-  }
-
-  /**
-   * 获取连接统计信息
-   * @returns {Object} 连接统计
-   */
-  getStats() {
-    return {
-      isConnected: this.isConnected(),
-      reconnectAttempts: this.reconnectAttempts,
-      maxReconnectAttempts: this.maxReconnectAttempts,
-      reconnectInProgress: this.reconnectInProgress
-    };
-  }
-}
-
-module.exports = ConnectionManager; 

package/module/MessageProcessor.js

@@ -1,203 +0,0 @@
-const log = require('chalk-style');
-const happy = require('happy-help');
-
-/**
- * 消息处理器模块
- * 负责消息处理、状态跟踪、ACK/REJECT逻辑
- */
-class MessageProcessor {
-  constructor(config) {
-    this.config = config;
-    this.processingMessages = new Set(); // 跟踪正在处理的消息
-  }
-
-  /**
-   * 开始消费消息
-   * @param {Object} channel - RabbitMQ频道
-   * @returns {Promise<Function>} 返回清理函数
-   */
-  async startConsuming(channel) {
-    const { channelName, callback, delay } = this.config;
-    
-    log.log(`开始消费: ${channelName}`);
-    
-    await channel.consume(channelName, async (msg) => {
-      if (msg !== null) {
-        await this._handleMessage(msg, channel, callback, delay);
-      } else {
-        // ✅ 修复关键bug：null消息不需要ACK操作
-        log.log('收到null消息，队列可能为空或连接中断');
-        // 移除错误的 channel.ack(msg) 调用
-      }
-    }, { noAck: false });
-    
-    // 返回清理函数，用于重连时清理状态
-    return () => {
-      this.processingMessages.clear();
-      log.log('已清理消息处理状态');
-    };
-  }
-
-  /**
-   * 处理单条消息
-   * @param {Object} msg - RabbitMQ消息对象
-   * @param {Object} channel - RabbitMQ频道
-   * @param {Function} callback - 消息处理回调函数
-   * @param {number} delay - 延迟ACK时间
-   * @private
-   */
-  async _handleMessage(msg, channel, callback, delay) {
-    const deliveryTag = msg.fields.deliveryTag;
-    
-    // 检查消息是否已在处理中
-    if (this.processingMessages.has(deliveryTag)) {
-      log.log(`消息 ${deliveryTag} 已在处理中，跳过`);
-      return;
-    }
-    
-    this.processingMessages.add(deliveryTag);
-    
-    // 检查消息内容有效性，对无效消息直接确认
-    if (!this._isValidMessageContent(msg)) {
-      log.log(`⚠️ 收到无效消息 ${deliveryTag}，内容为空或无法解析，自动确认以防止阻塞`);
-      this._acknowledgeMessage(msg, channel, deliveryTag, 0); // 立即确认无效消息
-      return;
-    }
-    
-    try {
-      const content = JSON.parse(msg.content.toString());
-      log.log(`🪴 队列收到消息: ${JSON.stringify(content)}`);
-      const startTime = Date.now();
-      
-      // 创建超时 Promise
-      const timeoutPromise = new Promise((_, reject) => {
-        setTimeout(() => {
-          reject(new Error(`消息处理超时 (${this.config.messageTimeout}ms)`));
-        }, this.config.messageTimeout);
-      });
-      
-      // 使用 Promise.race 实现超时控制
-      try {
-        await Promise.race([
-          callback(content),
-          timeoutPromise
-        ]);
-        
-        const endTime = Date.now() - startTime;
-        log.log(`☘️ 消息处理完成，延迟: ${delay}ms，总时间: ${endTime}ms`);
-        this._acknowledgeMessage(msg, channel, deliveryTag, delay);
-        
-      } catch (callbackError) {
-        if (callbackError.message.includes('超时')) {
-          log.error(`⏰ 消息 ${deliveryTag} 处理超时 (${this.config.messageTimeout}ms)`);
-        } else {
-          log.log('‼️ 处理消息返回错误:', callbackError.message);
-        }
-        await this._rejectMessage(msg, channel, deliveryTag);
-      }
-      
-    } catch (e) {
-      log.log('‼️ 处理消息时出错:', e.message);
-      await this._rejectMessage(msg, channel, deliveryTag);
-    }
-  }
-
-  /**
-   * 检查消息内容是否有效
-   * @param {Object} msg - RabbitMQ消息对象
-   * @returns {boolean} 消息内容是否有效
-   * @private
-   */
-  _isValidMessageContent(msg) {
-    try {
-      // 检查消息对象是否存在
-      if (!msg || !msg.content) {
-        return false;
-      }
-      
-      // 获取消息内容字符串
-      const contentStr = msg.content.toString();
-      
-      // 检查内容是否为空或只包含空白字符
-      if (!contentStr || contentStr.trim() === '') {
-        return false;
-      }
-      
-      // 检查是否为null字符串
-      if (contentStr.toLowerCase() === 'null' || contentStr.toLowerCase() === 'undefined') {
-        return false;
-      }
-      
-      // 尝试解析JSON，如果失败则认为无效
-      JSON.parse(contentStr);
-      return true;
-    } catch (error) {
-      // JSON解析失败，认为消息无效
-      return false;
-    }
-  }
-
-  /**
-   * 确认消息
-   * @param {Object} msg - RabbitMQ消息对象
-   * @param {Object} channel - RabbitMQ频道
-   * @param {string} deliveryTag - 消息标签
-   * @param {number} delay - 延迟时间
-   * @private
-   */
-  _acknowledgeMessage(msg, channel, deliveryTag, delay) {
-    // 确保消息还在处理集合中再进行ACK
-    if (this.processingMessages.has(deliveryTag)) {
-      setTimeout(() => {
-        try {
-          channel.ack(msg);
-          this.processingMessages.delete(deliveryTag);
-          log.log(`✅ 消息 ${deliveryTag} 已确认`);
-        } catch (ackError) {
-          log.error(`ACK消息 ${deliveryTag} 时出错:`, ackError.message);
-          this.processingMessages.delete(deliveryTag);
-        }
-      }, delay);
-    }
-  }
-
-  /**
-   * 拒绝消息并重新排队
-   * @param {Object} msg - RabbitMQ消息对象
-   * @param {Object} channel - RabbitMQ频道
-   * @param {string} deliveryTag - 消息标签
-   * @private
-   */
-  async _rejectMessage(msg, channel, deliveryTag) {
-    await happy.sleep(5);
-    
-    if (this.processingMessages.has(deliveryTag)) {
-      try {
-        channel.reject(msg, true);
-        this.processingMessages.delete(deliveryTag);
-        log.log(`❌ 消息 ${deliveryTag} 已拒绝并重新排队`);
-      } catch (rejectError) {
-        log.error(`拒绝消息 ${deliveryTag} 时出错:`, rejectError.message);
-        this.processingMessages.delete(deliveryTag);
-      }
-    }
-  }
-
-  /**
-   * 清理所有处理中的消息状态
-   */
-  clearProcessingMessages() {
-    this.processingMessages.clear();
-    log.log('已清理所有消息处理状态');
-  }
-
-  /**
-   * 获取当前处理中的消息数量
-   * @returns {number} 处理中的消息数量
-   */
-  getProcessingCount() {
-    return this.processingMessages.size;
-  }
-}
-
-module.exports = MessageProcessor;