@onlineapps/service-wrapper 2.0.40 → 2.0.42

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onlineapps/service-wrapper",
-  "version": "2.0.40",
+  "version": "2.0.42",
   "description": "Thin orchestration layer for microservices - delegates all infrastructure concerns to specialized connectors",
   "main": "src/index.js",
   "scripts": {
@@ -31,7 +31,7 @@
     "@onlineapps/conn-orch-api-mapper": "^1.0.0",
     "@onlineapps/conn-orch-cookbook": "^2.0.0",
     "@onlineapps/conn-orch-orchestrator": "^1.0.1",
-    "@onlineapps/conn-orch-registry": "^1.1.23",
+    "@onlineapps/conn-orch-registry": "^1.1.25",
     "@onlineapps/conn-orch-validator": "^2.0.0",
     "@onlineapps/service-common": "^1.0.0",
     "@onlineapps/monitoring-core": "^1.0.0"

package/src/ServiceWrapper.js

@@ -23,6 +23,16 @@ const CacheConnector = require('@onlineapps/conn-base-cache');
 const ErrorHandlerConnector = require('@onlineapps/conn-infra-error-handler');
 const { ValidationOrchestrator } = require('@onlineapps/conn-orch-validator');
 
+const INFRA_QUEUE_OWNERS = {
+  'workflow.init': 'Gateway (api_gateway)',
+  'registry.register': 'Registry (api_services_registry)',
+  'registry.heartbeats': 'Registry (api_services_registry)',
+  'validation.requests': 'Validator (api_services_validator)',
+  'workflow.completed': 'Delivery Dispatcher (api_delivery_dispatcher)',
+  'workflow.failed': 'Delivery Dispatcher (api_delivery_dispatcher)',
+  'infrastructure.health.checks': 'Registry (api_services_registry)'
+};
+
 /**
  * ServiceWrapper class
  * Collection of connectors that enhance business service with infrastructure
@@ -63,6 +73,117 @@ class ServiceWrapper {
     this.isInitialized = false;
   }
 
+  /**
+   * Start workflow listeners and create business queues only when BOTH conditions are met:
+   * 1. Service is validated and registered (certificate received)
+   * 2. Infrastructure is ready (all infrastructure services UP, required queues exist)
+   * 
+   * Business services may create their own queues ONLY when:
+   * - Service has received certificate (validated + registered)
+   * - AND infrastructure:health:all is true
+   * - AND required infrastructure queues exist (workflow.init, registry.register, etc.)
+   * 
+   * @private
+   * @param {Object} registrationResult
+   * @param {string} serviceName
+   */
+  async _startWorkflowListenersIfReady(registrationResult, serviceName) {
+    // Condition 1: Service must be validated and registered (certificate required)
+    if (!(registrationResult?.success && registrationResult.certificate)) {
+      this.logger?.warn('⚠ Registration succeeded but no certificate received - workflow listeners NOT started');
+      this.logger?.warn('⚠ Business queues will NOT be created until certificate is received');
+      return;
+    }
+
+    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...');
+    try {
+      const createdQueues = await this.mqClient.setupServiceQueues(serviceName, { includeWorkflow: true });
+      this.logger?.info('✓ Business 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(', ')}`);
+      }
+    } catch (queueError) {
+      this.logger?.error('Failed to initialize business queues', {
+        error: queueError.message,
+        stack: queueError.stack
+      });
+      throw new Error(`Failed to initialize business queues for ${serviceName}: ${queueError.message}`);
+    }
+
+    this.logger?.info('✓ Starting workflow listeners...');
+    try {
+      await this._startWorkflowInitListener();
+      await this._startServiceWorkflowListener();
+      this.logger?.info('✓ All workflow listeners started successfully');
+    } catch (listenerError) {
+      this.logger?.error('Failed to start workflow listeners', {
+        error: listenerError.message,
+        stack: listenerError.stack
+      });
+      throw new Error(`Failed to start workflow listeners for ${serviceName}: ${listenerError.message}`);
+    }
+  }
+
+  /**
+   * Wait until infrastructure reports healthy before allowing the next step
+   * @param {string} context - human readable description (e.g. 'registry registration')
+   * @private
+   */
+  async _waitForInfrastructureGate(context) {
+    const { waitForInfrastructureReady } = require('@onlineapps/service-common');
+    const redisUrl = this.config.wrapper?.cache?.url || process.env.REDIS_URL || 'redis://api_node_cache:6379';
+    const maxWait = parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_MAX_TIME) || 300000;
+    const checkInterval = parseInt(process.env.INFRASTRUCTURE_HEALTH_WAIT_CHECK_INTERVAL) || 5000;
+
+    const logWithPrefix = (level, message) => {
+      const prefixed = `[InfrastructureGate:${context}] ${message}`;
+      if (this.logger?.log) {
+        this.logger.log({ level, message: prefixed });
+      } else if (this.logger?.[level]) {
+        this.logger[level](prefixed);
+      } else {
+        console[level === 'error' ? 'error' : 'log'](prefixed);
+      }
+    };
+
+    const gateLogger = {
+      info: (message) => logWithPrefix('info', message),
+      log: (payload) => {
+        if (payload && typeof payload === 'object') {
+          logWithPrefix(payload.level || 'info', payload.message || '');
+        } else {
+          logWithPrefix('info', payload);
+        }
+      }
+    };
+
+    try {
+      await waitForInfrastructureReady({
+        redisUrl,
+        maxWait,
+        checkInterval,
+        logger: gateLogger
+      });
+    } catch (error) {
+      const message = `[InfrastructureGate] Cannot proceed with ${context}. ${error.message}`;
+      this.logger?.error(message, { context, error: error.message });
+      const gateError = new Error(message);
+      gateError.cause = error;
+      throw gateError;
+    }
+  }
+
   /**
    * Validate constructor options
    * @private
@@ -136,6 +257,53 @@ class ServiceWrapper {
    * Initialize all wrapper components
    * @async
    */
