@onlineapps/service-wrapper 2.1.85 → 2.1.86

package/config/runtime-defaults.json

@@ -12,14 +12,8 @@
         "heartbeatInterval": 30000
       },
       "infrastructureGate": {
-        "maxWaitMs": 300000,
-        "checkIntervalMs": 5000
-      },
-      "infrastructureVerify": {
-        "maxRetries": 12,
-        "baseDelayMs": 5000,
-        "maxDelayMs": 30000,
-        "queueCheckTimeoutMs": 5000
+        "maxWaitMs": 5000,
+        "checkIntervalMs": 2000
       },
       "monitoring": {
         "enabled": true,

package/package.json

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

package/src/ServiceWrapper.js

@@ -935,143 +935,34 @@ class ServiceWrapper {
    * 1. Service has certificate (validated + registered) - checked in _startWorkflowListenersIfReady()
    * 2. Infrastructure is ready - checked in this method
    * 
-   * Checks:
-   * 1. All infrastructure services are UP (via Redis key infrastructure:health:all)
-   * 2. Required infrastructure queues exist (workflow.init, registry.register, etc.)
+   * SEPARATION OF CONCERNS:
+   * - Business services MUST NOT check infrastructure queues directly.
+   * - Business services MUST trust Registry's infrastructure:health:all flag.
+   * - Infrastructure services are responsible for their own queue health.
+   * - If infrastructure is not ready within timeout, business service exits (Docker restarts it).
    * 
-   * Uses exponential backoff retry mechanism if infrastructure not ready.
    * @private
    */
   async _verifyInfrastructureReady(serviceName) {
-    const maxRetries = this.config.wrapper?.infrastructureVerify?.maxRetries;
-    const baseDelay = this.config.wrapper?.infrastructureVerify?.baseDelayMs;
-    const maxDelay = this.config.wrapper?.infrastructureVerify?.maxDelayMs;
-    const queueCheckTimeoutMs = this.config.wrapper?.infrastructureVerify?.queueCheckTimeoutMs;
-
-    if (typeof maxRetries !== 'number' || Number.isNaN(maxRetries) || maxRetries <= 0) {
-      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.maxRetries must be a positive number, got: ${maxRetries}`);
-    }
-    if (typeof baseDelay !== 'number' || Number.isNaN(baseDelay) || baseDelay <= 0) {
-      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.baseDelayMs must be a positive number, got: ${baseDelay}`);
-    }
-    if (typeof maxDelay !== 'number' || Number.isNaN(maxDelay) || maxDelay <= 0) {
-      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.maxDelayMs must be a positive number, got: ${maxDelay}`);
-    }
-    if (typeof queueCheckTimeoutMs !== 'number' || Number.isNaN(queueCheckTimeoutMs) || queueCheckTimeoutMs <= 0) {
-      throw new Error(`[InfrastructureVerify] Invalid configuration - wrapper.infrastructureVerify.queueCheckTimeoutMs must be a positive number, got: ${queueCheckTimeoutMs}`);
-    }
-    
-    // Required infrastructure queues that must exist before business queues can be created
-    const requiredInfrastructureQueues = [
-      'workflow.init',        // Gateway responsibility (workflow entrypoint)
-      'workflow.control',     // Gateway responsibility (shared control-flow steps)
-      'registry.register',    // Registry responsibility
-    ];
+    this.logger?.info('[InfrastructureReady] Checking infrastructure status via Registry (trusting infrastructure:health:all flag)...');
     
-    // Optional infrastructure queues (may not exist if services are not running)
-    const optionalInfrastructureQueues = [
-      'validation.requests',  // Validator responsibility
-      'workflow.completed',  // Delivery Dispatcher responsibility
-      'workflow.failed'      // Delivery Dispatcher responsibility
-    ];
-    
-    this.logger?.info('[InfrastructureVerify] Starting infrastructure readiness verification...', {
-      maxRetries,
-      baseDelay,
-      requiredQueues: requiredInfrastructureQueues
-    });
-    
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-      try {
-        await this._waitForInfrastructureGate('business queue setup');
-        
-        // Step 2: Verify required infrastructure queues exist
-        this.logger?.info('[InfrastructureVerify] Verifying required infrastructure queues exist...');
-        
-        const transport = this.mqClient._transport;
-        if (!transport || !transport._queueChannel) {
-          throw new Error('MQ transport not initialized - cannot verify infrastructure queues');
-        }
-        
-        const channel = transport._queueChannel;
-        if (channel.closed) {
-          throw new Error('MQ channel is closed - cannot verify infrastructure queues');
-        }
-        
-        const missingQueues = [];
-        for (const queueName of requiredInfrastructureQueues) {
-          try {
-            // Add timeout to prevent hanging on checkQueue
-            const checkPromise = channel.checkQueue(queueName);
-            const checkTimeoutPromise = new Promise((_, reject) => {
-              setTimeout(() => {
-                reject(new Error(`checkQueue timeout after ${queueCheckTimeoutMs}ms`));
-              }, queueCheckTimeoutMs);
-            });
-            
-            await Promise.race([checkPromise, checkTimeoutPromise]);
-            this.logger?.info(`[InfrastructureVerify] ✓ Queue exists: ${queueName}`);
-          } catch (checkErr) {
-            if (checkErr.code === 404 || checkErr.message.includes('timeout')) {
-              missingQueues.push(queueName);
-              this.logger?.warn(`[InfrastructureVerify] ✗ Queue missing or timeout: ${queueName} (${checkErr.message})`);
-            } else {
-              // Other error (e.g., channel closed) - treat as missing
-              missingQueues.push(queueName);
-              this.logger?.warn(`[InfrastructureVerify] ✗ Cannot check queue ${queueName}: ${checkErr.message}`);
-            }
-          }
-        }
-        
-        if (missingQueues.length > 0) {
-          const queueDetails = missingQueues.map((queueName) => {
-            const owner = INFRA_QUEUE_OWNERS[queueName] || 'responsible infrastructure service';
-            return `${queueName} (owner: ${owner})`;
-          });
-          throw new Error(
-            `[InfrastructureVerify] Required RabbitMQ queue(s) missing: ${queueDetails.join(', ')}. ` +
-            'Infrastructure service(s) responsible for these queues are not ready yet. ' +
-            'Resolve the infrastructure issue and restart the business service.'
-          );
-        }
-        
-        // Step 3: Log optional queues status (for debugging)
-        for (const queueName of optionalInfrastructureQueues) {
-          try {
-            const checkPromise = channel.checkQueue(queueName);
-            const checkTimeoutPromise = new Promise((_, reject) => {
-              setTimeout(() => reject(new Error('timeout')), queueCheckTimeoutMs);
-            });
-            await Promise.race([checkPromise, checkTimeoutPromise]);
-            this.logger?.info(`[InfrastructureVerify] ✓ Optional queue exists: ${queueName}`);
-          } catch (checkErr) {
-            if (checkErr.code === 404 || checkErr.message.includes('timeout')) {
-              this.logger?.debug(`[InfrastructureVerify] Optional queue missing or timeout (not critical): ${queueName}`);
-            }
-          }
-        }
-        
-        // All checks passed!
-        this.logger?.info('[InfrastructureVerify] ✓ Infrastructure verification complete - all required queues exist');
-        return;
-        
-      } catch (error) {
-        if (attempt === maxRetries) {
-          // Final attempt failed - throw error
-          this.logger?.error('[InfrastructureVerify] ✗ Infrastructure verification failed after all retries', {
-            error: error.message,
-            stack: error.stack
-          });
-          throw new Error(`Infrastructure verification failed for ${serviceName}: ${error.message}`);
-        }
-        
-        // Not final attempt - continue retry loop
-        const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
-        this.logger?.warn(`[InfrastructureVerify] Verification failed (attempt ${attempt}/${maxRetries}), retrying in ${delay}ms...`, {
-          error: error.message
-        });
-        await new Promise(resolve => setTimeout(resolve, delay));
-      }
+    try {
+      // Single check - if infra not ready, fail fast and let Docker restart
+      await this._waitForInfrastructureGate('business queue setup');
+      this.logger?.info('[InfrastructureReady] ✓ Infrastructure is ready (infrastructure:health:all = true)');
+    } catch (error) {
+      // Infrastructure not ready - fail fast with clear message
+      this.logger?.error('[InfrastructureReady] ✗ Infrastructure not ready - service will exit', {
+        error: error.message,
+        serviceName,
+        action: 'Docker will restart the service. Check infrastructure services (Gateway, Registry, Validator, Delivery, Monitoring).'
+      });
+      throw new Error(
+        `[InfrastructureReady] Infrastructure not ready for ${serviceName}. ` +
+        'Registry reports infrastructure:health:all != true. ' +
+        'Check infrastructure services and their logs. ' +
+        'This service will exit and Docker will restart it.'
+      );
     }
   }