@omen.foundation/node-microservice-runtime 0.1.51 → 0.1.53

package/src/logger.ts

@@ -9,7 +9,6 @@ import { OTLPLogExporter } from '@opentelemetry/exporter-logs-otlp-http';
 import { resourceFromAttributes, defaultResource } from '@opentelemetry/resources';
 import { discoverOrStartCollector } from './collector-manager.js';
 import type { Logger as PinoLogger } from 'pino';
-import deasync from 'deasync';
 
 // Helper to get require function that works in both CJS and ESM
 declare const require: any;
@@ -535,113 +534,6 @@ function createBeamableLogFormatter(
   });
 }
 
-/**
- * Synchronously initializes OTLP logging with a timeout.
- * This ensures OTLP is ready before any logs are emitted.
- * Similar to C# microservices which configure logging early in startup.
- * 
- * Uses a blocking wait mechanism to ensure initialization completes before returning.
- */
-function initializeOtlpSync(
-  serviceName?: string,
-  qualifiedServiceName?: string,
-  env?: EnvironmentConfig,
-  timeoutMs: number = 60000  // 60 seconds to allow collector download, startup, and readiness check
-): LoggerProvider | null {
-  // Match C# logic: (this.InDocker() || UseLocalOtel) && !BEAM_DISABLE_STANDARD_OTEL
-  const isInDocker = process.env.IS_LOCAL !== '1' && process.env.IS_LOCAL !== 'true';
-  const useLocalOtel = !!process.env.BEAM_LOCAL_OTEL;
-  const standardOtelEnabled = (isInDocker || useLocalOtel) && !process.env.BEAM_DISABLE_STANDARD_OTEL;
-  const hasExplicitEndpoint = !!process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT;
-  
-  // If OTLP is not needed, return immediately
-  if (!standardOtelEnabled && !hasExplicitEndpoint) {
-    return null;
-  }
-  
-  // Create a minimal console logger for initialization messages
-  const initLogger = pino({
-    name: 'beamable-otlp-init',
-    level: 'info',
-  }, process.stdout);
-
-  // If collector was already set up via setupCollectorBeforeLogging, 
-  // discoverOrStartCollector will find it and use a shorter timeout.
-  // If not, it will start it (with full timeout).
-  
-  // Use deasync to wait synchronously for the async initialization
-  // This allows the event loop to process while we wait, enabling async operations
-  // (like collector download) to complete
-  let provider: LoggerProvider | null = null;
-  let completed = false;
-  let initError: Error | null = null;
-  
-  // Start initialization promise (callbacks set flags for deasync.loopWhile to check)
-  initializeOtlpLogging(
-    serviceName,
-    qualifiedServiceName,
-    env,
-    initLogger
-  ).then((result) => {
-    provider = result;
-    completed = true;
-    if (result) {
-      initLogger.info('[OTLP] OpenTelemetry logging initialized successfully');
-    }
-    return result;
-  }).catch((error) => {
-    initError = error instanceof Error ? error : new Error(String(error));
-    completed = true;
-    initLogger.error(`[OTLP] Failed to initialize: ${initError.message}`);
-    return null;
-  });
-  
-  // Set timeout to prevent infinite wait
-  const startTime = Date.now();
-  const timeoutId = setTimeout(() => {
-    if (!completed) {
-      initLogger.warn(`[OTLP] Initialization timeout after ${timeoutMs}ms, continuing without OTLP`);
-      completed = true;
-    }
-  }, timeoutMs);
-  
-  // Wait synchronously for the promise to resolve using deasync
-  // deasync.loopWhile() allows event loop to process while we wait
-  // This enables async operations (like collector download) to run and complete
-  // CRITICAL: This must complete before the logger is created to capture all startup logs
-  try {
-    // Use deasync to wait for completion, with timeout check
-    // loopWhile returns false to stop waiting, true to continue
-    deasync.loopWhile(() => {
-      // Check if we've exceeded timeout
-      const elapsed = Date.now() - startTime;
-      if (elapsed >= timeoutMs) {
-        initLogger.warn(`[OTLP] Synchronous wait timeout after ${elapsed}ms`);
-        return false; // Stop waiting
-      }
-      // Continue waiting if not completed
-      // This allows the event loop to process async operations
-      return !completed;
-    });
-  } catch (error) {
-    // If deasync fails, log and continue
-    initLogger.error(`[OTLP] Error during synchronous wait: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  
-  clearTimeout(timeoutId);
-  
-  // Verify we got a provider (collector is ready)
-  if (completed && provider) {
-    initLogger.info('[OTLP] Initialization completed successfully, collector is ready');
-  } else if (!completed) {
-    initLogger.warn('[OTLP] Initialization did not complete in time, logs may not be sent via OTLP initially');
-    initLogger.warn('[OTLP] Service will continue without OTLP telemetry - requests will still be serviced');
-  } else {
-    initLogger.warn('[OTLP] Initialization completed but no provider returned, OTLP telemetry disabled');
-  }
-  
-  return provider;
-}
 
 export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptions = {}): Logger {
   const configuredDestination = options.destinationPath ?? process.env.LOG_PATH;
@@ -650,7 +542,13 @@ export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptio
   // Initialize OTLP synchronously BEFORE creating the logger
   // If otlpEndpoint is provided (collector already set up), create provider directly
   // Otherwise, try to discover/start collector (with timeout)
-  let otlpProvider: LoggerProvider | null = null;
+  // Check if standard OTLP is enabled (needed for the else branch)
+  const isInDocker = process.env.IS_LOCAL !== '1' && process.env.IS_LOCAL !== 'true';
+  const useLocalOtel = !!process.env.BEAM_LOCAL_OTEL;
+  const standardOtelEnabled = (isInDocker || useLocalOtel) && !process.env.BEAM_DISABLE_STANDARD_OTEL;
+  
+  // Shared reference for OTLP logger provider (create before async operations)
+  const otlpProviderRef: { provider: LoggerProvider | null } = { provider: null };
   
   if (options.otlpEndpoint) {
     // Collector is already set up, create OTLP provider directly without discovery/startup
@@ -699,7 +597,7 @@ export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptio
       return !completed;
     });
     
-    otlpProvider = provider;
+    otlpProviderRef.provider = provider;
     
     // Restore original endpoint if it existed
     if (originalEndpoint !== undefined) {
@@ -708,18 +606,59 @@ export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptio
       delete process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT;
     }
   } else {
-    // No endpoint provided - try to discover/start collector (full initialization)
-    // This ensures all logs from this point forward are captured via OTLP
-    otlpProvider = initializeOtlpSync(
-      options.serviceName,
-      options.qualifiedServiceName,
-      env,
-      60000 // 60 second timeout to allow collector download, startup, and readiness verification
-    );
+    // No endpoint provided - collector is starting asynchronously in background via startCollectorAsync()
+    // Don't block here - logger works immediately via stdout, OTLP will connect when collector is ready
+    otlpProviderRef.provider = null; // Start without OTLP - will connect when collector is ready
+    
+    // Start async discovery in background (non-blocking)
+    // This allows the service to start immediately while collector is downloading/starting
+    // CRITICAL: Only DISCOVER the collector, don't try to START it (startCollectorAsync handles startup)
+    if (standardOtelEnabled) {
+      // Poll for collector to become ready (won't block service startup)
+      // startCollectorAsync() is already starting it, we just need to wait and connect when ready
+      (async () => {
+        const bgLogger = pino({ name: 'beamable-otlp-bg', level: 'info' }, process.stdout);
+        const maxAttempts = 30; // Check for up to 30 seconds (30 * 1000ms)
+        const checkInterval = 1000; // Check every 1 second
+        
+        for (let attempt = 0; attempt < maxAttempts; attempt++) {
+          try {
+            // Import isCollectorRunning dynamically to avoid circular dependencies
+            const { isCollectorRunning } = await import('./collector-manager.js');
+            const collectorStatus = await isCollectorRunning();
+            
+            if (collectorStatus.isRunning && collectorStatus.isReady && collectorStatus.otlpEndpoint) {
+              // Collector is ready - initialize OTLP logging now
+              const endpoint = collectorStatus.otlpEndpoint.startsWith('http') 
+                ? collectorStatus.otlpEndpoint 
+                : `http://${collectorStatus.otlpEndpoint}`;
+              
+              const newProvider = await initializeOtlpLogging(
+                options.serviceName,
+                options.qualifiedServiceName,
+                env,
+                bgLogger
+              );
+              
+              if (newProvider) {
+                // Update the provider reference so future logs use OTLP
+                otlpProviderRef.provider = newProvider;
+                console.error(`[OTLP] Connected to collector at ${endpoint} (background connection)`);
+                break; // Success, stop polling
+              }
+            }
+          } catch (error) {
+            // Silently fail and continue polling
+          }
+          
+          // Wait before next check (unless we're on the last attempt)
+          if (attempt < maxAttempts - 1) {
+            await new Promise(resolve => setTimeout(resolve, checkInterval));
+          }
+        }
+      })(); // Fire and forget - don't await
+    }
   }
