@onlineapps/mq-client-core 1.0.33 → 1.0.35

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/mq-client-core",
-  "version": "1.0.33",
+  "version": "1.0.35",
   "description": "Core MQ client library for RabbitMQ - shared by infrastructure services and connectors",
   "main": "src/index.js",
   "scripts": {

package/src/transports/rabbitmqClient.js

@@ -35,6 +35,28 @@ class RabbitMQClient extends EventEmitter {
     this._channel = null; // ConfirmChannel for publish operations
     this._queueChannel = null; // Regular channel for queue operations (assertQueue, checkQueue)
     this._consumerChannel = null; // Dedicated channel for consume operations
+    
+    // Track active consumers for re-registration after channel recreation
+    this._activeConsumers = new Map(); // queue -> { handler, options, consumerTag }
+    
+    // Auto-reconnect flags
+    this._reconnecting = false;
+    this._reconnectAttempts = 0;
+    
+    // Channel close hooks - called when channel closes with detailed information
+    this._channelCloseHooks = []; // Array of { type: 'publisher'|'queue'|'consumer', callback: (details) => void }
+    
+    // Health monitoring
+    this._healthCheckInterval = null;
+    this._healthCheckIntervalMs = this._config.healthCheckInterval || 30000; // Default 30s
+    this._healthCheckEnabled = this._config.healthCheckEnabled !== false;
+    
+    // Health reporting callbacks
+    this._healthReportCallback = this._config.healthReportCallback || null; // (health) => Promise<void>
+    this._healthCriticalCallback = this._config.healthCriticalCallback || null; // (health) => Promise<void>
+    this._criticalHealthShutdown = this._config.criticalHealthShutdown !== false; // Default: true - shutdown on critical health
+    this._criticalHealthShutdownDelay = this._config.criticalHealthShutdownDelay || 60000; // Default: 60s delay before shutdown
+    this._criticalHealthStartTime = null; // Track when critical health started
   }
 
   /**
@@ -59,6 +81,50 @@ class RabbitMQClient extends EventEmitter {
   get queueChannel() {
     return this._queueChannel || this._channel; // Fallback to main channel if queueChannel not available
   }
+  
+  /**
+   * Register a hook to be called when a channel closes
+   * @param {string} type - Channel type: 'publisher', 'queue', 'consumer', or 'all'
+   * @param {Function} callback - Callback function receiving close details: { type, channel, error, reason, timestamp, stack }
+   */
+  onChannelClose(type, callback) {
+    this._channelCloseHooks.push({ type, callback });
+  }
+  
+  /**
+   * Call all registered channel close hooks
+   * @private
+   * @param {string} channelType - 'publisher', 'queue', or 'consumer'
+   * @param {Object} channel - The closed channel
+   * @param {Error} error - Error that caused closure (if any)
+   * @param {string} reason - Human-readable reason
+   */
+  _callChannelCloseHooks(channelType, channel, error, reason) {
+    const details = {
+      type: channelType,
+      channel: channel,
+      error: error,
+      reason: reason,
+      timestamp: new Date().toISOString(),
+      stack: error?.stack || new Error().stack,
+      connectionState: this._connection ? (this._connection.closed ? 'closed' : 'open') : 'null',
+      channelCreatedAt: channel?._createdAt || 'unknown',
+      lastOperation: channel?._lastOperation || 'unknown'
+    };
+    
+    for (const hook of this._channelCloseHooks) {
+      if (hook.type === 'all' || hook.type === channelType) {
+        try {
+          hook.callback(details);
+        } catch (hookErr) {
+          console.error(`[RabbitMQClient] [mq-client-core] Channel close hook error:`, hookErr.message);
+        }
+      }
+    }
+    
+    // Emit event for external listeners
+    this.emit('channel:close', details);
+  }
 
   /**
    * Connects to RabbitMQ server and creates a confirm channel.
@@ -94,15 +160,39 @@ class RabbitMQClient extends EventEmitter {
 
       // Use ConfirmChannel to enable publisher confirms for publish operations
       this._channel = await this._connection.createConfirmChannel();
+      
+      // Track channel metadata for debugging
+      this._channel._createdAt = new Date().toISOString();
+      this._channel._closeReason = null;
+      this._channel._lastOperation = 'Initial creation';
+      this._channel._type = 'publisher';
+      
       // Enable publisher confirms explicitly
-      this._channel.on('error', (err) => {
-        console.error('[RabbitMQClient] [mq-client-core] Publisher channel error:', err.message);
+      this._channel.on('error', async (err) => {
+        const reason = `Publisher channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+        this._channel._closeReason = reason;
+        console.error(`[RabbitMQClient] [mq-client-core] ${reason}`);
+        
+        // Call close hooks with detailed information
+        this._callChannelCloseHooks('publisher', this._channel, err, reason);
+        
+        // Auto-recreate channel if connection is still alive
+        await this._ensurePublisherChannel();
         this.emit('error', err);
       });
-      this._channel.on('close', () => {
-        console.warn('[RabbitMQClient] [mq-client-core] Publisher channel closed');
-        // Emit a channel close error
-        this.emit('error', new Error('RabbitMQ channel closed unexpectedly'));
+      this._channel.on('close', async () => {
+        const reason = this._channel._closeReason || 'Publisher channel closed unexpectedly';
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate on next publish`);
+        
+        // Call close hooks with detailed information
+        this._callChannelCloseHooks('publisher', this._channel, null, reason);
+        
+        // Mark channel as null - will be recreated on next publish
+        const closedChannel = this._channel;
+        this._channel = null;
+        
+        // Try to recreate immediately if connection is alive
+        await this._ensurePublisherChannel();
       });
       // Set up publisher confirms callback
       this._channel.on('drain', () => {
@@ -112,25 +202,80 @@ class RabbitMQClient extends EventEmitter {
       // Create a separate regular channel for queue operations (assertQueue, checkQueue)
       // This avoids RPC reply queue issues with ConfirmChannel.assertQueue()
       this._queueChannel = await this._connection.createChannel();
-      this._queueChannel.on('error', (err) => {
-        // Log but don't emit - queue channel errors are less critical
-        console.warn('[RabbitMQClient] Queue channel error:', err.message);
+      
+      // Track channel metadata for debugging
+      this._queueChannel._createdAt = new Date().toISOString();
+      this._queueChannel._closeReason = null;
+      this._queueChannel._lastOperation = 'Initial creation';
+      this._queueChannel._type = 'queue';
+      
+      this._queueChannel.on('error', async (err) => {
+        const reason = `Queue channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+        this._queueChannel._closeReason = reason;
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason}`);
+        
+        // Call close hooks with detailed information
+        this._callChannelCloseHooks('queue', this._queueChannel, err, reason);
+        
+        // Auto-recreate channel if connection is still alive
+        await this._ensureQueueChannel();
       });
-      this._queueChannel.on('close', () => {
-        console.warn('[RabbitMQClient] Queue channel closed');
+      this._queueChannel.on('close', async () => {
+        const reason = this._queueChannel._closeReason || 'Queue channel closed unexpectedly';
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate on next operation`);
+        
+        // Call close hooks with detailed information
+        this._callChannelCloseHooks('queue', this._queueChannel, null, reason);
+        
+        // Mark channel as null - will be recreated on next queue operation
+        const closedChannel = this._queueChannel;
+        this._queueChannel = null;
+        
+        // Try to recreate immediately if connection is alive
+        await this._ensureQueueChannel();
       });
       
       // Create a dedicated channel for consume operations
       // This prevents channel conflicts between publish (ConfirmChannel) and consume operations
       this._consumerChannel = await this._connection.createChannel();
-      this._consumerChannel.on('error', (err) => {
-        console.warn('[RabbitMQClient] Consumer channel error:', err.message);
+      
+      // Track channel metadata for debugging
+      this._consumerChannel._createdAt = new Date().toISOString();
+      this._consumerChannel._closeReason = null;
+      this._consumerChannel._lastOperation = 'Initial creation';
+      this._consumerChannel._type = 'consumer';
+      
+      this._consumerChannel.on('error', async (err) => {
+        const reason = `Consumer channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+        this._consumerChannel._closeReason = reason;
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason}`);
+        
+        // Call close hooks with detailed information
+        this._callChannelCloseHooks('consumer', this._consumerChannel, err, reason);
+        
+        // Auto-recreate channel and re-register consumers
+        await this._ensureConsumerChannel();
         this.emit('error', err);
       });
-      this._consumerChannel.on('close', () => {
-        console.warn('[RabbitMQClient] Consumer channel closed');
-        this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
+      this._consumerChannel.on('close', async () => {
+        const reason = this._consumerChannel._closeReason || 'Consumer channel closed unexpectedly';
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate and re-register consumers`);
+        
+        // Call close hooks with detailed information
+        this._callChannelCloseHooks('consumer', this._consumerChannel, null, reason);
+        
+        // Mark channel as null - will be recreated and consumers re-registered
+        const closedChannel = this._consumerChannel;
+        this._consumerChannel = null;
+        
+        // Try to recreate and re-register consumers immediately if connection is alive
+        await this._ensureConsumerChannel();
       });
+      
+      // Start health monitoring if enabled
+      if (this._healthCheckEnabled) {
+        this._startHealthMonitoring();
+      }
     } catch (err) {
       // Cleanup partially created resources
       if (this._connection) {
@@ -145,11 +290,446 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Ensure publisher channel exists and is open
+   * Auto-recreates if closed
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _ensurePublisherChannel() {
+    if (this._channel && !this._channel.closed) {
+      return; // Channel is good
+    }
+    
+    if (!this._connection || this._connection.closed) {
+      throw new Error('Cannot recreate publisher channel: connection is closed');
+    }
+    
+    try {
+      // Close old channel if exists
+      if (this._channel) {
+        try {
+          await this._channel.close();
+        } catch (_) {
+          // Ignore errors when closing already-closed channel
+        }
+      }
+      
+      // Create new ConfirmChannel
+      this._channel = await this._connection.createConfirmChannel();
+      
+      // Track channel metadata for debugging
+      this._channel._createdAt = new Date().toISOString();
+      this._channel._closeReason = null;
+      this._channel._lastOperation = 'Recreated via _ensurePublisherChannel()';
+      this._channel._type = 'publisher';
+      
+      this._channel.on('error', async (err) => {
+        const reason = `Publisher channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+        this._channel._closeReason = reason;
+        console.error(`[RabbitMQClient] [mq-client-core] ${reason}`);
+        
+        // Call close hooks
+        this._callChannelCloseHooks('publisher', this._channel, err, reason);
+        
+        await this._ensurePublisherChannel();
+        this.emit('error', err);
+      });
+      this._channel.on('close', async () => {
+        const reason = this._channel._closeReason || 'Publisher channel closed unexpectedly';
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate on next publish`);
+        
+        // Call close hooks
+        this._callChannelCloseHooks('publisher', this._channel, null, reason);
+        
+        const closedChannel = this._channel;
+        this._channel = null;
+        await this._ensurePublisherChannel();
+      });
+      this._channel.on('drain', () => {
+        console.log('[RabbitMQClient] [mq-client-core] Publisher channel drained');
+      });
+      
+      console.log('[RabbitMQClient] [mq-client-core] ✓ Publisher channel recreated');
+    } catch (err) {
+      this._channel = null;
+      throw new Error(`Failed to recreate publisher channel: ${err.message}`);
+    }
+  }
+
+  /**
+   * Ensure queue channel exists and is open
+   * Auto-recreates if closed
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _ensureQueueChannel() {
+    if (this._queueChannel && !this._queueChannel.closed) {
+      return; // Channel is good
+    }
+    
+    if (!this._connection || this._connection.closed) {
+      throw new Error('Cannot recreate queue channel: connection is closed');
+    }
+    
+    try {
+      // Close old channel if exists
+      if (this._queueChannel) {
+        try {
+          await this._queueChannel.close();
+        } catch (_) {
+          // Ignore errors when closing already-closed channel
+        }
+      }
+      
+      // Create new regular channel
+      this._queueChannel = await this._connection.createChannel();
+      
+      // Track channel metadata for debugging
+      this._queueChannel._createdAt = new Date().toISOString();
+      this._queueChannel._closeReason = null;
+      this._queueChannel._lastOperation = 'Recreated via _ensureQueueChannel()';
+      this._queueChannel._type = 'queue';
+      
+      this._queueChannel.on('error', async (err) => {
+        const reason = `Queue channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+        this._queueChannel._closeReason = reason;
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason}`);
+        
+        // Call close hooks
+        this._callChannelCloseHooks('queue', this._queueChannel, err, reason);
+        
+        await this._ensureQueueChannel();
+      });
+      this._queueChannel.on('close', async () => {
+        const reason = this._queueChannel._closeReason || 'Queue channel closed unexpectedly';
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate on next operation`);
+        
+        // Call close hooks
+        this._callChannelCloseHooks('queue', this._queueChannel, null, reason);
+        
+        const closedChannel = this._queueChannel;
+        this._queueChannel = null;
+        await this._ensureQueueChannel();
+      });
+      
+      console.log('[RabbitMQClient] [mq-client-core] ✓ Queue channel recreated');
+    } catch (err) {
+      this._queueChannel = null;
+      throw new Error(`Failed to recreate queue channel: ${err.message}`);
+    }
+  }
+
+  /**
+   * Ensure consumer channel exists and is open
+   * Auto-recreates and re-registers all consumers if closed
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _ensureConsumerChannel() {
+    if (this._consumerChannel && !this._consumerChannel.closed) {
+      return; // Channel is good
+    }
+    
+    if (!this._connection || this._connection.closed) {
+      throw new Error('Cannot recreate consumer channel: connection is closed');
+    }
+    
+    try {
+      // Close old channel if exists
+      if (this._consumerChannel) {
+        try {
+          await this._consumerChannel.close();
+        } catch (_) {
+          // Ignore errors when closing already-closed channel
+        }
+      }
+      
+      // Create new regular channel
+      this._consumerChannel = await this._connection.createChannel();
+      
+      // Track channel metadata for debugging
+      this._consumerChannel._createdAt = new Date().toISOString();
+      this._consumerChannel._closeReason = null;
+      this._consumerChannel._lastOperation = 'Recreated via _ensureConsumerChannel()';
+      this._consumerChannel._type = 'consumer';
+      
+      this._consumerChannel.on('error', async (err) => {
+        const reason = `Consumer channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+        this._consumerChannel._closeReason = reason;
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason}`);
+        
+        // Call close hooks
+        this._callChannelCloseHooks('consumer', this._consumerChannel, err, reason);
+        
+        await this._ensureConsumerChannel();
+        this.emit('error', err);
+      });
+      this._consumerChannel.on('close', async () => {
+        const reason = this._consumerChannel._closeReason || 'Consumer channel closed unexpectedly';
+        console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate and re-register consumers`);
+        
+        // Call close hooks
+        this._callChannelCloseHooks('consumer', this._consumerChannel, null, reason);
+        
+        const closedChannel = this._consumerChannel;
+        this._consumerChannel = null;
+        await this._ensureConsumerChannel();
+      });
+      
+      // Re-register all active consumers
+      if (this._activeConsumers.size > 0) {
+        console.log(`[RabbitMQClient] [mq-client-core] Re-registering ${this._activeConsumers.size} consumers...`);
+        for (const [queue, consumerInfo] of this._activeConsumers.entries()) {
+          try {
+            // Re-assert queue with correct options before consuming (may have been deleted)
+            if (consumerInfo.options.queueOptions) {
+              try {
+                await this._ensureQueueChannel();
+                this._trackChannelOperation(this._queueChannel, `assertQueue ${queue} (re-register)`);
+                await this._queueChannel.assertQueue(queue, consumerInfo.options.queueOptions);
+              } catch (assertErr) {
+                if (assertErr.code === 404) {
+                  console.warn(`[RabbitMQClient] [mq-client-core] Queue ${queue} does not exist, skipping consumer re-registration`);
+                  this._activeConsumers.delete(queue);
+                  continue;
+                }
+                // 406 error means queue exists with different args - skip this consumer
+                if (assertErr.code === 406) {
+                  console.warn(`[RabbitMQClient] [mq-client-core] Queue ${queue} exists with different args, skipping consumer re-registration`);
+                  this._activeConsumers.delete(queue);
+                  continue;
+                }
+                throw assertErr;
+              }
+            }
+            
+            const consumeResult = await this._consumerChannel.consume(
+              queue,
+              consumerInfo.handler,
+              { noAck: consumerInfo.options.noAck }
+            );
+            consumerInfo.consumerTag = consumeResult.consumerTag;
+            console.log(`[RabbitMQClient] [mq-client-core] ✓ Re-registered consumer for queue: ${queue} (consumerTag: ${consumeResult.consumerTag})`);
+          } catch (err) {
+            console.error(`[RabbitMQClient] [mq-client-core] Failed to re-register consumer for queue ${queue}:`, err.message);
+            // Remove failed consumer from tracking
+            this._activeConsumers.delete(queue);
+          }
+        }
+      }
+      
+      console.log('[RabbitMQClient] [mq-client-core] ✓ Consumer channel recreated');
+    } catch (err) {
+      this._consumerChannel = null;
+      throw new Error(`Failed to recreate consumer channel: ${err.message}`);
+    }
+  }
+
   /**
    * Disconnects: closes channel and connection.
    * @returns {Promise<void>}
    */
+  /**
+   * Start health monitoring - periodically checks channels, queues, and consumers
+   * @private
+   */
+  _startHealthMonitoring() {
+    if (this._healthCheckInterval) {
+      return; // Already started
+    }
+    
+    this._healthCheckInterval = setInterval(async () => {
+      try {
+        await this._performHealthCheck();
+      } catch (err) {
+        console.error(`[RabbitMQClient] [mq-client-core] Health check error:`, err.message);
+        // Emit event for external monitoring
+        this.emit('health:check:error', err);
+      }
+    }, this._healthCheckIntervalMs);
+    
+    console.log(`[RabbitMQClient] [mq-client-core] Health monitoring started (interval: ${this._healthCheckIntervalMs}ms)`);
+  }
+  
+  /**
+   * Stop health monitoring
+   * @private
+   */
+  _stopHealthMonitoring() {
+    if (this._healthCheckInterval) {
+      clearInterval(this._healthCheckInterval);
+      this._healthCheckInterval = null;
+      console.log('[RabbitMQClient] [mq-client-core] Health monitoring stopped');
+    }
+  }
+  
+  /**
+   * Perform health check - verify channels, queues, and consumers
+   * @private
+   * @returns {Promise<Object>} Health check results
+   */
+  async _performHealthCheck() {
+    const health = {
+      timestamp: new Date().toISOString(),
+      connection: {
+        exists: !!this._connection,
+        closed: this._connection ? this._connection.closed : true
+      },
+      channels: {
+        publisher: {
+          exists: !!this._channel,
+          closed: this._channel ? this._channel.closed : true
+        },
+        queue: {
+          exists: !!this._queueChannel,
+          closed: this._queueChannel ? this._queueChannel.closed : true
+        },
+        consumer: {
+          exists: !!this._consumerChannel,
+          closed: this._consumerChannel ? this._consumerChannel.closed : true
+        }
+      },
+      consumers: {
+        tracked: this._activeConsumers.size,
+        active: 0,
+        inactive: []
+      },
+      queues: {
+        checked: 0,
+        missing: [],
+        noConsumer: []
+      },
+      healthy: true,
+      issues: []
+    };
+    
+    // Check connection
+    if (!health.connection.exists || health.connection.closed) {
+      health.healthy = false;
+      health.issues.push('Connection is closed or missing');
+    }
+    
+    // Check channels
+    if (health.channels.publisher.closed || !health.channels.publisher.exists) {
+      health.healthy = false;
+      health.issues.push('Publisher channel is closed or missing');
+    }
+    if (health.channels.queue.closed || !health.channels.queue.exists) {
+      health.healthy = false;
+      health.issues.push('Queue channel is closed or missing');
+    }
+    if (health.channels.consumer.closed || !health.channels.consumer.exists) {
+      health.healthy = false;
+      health.issues.push('Consumer channel is closed or missing');
+    }
+    
+    // Check tracked consumers - verify queues exist and have active consumers
+    if (this._connection && !this._connection.closed && this._queueChannel && !this._queueChannel.closed) {
+      for (const [queue, consumerInfo] of this._activeConsumers.entries()) {
+        health.queues.checked++;
+        try {
+          // Check if queue exists
+          this._trackChannelOperation(this._queueChannel, `checkQueue ${queue}`);
+          const queueInfo = await this._queueChannel.checkQueue(queue);
+          if (queueInfo) {
+            // Queue exists - check if consumer is active
+            // Note: RabbitMQ doesn't provide direct API to check if consumer is active
+            // We can only verify that consumerTag is set
+            if (consumerInfo.consumerTag) {
+              health.consumers.active++;
+            } else {
+              health.consumers.inactive.push(queue);
+              health.queues.noConsumer.push(queue);
+              health.healthy = false;
+              health.issues.push(`Queue ${queue} has no active consumer (consumerTag missing)`);
+            }
+          } else {
+            health.queues.missing.push(queue);
+            health.healthy = false;
+            health.issues.push(`Queue ${queue} does not exist`);
+          }
+        } catch (err) {
+          if (err.code === 404) {
+            health.queues.missing.push(queue);
+            health.healthy = false;
+            health.issues.push(`Queue ${queue} does not exist (404)`);
+          } else {
+            health.healthy = false;
+            health.issues.push(`Error checking queue ${queue}: ${err.message}`);
+          }
+        }
+      }
+    }
+    
+    // Emit health check result
+    this.emit('health:check', health);
+    
+    // If unhealthy, log and potentially trigger shutdown
+    if (!health.healthy) {
+      console.error(`[RabbitMQClient] [mq-client-core] Health check FAILED:`, health.issues);
+      console.error(`[RabbitMQClient] [mq-client-core] Health details:`, JSON.stringify(health, null, 2));
+      
+      // Track critical health start time
+      if (!this._criticalHealthStartTime) {
+        this._criticalHealthStartTime = Date.now();
+        console.error(`[RabbitMQClient] [mq-client-core] Critical health detected at ${new Date(this._criticalHealthStartTime).toISOString()}`);
+      }
+      
+      // Report to monitoring if callback provided
+      if (this._healthReportCallback) {
+        try {
+          await this._healthReportCallback(health);
+        } catch (reportErr) {
+          console.error(`[RabbitMQClient] [mq-client-core] Health report callback failed:`, reportErr.message);
+        }
+      }
+      
+      // Call critical health callback if provided
+      if (this._healthCriticalCallback) {
+        try {
+          await this._healthCriticalCallback(health);
+        } catch (criticalErr) {
+          console.error(`[RabbitMQClient] [mq-client-core] Critical health callback failed:`, criticalErr.message);
+        }
+      }
+      
+      // Emit critical health event
+      this.emit('health:critical', health);
+      
+      // Check if we should shutdown after delay
+      if (this._criticalHealthShutdown) {
+        const timeSinceCritical = Date.now() - this._criticalHealthStartTime;
+        if (timeSinceCritical >= this._criticalHealthShutdownDelay) {
+          console.error(`[RabbitMQClient] [mq-client-core] Critical health persisted for ${timeSinceCritical}ms (threshold: ${this._criticalHealthShutdownDelay}ms) - triggering shutdown`);
+          this.emit('health:shutdown', health);
+          // Note: Actual shutdown should be handled by the application using this event
+        } else {
+          const remaining = this._criticalHealthShutdownDelay - timeSinceCritical;
+          console.warn(`[RabbitMQClient] [mq-client-core] Critical health will trigger shutdown in ${remaining}ms if not resolved`);
+        }
+      }
+    } else {
+      // Health is OK - reset critical health tracking
+      if (this._criticalHealthStartTime) {
+        const duration = Date.now() - this._criticalHealthStartTime;
+        console.log(`[RabbitMQClient] [mq-client-core] Health recovered after ${duration}ms of critical state`);
+        this._criticalHealthStartTime = null;
+      }
+      
+      console.log(`[RabbitMQClient] [mq-client-core] Health check OK: ${health.consumers.active}/${health.consumers.tracked} consumers active, ${health.queues.checked} queues checked`);
+    }
+    
+    return health;
+  }
+
   async disconnect() {
+    // Stop health monitoring
+    this._stopHealthMonitoring();
+    
+    // Clear active consumers tracking
+    this._activeConsumers.clear();
+    
     try {
       if (this._consumerChannel) {
         await this._consumerChannel.close();
@@ -194,15 +774,14 @@ class RabbitMQClient extends EventEmitter {
    * @throws {Error} If publish fails or channel is not available.
    */
   async publish(queue, buffer, options = {}) {
-    // Check channel state before publish
-    if (!this._channel || this._channel.closed) {
-      const errorMsg = `Cannot publish to queue "${queue}": channel is not initialized or closed (channel: ${!!this._channel}, closed: ${this._channel?.closed})`;
-      console.error('[RabbitMQClient] [mq-client-core] [PUBLISH]', errorMsg);
-      throw new Error(errorMsg);
-    }
+    // Ensure publisher channel exists and is open (auto-recreates if closed)
+    await this._ensurePublisherChannel();
+    
+    // Track operation for debugging
+    this._trackChannelOperation(this._channel, `publish to ${queue}`);
     
     // Log publish attempt for debugging
-    console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Attempting to publish to queue "${queue}" (channel open: ${!this._channel.closed})`);
+    console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Attempting to publish to queue "${queue}"`);
 
     const exchange = this._config.exchange || '';
     const routingKey = options.routingKey || queue;
@@ -217,21 +796,9 @@ class RabbitMQClient extends EventEmitter {
         // If queue doesn't exist (404), we should NOT auto-create it - infrastructure queues must be created explicitly
         // This prevents creating queues with wrong arguments (no TTL) which causes 406 errors later
         try {
-          // Check queueChannel state
-          if (!this._queueChannel || this._queueChannel.closed) {
-            // Recreate queueChannel if closed
-            if (this._connection && !this._connection.closed) {
-              this._queueChannel = await this._connection.createChannel();
-              this._queueChannel.on('error', (err) => {
-                console.warn('[RabbitMQClient] Queue channel error:', err.message);
-              });
-              this._queueChannel.on('close', () => {
-                console.warn('[RabbitMQClient] Queue channel closed');
-              });
-            } else {
-              throw new Error('Cannot publish: connection is closed');
-            }
-          }
+          // Ensure queue channel exists and is open (auto-recreates if closed)
+          await this._ensureQueueChannel();
+          this._trackChannelOperation(this._queueChannel, `checkQueue ${queue}`);
           await this._queueChannel.checkQueue(queue);
           // Queue exists - proceed to publish
         } catch (checkErr) {
@@ -259,6 +826,7 @@ class RabbitMQClient extends EventEmitter {
             // For non-infrastructure queues, allow auto-creation with default options
             const queueOptions = options.queueOptions || { durable: this._config.durable };
             console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Auto-creating non-infrastructure queue ${queue} with default options (no TTL). This should be avoided for production.`);
+            this._trackChannelOperation(this._queueChannel, `assertQueue ${queue}`);
             await this._queueChannel.assertQueue(queue, queueOptions);
           } else {
             // Other error - rethrow
@@ -266,23 +834,13 @@ class RabbitMQClient extends EventEmitter {
           }
         }
         // Publish to queue using ConfirmChannel (for publisher confirms)
-        // Check channel state again before sendToQueue
-        if (this._channel.closed) {
-          throw new Error(`Cannot publish to queue "${queue}": channel closed during operation (after queue check)`);
-        }
-        
+        // Channel is guaranteed to be open (ensured above)
         console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Sending message to queue "${queue}" (size: ${buffer.length} bytes)`);
         
-        // Use callback-based confirmation for more reliable error handling
+        // Use callback-based confirmation - kanály jsou spolehlivé, takže callback vždy dorazí
         const confirmPromise = new Promise((resolve, reject) => {
-          // Set up timeout
-          const timeout = setTimeout(() => {
-            reject(new Error(`Publisher confirm timeout after 5 seconds for queue "${queue}"`));
-          }, 5000);
-          
           // Send message with callback
-          const sent = this._channel.sendToQueue(queue, buffer, { persistent, headers }, (err, ok) => {
-            clearTimeout(timeout);
+          this._channel.sendToQueue(queue, buffer, { persistent, headers }, (err, ok) => {
             if (err) {
               console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Send callback error for queue "${queue}":`, err.message);
               reject(err);
@@ -291,42 +849,17 @@ class RabbitMQClient extends EventEmitter {
               resolve();
             }
           });
-          
-          // If sendToQueue returns false, channel is full - wait for drain
-          if (!sent) {
-            console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel full, waiting for drain for queue "${queue}"`);
-            this._channel.once('drain', () => {
-              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel drained for queue "${queue}"`);
-            });
-          }
         });
         
-        try {
-          await confirmPromise;
-        } catch (confirmErr) {
-          // Check if channel was closed during confirmation
-          if (this._channel.closed) {
-            const errorMsg = `Publisher confirm failed for queue "${queue}": channel closed during confirmation. Original error: ${confirmErr.message}`;
-            console.error('[RabbitMQClient] [mq-client-core] [PUBLISH]', errorMsg);
-            throw new Error(errorMsg);
-          }
-          throw confirmErr;
-        }
+        await confirmPromise;
       } else {
         // If exchange is specified, assert exchange and publish to it
-        if (this._channel.closed) {
-          throw new Error('Cannot publish: channel closed during operation');
-        }
+        // Channel is guaranteed to be open (ensured above)
         await this._channel.assertExchange(exchange, 'direct', { durable: this._config.durable });
         
-        // Use callback-based confirmation for exchange publish
+        // Use callback-based confirmation - kanály jsou spolehlivé
         const confirmPromise = new Promise((resolve, reject) => {
-          const timeout = setTimeout(() => {
-            reject(new Error(`Publisher confirm timeout after 5 seconds for exchange "${exchange}"`));
-          }, 5000);
-          
-          const sent = this._channel.publish(exchange, routingKey, buffer, { persistent, headers }, (err, ok) => {
-            clearTimeout(timeout);
+          this._channel.publish(exchange, routingKey, buffer, { persistent, headers }, (err, ok) => {
             if (err) {
               console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Exchange publish callback error:`, err.message);
               reject(err);
@@ -335,28 +868,22 @@ class RabbitMQClient extends EventEmitter {
               resolve();
             }
           });
-          
-          if (!sent) {
-            this._channel.once('drain', () => {
-              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel drained for exchange "${exchange}"`);
-            });
-          }
         });
         
-        try {
-          await confirmPromise;
-        } catch (confirmErr) {
-          if (this._channel.closed) {
-            throw new Error(`Publisher confirm failed for exchange "${exchange}": channel closed during confirmation. Original error: ${confirmErr.message}`);
-          }
-          throw confirmErr;
-        }
+        await confirmPromise;
       }
     } catch (err) {
-      // If channel was closed, mark it for recreation
+      // If channel was closed, try to recreate and retry once
       if (err.message && (err.message.includes('Channel closed') || err.message.includes('channel is closed') || this._channel?.closed)) {
-        console.warn('[RabbitMQClient] [mq-client-core] [PUBLISH] Channel closed during publish, will need to reconnect');
-        this._channel = null;
+        console.warn('[RabbitMQClient] [mq-client-core] [PUBLISH] Channel closed during publish, recreating and retrying...');
+        try {
+          await this._ensurePublisherChannel();
+          // Retry publish once
+          return await this.publish(queue, buffer, options);
+        } catch (retryErr) {
+          console.error('[RabbitMQClient] [mq-client-core] [PUBLISH] Retry failed:', retryErr.message);
+          throw retryErr;
+        }
       }
       this.emit('error', err);
       throw err;
@@ -372,41 +899,11 @@ class RabbitMQClient extends EventEmitter {
    * @throws {Error} If consume setup fails or channel is not available.
    */
   async consume(queue, onMessage, options = {}) {
-    // Use dedicated consumer channel instead of ConfirmChannel
-    // ConfirmChannel is optimized for publish operations, not consume
-    if (!this._consumerChannel) {
-      // Recreate consumer channel if closed
-      if (this._connection && !this._connection.closed) {
-        this._consumerChannel = await this._connection.createChannel();
-        this._consumerChannel.on('error', (err) => {
-          console.warn('[RabbitMQClient] Consumer channel error:', err.message);
-          this.emit('error', err);
-        });
-        this._consumerChannel.on('close', () => {
-          console.warn('[RabbitMQClient] Consumer channel closed');
-          this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
-        });
-      } else {
-        throw new Error('Cannot consume: consumer channel is not initialized and connection is closed');
-      }
-    }
+    // Ensure consumer channel exists and is open (auto-recreates if closed and re-registers consumers)
+    await this._ensureConsumerChannel();
     
-    if (this._consumerChannel.closed) {
-      // Recreate consumer channel if closed
-      if (this._connection && !this._connection.closed) {
-        this._consumerChannel = await this._connection.createChannel();
-        this._consumerChannel.on('error', (err) => {
-          console.warn('[RabbitMQClient] Consumer channel error:', err.message);
-          this.emit('error', err);
-        });
-        this._consumerChannel.on('close', () => {
-          console.warn('[RabbitMQClient] Consumer channel closed');
-          this.emit('error', new Error('RabbitMQ consumer channel closed unexpectedly'));
-        });
-      } else {
-        throw new Error('Cannot consume: consumer channel is closed and connection is closed');
-      }
-    }
+    // Track operation for debugging
+    this._trackChannelOperation(this._consumerChannel, `consume from ${queue}`);
 
     const durable = options.durable !== undefined ? options.durable : this._config.durable;
     const prefetch = options.prefetch !== undefined ? options.prefetch : this._config.prefetch;
@@ -485,6 +982,7 @@ class RabbitMQClient extends EventEmitter {
       
       try {
         console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] About to call assertQueue(${queue}, ${JSON.stringify(queueOptions)})`);
+        this._trackChannelOperation(this._queueChannel, `assertQueue ${queue}`);
         await this._queueChannel.assertQueue(queue, queueOptions);
         console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Queue ${queue} asserted successfully`);
       } catch (assertErr) {
@@ -516,25 +1014,36 @@ class RabbitMQClient extends EventEmitter {
       
       // Use dedicated consumer channel for consume operations
       // This prevents conflicts with ConfirmChannel used for publish operations
+      const messageHandler = async (msg) => {
+        if (msg === null) {
+          return;
+        }
+        try {
+          await onMessage(msg);
+          if (!noAck) {
+            this._consumerChannel.ack(msg);
+          }
+        } catch (handlerErr) {
+          // Negative acknowledge and requeue by default
+          this._consumerChannel.nack(msg, false, true);
+        }
+      };
+      
       const consumeResult = await this._consumerChannel.consume(
         queue,
-        async (msg) => {
-          if (msg === null) {
-            return;
-          }
-          try {
-            await onMessage(msg);
-            if (!noAck) {
-              this._consumerChannel.ack(msg);
-            }
-          } catch (handlerErr) {
-            // Negative acknowledge and requeue by default
-            this._consumerChannel.nack(msg, false, true);
-          }
-        },
+        messageHandler,
         { noAck }
       );
       
+      // Track consumer for auto re-registration if channel closes
+      this._activeConsumers.set(queue, {
+        handler: messageHandler,
+        options: { noAck, prefetch, durable, queueOptions },
+        consumerTag: consumeResult.consumerTag
+      });
+      
+      console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Consumer registered for queue "${queue}" (consumerTag: ${consumeResult.consumerTag})`);
+      
       // Return consumer tag for cancellation
       return consumeResult.consumerTag;
     } catch (err) {