@onlineapps/conn-infra-mq 1.1.47 → 1.1.49

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@onlineapps/conn-infra-mq",
-    "version": "1.1.47",
+    "version": "1.1.49",
     "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);
@@ -282,22 +299,10 @@ class RabbitMQClient extends EventEmitter {
         
         if (isInfraQueue) {
           // Infrastructure queue - should already exist, created by infrastructure initialization
-          // Use queueChannel (regular channel) for queue operations to avoid RPC reply queue issues
-          // Only check if it exists, don't try to create or assert with arguments
-          console.log(`[RabbitMQClient] DEBUG: Infrastructure queue ${queue}, checking existence...`);
-          try {
-            await this._queueChannel.checkQueue(queue);
-            console.log(`[RabbitMQClient] DEBUG: Infrastructure queue ${queue} exists`);
-            // Queue exists - proceed to consume
-          } catch (checkErr) {
-            console.error(`[RabbitMQClient] DEBUG: checkQueue failed for infrastructure queue ${queue}:`, checkErr.message);
-            if (checkErr.code === 404) {
-              // Queue doesn't exist - infrastructure problem
-              throw new Error(`Infrastructure queue '${queue}' not found. Queue should be created during infrastructure initialization.`);
-            }
-            // Other error - rethrow
-            throw checkErr;
-          }
+          // 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!
@@ -312,10 +317,16 @@ class RabbitMQClient extends EventEmitter {
         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 {
@@ -324,12 +335,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;