@onlineapps/mq-client-core 1.0.36 → 1.0.38

package/src/transports/rabbitmqClient.js

@@ -8,6 +8,15 @@
 
 const amqp = require('amqplib');
 const EventEmitter = require('events');
+const {
+  TransientPublishError,
+  PermanentPublishError,
+  QueueNotFoundError,
+  classifyPublishError,
+} = require('../utils/publishErrors');
+const PublishLayer = require('../layers/PublishLayer');
+const RecoveryWorker = require('../workers/RecoveryWorker');
+const PublishMonitor = require('../monitoring/PublishMonitor');
 
 class RabbitMQClient extends EventEmitter {
   /**
@@ -39,13 +48,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
@@ -57,6 +97,89 @@ class RabbitMQClient extends EventEmitter {
     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
+
+    // Publish layer (retry + buffer)
+    this._publishLayer = new PublishLayer({
+      client: this,
+      logger: console,
+      bufferConfig: {
+        inMemory: {
+          maxSize: this._config.publishBufferMaxSize || 100,
+          ttlMs: this._config.publishBufferTtlMs || 5 * 60 * 1000,
+        },
+        persistent: {
+          enabled: !!this._config.persistentBufferEnabled,
+          redisClient: this._config.persistentRedisClient || null,
+        },
+      },
+    });
+
+    // Recovery worker (connection recovery, queue creation pro business)
+    this._recoveryWorker = new RecoveryWorker({
+      client: this,
+      scope: this._config.recoveryScope || 'infrastructure',
+      queueCreationFilter: this._config.queueCreationFilter || null,
+      logger: console,
+    });
+
+    // Publish monitor (metriky)
+    this._publishMonitor = new PublishMonitor({
+      logger: console,
+    });
+
+    // Event listeners pro monitoring
+    this._setupPublishMonitoring();
+  }
+
+  /**
+   * Setup event listeners pro monitoring a recovery
+   * @private
+   */
+  _setupPublishMonitoring() {
+    // Monitoring events
+    this.on('publish:retry', (data) => {
+      if (data.attempt === 1) {
+        this._publishMonitor.trackAttempt(data.queue);
+      }
+    });
+
+    this.on('publish:success', (data) => {
+      this._publishMonitor.trackSuccess(data.queue, data.totalAttempts);
+    });
+
+    this.on('publish:failed', (data) => {
+      this._publishMonitor.trackFailure(data.queue, data.retryable);
+    });
+
+    // Track buffered messages
+    this.on('publish:buffered', () => {
+      this._publishMonitor.trackBuffered();
+    });
+
+    // Recovery worker - handle QueueNotFoundError via error event
+    this.on('error', async (err) => {
+      if (err instanceof QueueNotFoundError) {
+        try {
+          await this._recoveryWorker.handleQueueNotFound(err, { queue: err.queueName });
+        } catch (recoveryErr) {
+          // Recovery failed - error already thrown
+        }
+      }
+    });
+  }
+
+  /**
+   * Get publish metrics
+   */
+  getPublishMetrics() {
+    return this._publishMonitor.getMetrics();
+  }
+
+  /**
+   * Get Prometheus metrics
+   */
+  getPrometheusMetrics() {
+    return this._publishMonitor.getPrometheusMetrics();
   }
 
   /**
@@ -91,6 +214,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 +293,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 +348,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 +393,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 +406,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 +419,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 +440,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 +496,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,36 +536,29 @@ 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) {
       this._channel = null;
-      throw new Error(`Failed to recreate publisher channel: ${err.message}`);
+
+      const msg = err && err.message ? err.message : String(err);
+
+      // Pokud se connection právě zavírá, považujeme to za přechodný stav – explicitně vyhodíme
+      // TransientPublishError, aby vyšší vrstva (retry / worker) věděla, že má počkat na reconnect.
+      if (msg.includes('Connection closing') || msg.includes('Connection closed')) {
+        console.warn(
+          `[RabbitMQClient] [mq-client-core] Failed to recreate publisher channel (connection closing): ${msg}`
+        );
+        throw new TransientPublishError(
+          'Publisher channel cannot be recreated because connection is closing/closed (transient condition)',
+          err
+        );
+      }
+
+      // Ostatní chyby považujeme za permanentní problém na úrovni kanálu/spojení.
+      throw new PermanentPublishError(`Failed to recreate publisher channel: ${msg}`, err);
     }
   }
 
@@ -369,7 +574,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 +600,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 +627,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 +653,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 +916,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 +956,36 @@ 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 = {}) {
+    // PublishLayer zachovává stávající retry logiku a přidává možnost bufferování a
+    // jasnější klasifikaci chyb. API zůstává stejné.
+    return await this._publishLayer.publish(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();
     
@@ -812,9 +1014,10 @@ class RabbitMQClient extends EventEmitter {
           await this._queueChannel.checkQueue(queue);
           // Queue exists - proceed to publish
         } catch (checkErr) {
-          // If queue doesn't exist (404), this is an ERROR for infrastructure queues
-          // Infrastructure queues (workflow.*, registry.*, infrastructure.*, monitoring.*, validation.*) must be created explicitly with correct arguments
-          // We should NOT auto-create them here, as we don't have access to queueConfig in mq-client-core
+          // If queue doesn't exist (404), this je ERROR – ale rozlišujeme infra vs. non-infra:
+          // - Infrastructure queues (workflow.*, registry.*, infrastructure.*, monitoring.*, validation.*)
+          //   musí být vytvořené infra službami předem → QueueNotFoundError(isInfrastructure=true)
+          // - Non-infrastructure queues můžeme (pro business scénáře) vytvořit s default parametry
           if (checkErr.code === 404) {
             // Check if this is an infrastructure queue using queueConfig
             let isInfraQueue = false;
@@ -831,7 +1034,8 @@ class RabbitMQClient extends EventEmitter {
             }
             
             if (isInfraQueue) {
-              throw new Error(`Cannot publish to infrastructure queue ${queue}: queue does not exist. Infrastructure queues must be created explicitly with correct arguments (TTL, max-length, etc.) before publishing.`);
+              // Jasný, hlasitý signál pro infra služby – fronta chybí, je to programátorská chyba
+              throw new QueueNotFoundError(queue, true, checkErr);
             }
             // For non-infrastructure queues, allow auto-creation with default options
             const queueOptions = options.queueOptions || { durable: this._config.durable };
@@ -849,16 +1053,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 +1160,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);
@@ -883,23 +1180,30 @@ class RabbitMQClient extends EventEmitter {
         await confirmPromise;
       }
     } catch (err) {
-      // 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, recreating and retrying...');
+      // Pokud je kanál zavřený, stále se pokusíme o jedno interní obnovení a retry,
+      // aby byl publish co nejodolnější i předtím, než vstoupí do vyšší retry/recovery vrstvy.
+      if (err && 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, recreating and retrying once...');
         try {
           await this._ensurePublisherChannel();
-          // Retry publish once
+          // Retry publish once (může znovu vyhodit – už dojde do retry/recovery vrstvy)
           return await this.publish(queue, buffer, options);
         } catch (retryErr) {
-          console.error('[RabbitMQClient] [mq-client-core] [PUBLISH] Retry failed:', retryErr.message);
-          throw retryErr;
+          console.error('[RabbitMQClient] [mq-client-core] [PUBLISH] Retry after channel recreation failed:', retryErr.message);
+          const classifiedRetryErr = classifyPublishError(retryErr);
+          this.emit('error', classifiedRetryErr);
+          throw classifiedRetryErr;
         }
       }
-      this.emit('error', err);
-      throw err;
+
+      // Všechny ostatní chyby projdou jednotnou klasifikací do Transient/Permanent/QueueNotFound.
+      const classifiedErr = classifyPublishError(err);
+      this.emit('error', classifiedErr);
+      throw classifiedErr;
     }
   }
 
+
   /**
    * Starts consuming messages from the specified queue.
    * @param {string} queue                         - Queue name to consume from.
@@ -919,6 +1223,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 +1245,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 +1297,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 +1325,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 +1353,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 +1420,375 @@ 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');
+        
+        // Flush buffered messages po reconnectu
+        try {
+          const flushResult = await this._publishLayer.flushBuffered();
+          this._publishMonitor.trackFlushed(flushResult.inMemory + flushResult.persistent);
+          console.log(`[RabbitMQClient] ✓ Flushed ${flushResult.inMemory + flushResult.persistent} buffered messages after reconnection`);
+        } catch (flushErr) {
+          console.warn(`[RabbitMQClient] Failed to flush buffered messages after reconnection: ${flushErr.message}`);
+        }
+        
+        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.