@onlineapps/service-wrapper 2.1.85 → 2.1.87

package/config/runtime-defaults.json

@@ -12,19 +12,18 @@
         "heartbeatInterval": 30000
       },
       "infrastructureGate": {
-        "maxWaitMs": 300000,
-        "checkIntervalMs": 5000
-      },
-      "infrastructureVerify": {
-        "maxRetries": 12,
-        "baseDelayMs": 5000,
-        "maxDelayMs": 30000,
-        "queueCheckTimeoutMs": 5000
+        "maxWaitMs": 30000,
+        "checkIntervalMs": 2000
       },
       "monitoring": {
         "enabled": true,
         "metrics": ["requests", "errors", "duration"]
       },
+      "startupAlerts": {
+        "enabled": true,
+        "cooldownMs": 600000,
+        "stateFile": "/tmp/oa_startup_failure_state.json"
+      },
       "logging": {
         "enabled": true,
         "level": "info",

package/package.json

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

package/src/ServiceWrapper.js

@@ -423,6 +423,14 @@ class ServiceWrapper {
     
     // Cleanup before restart
     await this._cleanupBeforeRestart();
+
+    // Startup failure alert (works without MQ/monitoring)
+    try {
+      await this._maybeSendStartupFailureAlert({ phase, phaseName, error, isTransient });
+    } catch (alertErr) {
+      // Alerts must never block restart; log and continue.
+      console.warn('[StartupAlerts] Failed to send startup failure alert:', alertErr.message);
+    }
     
     if (isTransient) {
       // Přechodná chyba → restart může pomoci
@@ -431,11 +439,85 @@ class ServiceWrapper {
     } else {
       // Trvalá chyba → restart nepomůže
       console.error(`[FÁZE ${phase}] Permanent error - fix required, no restart`);
-      // TODO: Send alert (email, Slack, etc.)
       process.exit(1);
     }
   }
 
+  /**
+   * Send startup-failure alert via SMTP (independent of MQ).
+   * Uses service-common sendMonitoringFailFallbackEmail (SMTP config via INFRA_REPORT_* env).
+   * Throttled by a persistent state file (survives container restarts).
+   *
+   * @private
+   */
+  async _maybeSendStartupFailureAlert({ phase, phaseName, error, isTransient }) {
+    const cfg = this.config.wrapper?.startupAlerts;
+    if (!cfg || cfg.enabled !== true) {
+      return;
+    }
+
+    const cooldownMs = cfg.cooldownMs;
+    const stateFile = cfg.stateFile;
+    if (typeof cooldownMs !== 'number' || Number.isNaN(cooldownMs) || cooldownMs <= 0) {
+      throw new Error(`[StartupAlerts] Invalid configuration - wrapper.startupAlerts.cooldownMs must be a positive number, got: ${cooldownMs}`);
+    }
+    if (typeof stateFile !== 'string' || stateFile.trim() === '') {
+      throw new Error(`[StartupAlerts] Invalid configuration - wrapper.startupAlerts.stateFile must be a non-empty string, got: ${stateFile}`);
+    }
+
+    const fs = require('fs');
+    const path = require('path');
+    const serviceName = this.config.service?.name || 'unnamed-service';
+    const now = Date.now();
+
+    let state = { lastAlertAt: 0, failureCount: 0, lastFailureAt: 0 };
+    try {
+      if (fs.existsSync(stateFile)) {
+        const raw = fs.readFileSync(stateFile, 'utf8');
+        state = { ...state, ...(JSON.parse(raw) || {}) };
+      } else {
+        // Ensure parent dir exists (best-effort)
+        const dir = path.dirname(stateFile);
+        try { fs.mkdirSync(dir, { recursive: true }); } catch (_) { /* ignore */ }
+      }
+    } catch (e) {
+      // If state cannot be read, continue with defaults (alerting must not crash init)
+    }
+
+    state.failureCount = (state.failureCount || 0) + 1;
+    state.lastFailureAt = now;
+
+    const shouldSend = !state.lastAlertAt || (now - state.lastAlertAt) >= cooldownMs;
+    if (!shouldSend) {
+      // Persist updated counters anyway
+      try { fs.writeFileSync(stateFile, JSON.stringify(state), 'utf8'); } catch (_) { /* ignore */ }
+      return;
+    }
+
+    const { sendMonitoringFailFallbackEmail } = require('@onlineapps/service-common');
+    const transientLabel = isTransient ? 'TRANSIENT' : 'PERMANENT';
+    const subject = `[StartupFailure] ${serviceName} phase ${phase} (${transientLabel})`;
+    const text = [
+      `Service: ${serviceName}`,
+      `Phase: ${phase} (${phaseName})`,
+      `Type: ${transientLabel}`,
+      `Failure count (container): ${state.failureCount}`,
+      `Timestamp: ${new Date(now).toISOString()}`,
+      `Error: ${error?.message || 'unknown error'}`
+    ].join('\n');
+    const html = `<pre>${text}</pre>`;
+
+    const sent = await sendMonitoringFailFallbackEmail(subject, text, html);
+    state.lastAlertAt = now;
+    try { fs.writeFileSync(stateFile, JSON.stringify(state), 'utf8'); } catch (_) { /* ignore */ }
+
+    if (sent) {
+      this.logger?.info('[StartupAlerts] ✓ Startup failure alert sent', { service: serviceName, phase, transient: isTransient });
+    } else {
+      this.logger?.warn('[StartupAlerts] Startup failure alert not sent (SMTP config missing or send failed)', { service: serviceName, phase });
+    }
+  }
+
   async initialize() {
       if (this.isInitialized) {
       // Logger might not be initialized yet, use console as fallback
@@ -935,143 +1017,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
-    ];
-    
-    // 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('[InfrastructureReady] Checking infrastructure status via Registry (trusting infrastructure:health:all flag)...');
     
-    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.'
+      );
     }
   }