@onlineapps/service-wrapper 2.0.42 → 2.0.44

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.0.42",
+  "version": "2.0.44",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {

package/src/ServiceWrapper.js

@@ -98,35 +98,46 @@ class ServiceWrapper {
     this.logger?.info('✓ Certificate validated (service is validated and registered), verifying infrastructure readiness...');
 
     // Condition 2: Infrastructure must be ready before creating business queues
-    // Phase 8: verify infrastructure before creating business queues
-    await this._verifyInfrastructureReady(serviceName);
-
-    this.logger?.info('✓ Infrastructure verified, creating business queues...');
+    // FÁZE 0.8: verify infrastructure before creating workflow queues
+    const workflowQueueStartTime = Date.now();
+    this._logPhase('0.8', 'Workflow Queue Setup', 'STARTING');
+    
     try {
+      await this._verifyInfrastructureReady(serviceName);
+
+      this.logger?.info('✓ Infrastructure verified, creating workflow queues...');
       const createdQueues = await this.mqClient.setupServiceQueues(serviceName, { includeWorkflow: true });
-      this.logger?.info('✓ Business queues initialized via QueueManager', {
+      this.logger?.info('✓ Workflow queues initialized via QueueManager', {
         queues: Object.keys(createdQueues).map((k) => createdQueues[k])
       });
 
       const requiredQueues = ['main', 'dlq', 'workflow'];
       const missingQueues = requiredQueues.filter((q) => !createdQueues[q]);
       if (missingQueues.length > 0) {
-        throw new Error(`Failed to create all required business queues. Missing: ${missingQueues.join(', ')}`);
+        throw new Error(`Failed to create all required workflow queues. Missing: ${missingQueues.join(', ')}`);
       }
+
+      this._logPhase('0.8', 'Workflow Queue Setup', 'PASSED', null, Date.now() - workflowQueueStartTime);
     } catch (queueError) {
-      this.logger?.error('Failed to initialize business queues', {
+      this._logPhase('0.8', 'Workflow Queue Setup', 'FAILED', queueError, Date.now() - workflowQueueStartTime);
+      this.logger?.error('Failed to initialize workflow queues', {
         error: queueError.message,
         stack: queueError.stack
       });
-      throw new Error(`Failed to initialize business queues for ${serviceName}: ${queueError.message}`);
+      throw new Error(`Failed to initialize workflow queues for ${serviceName}: ${queueError.message}`);
     }
 
-    this.logger?.info('✓ Starting workflow listeners...');
+    // FÁZE 0.9: Spuštění workflow listenerů
+    const workflowListenerStartTime = Date.now();
+    this._logPhase('0.9', 'Workflow Listener Startup', 'STARTING');
+    
     try {
       await this._startWorkflowInitListener();
       await this._startServiceWorkflowListener();
       this.logger?.info('✓ All workflow listeners started successfully');
+      this._logPhase('0.9', 'Workflow Listener Startup', 'PASSED', null, Date.now() - workflowListenerStartTime);
     } catch (listenerError) {
+      this._logPhase('0.9', 'Workflow Listener Startup', 'FAILED', listenerError, Date.now() - workflowListenerStartTime);
       this.logger?.error('Failed to start workflow listeners', {
         error: listenerError.message,
         stack: listenerError.stack
@@ -285,13 +296,102 @@ class ServiceWrapper {
     }
   }
 
+  /**
+   * Cleanup all stateful resources before restart
+   * @private
+   */
+  async _cleanupBeforeRestart() {
+    const serviceName = this.config.service?.name || 'unnamed-service';
+    console.log(`[CLEANUP] Starting cleanup for ${serviceName} before restart...`);
+    
+    try {
+      // 1. Cancel all consumers
+      if (this.registryClient?.queueManager?.channel) {
+        try {
+          // Cancel registry consumer
+          if (this.registryClient.queueManager.consumerTag) {
+            await this.registryClient.queueManager.channel.cancel(this.registryClient.queueManager.consumerTag);
+            console.log(`[CLEANUP] ✓ Canceled registry consumer`);
+          }
+        } catch (err) {
+          console.warn(`[CLEANUP] Failed to cancel registry consumer:`, err.message);
+        }
+      }
+
+      // 2. Close workflow listeners
+      if (this.workflowInitConsumerTag) {
+        try {
+          if (this.mqClient?.channel) {
+            await this.mqClient.channel.cancel(this.workflowInitConsumerTag);
+            console.log(`[CLEANUP] ✓ Canceled workflow.init consumer`);
+          }
+        } catch (err) {
+          console.warn(`[CLEANUP] Failed to cancel workflow.init consumer:`, err.message);
+        }
+      }
+
+      if (this.serviceWorkflowConsumerTag) {
+        try {
+          if (this.mqClient?.channel) {
+            await this.mqClient.channel.cancel(this.serviceWorkflowConsumerTag);
+            console.log(`[CLEANUP] ✓ Canceled ${serviceName}.workflow consumer`);
+          }
+        } catch (err) {
+          console.warn(`[CLEANUP] Failed to cancel ${serviceName}.workflow consumer:`, err.message);
+        }
+      }
+
+      // 3. Close RabbitMQ connections
+      if (this.mqClient) {
+        try {
+          await this.mqClient.disconnect();
+          console.log(`[CLEANUP] ✓ Closed RabbitMQ connection`);
+        } catch (err) {
+          console.warn(`[CLEANUP] Failed to close RabbitMQ connection:`, err.message);
+        }
+      }
+
+      if (this.registryClient?.queueManager) {
+        try {
+          await this.registryClient.queueManager.disconnect();
+          console.log(`[CLEANUP] ✓ Closed Registry RabbitMQ connection`);
+        } catch (err) {
+          console.warn(`[CLEANUP] Failed to close Registry RabbitMQ connection:`, err.message);
+        }
+      }
+
+      // 4. Close Redis connection (if used)
+      if (this.cacheConnector) {
+        try {
+          await this.cacheConnector.disconnect();
+          console.log(`[CLEANUP] ✓ Closed Redis connection`);
+        } catch (err) {
+          console.warn(`[CLEANUP] Failed to close Redis connection:`, err.message);
+        }
+      }
+
+      // 5. Clear state variables
+      this.workflowInitConsumerTag = null;
+      this.serviceWorkflowConsumerTag = null;
+      this.isInitialized = false;
+
+      console.log(`[CLEANUP] ✓ Cleanup completed`);
+    } catch (error) {
+      console.error(`[CLEANUP] Error during cleanup:`, error.message);
+      // Continue with exit even if cleanup fails
+    }
+  }
+
   /**
    * Handle initialization error with restart strategy
    * @private
    */
-  _handleInitializationError(phase, phaseName, error, isTransient = false) {
+  async _handleInitializationError(phase, phaseName, error, isTransient = false) {
     this._logPhase(phase, phaseName, 'FAILED', error);
     
+    // Cleanup before restart
+    await this._cleanupBeforeRestart();
+    
     if (isTransient) {
       // Přechodná chyba → restart může pomoci
       console.error(`[FÁZE ${phase}] Transient error - service will restart (Docker/process manager)`);
@@ -358,9 +458,10 @@ class ServiceWrapper {
         this._logPhase('0.4', 'Infrastructure Health Check', 'SKIPPED', null, 0);
       }
 
-      // FÁZE 0.5 a 0.6: Vytvoření front a spuštění konzumerů
+      // FÁZE 0.5 a 0.6: Vytvoření registry fronty a spuštění konzumerů
       // Tyto fáze se provádějí v registryClient.init() během Fáze 0.7
-      // Logujeme je tam
+      // Vytváří se pouze {serviceName}.registry fronta (pro registry komunikaci)
+      // Workflow fronty se vytvoří až po úspěšné registraci (Fáze 0.8)
 
       // FÁZE 0.7: Registrace u Registry (pouze pokud vše výše prošlo)
       if (this.config.wrapper?.registry?.enabled !== false) {
@@ -880,11 +981,12 @@ class ServiceWrapper {
 
     try {
       // Subscribe to workflow.init queue (for all services)
-      await this.mqClient.consume(queueName, async (message) => {
+      const consumerTag = await this.mqClient.consume(queueName, async (message) => {
         await this._processWorkflowMessage(message, queueName);
       });
+      this.workflowInitConsumerTag = consumerTag;
 
-      this.logger?.info(`[ServiceWrapper] [CONSUMER] ✓ workflow.init listener started successfully for queue: ${queueName}`);
+      this.logger?.info(`[ServiceWrapper] [CONSUMER] ✓ workflow.init listener started successfully for queue: ${queueName} (consumerTag: ${consumerTag})`);
     } catch (consumeErr) {
       this.logger?.error(`[ServiceWrapper] [CONSUMER] ✗ Failed to start workflow.init listener for queue: ${queueName}`, {
         error: consumeErr.message,
@@ -913,11 +1015,12 @@ class ServiceWrapper {
 
     try {
       // Subscribe to service-specific queue
-      await this.mqClient.consume(serviceQueue, async (message) => {
+      const consumerTag = await this.mqClient.consume(serviceQueue, async (message) => {
         await this._processWorkflowMessage(message, serviceQueue);
       });
+      this.serviceWorkflowConsumerTag = consumerTag;
 
-      this.logger?.info(`[ServiceWrapper] [CONSUMER] ✓ Service-specific workflow listener started successfully for queue: ${serviceQueue}`);
+      this.logger?.info(`[ServiceWrapper] [CONSUMER] ✓ Service-specific workflow listener started successfully for queue: ${serviceQueue} (consumerTag: ${consumerTag})`);
     } catch (consumeErr) {
       this.logger?.error(`[ServiceWrapper] [CONSUMER] ✗ Failed to start service-specific workflow listener for queue: ${serviceQueue}`, {
         error: consumeErr.message,
@@ -949,11 +1052,17 @@ class ServiceWrapper {
       const isTest = flags.includes('test');
       const isTier2Validation = flags.includes('tier2-validation');
 
-      this.logger?.debug(`Processing message from ${queueName}`, {
+      // Log full message structure for debugging
+      this.logger?.info(`[ServiceWrapper] Processing message from ${queueName}`, {
         workflow_id: message.workflow_id,
+        current_step: message.current_step,
+        workflowId: message.workflowId, // Gateway sends workflowId, not workflow_id
         step: message.step?.operation || message.operation,
         flags,
-        isTest
+        isTest,
+        messageKeys: Object.keys(message),
+        hasCookbook: !!message.cookbook,
+        hasContext: !!message.context
       });
 
       // Check if this message is for our service
@@ -973,7 +1082,19 @@ class ServiceWrapper {
         result = await this._executeOperation(message.step.operation, message.input || {});
       } else if (this.orchestrator) {
         // Delegate to orchestrator for complex workflow processing
-        result = await this.orchestrator.processWorkflowMessage(message, serviceName);
+        // Normalize message format: Gateway sends workflowId, orchestrator expects workflow_id
+        const normalizedMessage = {
+          ...message,
+          workflow_id: message.workflow_id || message.workflowId,
+          current_step: message.current_step || (message.cookbook?.steps?.[0]?.id)
+        };
+        this.logger?.info(`[ServiceWrapper] Calling orchestrator.processWorkflowMessage`, {
+          workflow_id: normalizedMessage.workflow_id,
+          current_step: normalizedMessage.current_step,
+          hasCookbook: !!normalizedMessage.cookbook,
+          hasContext: !!normalizedMessage.context
+        });
+        result = await this.orchestrator.processWorkflowMessage(normalizedMessage, serviceName);
       } else {
         throw new Error(`Unknown message format or operation: ${JSON.stringify(message)}`);
       }