@onlineapps/mq-client-core 1.0.36 → 1.0.37

package/package.json

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

package/src/transports/rabbitmqClient.js

@@ -39,13 +39,44 @@ class RabbitMQClient extends EventEmitter {
     // Track active consumers for re-registration after channel recreation
     this._activeConsumers = new Map(); // queue -> { handler, options, consumerTag }
     
-    // Auto-reconnect flags
+    // Connection-level recovery
     this._reconnecting = false;
     this._reconnectAttempts = 0;
+    this._maxReconnectAttempts = this._config.maxReconnectAttempts || 10; // Max 10 attempts
+    this._reconnectBaseDelay = this._config.reconnectBaseDelay || 1000; // Start with 1 second
+    this._reconnectMaxDelay = this._config.reconnectMaxDelay || 30000; // Max 30 seconds
+    this._reconnectEnabled = this._config.reconnectEnabled !== false; // Default: enabled
+    this._reconnectTimer = null;
+    
+    // Publisher retry configuration
+    this._publishRetryEnabled = this._config.publishRetryEnabled !== false; // Default: enabled
+    this._publishMaxRetries = this._config.publishMaxRetries || 3; // Default: 3 attempts
+    this._publishRetryBaseDelay = this._config.publishRetryBaseDelay || 100; // Default: 100ms
+    this._publishRetryMaxDelay = this._config.publishRetryMaxDelay || 5000; // Default: 5s
+    this._publishRetryBackoffMultiplier = this._config.publishRetryBackoffMultiplier || 2; // Default: 2 (exponential)
+    this._publishConfirmationTimeout = this._config.publishConfirmationTimeout || 5000; // Default: 5s per attempt
     
     // Channel close hooks - called when channel closes with detailed information
     this._channelCloseHooks = []; // Array of { type: 'publisher'|'queue'|'consumer', callback: (details) => void }
     
+    // Channel thrashing detection - track close frequency per channel type
+    this._channelCloseHistory = {
+      publisher: [], // Array of { timestamp: number, reason: string }
+      queue: [],
+      consumer: []
+    };
+    this._thrashingThreshold = this._config.thrashingThreshold || 5; // Max closes per minute
+    this._thrashingWindowMs = this._config.thrashingWindowMs || 60000; // 1 minute window
+    this._thrashingAlertCallback = this._config.thrashingAlertCallback || null; // (type, count, windowMs) => void
+    this._thrashingAlertsSent = new Set(); // Track which alerts we've already sent to avoid spam
+    
+    // Prefetch monitoring - track utilization per queue
+    this._prefetchTracking = new Map(); // queue -> { prefetchCount: number, inFlight: number, lastCheck: number }
+    this._prefetchUtilizationThreshold = this._config.prefetchUtilizationThreshold || 0.8; // 80% threshold
+    this._prefetchCheckInterval = this._config.prefetchCheckInterval || 10000; // Check every 10s
+    this._prefetchAlertCallback = this._config.prefetchAlertCallback || null; // (queue, utilization, inFlight, prefetchCount) => void
+    this._prefetchCheckTimer = null;
+    
     // Health monitoring
     this._healthCheckInterval = null;
     this._healthCheckIntervalMs = this._config.healthCheckInterval || 30000; // Default 30s
@@ -91,6 +122,76 @@ class RabbitMQClient extends EventEmitter {
     this._channelCloseHooks.push({ type, callback });
   }
   
+  /**
+   * Track channel close event for thrashing detection
+   * @private
+   * @param {string} channelType - 'publisher', 'queue', or 'consumer'
+   * @param {string} reason - Human-readable reason
+   */
+  _trackChannelClose(channelType, reason) {
+    const now = Date.now();
+    const history = this._channelCloseHistory[channelType];
+    
+    if (!history) {
+      console.warn(`[RabbitMQClient] Unknown channel type for thrashing tracking: ${channelType}`);
+      return;
+    }
+    
+    // Add new close event
+    history.push({
+      timestamp: now,
+      reason: reason || 'unknown'
+    });
+    
+    // Remove old events outside the window
+    const cutoff = now - this._thrashingWindowMs;
+    while (history.length > 0 && history[0].timestamp < cutoff) {
+      history.shift();
+    }
+    
+    // Check for thrashing
+    if (history.length >= this._thrashingThreshold) {
+      const alertKey = `${channelType}:${Math.floor(now / this._thrashingWindowMs)}`;
+      
+      // Only alert once per window to avoid spam
+      if (!this._thrashingAlertsSent.has(alertKey)) {
+        this._thrashingAlertsSent.add(alertKey);
+        
+        // Clean up old alert keys (keep only last 10 windows)
+        if (this._thrashingAlertsSent.size > 10) {
+          const oldestKey = Array.from(this._thrashingAlertsSent).sort()[0];
+          this._thrashingAlertsSent.delete(oldestKey);
+        }
+        
+        const message = `Channel thrashing detected: ${channelType} channel closed ${history.length} times in ${Math.round(this._thrashingWindowMs / 1000)}s (threshold: ${this._thrashingThreshold})`;
+        console.error(`[RabbitMQClient] [mq-client-core] 🚨 ${message}`);
+        
+        // Call alert callback if provided
+        if (this._thrashingAlertCallback) {
+          try {
+            this._thrashingAlertCallback(channelType, history.length, this._thrashingWindowMs, {
+              recentCloses: history.slice(-this._thrashingThreshold),
+              threshold: this._thrashingThreshold,
+              windowMs: this._thrashingWindowMs
+            });
+          } catch (alertErr) {
+            console.error(`[RabbitMQClient] [mq-client-core] Thrashing alert callback error:`, alertErr.message);
+          }
+        }
+        
+        // Emit event for external listeners
+        this.emit('channel:thrashing', {
+          type: channelType,
+          count: history.length,
+          windowMs: this._thrashingWindowMs,
+          threshold: this._thrashingThreshold,
+          recentCloses: history.slice(-this._thrashingThreshold),
+          timestamp: new Date().toISOString()
+        });
+      }
+    }
+  }
+
   /**
    * Call all registered channel close hooks
    * @private
@@ -100,6 +201,9 @@ class RabbitMQClient extends EventEmitter {
    * @param {string} reason - Human-readable reason
    */
   _callChannelCloseHooks(channelType, channel, error, reason) {
+    // Track channel close for thrashing detection
+    this._trackChannelClose(channelType, reason);
+    
     const details = {
       type: channelType,
       channel: channel,
@@ -152,10 +256,40 @@ class RabbitMQClient extends EventEmitter {
       console.log('[RabbitMQClient] Starting connection race...');
       this._connection = await Promise.race([connectPromise, timeoutPromise]);
       console.log('[RabbitMQClient] Connection established');
-      this._connection.on('error', (err) => this.emit('error', err));
+      this._reconnectAttempts = 0; // Reset reconnect attempts on successful connection
+      
+      this._connection.on('error', (err) => {
+        console.error('[RabbitMQClient] Connection error:', err.message);
+        this.emit('error', err);
+        // Connection errors may lead to close event - let close handler handle reconnection
+      });
+      
       this._connection.on('close', () => {
-        // Emit a connection close error to notify listeners
+        console.warn('[RabbitMQClient] Connection closed unexpectedly - close handler STARTED');
+        console.log(`[RabbitMQClient] Close handler: reconnectEnabled=${this._reconnectEnabled}, reconnecting=${this._reconnecting}`);
+        
+        // Mark all channels as closed
+        this._channel = null;
+        this._queueChannel = null;
+        this._consumerChannel = null;
+        
+        // CONNECTION-LEVEL RECOVERY: Attempt to reconnect with exponential backoff
+        // PREDICTABLE: Check conditions and log why reconnect is/isn't starting
+        // IMPORTANT: Do this BEFORE emitting error, so reconnect can start even if error handler throws
+        if (this._reconnectEnabled && !this._reconnecting) {
+          console.log('[RabbitMQClient] ✓ Conditions met - starting connection-level recovery from initial connect() close handler');
+          this._reconnectWithBackoff().catch(err => {
+            console.error('[RabbitMQClient] Reconnection failed after all attempts:', err.message);
+            this.emit('error', err);
+          });
+        } else {
+          console.warn(`[RabbitMQClient] ✗ Reconnect NOT starting: enabled=${this._reconnectEnabled}, reconnecting=${this._reconnecting}`);
+        }
+        
+        // Emit connection close event AFTER starting reconnect (so reconnect isn't blocked by error handler)
         this.emit('error', new Error('RabbitMQ connection closed unexpectedly'));
+        
+        console.log('[RabbitMQClient] Close handler FINISHED');
       });
 
       // Use ConfirmChannel to enable publisher confirms for publish operations
@@ -167,37 +301,8 @@ class RabbitMQClient extends EventEmitter {
       this._channel._lastOperation = 'Initial creation';
       this._channel._type = 'publisher';
       
-      // Enable publisher confirms explicitly
-      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', 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', () => {
-        console.log('[RabbitMQClient] [mq-client-core] Publisher channel drained');
-      });
+      // Attach event handlers
+      this._attachPublisherChannelHandlers(this._channel);
       
       // Create a separate regular channel for queue operations (assertQueue, checkQueue)
       // This avoids RPC reply queue issues with ConfirmChannel.assertQueue()
@@ -209,31 +314,8 @@ class RabbitMQClient extends EventEmitter {
       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', 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();
-      });
+      // Attach event handlers
+      this._attachQueueChannelHandlers(this._queueChannel);
       
       // Create a dedicated channel for consume operations
       // This prevents channel conflicts between publish (ConfirmChannel) and consume operations
@@ -245,32 +327,8 @@ class RabbitMQClient extends EventEmitter {
       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', 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();
-      });
+      // Attach event handlers
+      this._attachConsumerChannelHandlers(this._consumerChannel);
       
       // Start health monitoring if enabled
       if (this._healthCheckEnabled) {
@@ -290,6 +348,50 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Wait for reconnection to complete
+   * Used by both retry mechanism and channel creation
+   * @private
+   * @returns {Promise<void>}
+   * @throws {Error} If reconnection fails or times out
+   */
+  async _waitForReconnection() {
+    if (!this._reconnecting) {
+      throw new Error('Cannot wait for reconnection: not currently reconnecting');
+    }
+    
+    // Wait for 'reconnected' event
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this.removeListener('reconnected', onReconnected);
+        this.removeListener('error', onError);
+        reject(new Error('Reconnection timeout after 30 seconds'));
+      }, 30000); // 30 seconds timeout
+      
+      const onReconnected = () => {
+        clearTimeout(timeout);
+        this.removeListener('reconnected', onReconnected);
+        this.removeListener('error', onError);
+        // Wait a bit for channels to be fully recreated
+        setTimeout(resolve, 500);
+      };
+      
+      const onError = (error) => {
+        // Ignore connection errors during reconnection
+        if (error.message && error.message.includes('Connection closed unexpectedly')) {
+          return; // Expected during reconnection
+        }
+        clearTimeout(timeout);
+        this.removeListener('reconnected', onReconnected);
+        this.removeListener('error', onError);
+        reject(error);
+      };
+      
+      this.once('reconnected', onReconnected);
+      this.on('error', onError);
+    });
+  }
+
   /**
    * Ensure publisher channel exists and is open
    * Auto-recreates if closed
@@ -302,7 +404,25 @@ class RabbitMQClient extends EventEmitter {
     }
     
     if (!this._connection || this._connection.closed) {
-      throw new Error('Cannot recreate publisher channel: connection is closed');
+      // Connection is closed - wait for reconnection
+      console.warn('[RabbitMQClient] [mq-client-core] Cannot recreate publisher channel: connection is closed (waiting for reconnection)');
+      
+      // Wait for reconnection to complete
+      if (this._reconnecting) {
+        await this._waitForReconnection();
+        
+        // After reconnection, try again
+        if (this._channel && !this._channel.closed) {
+          return; // Channel was recreated during reconnection
+        }
+        // If still no channel, connection might have failed - check again
+        if (!this._connection || this._connection.closed) {
+          throw new Error('Connection reconnection failed - cannot create publisher channel');
+        }
+      } else {
+        // Not reconnecting - connection is closed and not recovering
+        throw new Error('Connection is closed and not reconnecting - cannot create publisher channel');
+      }
     }
     
     try {
@@ -324,31 +444,8 @@ class RabbitMQClient extends EventEmitter {
       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');
-      });
+      // Attach event handlers
+      this._attachPublisherChannelHandlers(this._channel);
       
       console.log('[RabbitMQClient] [mq-client-core] ✓ Publisher channel recreated');
     } catch (err) {
@@ -369,7 +466,11 @@ class RabbitMQClient extends EventEmitter {
     }
     
     if (!this._connection || this._connection.closed) {
-      throw new Error('Cannot recreate queue channel: connection is closed');
+      // Connection is closed - cannot recreate channel
+      // Reconnection logic will handle this - don't throw, just return
+      // The channel will be recreated after reconnection completes
+      console.warn('[RabbitMQClient] [mq-client-core] Cannot recreate queue channel: connection is closed (reconnection in progress)');
+      return;
     }
     
     try {
@@ -391,32 +492,18 @@ class RabbitMQClient extends EventEmitter {
       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();
-      });
+      // Attach event handlers
+      this._attachQueueChannelHandlers(this._queueChannel);
       
       console.log('[RabbitMQClient] [mq-client-core] ✓ Queue channel recreated');
     } catch (err) {
       this._queueChannel = null;
-      throw new Error(`Failed to recreate queue channel: ${err.message}`);
+      // If connection is closed, don't throw - reconnection will handle it
+      if (this._connection && !this._connection.closed) {
+        throw new Error(`Failed to recreate queue channel: ${err.message}`);
+      }
+      // Connection is closed - reconnection will recreate channel
+      console.warn(`[RabbitMQClient] [mq-client-core] Failed to recreate queue channel (connection closed): ${err.message}`);
     }
   }
 
@@ -432,7 +519,11 @@ class RabbitMQClient extends EventEmitter {
     }
     
     if (!this._connection || this._connection.closed) {
-      throw new Error('Cannot recreate consumer channel: connection is closed');
+      // Connection is closed - cannot recreate channel
+      // Reconnection logic will handle this - don't throw, just return
+      // The channel will be recreated after reconnection completes
+      console.warn('[RabbitMQClient] [mq-client-core] Cannot recreate consumer channel: connection is closed (reconnection in progress)');
+      return;
     }
     
     try {
@@ -454,28 +545,8 @@ class RabbitMQClient extends EventEmitter {
       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();
-      });
+      // Attach event handlers
+      this._attachConsumerChannelHandlers(this._consumerChannel);
       
       // Re-register all active consumers
       if (this._activeConsumers.size > 0) {
@@ -737,9 +808,15 @@ class RabbitMQClient extends EventEmitter {
     // Stop health monitoring
     this._stopHealthMonitoring();
     
+    // Stop prefetch monitoring
+    this._stopPrefetchMonitoring();
+    
     // Clear active consumers tracking
     this._activeConsumers.clear();
     
+    // Clear prefetch tracking
+    this._prefetchTracking.clear();
+    
     try {
       if (this._consumerChannel) {
         await this._consumerChannel.close();
@@ -771,19 +848,39 @@ class RabbitMQClient extends EventEmitter {
         this._connection = null;
       }
     } catch (err) {
-      this.emit('error', err);
+      // Don't emit error for expected connection closure during disconnect
+      // This is a predictable, intentional closure
+      if (err.message && err.message.includes('Connection closed (by client)')) {
+        console.log('[RabbitMQClient] Connection closed during disconnect (expected)');
+      } else {
+        this.emit('error', err);
+      }
     }
   }
 
   /**
    * Publishes a message buffer to the specified queue (or default queue) or exchange.
+   * Implements systematic retry with exponential backoff for transient failures.
    * @param {string} queue           - Target queue name.
    * @param {Buffer} buffer          - Message payload as Buffer.
    * @param {Object} [options]       - Overrides: routingKey, persistent, headers.
    * @returns {Promise<void>}
-   * @throws {Error} If publish fails or channel is not available.
+   * @throws {Error} If publish fails after all retry attempts.
    */
   async publish(queue, buffer, options = {}) {
+    // Wrap in retry logic if enabled
+    if (this._publishRetryEnabled) {
+      return await this._publishWithRetry(queue, buffer, options);
+    } else {
+      return await this._publishOnce(queue, buffer, options);
+    }
+  }
+
+  /**
+   * Internal publish implementation - single attempt without retry
+   * @private
+   */
+  async _publishOnce(queue, buffer, options = {}) {
     // Ensure publisher channel exists and is open (auto-recreates if closed)
     await this._ensurePublisherChannel();
     
@@ -849,16 +946,103 @@ class RabbitMQClient extends EventEmitter {
         
         // Use callback-based confirmation - kanály jsou spolehlivé, takže callback vždy dorazí
         const confirmPromise = new Promise((resolve, reject) => {
+          // Set timeout for publish confirmation (configurable)
+          const timeout = setTimeout(() => {
+            reject(new Error(`Publish confirmation timeout for queue "${queue}" after ${this._publishConfirmationTimeout}ms`));
+          }, this._publishConfirmationTimeout);
+          
+          // Check if channel is still valid before sending
+          if (!this._channel || this._channel.closed) {
+            clearTimeout(timeout);
+            reject(new Error(`Cannot publish: channel is closed for queue "${queue}"`));
+            return;
+          }
+          
+          // Track original channel to detect if it was closed/recreated during publish
+          const originalChannel = this._channel;
+          const channelId = originalChannel ? originalChannel._createdAt : null;
+          let callbackInvoked = false;
+          
           // Send message with callback
-          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);
+          try {
+            originalChannel.sendToQueue(queue, buffer, { persistent, headers }, (err, ok) => {
+              callbackInvoked = true;
+              clearTimeout(timeout);
+              
+              // CRITICAL: Check if channel was closed or recreated during publish
+              // If channel was recreated, the delivery tag is invalid - ignore this callback
+              if (!this._channel || this._channel.closed || this._channel !== originalChannel || 
+                  (this._channel._createdAt && this._channel._createdAt !== channelId)) {
+                // Channel was closed or recreated - delivery tag is invalid
+                console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel closed/recreated during publish to queue "${queue}", ignoring callback`);
+                // If we're reconnecting, wait and retry
+                if (this._reconnecting) {
+                  this._waitForReconnection().then(() => {
+                    // Retry publish after reconnection
+                    return this.publish(queue, buffer, options);
+                  }).then(resolve).catch(reject);
+                } else {
+                  // Not reconnecting - this is a real error
+                  // We cannot guarantee the message was delivered - must fail
+                  reject(new Error(`Channel closed during publish to queue "${queue}" and not reconnecting - message delivery not guaranteed`));
+                }
+                return;
+              }
+              
+              if (err) {
+                // Check if error is about invalid delivery tag (channel was closed)
+                if (err.message && (err.message.includes('unknown delivery tag') || err.message.includes('PRECONDITION_FAILED'))) {
+                  console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Delivery tag invalid (channel may have been closed) for queue "${queue}"`);
+                  // If we're reconnecting, wait and retry
+                  if (this._reconnecting) {
+                    this._waitForReconnection().then(() => {
+                      // Retry publish after reconnection
+                      return this.publish(queue, buffer, options);
+                    }).then(resolve).catch(reject);
+                  } else {
+                    // Not reconnecting - delivery tag is invalid, message delivery not guaranteed
+                    reject(new Error(`Delivery tag invalid for queue "${queue}" (channel closed) and not reconnecting - message delivery not guaranteed`));
+                  }
+                } else {
+                  console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Send callback error for queue "${queue}":`, err.message);
+                  reject(err);
+                }
+              } else {
+                console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Message confirmed for queue "${queue}"`);
+                resolve();
+              }
+            });
+            
+            // Set a safety timeout - if callback wasn't invoked and channel closed, retry
+            setTimeout(() => {
+              if (!callbackInvoked && (!this._channel || this._channel.closed || this._channel !== originalChannel)) {
+                console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Callback timeout and channel closed for queue "${queue}", will retry after reconnection`);
+                if (this._reconnecting) {
+                  clearTimeout(timeout);
+                  this._waitForReconnection().then(() => {
+                    return this.publish(queue, buffer, options);
+                  }).then(resolve).catch(reject);
+                }
+              }
+            }, 1000);
+          } catch (sendErr) {
+            clearTimeout(timeout);
+            // If channel is closed, try to wait for reconnection and retry
+            if (sendErr.message && (sendErr.message.includes('Channel ended') || sendErr.message.includes('Channel closed'))) {
+              console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Channel closed during sendToQueue, will retry after reconnection`);
+              // Wait for reconnection and retry
+              if (this._reconnecting) {
+                this._waitForReconnection().then(() => {
+                  // Retry publish after reconnection
+                  return this.publish(queue, buffer, options);
+                }).then(resolve).catch(reject);
+              } else {
+                reject(sendErr);
+              }
             } else {
-              console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Message confirmed for queue "${queue}"`);
-              resolve();
+              reject(sendErr);
             }
-          });
+          }
         });
         
         await confirmPromise;
@@ -869,7 +1053,13 @@ class RabbitMQClient extends EventEmitter {
         
         // Use callback-based confirmation - kanály jsou spolehlivé
         const confirmPromise = new Promise((resolve, reject) => {
+          // Set timeout for exchange publish confirmation
+          const timeout = setTimeout(() => {
+            reject(new Error(`Exchange publish confirmation timeout for exchange "${exchange}" after ${this._publishConfirmationTimeout}ms`));
+          }, this._publishConfirmationTimeout);
+          
           this._channel.publish(exchange, routingKey, buffer, { persistent, headers }, (err, ok) => {
+            clearTimeout(timeout);
             if (err) {
               console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Exchange publish callback error:`, err.message);
               reject(err);
@@ -900,6 +1090,182 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Publish with systematic retry and exponential backoff
+   * @private
+   * @param {string} queue - Target queue name
+   * @param {Buffer} buffer - Message payload
+   * @param {Object} options - Publish options
+   * @returns {Promise<void>}
+   */
+  async _publishWithRetry(queue, buffer, options = {}) {
+    let lastError = null;
+    let attempt = 0;
+    
+    while (attempt < this._publishMaxRetries) {
+      attempt++;
+      
+      try {
+        // Emit retry attempt event for monitoring
+        if (attempt > 1) {
+          this.emit('publish:retry', {
+            queue,
+            attempt,
+            maxRetries: this._publishMaxRetries,
+            lastError: lastError?.message
+          });
+          console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Retry attempt ${attempt}/${this._publishMaxRetries} for queue "${queue}"`);
+        }
+        
+        // Attempt publish
+        await this._publishOnce(queue, buffer, options);
+        
+        // Success - emit success event if this was a retry
+        if (attempt > 1) {
+          this.emit('publish:success', {
+            queue,
+            attempt,
+            totalAttempts: attempt
+          });
+          console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Published successfully after ${attempt} attempts for queue "${queue}"`);
+        }
+        
+        return; // Success - exit retry loop
+        
+      } catch (err) {
+        lastError = err;
+        
+        // Check if error is retryable
+        const isRetryable = this._isPublishErrorRetryable(err);
+        
+        if (!isRetryable) {
+          // Non-retryable error - fail immediately
+          console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Non-retryable error for queue "${queue}":`, err.message);
+          this.emit('publish:failed', {
+            queue,
+            attempt,
+            error: err.message,
+            retryable: false
+          });
+          throw err;
+        }
+        
+        // Retryable error - check if we have more attempts
+        if (attempt >= this._publishMaxRetries) {
+          // Max retries exceeded
+          console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✗ Failed after ${attempt} attempts for queue "${queue}":`, err.message);
+          this.emit('publish:failed', {
+            queue,
+            attempt,
+            error: err.message,
+            retryable: true,
+            maxRetriesExceeded: true
+          });
+          throw new Error(`Publish failed after ${attempt} attempts for queue "${queue}": ${err.message}`);
+        }
+        
+        // CRITICAL: If reconnecting, wait for reconnection to complete before retry
+        // This ensures we don't waste retry attempts while connection is being restored
+        if (this._reconnecting) {
+          console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] Connection is reconnecting, waiting for reconnection before retry ${attempt + 1}/${this._publishMaxRetries}...`);
+          try {
+            await this._waitForReconnection();
+            console.log(`[RabbitMQClient] [mq-client-core] [PUBLISH] ✓ Reconnection completed, proceeding with retry ${attempt + 1}/${this._publishMaxRetries}`);
+            // Continue to retry immediately after reconnection (no additional delay needed)
+            continue;
+          } catch (reconnectErr) {
+            // Reconnection failed - this is a critical error
+            console.error(`[RabbitMQClient] [mq-client-core] [PUBLISH] Reconnection failed:`, reconnectErr.message);
+            this.emit('publish:failed', {
+              queue,
+              attempt,
+              error: `Reconnection failed: ${reconnectErr.message}`,
+              retryable: false,
+              reconnectFailed: true
+            });
+            throw new Error(`Publish failed: reconnection failed after ${attempt} attempts for queue "${queue}": ${reconnectErr.message}`);
+          }
+        }
+        
+        // Calculate exponential backoff delay (only if not reconnecting)
+        const delay = Math.min(
+          this._publishRetryBaseDelay * Math.pow(this._publishRetryBackoffMultiplier, attempt - 1),
+          this._publishRetryMaxDelay
+        );
+        
+        console.warn(`[RabbitMQClient] [mq-client-core] [PUBLISH] Retryable error for queue "${queue}" (attempt ${attempt}/${this._publishMaxRetries}), waiting ${delay}ms before retry:`, err.message);
+        
+        // Wait before retry
+        await new Promise(resolve => setTimeout(resolve, delay));
+      }
+    }
+    
+    // Should never reach here, but just in case
+    throw lastError || new Error(`Publish failed for queue "${queue}" after ${attempt} attempts`);
+  }
+
+  /**
+   * Determine if a publish error is retryable
+   * @private
+   * @param {Error} err - Error to check
+   * @returns {boolean} True if error is retryable
+   */
+  _isPublishErrorRetryable(err) {
+    if (!err || !err.message) {
+      return false;
+    }
+    
+    const message = err.message.toLowerCase();
+    
+    // Retryable errors: connection/channel issues, timeouts, transient broker errors
+    const retryablePatterns = [
+      'channel closed',
+      'channel ended',
+      'connection closed',
+      'connection ended',
+      'timeout',
+      'confirmation timeout',
+      'delivery tag invalid',
+      'unknown delivery tag',
+      'precondition_failed.*delivery tag',
+      'not connected',
+      'reconnecting'
+    ];
+    
+    // Non-retryable errors: permanent failures, validation errors
+    const nonRetryablePatterns = [
+      'queue does not exist',
+      'exchange does not exist',
+      'access refused',
+      'not found',
+      'permission denied',
+      'invalid',
+      'malformed'
+    ];
+    
+    // Check non-retryable first
+    for (const pattern of nonRetryablePatterns) {
+      if (message.includes(pattern)) {
+        return false;
+      }
+    }
+    
+    // Check retryable
+    for (const pattern of retryablePatterns) {
+      if (message.includes(pattern)) {
+        return true;
+      }
+    }
+    
+    // Default: if we're reconnecting, it's retryable
+    if (this._reconnecting) {
+      return true;
+    }
+    
+    // Default: unknown errors are not retryable (fail fast)
+    return false;
+  }
+
   /**
    * Starts consuming messages from the specified queue.
    * @param {string} queue                         - Queue name to consume from.
@@ -919,6 +1285,9 @@ class RabbitMQClient extends EventEmitter {
     const prefetch = options.prefetch !== undefined ? options.prefetch : this._config.prefetch;
     const noAck = options.noAck !== undefined ? options.noAck : this._config.noAck;
 
+    // Initialize queueOptions with default value
+    let queueOptions = options.queueOptions || { durable };
+    
     try {
       // Skip assertQueue for reply queues (they're already created with specific settings)
       // Reply queues start with 'rpc.reply.' and are created as non-durable
@@ -938,8 +1307,6 @@ class RabbitMQClient extends EventEmitter {
       const isInfraQueue = queueConfig ? queueConfig.isInfrastructureQueue(queue) : false;
       const isBusinessQueue = queueConfig ? queueConfig.isBusinessQueue(queue) : false;
       
-      let queueOptions = options.queueOptions || { durable };
-      
       if (queueConfig) {
         if (isInfraQueue) {
           // Infrastructure queue - use central config
@@ -992,6 +1359,13 @@ class RabbitMQClient extends EventEmitter {
       
       try {
         console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] About to call assertQueue(${queue}, ${JSON.stringify(queueOptions)})`);
+        
+        // Ensure queue channel is available
+        await this._ensureQueueChannel();
+        if (!this._queueChannel) {
+          throw new Error('Queue channel is not available (connection may be closed)');
+        }
+        
         this._trackChannelOperation(this._queueChannel, `assertQueue ${queue}`);
         await this._queueChannel.assertQueue(queue, queueOptions);
         console.log(`[RabbitMQClient] [mq-client-core] [CONSUMER] ✓ Queue ${queue} asserted successfully`);
@@ -1013,6 +1387,23 @@ class RabbitMQClient extends EventEmitter {
       // Set prefetch if provided (on consumer channel)
       if (typeof prefetch === 'number') {
         this._consumerChannel.prefetch(prefetch);
+        
+        // Track prefetch for monitoring
+        if (!this._prefetchTracking.has(queue)) {
+          this._prefetchTracking.set(queue, {
+            prefetchCount: prefetch,
+            inFlight: 0,
+            lastCheck: Date.now()
+          });
+        } else {
+          const tracking = this._prefetchTracking.get(queue);
+          tracking.prefetchCount = prefetch;
+        }
+        
+        // Start prefetch monitoring if not already started
+        if (!this._prefetchCheckTimer) {
+          this._startPrefetchMonitoring();
+        }
       }
 
       // CRITICAL: Log before calling amqplib's consume()
@@ -1024,18 +1415,47 @@ class RabbitMQClient extends EventEmitter {
       
       // Use dedicated consumer channel for consume operations
       // This prevents conflicts with ConfirmChannel used for publish operations
+      // Wrap handler to track message processing and prefetch utilization
       const messageHandler = async (msg) => {
         if (msg === null) {
-          return;
+          return; // Consumer cancellation
         }
+        
+        // Track in-flight message (increment)
+        const tracking = this._prefetchTracking.get(queue);
+        if (tracking) {
+          tracking.inFlight++;
+          tracking.lastCheck = Date.now();
+          this._checkPrefetchUtilization(queue, tracking);
+        }
+        
         try {
           await onMessage(msg);
+          // Acknowledge message after successful processing
           if (!noAck) {
             this._consumerChannel.ack(msg);
+            // Track ack (decrement in-flight)
+            if (tracking) {
+              tracking.inFlight = Math.max(0, tracking.inFlight - 1);
+              tracking.lastCheck = Date.now();
+            }
           }
         } catch (handlerErr) {
           // Negative acknowledge and requeue by default
-          this._consumerChannel.nack(msg, false, true);
+          // Check if channel is still valid before nacking
+          if (this._consumerChannel && !this._consumerChannel.closed) {
+            try {
+              this._consumerChannel.nack(msg, false, true);
+            } catch (nackErr) {
+              // Channel may have closed during nack - ignore
+              console.warn(`[RabbitMQClient] [mq-client-core] Failed to nack message (channel may be closed): ${nackErr.message}`);
+            }
+          }
+          // Track nack (decrement in-flight)
+          if (tracking) {
+            tracking.inFlight = Math.max(0, tracking.inFlight - 1);
+            tracking.lastCheck = Date.now();
+          }
         }
       };
       
@@ -1062,6 +1482,366 @@ class RabbitMQClient extends EventEmitter {
     }
   }
 
+  /**
+   * Reconnect to RabbitMQ with exponential backoff
+   * CONNECTION-LEVEL RECOVERY: Recreates connection and all channels, re-registers consumers
+   * @private
+   * @returns {Promise<void>}
+   */
+  async _reconnectWithBackoff() {
+    if (this._reconnecting) {
+      console.log('[RabbitMQClient] Reconnection already in progress, skipping');
+      return;
+    }
+
+    this._reconnecting = true;
+    console.log(`[RabbitMQClient] Starting connection-level recovery (attempt ${this._reconnectAttempts + 1}/${this._maxReconnectAttempts})...`);
+
+    while (this._reconnectAttempts < this._maxReconnectAttempts) {
+      try {
+        // Calculate exponential backoff delay: baseDelay * 2^attempts, capped at maxDelay
+        const delay = Math.min(
+          this._reconnectBaseDelay * Math.pow(2, this._reconnectAttempts),
+          this._reconnectMaxDelay
+        );
+        
+        console.log(`[RabbitMQClient] Waiting ${delay}ms before reconnection attempt ${this._reconnectAttempts + 1}...`);
+        await new Promise(resolve => setTimeout(resolve, delay));
+
+        // Attempt to reconnect
+        console.log(`[RabbitMQClient] Reconnection attempt ${this._reconnectAttempts + 1}...`);
+        
+        // Close old connection if exists
+        if (this._connection) {
+          try {
+            await this._connection.close();
+          } catch (_) {
+            // Ignore errors when closing already-closed connection
+          }
+          this._connection = null;
+        }
+
+        // Reconnect
+        const rawTarget = this._config.host || this._config.url;
+        const heartbeat = this._config.heartbeat ?? 30;
+        const connectionName =
+          this._config.connectionName ||
+          this._config.clientName ||
+          `oa-client:${process.env.SERVICE_NAME || 'unknown'}:${process.pid}`;
+
+        const connectArgs = typeof rawTarget === 'string'
+          ? [rawTarget, { heartbeat, clientProperties: { connection_name: connectionName } }]
+          : [{ ...rawTarget, heartbeat, clientProperties: { connection_name: connectionName } }];
+
+        const connectPromise = amqp.connect(...connectArgs);
+        const timeoutPromise = new Promise((_, reject) => {
+          setTimeout(() => reject(new Error('Connection timeout after 10 seconds')), 10000);
+        });
+
+        this._connection = await Promise.race([connectPromise, timeoutPromise]);
+        console.log('[RabbitMQClient] ✓ Connection re-established');
+
+        // Re-attach connection event handlers
+        this._connection.on('error', (err) => {
+          console.error('[RabbitMQClient] Connection error:', err.message);
+          this.emit('error', err);
+        });
+
+        this._connection.on('close', () => {
+          console.warn('[RabbitMQClient] Connection closed unexpectedly');
+          this._channel = null;
+          this._queueChannel = null;
+          this._consumerChannel = null;
+          this.emit('error', new Error('RabbitMQ connection closed unexpectedly'));
+          
+          // Attempt to reconnect again if enabled
+          if (this._reconnectEnabled && !this._reconnecting) {
+            this._reconnectWithBackoff().catch(err => {
+              console.error('[RabbitMQClient] Reconnection failed after all attempts:', err.message);
+              this.emit('error', err);
+            });
+          }
+        });
+
+        // Recreate all channels
+        console.log('[RabbitMQClient] Recreating channels...');
+        
+        // Recreate publisher channel
+        this._channel = await this._connection.createConfirmChannel();
+        this._channel._createdAt = new Date().toISOString();
+        this._channel._closeReason = null;
+        this._channel._lastOperation = 'Recreated via _reconnectWithBackoff()';
+        this._channel._type = 'publisher';
+        this._attachPublisherChannelHandlers(this._channel);
+        
+        // Recreate queue channel
+        this._queueChannel = await this._connection.createChannel();
+        this._queueChannel._createdAt = new Date().toISOString();
+        this._queueChannel._closeReason = null;
+        this._queueChannel._lastOperation = 'Recreated via _reconnectWithBackoff()';
+        this._queueChannel._type = 'queue';
+        this._attachQueueChannelHandlers(this._queueChannel);
+        
+        // Recreate consumer channel and re-register all consumers
+        this._consumerChannel = await this._connection.createChannel();
+        this._consumerChannel._createdAt = new Date().toISOString();
+        this._consumerChannel._closeReason = null;
+        // IMPORTANT: Don't re-register consumers here - _ensureConsumerChannel() will do it
+        // This prevents duplicate re-registration (once in _reconnectWithBackoff, once in _ensureConsumerChannel)
+        // Just ensure consumer channel is created - it will automatically re-register all active consumers
+        await this._ensureConsumerChannel();
+
+        // Reset reconnect state
+        this._reconnectAttempts = 0;
+        this._reconnecting = false;
+        
+        // CRITICAL: Verify all channels are ready before emitting 'reconnected'
+        // This ensures publish/consume operations can proceed immediately after reconnection
+        if (!this._channel || this._channel.closed) {
+          throw new Error('Publisher channel not ready after reconnection');
+        }
+        if (!this._queueChannel || this._queueChannel.closed) {
+          throw new Error('Queue channel not ready after reconnection');
+        }
+        if (!this._consumerChannel || this._consumerChannel.closed) {
+          throw new Error('Consumer channel not ready after reconnection');
+        }
+        
+        console.log('[RabbitMQClient] ✓ Connection-level recovery completed successfully - all channels ready');
+        this.emit('reconnected');
+        
+        return; // Success - exit reconnection loop
+      } catch (err) {
+        this._reconnectAttempts++;
+        console.error(`[RabbitMQClient] Reconnection attempt ${this._reconnectAttempts} failed:`, err.message);
+        
+        if (this._reconnectAttempts >= this._maxReconnectAttempts) {
+          console.error(`[RabbitMQClient] ✗ Connection-level recovery failed after ${this._maxReconnectAttempts} attempts`);
+          this._reconnecting = false;
+          throw new Error(`Failed to reconnect after ${this._maxReconnectAttempts} attempts: ${err.message}`);
+        }
+        // Continue to next attempt
+      }
+    }
+  }
+
+  /**
+   * Attach event handlers to publisher channel
+   * @private
+   */
+  _attachPublisherChannelHandlers(channel) {
+    channel.on('error', async (err) => {
+      const reason = `Publisher channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+      channel._closeReason = reason;
+      
+      // "unknown delivery tag" errors occur when channel closes during publish
+      // This is expected - the publish callback will handle retry
+      // We still log it but don't try to recreate channel (it's already closing)
+      if (err.message && err.message.includes('unknown delivery tag')) {
+        console.warn(`[RabbitMQClient] [mq-client-core] Publisher channel error (channel closing during publish): ${err.message}`);
+        // Don't try to recreate - channel is already closing
+        // Don't emit error - publish callback will handle retry
+        return;
+      }
+      
+      console.error(`[RabbitMQClient] [mq-client-core] ${reason}`);
+      this._callChannelCloseHooks('publisher', channel, err, reason);
+      
+      // Only try to recreate if connection is available
+      // If connection is closed, reconnection logic will handle channel recreation
+      if (this._connection && !this._connection.closed) {
+        try {
+          await this._ensurePublisherChannel();
+        } catch (recreateErr) {
+          // Ignore errors during channel recreation if connection is closing
+          console.warn(`[RabbitMQClient] [mq-client-core] Failed to recreate publisher channel (connection may be closing): ${recreateErr.message}`);
+        }
+      }
+      
+      this.emit('error', err);
+    });
+    
+    channel.on('close', async () => {
+      const reason = channel._closeReason || 'Publisher channel closed unexpectedly';
+      console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate on next publish`);
+      this._callChannelCloseHooks('publisher', channel, null, reason);
+      const closedChannel = this._channel;
+      this._channel = null;
+      
+      // Only try to recreate if connection is available
+      // If connection is closed, reconnection logic will handle channel recreation
+      if (this._connection && !this._connection.closed) {
+        try {
+          await this._ensurePublisherChannel();
+        } catch (err) {
+          // Ignore errors during channel recreation if connection is closing
+          console.warn(`[RabbitMQClient] [mq-client-core] Failed to recreate publisher channel (connection may be closing): ${err.message}`);
+        }
+      }
+    });
+    
+    channel.on('drain', () => {
+      console.log('[RabbitMQClient] [mq-client-core] Publisher channel drained');
+    });
+  }
+
+  /**
+   * Attach event handlers to queue channel
+   * @private
+   */
+  _attachQueueChannelHandlers(channel) {
+    channel.on('error', async (err) => {
+      const reason = `Queue channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+      channel._closeReason = reason;
+      console.warn(`[RabbitMQClient] [mq-client-core] ${reason}`);
+      this._callChannelCloseHooks('queue', channel, err, reason);
+      await this._ensureQueueChannel();
+    });
+    
+    channel.on('close', async () => {
+      const reason = channel._closeReason || 'Queue channel closed unexpectedly';
+      console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate on next operation`);
+      this._callChannelCloseHooks('queue', channel, null, reason);
+      const closedChannel = this._queueChannel;
+      this._queueChannel = null;
+      
+      // PREDICTABLE: Only recreate if connection is available and not closing
+      // If connection is closed, reconnection logic will handle channel recreation
+      if (this._connection && !this._connection.closed && !this._reconnecting) {
+        try {
+          await this._ensureQueueChannel();
+        } catch (err) {
+          // If connection is closing, this is expected - don't throw
+          if (err.message && err.message.includes('Connection closed')) {
+            console.warn(`[RabbitMQClient] [mq-client-core] Queue channel close during connection closure (expected - reconnection will handle)`);
+          } else {
+            // Log but don't throw - channel will be recreated on next use or during reconnection
+            console.warn(`[RabbitMQClient] [mq-client-core] Failed to recreate queue channel: ${err.message} (will be recreated on next use)`);
+          }
+        }
+      } else {
+        console.warn(`[RabbitMQClient] [mq-client-core] Queue channel closed - will be recreated during reconnection or on next use`);
+      }
+    });
+  }
+
+  /**
+   * Attach event handlers to consumer channel
+   * @private
+   */
+  _attachConsumerChannelHandlers(channel) {
+    channel.on('error', async (err) => {
+      const reason = `Consumer channel error: ${err.message} (code: ${err.code || 'unknown'})`;
+      channel._closeReason = reason;
+      console.warn(`[RabbitMQClient] [mq-client-core] ${reason}`);
+      this._callChannelCloseHooks('consumer', channel, err, reason);
+      await this._ensureConsumerChannel();
+      this.emit('error', err);
+    });
+    
+    channel.on('close', async () => {
+      const reason = channel._closeReason || 'Consumer channel closed unexpectedly';
+      console.warn(`[RabbitMQClient] [mq-client-core] ${reason} - will auto-recreate and re-register consumers`);
+      this._callChannelCloseHooks('consumer', channel, null, reason);
+      const closedChannel = this._consumerChannel;
+      this._consumerChannel = null;
+      
+      // Only try to recreate if connection is available
+      // If connection is closed, reconnection logic will handle channel recreation
+      if (this._connection && !this._connection.closed) {
+        try {
+          await this._ensureConsumerChannel();
+        } catch (err) {
+          // Ignore errors during channel recreation if connection is closing
+          console.warn(`[RabbitMQClient] [mq-client-core] Failed to recreate consumer channel (connection may be closing): ${err.message}`);
+        }
+      }
+    });
+  }
+
+  /**
+   * Check prefetch utilization for a queue and alert if threshold exceeded
+   * @private
+   * @param {string} queue - Queue name
+   * @param {Object} tracking - Prefetch tracking object
+   */
+  _checkPrefetchUtilization(queue, tracking) {
+    if (!tracking || tracking.prefetchCount === 0) {
+      return; // No prefetch set or tracking not available
+    }
+    
+    const utilization = tracking.inFlight / tracking.prefetchCount;
+    
+    if (utilization >= this._prefetchUtilizationThreshold) {
+      const message = `Prefetch utilization high: queue '${queue}' has ${tracking.inFlight}/${tracking.prefetchCount} messages in-flight (${Math.round(utilization * 100)}%, threshold: ${Math.round(this._prefetchUtilizationThreshold * 100)}%)`;
+      console.warn(`[RabbitMQClient] [mq-client-core] ⚠️ ${message}`);
+      
+      // Call alert callback if provided
+      if (this._prefetchAlertCallback) {
+        try {
+          this._prefetchAlertCallback(queue, utilization, tracking.inFlight, tracking.prefetchCount);
+        } catch (alertErr) {
+          console.error(`[RabbitMQClient] [mq-client-core] Prefetch alert callback error:`, alertErr.message);
+        }
+      }
+      
+      // Emit event for external listeners
+      this.emit('prefetch:high-utilization', {
+        queue,
+        utilization,
+        inFlight: tracking.inFlight,
+        prefetchCount: tracking.prefetchCount,
+        threshold: this._prefetchUtilizationThreshold,
+        timestamp: new Date().toISOString()
+      });
+    }
+  }
+
+  /**
+   * Start periodic prefetch monitoring
+   * @private
+   */
+  _startPrefetchMonitoring() {
+    if (this._prefetchCheckTimer) {
+      return; // Already started
+    }
+    
+    this._prefetchCheckTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [queue, tracking] of this._prefetchTracking.entries()) {
+        // Only check if we have recent activity (within last 30s)
+        if (now - tracking.lastCheck < 30000) {
+          this._checkPrefetchUtilization(queue, tracking);
+        }
+      }
+    }, this._prefetchCheckInterval);
+    
+    console.log(`[RabbitMQClient] [mq-client-core] Prefetch monitoring started (interval: ${this._prefetchCheckInterval}ms, threshold: ${Math.round(this._prefetchUtilizationThreshold * 100)}%)`);
+  }
+
+  /**
+   * Stop prefetch monitoring
+   * @private
+   */
+  _stopPrefetchMonitoring() {
+    if (this._prefetchCheckTimer) {
+      clearInterval(this._prefetchCheckTimer);
+      this._prefetchCheckTimer = null;
+    }
+  }
+
+  /**
+   * Track channel operation for debugging
+   * @private
+   * @param {Object} channel - Channel object
+   * @param {string} operation - Operation description
+   */
+  _trackChannelOperation(channel, operation) {
+    if (channel && typeof channel === 'object') {
+      channel._lastOperation = operation;
+    }
+  }
+
   /**
    * Acknowledges a message.
    * @param {Object} msg - RabbitMQ message object.