-  
-  // Shared reference for OTLP logger provider
-  const otlpProviderRef: { provider: LoggerProvider | null } = { provider: otlpProvider };
 
   const pinoOptions: LoggerOptions = {
     name: options.name ?? 'beamable-node-runtime',

package/src/runtime.ts

@@ -4,7 +4,7 @@ import { GatewayRequester } from './requester.js';
 import { AuthManager } from './auth.js';
 import { createLogger } from './logger.js';
 import { loadEnvironmentConfig } from './env.js';
-import { setupCollectorBeforeLogging } from './collector-manager.js';
+import { startCollectorAndWaitForReady } from './collector-manager.js';
 import pino from 'pino';
 import { listRegisteredServices, getServiceOptions, getConfigureServicesHandlers, getInitializeServicesHandlers } from './decorators.js';
 import { generateOpenApiDocument } from './docs.js';
@@ -80,30 +80,47 @@ export class MicroserviceRuntime {
     const primaryService = registered[0];
     const qualifiedServiceName = `micro_${primaryService.qualifiedName}`;
     
-    // STEP 3: Setup collector BEFORE creating the main logger
-    // This ensures all logs from the main logger are captured via OTLP
-    startupLogger.info('Setting up OpenTelemetry collector...');
-    // Timeout needs to account for:
-    // - API call for credentials (~1-2 seconds)
-    // - Downloading collector binary (~12MB, can take 30-60+ seconds on slow networks)
-    // - Downloading collector config (~1 second)
-    // - Starting collector process (~1 second)
-    // - Waiting for collector to be ready (up to 60 seconds)
-    // Total: ~90-125 seconds minimum, so use 180 seconds (3 minutes) for safety
-    // Real-world testing shows downloads can take 2+ minutes on slow networks
-    const otlpEndpoint = setupCollectorBeforeLogging(
-      this.env,
-      180000 // 180 second timeout (3 minutes) to allow for slow downloads + startup + readiness
-    );
+    // STEP 3: Wait for collector to be ready BEFORE creating structured logger
+    // Portal logs (structured logs via OTLP) should only appear AFTER collector is ready
+    // This ensures all runtime startup logs are captured and appear in Portal
+    // Use deasync to wait synchronously (constructor can't be async)
+    startupLogger.info('Setting up OpenTelemetry collector (waiting for readiness before enabling Portal logs)...');
     
-    if (otlpEndpoint) {
-      startupLogger.info(`Collector ready at ${otlpEndpoint}, creating main logger...`);
-    } else {
-      startupLogger.warn('Collector setup did not complete, continuing without OTLP logging');
-    }
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const deasync = require('deasync');
+    let otlpEndpoint: string | null = null;
+    let collectorReady = false;
+    let collectorError: string | null = null;
+    
+    // Start collector setup asynchronously
+    startCollectorAndWaitForReady(this.env, 180000)
+      .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);
+        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
+    });
     
-    // STEP 4: Create main logger (collector is now ready, so all logs will be captured)
-    // Pass the OTLP endpoint to skip re-discovery/startup
+    // STEP 4: Create main structured logger (collector is now ready, Portal logs will work)
+    // Pass the OTLP endpoint to ensure it uses the ready collector
     this.logger = createLogger(this.env, {
       name: 'beamable-node-microservice',
       serviceName: primaryService.name,