+  /**
+   * Log phase with transparent format
+   * @private
+   */
+  _logPhase(phase, phaseName, status, error = null, duration = null) {
+    const logMsg = `[FÁZE ${phase}] ${phaseName} - ${status}`;
+    const logData = {
+      phase,
+      phaseName,
+      status,
+      timestamp: new Date().toISOString(),
+      duration,
+      error: error ? { message: error.message, stack: error.stack } : null,
+      serviceName: this.config.service?.name || 'unnamed-service'
+    };
+
+    if (status === 'PASSED') {
+      this.logger?.info(logMsg, logData);
+      console.log(logMsg);
+    } else if (status === 'FAILED') {
+      this.logger?.error(logMsg, logData);
+      console.error(logMsg, error ? `: ${error.message}` : '');
+    } else {
+      this.logger?.info(logMsg, logData);
+      console.log(logMsg);
+    }
+  }
+
+  /**
+   * Handle initialization error with restart strategy
+   * @private
+   */
+  _handleInitializationError(phase, phaseName, error, isTransient = false) {
+    this._logPhase(phase, phaseName, 'FAILED', error);
+    
+    if (isTransient) {
+      // Přechodná chyba → restart může pomoci
+      console.error(`[FÁZE ${phase}] Transient error - service will restart (Docker/process manager)`);
+      process.exit(1); // Docker/process manager restartuje
+    } 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);
+    }
+  }
+
   async initialize() {
       if (this.isInitialized) {
       // Logger might not be initialized yet, use console as fallback
@@ -143,48 +311,96 @@ class ServiceWrapper {
       return;
     }
 
+    const serviceName = this.config.service?.name || 'unnamed-service';
+    const startTime = Date.now();
+
     try {
-      const serviceName = this.config.service?.name || 'unnamed-service';
-      // Logger might not be initialized yet, use console as fallback
-      (this.logger || console).info(`Initializing ServiceWrapper for ${serviceName}`);
+      // FÁZE 0.1: Načtení konfigurace
+      // Konfigurace se načítá v konstruktoru, takže tady jen logujeme
+      this._logPhase('0.1', 'Configuration Load', 'PASSED', null, Date.now() - startTime);
 
-      // 1. Initialize monitoring first (needed for logging)
-      if (this.config.wrapper?.monitoring?.enabled !== false) {
-        await this._initializeMonitoring();
+      // FÁZE 0.2: Tier 1 validace (PŘED MQ připojením)
+      if (this.serviceRoot && this.config.wrapper?.validation?.enabled !== false) {
+        const validationStartTime = Date.now();
+        try {
+          await this._ensureValidationProof();
+          this._logPhase('0.2', 'Tier 1 Validation', 'PASSED', null, Date.now() - validationStartTime);
+        } catch (error) {
+          this._handleInitializationError('0.2', 'Tier 1 Validation', error, false); // Trvalá chyba
+        }
+      } else {
+        this._logPhase('0.2', 'Tier 1 Validation', 'SKIPPED', null, 0);
       }
 
-      // 2. Initialize MQ connection
+      // FÁZE 0.3: RabbitMQ připojení (pouze pokud Tier 1 prošla)
       if (this.config.wrapper?.mq?.enabled !== false) {
-        await this._initializeMQ();
-        // NOTE: workflow.init listener starts ONLY after successful registration (see _initializeRegistry)
+        const mqStartTime = Date.now();
+        try {
+          await this._initializeMQ();
+          this._logPhase('0.3', 'RabbitMQ Connection', 'PASSED', null, Date.now() - mqStartTime);
+        } catch (error) {
+          this._handleInitializationError('0.3', 'RabbitMQ Connection', error, true); // Přechodná chyba
+        }
+      } else {
+        this._logPhase('0.3', 'RabbitMQ Connection', 'SKIPPED', null, 0);
       }
 
-      // 3. Run pre-validation (Tier 1)
-      // Validates service structure, config, operations, cookbook tests
-      // Skips if valid proof exists in conn-runtime/validation-proof.json
-      // NOTE: Validation is required for service-specific workflow listener and registration
-      if (this.serviceRoot && this.config.wrapper?.validation?.enabled !== false) {
-        await this._ensureValidationProof();
+      // FÁZE 0.4: Kontrola infrastructure:health:all (pouze pokud MQ připojeno)
+      if (this.mqClient) {
+        const healthCheckStartTime = Date.now();
+        try {
+          await this._waitForInfrastructureGate('infrastructure health check');
+          this._logPhase('0.4', 'Infrastructure Health Check', 'PASSED', null, Date.now() - healthCheckStartTime);
+        } catch (error) {
+          this._handleInitializationError('0.4', 'Infrastructure Health Check', error, true); // Přechodná chyba
+        }
+      } else {
+        this._logPhase('0.4', 'Infrastructure Health Check', 'SKIPPED', null, 0);
       }
 
-      // 4. Initialize service registry
-      // NOTE: Service-specific workflow listener ({serviceName}.workflow) will be started
-      // ONLY after successful validation and registration (see _initializeRegistry)
+      // FÁZE 0.5 a 0.6: Vytvoření front a spuštění konzumerů
+      // Tyto fáze se provádějí v registryClient.init() během Fáze 0.7
+      // Logujeme je tam
+
+      // FÁZE 0.7: Registrace u Registry (pouze pokud vše výše prošlo)
       if (this.config.wrapper?.registry?.enabled !== false) {
-        await this._initializeRegistry();
+        const registryStartTime = Date.now();
+        try {
+          await this._initializeRegistry();
+          this._logPhase('0.7', 'Registry Registration', 'PASSED', null, Date.now() - registryStartTime);
+        } catch (error) {
+          this._handleInitializationError('0.7', 'Registry Registration', error, true); // Přechodná chyba
+        }
+      } else {
+        this._logPhase('0.7', 'Registry Registration', 'SKIPPED', null, 0);
+      }
+
+      // Initialize monitoring (needed for logging, but not critical for startup)
+      if (this.config.wrapper?.monitoring?.enabled !== false) {
+        try {
+          await this._initializeMonitoring();
+        } catch (error) {
+          // Monitoring není kritický, jen logujeme
+          console.warn('Monitoring initialization failed (non-critical):', error.message);
+        }
       }
 
-      // 5. Initialize cache if configured
+      // Initialize cache if configured
       if (this.config.wrapper?.cache?.enabled === true) {
-        await this._initializeCache();
+        try {
+          await this._initializeCache();
+        } catch (error) {
+          // Cache není kritický, jen logujeme
+          console.warn('Cache initialization failed (non-critical):', error.message);
+        }
       }
 
-      // 6. Setup health checks
+      // Setup health checks
       if (this.config.wrapper?.health?.enabled !== false) {
         this._setupHealthChecks();
       }
 
-      // 7. Initialize orchestrator for workflow processing
+      // Initialize orchestrator for workflow processing
       // NOTE: Orchestrator is prepared but workflow listeners will be started
       // ONLY after receiving certificate from Registry (see _initializeRegistry)
       if (this.mqClient) {
@@ -192,16 +408,13 @@ class ServiceWrapper {
       }
 
       this.isInitialized = true;
+      this._logPhase('INIT', 'ServiceWrapper Initialization', 'PASSED', null, Date.now() - startTime);
       this.logger?.info(`ServiceWrapper initialized successfully for ${serviceName}`);
 
     } catch (error) {
-      // Always log errors - use logger if available, otherwise console
-      if (this.logger) {
-        this.logger.error('Failed to initialize ServiceWrapper', { error: error.message, stack: error.stack });
-      } else {
-        console.error('Failed to initialize ServiceWrapper:', error);
-      }
-      throw error;
+      // Unexpected error - log and exit
+      console.error('[UNEXPECTED ERROR]', error);
+      process.exit(1);
     }
   }
 
@@ -267,8 +480,18 @@ class ServiceWrapper {
       logger: this.logger || console
     });
 
-    await this.mqClient.connect();
-    this.logger?.info('MQ connector initialized');
+    try {
+      await this.mqClient.connect();
+      this.logger?.info('MQ connector initialized');
+    } catch (error) {
+      const message = `[MQConnector] Unable to connect to RabbitMQ at ${mqUrl}. ` +
+        'Verify that api_services_queuer is running and accessible. ' +
+        `Original error: ${error.message || error}`;
+      this.logger?.error(message, { error: error.message, code: error.code });
+      const wrappedError = new Error(message);
+      wrappedError.cause = error;
+      throw wrappedError;
+    }
 
     // NOTE: Business services (ServiceWrapper) do NOT create infrastructure queues
     // Infrastructure queues are created by infrastructure services (Monitoring Consumer, Gateway)
@@ -289,6 +512,10 @@ class ServiceWrapper {
     const servicePort = this.config.service?.port || process.env.PORT || 3000;
     const mqUrl = this.config.wrapper?.mq?.url || '';
 
+    // Infrastructure health check was already done in Fáze 0.4
+    // FÁZE 0.5 a 0.6: Vytvoření front a spuštění konzumerů se provádí v registryClient.init()
+    // FÁZE 0.7: Registrace u Registry
+
     this.registryClient = new RegistryConnector.ServiceRegistryClient({
       amqpUrl: mqUrl,
       serviceName: serviceName,
@@ -318,66 +545,57 @@ class ServiceWrapper {
     // RegistryClient loads proof during init() and includes it in registration message
 
     try {
+      const logMsg = `[ServiceWrapper] [REGISTRATION] About to call registryClient.register() for ${serviceName}`;
+      this.logger?.info(logMsg);
+      console.log(logMsg); // Fallback if logger not initialized
+      
       const registrationResult = await this.registryClient.register(serviceInfo);
-      this.logger?.info(`Service registered: ${serviceName}`, { registrationResult });
+      
+      const returnLog = `[ServiceWrapper] [REGISTRATION] ✓ registryClient.register() returned`;
+      const returnData = {
+        hasResult: !!registrationResult,
+        resultType: typeof registrationResult,
+        resultKeys: registrationResult ? Object.keys(registrationResult) : [],
+        registrationResult
+      };
+      this.logger?.info(returnLog, returnData);
+      console.log(returnLog, JSON.stringify(returnData, null, 2)); // Fallback if logger not initialized
+      const serviceRegisteredLog = `Service registered: ${serviceName}`;
+      const serviceRegisteredData = { 
+        registrationResult,
+        hasSuccess: !!registrationResult?.success,
+        hasCertificate: !!registrationResult?.certificate,
+        certificateId: registrationResult?.certificate?.id || registrationResult?.certificate?.certificateId || 'none'
+      };
+      this.logger?.info(serviceRegisteredLog, serviceRegisteredData);
+      console.log(serviceRegisteredLog, JSON.stringify(serviceRegisteredData, null, 2)); // Fallback if logger not initialized
 
       // Store certificate if received
       if (registrationResult.certificate) {
         this.certificate = registrationResult.certificate;
-        this.logger?.info(`✓ Certificate received: ${registrationResult.certificate.certificateId}`);
-      }
-
-      // CRITICAL: Start workflow listeners ONLY after successful validation and registration with certificate
-      // Both workflow.init and service-specific listeners start here
-      if (registrationResult.success && registrationResult.certificate) {
-        this.logger?.info('✓ Certificate validated, verifying infrastructure readiness...');
-        
-        // PHASE 8: Verify infrastructure services are ready before creating business queues
-        await this._verifyInfrastructureReady(serviceName);
-        
-        this.logger?.info('✓ Infrastructure verified, creating business queues...');
-        try {
-          // CRITICAL: Create ALL business queues atomically (main, dlq, workflow)
-          // This MUST succeed completely - if one queue fails, all fail
-          const createdQueues = await this.mqClient.setupServiceQueues(serviceName, { includeWorkflow: true });
-          this.logger?.info('✓ Business queues initialized via QueueManager', { 
-            queues: Object.keys(createdQueues).map(k => createdQueues[k])
-          });
-          
-          // Verify all queues were created
-          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(', ')}`);
-          }
-        } catch (queueError) {
-          this.logger?.error('Failed to initialize business queues', { 
-            error: queueError.message,
-            stack: queueError.stack
-          });
-          throw new Error(`Failed to initialize business queues for ${serviceName}: ${queueError.message}`);
-        }
-
-        // CRITICAL: Start workflow listeners ONLY after all queues are created
-        // Queues must exist before we try to consume from them
-        this.logger?.info('✓ Starting workflow listeners...');
-        try {
-          // Start workflow.init listener (for all services)
-          await this._startWorkflowInitListener();
-          // Start service-specific workflow listener
-          await this._startServiceWorkflowListener();
-          this.logger?.info('✓ All workflow listeners started successfully');
-        } catch (listenerError) {
-          this.logger?.error('Failed to start workflow listeners', {
-            error: listenerError.message,
-            stack: listenerError.stack
-          });
-          throw new Error(`Failed to start workflow listeners for ${serviceName}: ${listenerError.message}`);
-        }
+        const certLog = `✓ Certificate received: ${registrationResult.certificate.certificateId || registrationResult.certificate.id || 'unknown'}`;
+        this.logger?.info(certLog);
+        console.log(certLog); // Fallback if logger not initialized
       } else {
-        this.logger?.warn('⚠ Registration succeeded but no certificate received - workflow listeners NOT started');
+        const noCertLog = `⚠ No certificate in registration result`;
+        const noCertData = {
+          registrationResultKeys: Object.keys(registrationResult || {}),
+          registrationResult
+        };
+        this.logger?.warn(noCertLog, noCertData);
+        console.warn(noCertLog, JSON.stringify(noCertData, null, 2)); // Fallback if logger not initialized
       }
 
+      const workflowLog = `[ServiceWrapper] Calling _startWorkflowListenersIfReady with registrationResult`;
+      const workflowData = {
+        hasSuccess: !!registrationResult?.success,
+        hasCertificate: !!registrationResult?.certificate
+      };
+      this.logger?.info(workflowLog, workflowData);
+      console.log(workflowLog, JSON.stringify(workflowData, null, 2)); // Fallback if logger not initialized
+      
+      await this._startWorkflowListenersIfReady(registrationResult, serviceName);
+
     } catch (error) {
       this.logger?.error(`Service registration failed: ${error.message}`, { error: error.message, stack: error.stack });
       throw new Error(`Failed to register service ${serviceName}: ${error.message}`);
@@ -403,6 +621,11 @@ class ServiceWrapper {
    * Verify infrastructure services are ready before creating business queues
    * Phase 8: Business Services Infrastructure Verification
    * 
+   * IMPORTANT: This method is called ONLY after service has received certificate (validated + registered).
+   * Business queues are created when BOTH conditions are met:
+   * 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.)
@@ -437,41 +660,7 @@ class ServiceWrapper {
     
     for (let attempt = 1; attempt <= maxRetries; attempt++) {
       try {
-        // Step 1: Check infrastructure health via Redis (using service-common)
-        // ServiceWrapper uses service-common (shared utility) to maintain architectural separation
-        this.logger?.info(`[InfrastructureVerify] Attempt ${attempt}/${maxRetries}: Checking infrastructure health...`);
-        
-        const redisUrl = this.config.wrapper?.cache?.url || process.env.REDIS_URL || 'redis://api_node_cache:6379';
-        
-        try {
-          const { waitForInfrastructureReady } = require('@onlineapps/service-common');
-          const waitMaxTime = 10000; // 10 seconds per attempt
-          const waitCheckInterval = 2000; // Check every 2 seconds
-          
-          await waitForInfrastructureReady({
-            redisUrl: redisUrl,
-            maxWait: waitMaxTime,
-            checkInterval: waitCheckInterval,
-            logger: {
-              log: (msg) => this.logger?.info(`[InfrastructureVerify] ${msg}`),
-              info: (msg) => this.logger?.info(`[InfrastructureVerify] ${msg}`)
-            }
-          });
-          this.logger?.info('[InfrastructureVerify] ✓ All infrastructure services are UP');
-        } catch (healthError) {
-          // Infrastructure not ready yet - will retry with exponential backoff
-          const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
-          this.logger?.warn(`[InfrastructureVerify] Infrastructure not ready (attempt ${attempt}/${maxRetries}), retrying in ${delay}ms...`, {
-            error: healthError.message
-          });
-          
-          if (attempt < maxRetries) {
-            await new Promise(resolve => setTimeout(resolve, delay));
-            continue; // Retry
-          } else {
-            throw new Error(`Infrastructure services not ready after ${maxRetries} attempts: ${healthError.message}`);
-          }
-        }
+        await this._waitForInfrastructureGate('business queue setup');
         
         // Step 2: Verify required infrastructure queues exist
         this.logger?.info('[InfrastructureVerify] Verifying required infrastructure queues exist...');
@@ -487,14 +676,23 @@ class ServiceWrapper {
         }
         
         const missingQueues = [];
+        const QUEUE_CHECK_TIMEOUT = 5000; // 5 seconds per queue check
         for (const queueName of requiredInfrastructureQueues) {
           try {
-            await channel.checkQueue(queueName);
+            // Add timeout to prevent hanging on checkQueue
+            const checkPromise = channel.checkQueue(queueName);
+            const checkTimeoutPromise = new Promise((_, reject) => {
+              setTimeout(() => {
+                reject(new Error(`checkQueue timeout after ${QUEUE_CHECK_TIMEOUT}ms`));
+              }, QUEUE_CHECK_TIMEOUT);
+            });
+            
+            await Promise.race([checkPromise, checkTimeoutPromise]);
             this.logger?.info(`[InfrastructureVerify] ✓ Queue exists: ${queueName}`);
           } catch (checkErr) {
-            if (checkErr.code === 404) {
+            if (checkErr.code === 404 || checkErr.message.includes('timeout')) {
               missingQueues.push(queueName);
-              this.logger?.warn(`[InfrastructureVerify] ✗ Queue missing: ${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);
@@ -504,25 +702,29 @@ class ServiceWrapper {
         }
         
         if (missingQueues.length > 0) {
-          const delay = Math.min(baseDelay * Math.pow(2, attempt - 1), maxDelay);
-          this.logger?.warn(`[InfrastructureVerify] Missing required infrastructure queues (attempt ${attempt}/${maxRetries}): ${missingQueues.join(', ')}. Retrying in ${delay}ms...`);
-          
-          if (attempt < maxRetries) {
-            await new Promise(resolve => setTimeout(resolve, delay));
-            continue; // Retry
-          } else {
-            throw new Error(`Required infrastructure queues missing after ${maxRetries} attempts: ${missingQueues.join(', ')}`);
-          }
+          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 {
-            await channel.checkQueue(queueName);
+            const checkPromise = channel.checkQueue(queueName);
+            const checkTimeoutPromise = new Promise((_, reject) => {
+              setTimeout(() => reject(new Error('timeout')), QUEUE_CHECK_TIMEOUT);
+            });
+            await Promise.race([checkPromise, checkTimeoutPromise]);
             this.logger?.info(`[InfrastructureVerify] ✓ Optional queue exists: ${queueName}`);
           } catch (checkErr) {
-            if (checkErr.code === 404) {
-              this.logger?.debug(`[InfrastructureVerify] Optional queue missing (not critical): ${queueName}`);
+            if (checkErr.code === 404 || checkErr.message.includes('timeout')) {
+              this.logger?.debug(`[InfrastructureVerify] Optional queue missing or timeout (not critical): ${queueName}`);
             }
           }
         }
@@ -996,9 +1198,7 @@ class ServiceWrapper {
     if (!this.config.service?.version) {
       throw new Error('Service version is required for validation');
     }
-    if (!this.logger) {
-      throw new Error('Monitoring must be initialized before validation');
-    }
+    // Logger není povinný - validace může běžet i bez něj (použije console)
 
     const { name: serviceName, version: serviceVersion, port: servicePort } = this.config.service;