@onlineapps/conn-infra-mq 1.1.36 → 1.1.37

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.36",
+    "version": "1.1.37",
     "description": "A promise-based, broker-agnostic client for sending and receiving messages via RabbitMQ",
     "main": "src/index.js",
     "repository": {

package/src/layers/QueueManager.js

@@ -249,29 +249,64 @@ class QueueManager {
     for (const queueInfo of queueNames) {
       // CRITICAL: Check if channel is closed before each queue operation (may have been closed by previous 406)
       // Channel closes SYNCHRONOUSLY on 406, so we must check before each assertQueue
-      // amqplib's channel.closed may be undefined, so we test by trying a no-op operation
+      // We check channel state directly - if it's null or closed, recreate it
       if (!channel) {
         console.warn(`[QueueManager] DEBUG: Channel is null before ${queueInfo.name}, recreating...`);
         channel = await transport._connection.createChannel();
+        channel._createdAt = new Date().toISOString();
+        channel._closeReason = null;
+        channel._lastOperation = `Recreated (was null) before ${queueInfo.name}`;
+        
+        channel.on('error', (err) => {
+          console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
+          channel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+        });
+        channel.on('close', () => {
+          console.error('[RabbitMQClient] Recreated queue channel closed');
+          console.error('[RabbitMQClient] Close reason:', channel._closeReason || 'Unknown');
+        });
+        
         transport.queueChannel = channel;
         console.log(`[QueueManager] DEBUG: Channel recreated (was null) before ${queueInfo.name}`);
       } else {
-        // Test if channel is usable by trying a no-op (checkQueue on a known queue)
-        // This will throw if channel is closed
+        // Check if channel is closed - amqplib may not set closed property immediately
+        // We check by trying to access channel properties - if it throws, channel is closed
         let channelUsable = false;
         try {
-          // Try to check a queue that definitely exists (workflow.init) - this tests channel usability
-          // If channel is closed, this will throw immediately
-          await channel.checkQueue('workflow.init');
+          // Check if channel has closed property set to true
+          if (channel.closed === true) {
+            console.warn(`[QueueManager] DEBUG: Channel.closed === true before ${queueInfo.name}, recreating...`);
+            throw new Error('Channel closed property is true');
+          }
+          
+          // Channel exists and closed is not true - assume it's usable
+          // We don't test with checkQueue() because that can also close channel on 404
           channelUsable = true;
-          console.log(`[QueueManager] DEBUG: Channel is usable before ${queueInfo.name}`);
+          console.log(`[QueueManager] DEBUG: Channel appears usable before ${queueInfo.name} (closed=${channel.closed})`);
         } catch (testErr) {
           // Channel is closed or unusable - recreate it
-          console.warn(`[QueueManager] DEBUG: Channel test failed before ${queueInfo.name} (${testErr.message}), recreating...`);
+          console.warn(`[QueueManager] DEBUG: Channel check failed before ${queueInfo.name} (${testErr.message}), recreating...`);
+          console.warn(`[QueueManager] DEBUG: Channel close reason: ${channel._closeReason || 'N/A'}`);
+          console.warn(`[QueueManager] DEBUG: Channel last operation: ${channel._lastOperation || 'N/A'}`);
+          
           try {
-            channel = await transport._connection.createChannel();
+            const newChannel = await transport._connection.createChannel();
+            newChannel._createdAt = new Date().toISOString();
+            newChannel._closeReason = null;
+            newChannel._lastOperation = `Recreated (check failed) before ${queueInfo.name}`;
+            
+            newChannel.on('error', (err) => {
+              console.error('[RabbitMQClient] Recreated queue channel error:', err.message);
+              newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+            });
+            newChannel.on('close', () => {
+              console.error('[RabbitMQClient] Recreated queue channel closed');
+              console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
+            });
+            
+            channel = newChannel;
             transport.queueChannel = channel;
-            console.log(`[QueueManager] DEBUG: Channel recreated (test failed) before ${queueInfo.name}`);
+            console.log(`[QueueManager] DEBUG: Channel recreated (check failed) before ${queueInfo.name}`);
             channelUsable = true;
           } catch (recreateErr) {
             throw new Error(`Failed to recreate channel before ${queueInfo.name}: ${recreateErr.message}`);
@@ -332,61 +367,108 @@ class QueueManager {
       
       // CRITICAL: Use assertQueue directly - if queue exists with different args (406), that's OK
       // BUT: 406 PRECONDITION-FAILED closes the channel in amqplib!
-      // Solution: Catch 406, recreate channel immediately, and continue
+      // Solution: Track channel state, catch 406, recreate channel immediately, and continue
       let queueCreated = false;
+      
+      // CRITICAL: Track operation on channel for debugging
+      if (channel && channel._lastOperation !== undefined) {
+        channel._lastOperation = `About to assertQueue ${queueName}`;
+      }
+      
       try {
-        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName} with options:`, JSON.stringify(queueOptions, null, 2));
+        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName}`);
+        console.log(`[QueueManager] DEBUG: Channel state: exists=${!!channel}, closed=${channel ? (channel.closed === true ? 'true' : channel.closed === false ? 'false' : 'undefined') : 'N/A'}`);
+        console.log(`[QueueManager] DEBUG: Channel created at: ${channel?._createdAt || 'N/A'}`);
+        console.log(`[QueueManager] DEBUG: Queue options:`, JSON.stringify(queueOptions, null, 2));
         
         await channel.assertQueue(queueName, queueOptions);
         
         console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}`);
+        if (channel && channel._lastOperation !== undefined) {
+          channel._lastOperation = `assertQueue ${queueName} succeeded`;
+        }
         queues[queueInfo.type] = queueName;
         queueCreated = true;
         console.info(`[QueueManager] ✓ Created business queue: ${queueName}`);
       } catch (assertErr) {
         console.error(`[QueueManager] DEBUG: assertQueue failed for ${queueName}:`, assertErr.message);
         console.error(`[QueueManager] DEBUG: Error code: ${assertErr.code}`);
+        console.error(`[QueueManager] DEBUG: Channel state after error: exists=${!!channel}, closed=${channel ? (channel.closed === true ? 'true' : channel.closed === false ? 'false' : 'undefined') : 'N/A'}`);
+        console.error(`[QueueManager] DEBUG: Channel close reason: ${channel?._closeReason || 'N/A'}`);
         
         // If 406 PRECONDITION-FAILED, queue exists with different args - channel is closed, recreate it IMMEDIATELY
-        // CRITICAL: amqplib closes channel on 406, so we MUST recreate it to continue
+        // CRITICAL: amqplib closes channel on 406 SYNCHRONOUSLY, so we MUST recreate it to continue
         if (assertErr.code === 406) {
-          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406), channel will be closed. Recreating channel...`);
+          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406), channel WILL BE CLOSED. Recreating channel IMMEDIATELY...`);
           
-          // Recreate channel IMMEDIATELY - 406 closes it synchronously
+          // CRITICAL: Channel is already closed by amqplib at this point
+          // We MUST create a new channel before continuing
           try {
             // Wait a tiny bit for channel close event to propagate
             await new Promise(resolve => setImmediate(resolve));
-            channel = await transport._connection.createChannel();
+            
+            // Create new channel
+            const newChannel = await transport._connection.createChannel();
+            newChannel._createdAt = new Date().toISOString();
+            newChannel._closeReason = null;
+            newChannel._lastOperation = `Recreated after 406 for ${queueName}`;
+            
+            // Set up error/close handlers for new channel
+            newChannel.on('error', (err) => {
+              console.error('[RabbitMQClient] New queue channel error:', err.message);
+              newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+            });
+            newChannel.on('close', () => {
+              console.error('[RabbitMQClient] New queue channel closed');
+              console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
+            });
+            
+            // Update references
+            channel = newChannel;
             transport.queueChannel = channel;
+            
             console.log(`[QueueManager] DEBUG: Channel recreated after 406 for ${queueName}`);
+            console.log(`[QueueManager] DEBUG: New channel created at: ${channel._createdAt}`);
           } catch (recreateErr) {
+            console.error(`[QueueManager] DEBUG: Failed to recreate channel after 406:`, recreateErr.message);
             throw new Error(`Failed to recreate channel after 406 for ${queueName}: ${recreateErr.message}`);
           }
           
           // Queue exists (just with different args) - accept it
           queues[queueInfo.type] = queueName;
           queueCreated = true;
-        } else {
-          // Other error - check if it's a channel closed error
-          if (assertErr.message && assertErr.message.includes('Channel closed')) {
-            console.error(`[QueueManager] DEBUG: Channel was closed during assertQueue for ${queueName}, recreating...`);
-            // Try to recreate channel
-            try {
-              await new Promise(resolve => setImmediate(resolve));
-              channel = await transport._connection.createChannel();
-              transport.queueChannel = channel;
-              console.log(`[QueueManager] DEBUG: Channel recreated after channel closed error for ${queueName}`);
-            } catch (recreateErr) {
-              throw new Error(`Channel closed during assertQueue for ${queueName} and failed to recreate: ${recreateErr.message}`);
-            }
-            // Retry assertQueue with new channel (but only if it's not 406)
-            if (assertErr.code !== 406) {
-              throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
-            }
-          } else {
-            // Other error - critical, cannot continue
-            throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
+        } else if (assertErr.message && assertErr.message.includes('Channel closed')) {
+          // Channel closed error (not 406) - recreate channel
+          console.error(`[QueueManager] DEBUG: Channel was closed during assertQueue for ${queueName} (not 406), recreating...`);
+          try {
+            await new Promise(resolve => setImmediate(resolve));
+            
+            const newChannel = await transport._connection.createChannel();
+            newChannel._createdAt = new Date().toISOString();
+            newChannel._closeReason = null;
+            newChannel._lastOperation = `Recreated after channel closed error for ${queueName}`;
+            
+            newChannel.on('error', (err) => {
+              console.error('[RabbitMQClient] New queue channel error:', err.message);
+              newChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
+            });
+            newChannel.on('close', () => {
+              console.error('[RabbitMQClient] New queue channel closed');
+              console.error('[RabbitMQClient] Close reason:', newChannel._closeReason || 'Unknown');
+            });
+            
+            channel = newChannel;
+            transport.queueChannel = channel;
+            
+            console.log(`[QueueManager] DEBUG: Channel recreated after channel closed error for ${queueName}`);
+          } catch (recreateErr) {
+            throw new Error(`Channel closed during assertQueue for ${queueName} and failed to recreate: ${recreateErr.message}`);
           }
+          // Don't set queueCreated - this is a real error, not a 406
+          throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
+        } else {
+          // Other error - critical, cannot continue
+          throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
         }
       }
       

package/src/transports/rabbitmqClient.js

@@ -78,13 +78,26 @@ class RabbitMQClient extends EventEmitter {
       // Create a separate regular channel for queue operations (assertQueue, checkQueue)
       // This avoids RPC reply queue issues with ConfirmChannel.assertQueue()
       this._queueChannel = await this._connection.createChannel();
+      
+      // CRITICAL: Track channel state and close reason
+      this._queueChannel._createdAt = new Date().toISOString();
+      this._queueChannel._closeReason = null;
+      this._queueChannel._lastOperation = null;
+      
       this._queueChannel.on('error', (err) => {
         // Log but don't emit - queue channel errors are less critical
         console.error('[RabbitMQClient] Queue channel error:', err.message);
+        console.error('[RabbitMQClient] Error code:', err.code);
+        console.error('[RabbitMQClient] Channel created at:', this._queueChannel._createdAt);
+        console.error('[RabbitMQClient] Last operation:', this._queueChannel._lastOperation);
         console.error('[RabbitMQClient] Stack trace:', new Error().stack);
+        this._queueChannel._closeReason = `Error: ${err.message} (code: ${err.code})`;
       });
       this._queueChannel.on('close', () => {
         console.error('[RabbitMQClient] Queue channel closed');
+        console.error('[RabbitMQClient] Channel created at:', this._queueChannel._createdAt);
+        console.error('[RabbitMQClient] Close reason:', this._queueChannel._closeReason || 'Unknown');
+        console.error('[RabbitMQClient] Last operation:', this._queueChannel._lastOperation);
         console.error('[RabbitMQClient] Stack trace at close:', new Error().stack);
       });
     } catch (err) {