@onlineapps/conn-infra-mq 1.1.48 → 1.1.50

package/package.json

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

package/src/layers/QueueManager.js

@@ -209,6 +209,12 @@ class QueueManager {
    * @param {Object} options - Configuration options
    */
   async setupServiceQueues(serviceName, options = {}) {
+    const setupStartTime = Date.now();
+    const setupStartTimeISO = new Date().toISOString();
+    
+    console.log(`[QueueManager] [SETUP] Starting setupServiceQueues() for service: ${serviceName} at ${setupStartTimeISO}`);
+    console.log(`[QueueManager] [SETUP] Options:`, JSON.stringify(options));
+    
     const transport = this.client._transport;
     if (!transport || !transport.channel) {
       throw new Error('MQ client not connected');
@@ -218,6 +224,9 @@ class QueueManager {
     // If channel is closed, we cannot continue - this is a critical error
     let channel = transport.queueChannel || transport.channel;
     
+    console.log(`[QueueManager] [SETUP] Channel state: exists=${!!channel}, closed=${channel ? channel.closed : 'N/A'}`);
+    console.log(`[QueueManager] [SETUP] QueueChannel exists: ${!!transport.queueChannel}, MainChannel exists: ${!!transport.channel}`);
+    
     if (!channel || channel.closed) {
       throw new Error('Queue channel is not available or closed - cannot create business queues');
     }
@@ -231,6 +240,8 @@ class QueueManager {
     if (options.includeWorkflow !== false) {
       queueNames.push({ name: `${serviceName}.workflow`, type: 'workflow' });
     }
+    
+    console.log(`[QueueManager] [SETUP] Will create ${queueNames.length} queues:`, queueNames.map(q => q.name).join(', '));
 
     // CRITICAL: Create ALL queues using assertQueue directly (no checkQueue first to avoid channel closure)
     // This ensures all queues are created atomically
@@ -384,9 +395,13 @@ class QueueManager {
       let queueCreated = false;
       
       try {
-        console.log(`[QueueManager] DEBUG: About to assertQueue ${queueName} with correct arguments`);
-        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: Queue options:`, JSON.stringify(queueOptions));
+        const assertStartTime = Date.now();
+        console.log(`[QueueManager] [QUEUE] Starting assertQueue for: ${queueName} at ${new Date().toISOString()}`);
+        console.log(`[QueueManager] [QUEUE] Queue type: ${queueInfo.type}`);
+        console.log(`[QueueManager] [QUEUE] Channel state: exists=${!!channel}, closed=${channel ? (channel.closed === true ? 'true' : channel.closed === false ? 'false' : 'undefined') : 'N/A'}`);
+        console.log(`[QueueManager] [QUEUE] Channel created at: ${channel._createdAt || 'N/A'}`);
+        console.log(`[QueueManager] [QUEUE] Channel last operation: ${channel._lastOperation || 'N/A'}`);
+        console.log(`[QueueManager] [QUEUE] Queue options:`, JSON.stringify(queueOptions, null, 2));
         
         // CRITICAL: Use assertQueue() DIRECTLY - it's idempotent
         // If queue doesn't exist → creates it
@@ -394,8 +409,10 @@ class QueueManager {
         // If queue exists with different params → 406, channel closes (should not happen now, but handle it)
         await channel.assertQueue(queueName, queueOptions);
         
+        const assertEndTime = Date.now();
         // Queue created or already exists with same params
-        console.log(`[QueueManager] DEBUG: assertQueue succeeded for ${queueName}`);
+        console.log(`[QueueManager] [QUEUE] ✓ assertQueue succeeded for ${queueName} (took ${assertEndTime - assertStartTime}ms)`);
+        console.log(`[QueueManager] [QUEUE] Queue created/verified at: ${new Date().toISOString()}`);
         if (channel && channel._lastOperation !== undefined) {
           channel._lastOperation = `assertQueue ${queueName} succeeded`;
         }
@@ -528,6 +545,10 @@ class QueueManager {
       }
     }
 
+    const setupEndTime = Date.now();
+    console.log(`[QueueManager] [SETUP] ✓ setupServiceQueues completed successfully at ${new Date().toISOString()} (total time: ${setupEndTime - setupStartTime}ms)`);
+    console.log(`[QueueManager] [SETUP] Created queues:`, Object.keys(queues).map(k => `${k}=${queues[k]}`).join(', '));
+    console.log(`[QueueManager] [SETUP] Channel state after setup: closed=${channel ? channel.closed : 'N/A'}`);
     console.log(`[QueueManager] DEBUG: setupServiceQueues completed successfully, channel closed=${channel.closed}`);
     return queues;
   }

package/src/transports/rabbitmqClient.js

@@ -68,22 +68,39 @@ class RabbitMQClient extends EventEmitter {
 
       // Use ConfirmChannel to enable publisher confirms for publish operations
       // BUT: Create a separate regular channel for queue operations to avoid RPC reply queue issues
+      const channelStartTime = Date.now();
       this._channel = await this._connection.createConfirmChannel();
-      this._channel.on('error', (err) => this.emit('error', err));
+      const channelEndTime = Date.now();
+      const channelCreatedAt = new Date().toISOString();
+      
+      console.log(`[RabbitMQClient] [CHANNEL] Created ConfirmChannel at ${channelCreatedAt} (took ${channelEndTime - channelStartTime}ms)`);
+      console.log(`[RabbitMQClient] [CHANNEL] ConfirmChannel state: closed=${this._channel.closed}`);
+      
+      this._channel.on('error', (err) => {
+        console.error(`[RabbitMQClient] [CHANNEL] ConfirmChannel error at ${new Date().toISOString()}:`, err.message, err.code);
+        this.emit('error', err);
+      });
       this._channel.on('close', () => {
+        console.error(`[RabbitMQClient] [CHANNEL] ConfirmChannel closed at ${new Date().toISOString()}`);
+        console.error(`[RabbitMQClient] [CHANNEL] Channel was created at: ${channelCreatedAt}`);
         // Emit a channel close error
         this.emit('error', new Error('RabbitMQ channel closed unexpectedly'));
       });
       
       // Create a separate regular channel for queue operations (assertQueue, checkQueue)
       // This avoids RPC reply queue issues with ConfirmChannel.assertQueue()
+      const queueChannelStartTime = Date.now();
       this._queueChannel = await this._connection.createChannel();
+      const queueChannelEndTime = Date.now();
       
       // CRITICAL: Track channel state and close reason
       this._queueChannel._createdAt = new Date().toISOString();
       this._queueChannel._closeReason = null;
       this._queueChannel._lastOperation = null;
       
+      console.log(`[RabbitMQClient] [CHANNEL] Created queueChannel at ${this._queueChannel._createdAt} (took ${queueChannelEndTime - queueChannelStartTime}ms)`);
+      console.log(`[RabbitMQClient] [CHANNEL] QueueChannel state: closed=${this._queueChannel.closed}, connection=${this._connection ? 'connected' : '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);
@@ -277,33 +294,71 @@ class RabbitMQClient extends EventEmitter {
       // Skip assertQueue for reply queues (they're already created with specific settings)
       // Reply queues start with 'rpc.reply.' and are created as non-durable
       if (!queue.startsWith('rpc.reply.')) {
-        // Check if this is an infrastructure queue - services should NEVER create these
+        // CRITICAL: amqplib's channel.consume() may internally call assertQueue() without parameters
+        // This causes 406 errors if queue exists with different arguments
+        // Solution: Explicitly assertQueue() with correct parameters BEFORE consume()
         const isInfraQueue = queueConfig.isInfrastructureQueue(queue);
+        const isBusinessQueue = queueConfig.isBusinessQueue(queue);
+        
+        let queueOptions = { durable };
         
         if (isInfraQueue) {
-          // Infrastructure queue - should already exist, created by infrastructure initialization
-          // CRITICAL: Do NOT use checkQueue() - it closes channel on 406 if queue exists with different args
-          // Just proceed to consume() - if queue doesn't exist, consume() will fail with clear error
-          // This avoids channel closure from checkQueue() on infrastructure queues
-          console.log(`[RabbitMQClient] DEBUG: Infrastructure queue ${queue}, skipping checkQueue() - queue should already exist (created by infrastructure initialization)`);
-        } else {
-          // Business queue - should already be created by setupServiceQueues() BEFORE consume is called
-          // CRITICAL: Do NOT use checkQueue() - it closes channel on 404!
-          // If queue doesn't exist, that's a programming error (setupServiceQueues() should have created it)
-          // Just proceed to consume - if queue doesn't exist, consume will fail with a clear error
-          // This avoids channel closure from checkQueue() on non-existent queues
-          console.log(`[RabbitMQClient] DEBUG: Business queue ${queue}, skipping checkQueue() - queue should already exist`);
+          // Infrastructure queue - use central config
+          try {
+            const infraConfig = queueConfig.getInfrastructureQueueConfig(queue);
+            queueOptions = {
+              durable: infraConfig.durable !== false,
+              arguments: { ...infraConfig.arguments }
+            };
+            console.log(`[RabbitMQClient] [CONSUMER] Asserting infrastructure queue ${queue} with config from queueConfig`);
+          } catch (configErr) {
+            console.warn(`[RabbitMQClient] [CONSUMER] Infrastructure queue config not found for ${queue}, using default:`, configErr.message);
+          }
+        } else if (isBusinessQueue) {
+          // Business queue - use central config
+          try {
+            const parsed = queueConfig.parseBusinessQueue(queue);
+            if (parsed) {
+              const businessConfig = queueConfig.getBusinessQueueConfig(parsed.queueType, parsed.serviceName);
+              queueOptions = {
+                durable: businessConfig.durable !== false,
+                arguments: { ...businessConfig.arguments }
+              };
+              console.log(`[RabbitMQClient] [CONSUMER] Asserting business queue ${queue} with config from queueConfig`);
+            }
+          } catch (configErr) {
+            console.warn(`[RabbitMQClient] [CONSUMER] Business queue config not found for ${queue}, using default:`, configErr.message);
+          }
         }
+        
+        // CRITICAL: Assert queue with correct parameters BEFORE consume()
+        // This prevents amqplib from calling assertQueue() internally without parameters
+        const assertStartTime = Date.now();
+        console.log(`[RabbitMQClient] [CONSUMER] Asserting queue ${queue} before consume() at ${new Date().toISOString()}`);
+        console.log(`[RabbitMQClient] [CONSUMER] Queue options:`, JSON.stringify(queueOptions, null, 2));
+        
+        // Use queueChannel for assertQueue to avoid RPC reply queue issues
+        const channelForAssert = this._queueChannel || this._channel;
+        await channelForAssert.assertQueue(queue, queueOptions);
+        
+        const assertEndTime = Date.now();
+        console.log(`[RabbitMQClient] [CONSUMER] ✓ Queue ${queue} asserted (took ${assertEndTime - assertStartTime}ms)`);
       }
       // Set prefetch if provided
       if (typeof prefetch === 'number') {
         this._channel.prefetch(prefetch);
       }
 
-      await this._channel.consume(
+      const consumeStartTime = Date.now();
+      console.log(`[RabbitMQClient] [CONSUMER] Starting consume() for queue: ${queue} at ${new Date().toISOString()}`);
+      console.log(`[RabbitMQClient] [CONSUMER] Options: prefetch=${prefetch}, noAck=${noAck}, durable=${durable}`);
+      console.log(`[RabbitMQClient] [CONSUMER] Channel state before consume: closed=${this._channel.closed}`);
+      
+      const consumeResult = await this._channel.consume(
         queue,
         async (msg) => {
           if (msg === null) {
+            console.log(`[RabbitMQClient] [CONSUMER] Received null message (queue ${queue} was deleted or connection closed)`);
             return;
           }
           try {
@@ -312,12 +367,31 @@ class RabbitMQClient extends EventEmitter {
               this._channel.ack(msg);
             }
           } catch (handlerErr) {
+            console.error(`[RabbitMQClient] [CONSUMER] Error processing message from ${queue}:`, handlerErr.message);
             // Negative acknowledge and requeue by default
             this._channel.nack(msg, false, true);
           }
         },
         { noAck }
       );
+      
+      const consumeEndTime = Date.now();
+      const consumerTag = consumeResult.consumerTag;
+      console.log(`[RabbitMQClient] [CONSUMER] ✓ Consumer created for queue: ${queue} at ${new Date().toISOString()} (took ${consumeEndTime - consumeStartTime}ms)`);
+      console.log(`[RabbitMQClient] [CONSUMER] ConsumerTag: ${consumerTag}`);
+      console.log(`[RabbitMQClient] [CONSUMER] Channel state after consume: closed=${this._channel.closed}`);
+      
+      // Store consumerTag for cleanup tracking
+      if (!this._consumers) {
+        this._consumers = new Map();
+      }
+      this._consumers.set(queue, {
+        consumerTag,
+        createdAt: new Date().toISOString(),
+        queue,
+        prefetch,
+        noAck
+      });
     } catch (err) {
       this.emit('error', err);
       throw err;