@omen.foundation/node-microservice-runtime 0.1.43 → 0.1.45

package/src/logger.ts

@@ -41,6 +41,7 @@ interface LoggerFactoryOptions {
   destinationPath?: string;
   serviceName?: string; // Service name for log filtering (e.g., "ExampleNodeService")
   qualifiedServiceName?: string; // Full qualified service name (e.g., "micro_ExampleNodeService")
+  otlpEndpoint?: string; // OTLP endpoint if collector is already set up (avoids re-discovery)
 }
 
 /**
@@ -560,6 +561,10 @@ function initializeOtlpSync(
     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
@@ -640,15 +645,75 @@ export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptio
   const usePrettyLogs = shouldUsePrettyLogs();
   
   // Initialize OTLP synchronously BEFORE creating the logger
-  // This ensures all logs from this point forward are captured via OTLP
-  // Similar to C# microservices which configure logging early in startup
-  // CRITICAL: We wait for collector to be fully initialized and ready before proceeding
-  const otlpProvider = initializeOtlpSync(
-    options.serviceName,
-    options.qualifiedServiceName,
-    env,
-    60000 // 60 second timeout to allow collector download, startup, and readiness verification
-  );
+  // If otlpEndpoint is provided (collector already set up), create provider directly
+  // Otherwise, try to discover/start collector (with timeout)
+  let otlpProvider: LoggerProvider | null = null;
+  
+  if (options.otlpEndpoint) {
+    // Collector is already set up, create OTLP provider directly without discovery/startup
+    // Set endpoint in env temporarily so initializeOtlpLogging uses it directly
+    const originalEndpoint = process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT;
+    process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT = options.otlpEndpoint;
+    
+    // Create OTLP provider directly (collector is already running, so this should be fast)
+    const initLogger = pino({
+      name: 'beamable-otlp-init',
+      level: 'info',
+    }, process.stdout);
+    
+    // Create provider synchronously - since endpoint is explicitly provided,
+    // initializeOtlpLogging will skip discovery and create provider directly
+    let provider: LoggerProvider | null = null;
+    let completed = false;
+    
+    initializeOtlpLogging(
+      options.serviceName,
+      options.qualifiedServiceName,
+      env,
+      initLogger
+    ).then((result) => {
+      provider = result;
+      completed = true;
+      if (result) {
+        initLogger.info(`[OTLP] OTLP provider created using existing collector at ${options.otlpEndpoint}`);
+      }
+    }).catch((error) => {
+      initLogger.error(`[OTLP] Failed to create OTLP provider: ${error instanceof Error ? error.message : String(error)}`);
+      completed = true;
+      provider = null;
+    });
+    
+    // Wait briefly for provider creation (should be very fast, < 1 second)
+    // eslint-disable-next-line @typescript-eslint/no-require-imports
+    const deasync = require('deasync');
+    const startTime = Date.now();
+    const timeout = 2000; // 2 second timeout (should be fast since no discovery needed)
+    
+    deasync.loopWhile(() => {
+      if (Date.now() - startTime >= timeout) {
+        return false;
+      }
+      return !completed;
+    });
+    
+    otlpProvider = provider;
+    
+    // Restore original endpoint if it existed
+    if (originalEndpoint !== undefined) {
+      process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT = originalEndpoint;
+    } else {
+      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
+    );
+  }
   
   // Shared reference for OTLP logger provider
   const otlpProviderRef: { provider: LoggerProvider | null } = { provider: otlpProvider };

package/src/runtime.ts

@@ -4,6 +4,8 @@ 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 pino from 'pino';
 import { listRegisteredServices, getServiceOptions, getConfigureServicesHandlers, getInitializeServicesHandlers } from './decorators.js';
 import { generateOpenApiDocument } from './docs.js';
 import { VERSION } from './index.js';
@@ -60,7 +62,15 @@ export class MicroserviceRuntime {
   constructor(env?: EnvironmentConfig) {
     this.env = env ?? loadEnvironmentConfig();
     
-    // Get registered services first to extract service name for logger
+    // STEP 1: Create minimal console logger for startup messages (before collector setup)
+    // This ensures we have logging available immediately, even before collector is ready
+    const startupLogger = pino({
+      name: 'beamable-runtime-startup',
+      level: 'info',
+    }, process.stdout);
+    startupLogger.info('Starting Beamable Node microservice runtime.');
+    
+    // STEP 2: Get registered services to extract service name
     const registered = listRegisteredServices();
     if (registered.length === 0) {
       throw new Error('No microservices registered. Use the @Microservice decorator to register at least one class.');
@@ -70,10 +80,27 @@ 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...');
+    const otlpEndpoint = setupCollectorBeforeLogging(
+      this.env,
+      60000 // 60 second timeout
+    );
+    
+    if (otlpEndpoint) {
+      startupLogger.info(`Collector ready at ${otlpEndpoint}, creating main logger...`);
+    } else {
+      startupLogger.warn('Collector setup did not complete, continuing without OTLP logging');
+    }
+    
+    // STEP 4: Create main logger (collector is now ready, so all logs will be captured)
+    // Pass the OTLP endpoint to skip re-discovery/startup
     this.logger = createLogger(this.env, {
       name: 'beamable-node-microservice',
       serviceName: primaryService.name,
       qualifiedServiceName: qualifiedServiceName,
+      otlpEndpoint: otlpEndpoint || undefined, // Pass endpoint if collector was set up
     });
     this.serviceManager = new BeamableServiceManager(this.env, this.logger);