@omen.foundation/node-microservice-runtime 0.1.50 → 0.1.52

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,49 @@ 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
+    // 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
+    if (standardOtelEnabled) {
+      // Try to discover collector asynchronously (won't block service startup)
+      // If collector is already running, we'll connect immediately
+      // If not, we'll retry periodically in the background
+      (async () => {
+        // Give collector a moment to start (if it's just starting)
+        await new Promise(resolve => setTimeout(resolve, 2000));
+        
+        // Try to discover collector (quick check, non-blocking)
+        try {
+          const discoveredEndpoint = await discoverOrStartCollector(
+            pino({ name: 'beamable-otlp-bg', level: 'info' }, process.stdout),
+            standardOtelEnabled,
+            env
+          );
+          
+          if (discoveredEndpoint) {
+            // Collector is ready - initialize OTLP logging now
+            const newProvider = await initializeOtlpLogging(
+              options.serviceName,
+              options.qualifiedServiceName,
+              env,
+              pino({ name: 'beamable-otlp-bg', level: 'info' }, process.stdout)
+            );
+            
+            if (newProvider) {
+              // Update the provider reference so future logs use OTLP
+              otlpProviderRef.provider = newProvider;
+              console.error(`[OTLP] Connected to collector at ${discoveredEndpoint} (background connection)`);
+            }
+          }
+        } catch (error) {
+          // Silently fail - collector will connect later if it starts
+        }
+      })(); // 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 { startCollectorAsync } from './collector-manager.js';
 import pino from 'pino';
 import { listRegisteredServices, getServiceOptions, getConfigureServicesHandlers, getInitializeServicesHandlers } from './decorators.js';
 import { generateOpenApiDocument } from './docs.js';
@@ -80,34 +80,20 @@ 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 5-10+ 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: ~70-80 seconds minimum, so use 120 seconds for safety
-    const otlpEndpoint = setupCollectorBeforeLogging(
-      this.env,
-      120000 // 120 second timeout to allow for download + startup + readiness
-    );
-    
-    if (otlpEndpoint) {
-      startupLogger.info(`Collector ready at ${otlpEndpoint}, creating main logger...`);
-    } else {
-      startupLogger.warn('Collector setup did not complete, continuing without OTLP logging');
-    }
+    // STEP 3: Start collector asynchronously in background (NON-BLOCKING)
+    // This allows the service to start immediately while collector downloads/starts
+    // Logs will work immediately (stdout), OTLP will connect when collector is ready
+    startupLogger.info('Starting OpenTelemetry collector setup in background (non-blocking)...');
+    startCollectorAsync(this.env);
     
-    // 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 logger immediately (service can start serving requests)
+    // Logger works immediately via stdout, OTLP will connect when collector is ready
+    // The logger will automatically start using OTLP once the collector is available
     this.logger = createLogger(this.env, {
       name: 'beamable-node-microservice',
       serviceName: primaryService.name,
       qualifiedServiceName: qualifiedServiceName,
-      otlpEndpoint: otlpEndpoint || undefined, // Pass endpoint if collector was set up
+      // Don't pass otlpEndpoint - let it discover/connect when collector is ready
     });
     this.serviceManager = new BeamableServiceManager(this.env, this.logger);