@onlineapps/infrastructure-tools 1.0.29 → 1.0.31

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/infrastructure-tools",
-  "version": "1.0.29",
+  "version": "1.0.31",
   "description": "Infrastructure orchestration utilities for OA Drive infrastructure services (health tracking, queue initialization, service discovery)",
   "main": "src/index.js",
   "scripts": {
@@ -22,7 +22,8 @@
   "dependencies": {
     "@onlineapps/mq-client-core": "^1.0.47",
     "@onlineapps/service-common": "^1.0.5",
-    "uuid": "^9.0.1"
+    "uuid": "^9.0.1",
+    "@onlineapps/infra-logger": "^1.0.0"
   },
   "devDependencies": {
     "jest": "^29.7.0"

package/src/index.js

@@ -38,6 +38,9 @@ const {
 const BaseClient = require('@onlineapps/mq-client-core');
 const queueConfig = require('@onlineapps/mq-client-core/src/config/queueConfig');
 
+// Re-export infra-logger (infrastructure services should use infrastructure-tools, not infra-logger directly)
+const { createLogger: createInfraLogger } = require('@onlineapps/infra-logger');
+
 const { initInfrastructureQueues } = require('./orchestration/initInfrastructureQueues');
 const {
   createHealthPublisher,
@@ -83,9 +86,12 @@ module.exports = {
   createBaseClientAdapter,
   createAmqplibAdapter,
   
-  // Logger utility (consistent with conn-infra-mq pattern)
+  // Logger utilities
+  // createLogger - legacy logger wrapper (for backward compatibility)
   createLogger,
-
+  // createInfraLogger - structured logging from @onlineapps/infra-logger (preferred)
+  createInfraLogger,
+  
   // Monitoring utilities
   sendQueueMismatchAlert
 };

package/src/orchestration/initInfrastructureQueues.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const { sendQueueMismatchAlert } = require('../monitoring/queueMismatchReporter');
+const { createInfraLogger } = require('@onlineapps/infrastructure-tools');
 
 /**
  * initInfrastructureQueues.js
@@ -79,6 +80,17 @@ async function initInfrastructureQueues(channel, options = {}) {
     return workingChannel;
   };
 
+  // Structured log: queue initialization start
+  const log = createInfraLogger('infrastructure-tools', 'queue-init');
+  log.lifecycle(serviceName, 'INIT_START', {
+    handler: 'initInfrastructureQueues',
+    function: 'initInfrastructureQueues',
+    input: {
+      queues_count: queuesToCreate.length,
+      queues: queuesToCreate
+    }
+  });
+  
   logger.log(`[QueueInit] Initializing ${queuesToCreate.length} infrastructure queues...`);
 
   for (const queueName of queuesToCreate) {
@@ -108,98 +120,11 @@ async function initInfrastructureQueues(channel, options = {}) {
         throw configError;
       }
       
-      // CRITICAL: First check if queue exists and what parameters it has
-      // This prevents 406 errors by proactively deleting queues with wrong parameters
-      // Use a separate channel for checkQueue to avoid channel closure issues
-      // NOTE: checkQueue() does NOT create queue - it only checks if it exists
-      let queueExists = false;
-      let queueNeedsRecreation = false;
-      let checkChannelForDelete = null;
-      
-      try {
-        // Use a separate channel for checking queue (to avoid closing workingChannel)
-        // CRITICAL: checkQueue() does NOT create queue - it only checks existence
-        checkChannelForDelete = await connection.createChannel();
-        const queueInfo = await checkChannelForDelete.checkQueue(queueName);
-        queueExists = true;
-        
-        // Check if queue has correct arguments
-        const currentArgs = queueInfo.arguments || {};
-        const expectedArgs = config.arguments || {};
-        
-        // Compare arguments (TTL, max-length, etc.)
-        const argsMatch = Object.keys(expectedArgs).every(key => {
-          return currentArgs[key] === expectedArgs[key];
-        }) && Object.keys(currentArgs).every(key => {
-          // Allow extra args in current queue, but required args must match
-          return expectedArgs[key] === undefined || currentArgs[key] === expectedArgs[key];
-        });
-        
-        if (!argsMatch) {
-          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - will delete and recreate`, {
-            current: currentArgs,
-            expected: expectedArgs
-          });
-          queueNeedsRecreation = true;
-        } else {
-          logger.log(`[QueueInit] ✓ Queue ${queueName} exists with correct parameters`);
-          // Close check channel if queue is OK
-          try {
-            await checkChannelForDelete.close();
-            checkChannelForDelete = null;
-          } catch (closeErr) {
-            // Ignore
-          }
-        }
-      } catch (checkError) {
-        // Queue doesn't exist - will be created
-        queueExists = false;
-        logger.log(`[QueueInit] Queue ${queueName} does not exist (${checkError.code || checkError.message}) - will be created`);
-        // Close check channel if queue doesn't exist
-        if (checkChannelForDelete) {
-          try {
-            await checkChannelForDelete.close();
-            checkChannelForDelete = null;
-          } catch (closeErr) {
-            // Ignore
-          }
-        }
-      }
-      
-      // CRITICAL: If queue exists with wrong parameters, delete it first
-      // This must be done BEFORE assertQueue to avoid 406 errors
-      if (queueNeedsRecreation) {
-        try {
-          // Use the check channel for deletion (or create new one if check failed)
-          const deleteChannel = checkChannelForDelete || await connection.createChannel();
-          await deleteChannel.deleteQueue(queueName, { ifEmpty: false });
-          logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
-          // Close delete channel after use
-          try {
-            await deleteChannel.close();
-          } catch (closeErr) {
-            // Ignore close errors
-          }
-          checkChannelForDelete = null;
-          
-          // Wait to ensure deletion is processed and no frames are pending
-          await new Promise(resolve => setTimeout(resolve, 300));
-          queueExists = false; // Queue no longer exists, will be created
-        } catch (deleteError) {
-          logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
-          // Clean up check channel if still open
-          if (checkChannelForDelete) {
-            try {
-              await checkChannelForDelete.close();
-            } catch (closeErr) {
-              // Ignore
-            }
-          }
-          throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
-        }
-      }
-      
-      // CRITICAL: Now create/verify queue with correct parameters
+      // CRITICAL: Create/verify queue directly with assertQueue
+      // NOTE: We do NOT use checkQueue first because:
+      // - checkQueue throws 404 if queue doesn't exist, which closes the channel
+      // - assertQueue creates queue if it doesn't exist, OR verifies params if it does
+      // - If params mismatch, we get 406 PRECONDITION-FAILED which we handle below
       const ensureQueue = async () => {
         const activeChannel = await getChannel();
         return activeChannel.assertQueue(queueName, {
@@ -213,13 +138,15 @@ async function initInfrastructureQueues(channel, options = {}) {
         await ensureQueue();
         logger.log(`[QueueInit] ✓ Created/verified infrastructure queue: ${queueName}`);
       } catch (assertError) {
-        logger.error(`[QueueInit] ✗ Failed to create/verify queue ${queueName}:`, {
+        logger.error(`[QueueInit] ✗ assertQueue failed for ${queueName}:`, {
           error: assertError.message,
           code: assertError.code,
           classId: assertError.classId,
           methodId: assertError.methodId
         });
+        
         if (assertError.code === 406) {
+          // 406 PRECONDITION-FAILED: queue exists with different parameters
           if (alertOnMismatch) {
             try {
               await sendQueueMismatchAlert({
@@ -234,12 +161,11 @@ async function initInfrastructureQueues(channel, options = {}) {
               logger.warn('[QueueInit] Failed to send queue mismatch alert', alertError.message);
             }
           }
-          logger.warn(
-            `[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`
-          );
+          
+          logger.warn(`[QueueInit] ⚠ Queue ${queueName} exists with different arguments - deleting and recreating...`);
+          
           try {
-            // CRITICAL: Use a fresh channel for delete operation to avoid closed channel errors
-            // Close the current channel first to prevent it from receiving frames during deletion
+            // Close the current channel first (it's likely closed from 406 error anyway)
             if (workingChannel && !workingChannel.__queueInitClosed) {
               try {
                 await workingChannel.close();
@@ -249,27 +175,23 @@ async function initInfrastructureQueues(channel, options = {}) {
               }
             }
             
+            // Delete queue with fresh channel
             const deleteChannel = await getChannel(true);
             await deleteChannel.deleteQueue(queueName, { ifEmpty: false });
             logger.log(`[QueueInit] ✓ Deleted queue ${queueName} with incorrect parameters`);
-            // Close delete channel after use to avoid channel leaks
+            
+            // Close delete channel
             try {
               await deleteChannel.close();
             } catch (closeErr) {
-              // Ignore close errors - channel may already be closed
+              // Ignore close errors
             }
           } catch (deleteError) {
-            logger.error(
-              `[QueueInit] ✗ Failed to delete queue ${queueName}:`,
-              deleteError.message
-            );
-            throw new Error(
-              `Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`
-            );
+            logger.error(`[QueueInit] ✗ Failed to delete queue ${queueName}:`, deleteError.message);
+            throw new Error(`Cannot delete queue ${queueName} with incorrect parameters: ${deleteError.message}`);
           }
 
-          // CRITICAL: Recreate with correct parameters using a fresh channel
-          // Wait a brief moment to ensure queue deletion is fully processed and no frames are pending
+          // Recreate with correct parameters using a fresh channel
           await new Promise(resolve => setTimeout(resolve, 200));
           const recreateChannel = await getChannel(true);
           try {
@@ -277,17 +199,14 @@ async function initInfrastructureQueues(channel, options = {}) {
               durable: config.durable !== false,
               arguments: { ...config.arguments }
             });
-            logger.log(
-              `[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`
-            );
-            // Update workingChannel to the new channel for subsequent operations
+            logger.log(`[QueueInit] ✓ Recreated infrastructure queue: ${queueName} with correct parameters`);
             workingChannel = recreateChannel;
           } catch (recreateError) {
             logger.error(`[QueueInit] ✗ Failed to recreate ${queueName}:`, recreateError.message);
             throw recreateError;
           }
         } else {
-          logger.error(`[QueueInit] ✗ Failed to create ${queueName}:`, assertError.message);
+          // Other error - rethrow
           throw assertError;
         }
       }
@@ -297,10 +216,17 @@ async function initInfrastructureQueues(channel, options = {}) {
     }
   }
 
+  // Structured log: queue initialization complete
+  log.lifecycle(serviceName, 'INIT_COMPLETE', {
+    handler: 'initInfrastructureQueues',
+    function: 'initInfrastructureQueues',
+    input: { queues_count: queuesToCreate.length },
+    output: { status: 'completed', queues_initialized: queuesToCreate.length }
+  });
+  
   logger.log(`[QueueInit] Infrastructure queues initialization complete`);
 }
 
 module.exports = {
   initInfrastructureQueues
 };
-