@onlineapps/conn-infra-mq 1.1.36 → 1.1.38

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.36",
+    "version": "1.1.38",
     "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}`);
@@ -330,63 +365,94 @@ 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
+      // CRITICAL: Use the SAME pattern as ensureQueue() - checkQueue() FIRST, then assertQueue() only if 404
+      // This prevents channel closure on 406 PRECONDITION-FAILED
+      // Pattern: checkQueue() -> if 404, assertQueue() -> if 406, use existing queue (channel stays open)
       let queueCreated = false;
+      
+      // Track operation on channel for debugging
+      if (channel && channel._lastOperation !== undefined) {
+        channel._lastOperation = `About to checkQueue ${queueName}`;
+      }
+      
       try {
-        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName} with options:`, JSON.stringify(queueOptions, null, 2));
+        console.log(`[QueueManager] DEBUG: About to checkQueue ${queueName} (same pattern as ensureQueue)`);
+        console.log(`[QueueManager] DEBUG: Channel state: exists=${!!channel}, closed=${channel ? (channel.closed === true ? 'true' : channel.closed === false ? 'false' : 'undefined') : 'N/A'}`);
         
-        await channel.assertQueue(queueName, queueOptions);
+        // CRITICAL: Use checkQueue() FIRST (same as ensureQueue() pattern)
+        // This prevents channel closure on 406 - if queue exists with different args, checkQueue() returns 406 but channel stays open
+        await channel.checkQueue(queueName);
         
-        console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}`);
+        // Queue exists - use it
+        console.log(`[QueueManager] DEBUG: checkQueue succeeded - queue ${queueName} exists`);
+        if (channel && channel._lastOperation !== undefined) {
+          channel._lastOperation = `checkQueue ${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.info(`[QueueManager] ✓ Business queue exists: ${queueName}`);
+      } catch (checkErr) {
+        console.log(`[QueueManager] DEBUG: checkQueue failed for ${queueName}:`, checkErr.message);
+        console.log(`[QueueManager] DEBUG: Error code: ${checkErr.code}`);
+        
+        // Check if channel is still open
+        if (!channel || channel.closed) {
+          throw new Error('Channel closed during checkQueue - cannot verify queue');
+        }
         
-        // 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
-        if (assertErr.code === 406) {
-          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406), channel will be closed. Recreating channel...`);
+        // If queue doesn't exist (404), create it using assertQueue
+        if (checkErr.code === 404) {
+          console.log(`[QueueManager] DEBUG: Queue ${queueName} doesn't exist (404), creating with assertQueue...`);
           
-          // Recreate channel IMMEDIATELY - 406 closes it synchronously
-          try {
-            // Wait a tiny bit for channel close event to propagate
-            await new Promise(resolve => setImmediate(resolve));
-            channel = await transport._connection.createChannel();
-            transport.queueChannel = channel;
-            console.log(`[QueueManager] DEBUG: Channel recreated after 406 for ${queueName}`);
-          } catch (recreateErr) {
-            throw new Error(`Failed to recreate channel after 406 for ${queueName}: ${recreateErr.message}`);
+          if (channel && channel._lastOperation !== undefined) {
+            channel._lastOperation = `About to assertQueue ${queueName} (queue doesn't exist)`;
           }
           
-          // 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}`);
+          try {
+            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) {
+            // If channel closed during assertQueue, it's a real error
+            if (!channel || channel.closed) {
+              throw new Error(`Channel closed during assertQueue for ${queueName} - check channel management`);
             }
-            // 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}`);
+            
+            // If 406 PRECONDITION-FAILED, queue exists with different args (race condition?)
+            if (assertErr.code === 406) {
+              console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406 from assertQueue):`, assertErr.message);
+              // Channel should still be open - try checkQueue to verify
+              if (!channel || channel.closed) {
+                throw new Error('Channel closed - cannot check existing queue');
+              }
+              try {
+                await channel.checkQueue(queueName);
+                queues[queueInfo.type] = queueName;
+                queueCreated = true;
+                console.info(`[QueueManager] ✓ Business queue exists (verified): ${queueName}`);
+              } catch (verifyErr) {
+                throw new Error(`Failed to verify existing queue ${queueName}: ${verifyErr.message}`);
+              }
+            } else {
+              // Other errors - rethrow
+              throw assertErr;
             }
-          } else {
-            // Other error - critical, cannot continue
-            throw new Error(`Failed to create business queue ${queueName}: ${assertErr.message}`);
           }
+        } else if (checkErr.code === 406) {
+          // Queue exists with different args (406 from checkQueue) - use it as-is
+          // CRITICAL: checkQueue() on 406 does NOT close channel (unlike assertQueue() on 406)
+          console.warn(`[QueueManager] Queue ${queueName} exists with different arguments (406 from checkQueue), using as-is:`, checkErr.message);
+          queues[queueInfo.type] = queueName;
+          queueCreated = true;
+          console.info(`[QueueManager] ✓ Business queue exists (different args): ${queueName}`);
+        } else {
+          // Other error - rethrow
+          throw checkErr;
         }
       }
       

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) {