@omen.foundation/node-microservice-runtime 0.1.55 → 0.1.57

package/src/collector-manager.ts

@@ -123,15 +123,22 @@ export async function fetchClickHouseCredentials(
   const uriPath = '/api/beamo/otel/auth/writer/config';
   const configUrl = new URL(uriPath, apiUrl).toString();
   
+  // Create a minimal logger for verbose output
+  const verboseLogger = pino({ name: 'fetch-credentials', level: 'info' }, process.stdout);
+  verboseLogger.info(`[Credentials] Starting credential fetch from ${configUrl}...`);
+  
   // Get secret from environment (required for signed requests)
   const secret = process.env.SECRET;
   if (!secret) {
+    verboseLogger.error('[Credentials] SECRET environment variable is missing');
     throw new Error('SECRET environment variable is required to fetch ClickHouse credentials');
   }
+  verboseLogger.info('[Credentials] SECRET found, calculating signature...');
   
   // Calculate signature for signed request (matching C# HttpSignedRequester)
   const pathAndQuery = getPathAndQuery(uriPath);
   const signature = calculateSignature(env.pid, secret, pathAndQuery, null, '1');
+  verboseLogger.info('[Credentials] Signature calculated, making API request...');
   
   // Build headers with signed authentication (matching C# HttpSignedRequester)
   const headers: Record<string, string> = {
@@ -141,22 +148,29 @@ export async function fetchClickHouseCredentials(
     'X-BEAM-SIGNATURE': signature,
   };
   
+  const fetchStartTime = Date.now();
   const response = await fetch(configUrl, {
     method: 'GET',
     headers,
   });
+  const fetchElapsed = Date.now() - fetchStartTime;
+  verboseLogger.info(`[Credentials] API request completed in ${fetchElapsed}ms, status: ${response.status}`);
   
   if (!response.ok) {
     const errorText = await response.text().catch(() => 'Unknown error');
+    verboseLogger.error(`[Credentials] API request failed: ${response.status} ${response.statusText}`);
     throw new Error(`Failed to fetch ClickHouse credentials from ${configUrl}: ${response.status} ${response.statusText} - ${errorText.substring(0, 200)}`);
   }
   
+  verboseLogger.info('[Credentials] Parsing response JSON...');
   const credentials = await response.json() as ClickHouseCredentials;
   
   if (!credentials.endpoint || !credentials.username || !credentials.password) {
+    verboseLogger.error('[Credentials] Invalid response: missing required fields');
     throw new Error('Invalid ClickHouse credentials response: missing required fields');
   }
   
+  verboseLogger.info(`[Credentials] Successfully fetched credentials (endpoint: ${credentials.endpoint}, username: ${credentials.username})`);
   return credentials;
 }
 
@@ -555,7 +569,7 @@ export function addAuthEnvironmentVars(endpoint: string, username: string, passw
  */
 export async function startCollectorAndWaitForReady(
   env: EnvironmentConfig,
-  timeoutMs: number = 180000 // 3 minutes to allow for download + startup
+  _timeoutMs?: number // Not used - kept for API compatibility
 ): Promise<string | null> {
   // Match C# logic: (this.InDocker() || UseLocalOtel) && !BEAM_DISABLE_STANDARD_OTEL
   const isInDocker = process.env.IS_LOCAL !== '1' && process.env.IS_LOCAL !== 'true';
@@ -575,65 +589,25 @@ export async function startCollectorAndWaitForReady(
   }, process.stdout);
 
   initLogger.info('[OTLP] Setting up collector (waiting for readiness before enabling Portal logs)...');
+  const setupStartTime = Date.now();
 
-  // Wait for collector to be ready with timeout
-  const startTime = Date.now();
-  let endpoint: string | null = null;
-  let completed = false;
-
-  // Start collector setup - wrap in a promise that handles errors
-  const setupPromise = discoverOrStartCollector(initLogger, standardOtelEnabled, env)
-    .then((result) => {
-      if (result) {
-        return result;
-      }
-      return null;
-    })
-    .catch((error) => {
-      initLogger.error(`[OTLP] Collector setup error: ${error instanceof Error ? error.message : String(error)}`);
-      return null;
-    });
-  
-  // Set timeout - only resolve if setup hasn't completed
-  const timeoutPromise = new Promise<string | null>((resolve) => {
-    setTimeout(() => {
-      if (!completed) {
-        initLogger.warn(`[OTLP] Collector setup timeout after ${timeoutMs}ms, continuing without Portal logs`);
-        completed = true;
-        resolve(null);
-      }
-    }, timeoutMs);
-  });
-
-  // Race between setup and timeout - wait for whichever completes first
-  // But we need to check if setup actually succeeded (got a valid endpoint)
+  // Simple linear async/await - no timeouts, no Promise.race complexity
   try {
-    const result = await Promise.race([setupPromise, timeoutPromise]);
+    initLogger.info('[OTLP] Step 1: Discovering or starting collector...');
+    const endpoint = await discoverOrStartCollector(initLogger, standardOtelEnabled, env);
+    const elapsed = Date.now() - setupStartTime;
     
-    // Check if we got a valid endpoint (setup completed successfully)
-    if (result && typeof result === 'string' && result.length > 0 && !completed) {
-      endpoint = result;
-      completed = true;
-      const elapsed = Date.now() - startTime;
-      initLogger.info(`[OTLP] Collector ready at ${endpoint} (took ${elapsed}ms). Portal logs now enabled.`);
+    if (endpoint) {
+      initLogger.info(`[OTLP] Collector ready at ${endpoint}. Portal logs now enabled. (took ${elapsed}ms)`);
       return endpoint;
+    } else {
+      initLogger.warn(`[OTLP] Collector setup failed, continuing without Portal logs. (took ${elapsed}ms)`);
+      return null;
     }
-    
-    // If we got here, either:
-    // 1. Setup returned null (failed or timed out internally)
-    // 2. Timeout promise resolved
-    // 3. Result is not a valid endpoint string
-    if (!completed) {
-      completed = true;
-    }
-    return null;
   } catch (error) {
-    // Setup promise rejected - collector startup failed
+    const elapsed = Date.now() - setupStartTime;
     const errorMsg = error instanceof Error ? error.message : String(error);
-    initLogger.error(`[OTLP] Collector setup failed: ${errorMsg}`);
-    if (!completed) {
-      completed = true;
-    }
+    initLogger.error(`[OTLP] Collector setup failed after ${elapsed}ms: ${errorMsg}`);
     return null;
   }
 }
@@ -796,7 +770,10 @@ export async function startCollector(
   if ((!clickhouseEndpoint || !clickhouseUsername || !clickhousePassword) && env) {
     try {
       logger.info('[Collector] Fetching ClickHouse credentials from Beamable API...');
+      const credStartTime = Date.now();
       const credentials = await fetchClickHouseCredentials(env);
+      const credElapsed = Date.now() - credStartTime;
+      logger.info(`[Collector] ClickHouse credentials fetch completed in ${credElapsed}ms`);
       clickhouseEndpoint = credentials.endpoint;
       clickhouseUsername = credentials.username;
       clickhousePassword = credentials.password;
@@ -833,8 +810,11 @@ export async function startCollector(
   }
   
   // Now resolve collector binary and config (after credentials are fetched and set)
-  logger.info('[Collector] Resolving collector binary and config...');
+  logger.info('[Collector] Step 2: Resolving collector binary and config...');
+  const resolveStartTime = Date.now();
   const collectorInfo = await resolveCollector(true, logger);
+  const resolveElapsed = Date.now() - resolveStartTime;
+  logger.info(`[Collector] Collector binary/config resolution completed in ${resolveElapsed}ms`);
   
   if (!collectorInfo.binaryPath) {
     logger.error('[Collector] Binary not found and download failed');
@@ -1067,11 +1047,14 @@ export async function discoverOrStartCollector(
   
   // First, check if collector is already running (via UDP discovery)
   if (!globalCollectorProcess) {
+    logger.info('[Collector] Checking for existing collector via UDP discovery...');
     const status = await isCollectorRunning();
+    logger.info(`[Collector] UDP discovery result: isRunning=${status.isRunning}, isReady=${status.isReady}, endpoint=${status.otlpEndpoint || 'none'}`);
     if (status.isRunning && status.isReady && status.otlpEndpoint) {
       logger.info(`[Collector] Found running collector at ${status.otlpEndpoint}`);
       return `http://${status.otlpEndpoint}`;
     }
+    logger.info('[Collector] No existing collector found, will start new one...');
   }
   
   // Collector not running - start it (or wait for existing one to be ready)
@@ -1089,12 +1072,15 @@ export async function discoverOrStartCollector(
         logger.info(`[Collector] Waiting for existing collector to become ready at ${endpoint}...`);
     } else {
       // Start a new collector
-      logger.info('[Collector] Starting OpenTelemetry collector...');
+      logger.info('[Collector] Starting new OpenTelemetry collector...');
+      const startCollectorTime = Date.now();
       const startResult = await startCollector(logger, undefined, env);
+      const startCollectorElapsed = Date.now() - startCollectorTime;
+      logger.info(`[Collector] Collector process started in ${startCollectorElapsed}ms, endpoint: ${startResult.endpoint}`);
       endpoint = startResult.endpoint;
       
       // Check if collector process exited immediately (crashed)
-      // Wait a bit longer to see if it crashes right after starting
+      logger.info('[Collector] Checking if collector process is still running...');
       await new Promise(resolve => setTimeout(resolve, 200));
       
       if (globalCollectorExitCode !== null && globalCollectorExitCode !== 0) {
@@ -1103,6 +1089,7 @@ export async function discoverOrStartCollector(
         logger.error(`[Collector] ${errorMsg}`);
         return null;
       }
+      logger.info('[Collector] Collector process is still running, proceeding to readiness check...');
     }
     
     // CRITICAL: Wait for collector to be fully ready before returning
@@ -1112,28 +1099,33 @@ export async function discoverOrStartCollector(
     const checkInterval = 500; // Check every 500ms
     const maxChecks = Math.floor(maxWaitTime / checkInterval);
     
-    logger.info('[Collector] Waiting for collector to become ready...');
+    logger.info(`[Collector] Waiting for collector to become ready (checking every ${checkInterval}ms, max ${maxWaitTime / 1000}s)...`);
+    const readinessStartTime = Date.now();
     
     for (let i = 0; i < maxChecks; i++) {
       await new Promise(resolve => setTimeout(resolve, checkInterval));
+      const elapsed = Date.now() - readinessStartTime;
       
       // Check if process exited during wait
       if (globalCollectorExitCode !== null && globalCollectorExitCode !== 0) {
         const errorMsg = `Collector process exited during startup with code ${globalCollectorExitCode}. ${globalCollectorStderr.length > 0 ? `Stderr: ${globalCollectorStderr.join('; ')}` : 'No stderr output.'}`;
         globalCollectorInitError = errorMsg;
-        logger.error(`[Collector] ${errorMsg}`);
+        logger.error(`[Collector] ${errorMsg} (after ${elapsed}ms)`);
         return null;
       }
       
+      logger.info(`[Collector] Checking collector readiness... (${(elapsed / 1000).toFixed(1)}s elapsed, attempt ${i + 1}/${maxChecks})`);
       const newStatus = await isCollectorRunning();
+      logger.info(`[Collector] Collector status: isRunning=${newStatus.isRunning}, isReady=${newStatus.isReady}, pid=${newStatus.pid}, endpoint=${newStatus.otlpEndpoint || 'none'}`);
+      
       if (newStatus.isRunning && newStatus.isReady) {
-        logger.info(`[Collector] Collector is ready at ${newStatus.otlpEndpoint || endpoint}`);
+        logger.info(`[Collector] Collector is ready at ${newStatus.otlpEndpoint || endpoint} (ready after ${elapsed}ms)`);
         return newStatus.otlpEndpoint ? `http://${newStatus.otlpEndpoint}` : endpoint;
       }
       
-      // Log progress every 2 seconds
-      if (i > 0 && i % 4 === 0) {
-        logger.info(`[Collector] Still waiting for collector to become ready... (${(i * checkInterval) / 1000}s elapsed)`);
+      // Log progress every second (every 2 checks)
+      if (i > 0 && i % 2 === 0) {
+        logger.info(`[Collector] Still waiting for collector to become ready... (${(elapsed / 1000).toFixed(1)}s elapsed)`);
       }
     }
     

package/src/runtime.ts

@@ -87,40 +87,28 @@ export class MicroserviceRuntime {
     // Use deasync to wait synchronously (constructor can't be async)
     startupLogger.info('Setting up OpenTelemetry collector (waiting for readiness before enabling Portal logs)...');
     
+    // Wait for collector to be ready - simple linear async/await
+    // Use deasync since constructor can't be async
     let otlpEndpoint: string | null = null;
     let collectorReady = false;
-    let collectorError: string | null = null;
     
-    // Start collector setup asynchronously
-    startCollectorAndWaitForReady(this.env, 180000)
+    startCollectorAndWaitForReady(this.env)
       .then((endpoint) => {
         otlpEndpoint = endpoint;
         collectorReady = true;
-        if (endpoint) {
-          startupLogger.info(`Collector ready at ${endpoint}, creating structured logger for Portal logs...`);
-        } else {
-          startupLogger.warn('Collector setup did not complete in time, Portal logs will not be available');
-        }
       })
       .catch((error) => {
-        collectorError = error instanceof Error ? error.message : String(error);
+        const errorMsg = error instanceof Error ? error.message : String(error);
+        startupLogger.error(`Failed to setup collector: ${errorMsg}`);
+        otlpEndpoint = null;
         collectorReady = true;
-        startupLogger.error(`Failed to setup collector: ${collectorError}`);
       });
     
-    // Wait synchronously for collector to be ready (with timeout)
-    const startTime = Date.now();
-    const timeoutMs = 180000; // 3 minutes
-    deasync.loopWhile(() => {
-      if (Date.now() - startTime >= timeoutMs) {
-        return false; // Timeout
-      }
-      return !collectorReady; // Continue waiting if not ready
-    });
+    // Wait synchronously for collector to be ready (constructor can't be async)
+    deasync.loopWhile(() => !collectorReady);
     
     // STEP 4: Create main logger
     // CRITICAL: Only create structured logger (Portal logs) if collector is ready
-    // If collector timed out or failed, continue with minimal console logger
     // This ensures Portal logs only appear AFTER collector is ready
     if (otlpEndpoint) {
       // Collector is ready - create structured logger with OTLP support