@omen.foundation/node-microservice-runtime 0.1.65 → 0.1.67

package/src/logger.ts

@@ -1,727 +0,0 @@
-import pino, { destination, type Logger, type LoggerOptions } from 'pino';
-import { Transform } from 'node:stream';
-import { createRequire } from 'node:module';
-import { ensureWritableTempDirectory } from './env.js';
-import type { EnvironmentConfig } from './types.js';
-import { logs } from '@opentelemetry/api-logs';
-import { LoggerProvider, SimpleLogRecordProcessor } from '@opentelemetry/sdk-logs';
-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';
-
-// Helper to get require function that works in both CJS and ESM
-declare const require: any;
-function getRequire(): any {
-  // Check if we're in CJS context (require.main exists)
-  if (typeof require !== 'undefined' && typeof require.main !== 'undefined') {
-    // CJS context - use require directly
-    return require;
-  }
-  // ESM context - use createRequire with import.meta.url
-  // TypeScript will complain in CJS builds, but this code only runs in ESM
-  // @ts-ignore - import.meta is ESM-only, TypeScript error in CJS is expected
-  return createRequire(import.meta.url);
-}
-
-/**
- * Determines if we should use pretty logs (local dev) or raw JSON logs (deployed).
- * 
- * Simple check: If IS_LOCAL=1 is set in environment, use pretty logs.
- * Otherwise, use raw Beamable JSON format for log collection.
- */
-function shouldUsePrettyLogs(): boolean {
-  // Check for explicit IS_LOCAL flag
-  return process.env.IS_LOCAL === '1' || process.env.IS_LOCAL === 'true';
-}
-
-interface LoggerFactoryOptions {
-  name?: string;
-  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)
-}
-
-/**
- * Maps Pino log levels to Beamable log levels
- * Pino levels: 10=trace, 20=debug, 30=info, 40=warn, 50=error, 60=fatal
- * Beamable levels: Debug, Info, Warning, Error, Fatal
- */
-function mapPinoLevelToBeamableLevel(level: number): string {
-  switch (level) {
-    case 10: // trace
-      return 'Debug';
-    case 20: // debug
-      return 'Debug';
-    case 30: // info
-      return 'Info';
-    case 40: // warn
-      return 'Warning';
-    case 50: // error
-      return 'Error';
-    case 60: // fatal
-      return 'Fatal';
-    default:
-      return 'Info';
-  }
-}
-
-/**
- * Initializes OpenTelemetry OTLP log exporter if configured.
- * Similar to C# microservices, checks for BEAM_OTEL_EXPORTER_OTLP_ENDPOINT or uses standard enabled flag.
- * 
- * @param serviceName - Service name for resource attributes
- * @param qualifiedServiceName - Qualified service name for resource attributes
- * @param env - Environment configuration
- * @returns OTLP logger provider if configured, null otherwise
- */
-async function initializeOtlpLogging(
-  serviceName?: string,
-  qualifiedServiceName?: string,
-  env?: EnvironmentConfig,
-  logger?: PinoLogger
-): Promise<LoggerProvider | null> {
-  // Check for explicit OTLP endpoint (same as C#: BEAM_OTEL_EXPORTER_OTLP_ENDPOINT)
-  // Also check standard OTEL environment variables
-  const otlpEndpoint = process.env.BEAM_OTEL_EXPORTER_OTLP_ENDPOINT 
-    || process.env.OTEL_EXPORTER_OTLP_ENDPOINT
-    || (process.env.OTEL_EXPORTER_OTLP_ENDPOINT_LOGS ? process.env.OTEL_EXPORTER_OTLP_ENDPOINT_LOGS : null);
-  
-  // Check for explicit OTLP protocol (same as C#: OtelExporterOtlpProtocol)
-  // C# uses OtlpExportProtocol enum: HttpProtobuf or HttpJson
-  const otlpProtocol = process.env.BEAM_OTEL_EXPORTER_OTLP_PROTOCOL
-    || process.env.OTEL_EXPORTER_OTLP_PROTOCOL
-    || process.env.OTEL_EXPORTER_OTLP_PROTOCOL_LOGS;
-  
-  // Check if standard OTLP is enabled (matching C# OtelExporterStandardEnabled)
-  // C#: (this.InDocker() || UseLocalOtel) && string.IsNullOrEmpty(Environment.GetEnvironmentVariable("BEAM_DISABLE_STANDARD_OTEL"))
-  // UseLocalOtel = BEAM_LOCAL_OTEL is set
-  // InDocker = IS_LOCAL is not set (for Node.js, we check IS_LOCAL !== '1' && !== 'true')
-  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;
-  
-  // If no explicit endpoint and standard OTLP not enabled, skip OTLP
-  if (!otlpEndpoint && !standardOtelEnabled) {
-    return Promise.resolve(null);
-  }
-  
-  try {
-    // Build resource attributes (similar to C# resourceProvider)
-    const resourceAttributes: Record<string, string> = {};
-    if (serviceName) {
-      resourceAttributes['service.namespace'] = serviceName;
-      resourceAttributes['service.name'] = serviceName;
-    }
-    if (qualifiedServiceName) {
-      resourceAttributes['service.instance.id'] = qualifiedServiceName;
-    }
-    if (env?.cid) {
-      resourceAttributes['beam.cid'] = String(env.cid);
-    }
-    if (env?.pid) {
-      resourceAttributes['beam.pid'] = String(env.pid);
-    }
-    if (env?.routingKey) {
-      resourceAttributes['beam.routing_key'] = String(env.routingKey);
-    }
-    
-    // Determine endpoint URL
-    // If explicit endpoint provided, use it directly (skip discovery/startup)
-    // If standard OTLP enabled but no explicit endpoint, try to discover or start collector
-    let endpointUrl = otlpEndpoint;
-    
-    // CRITICAL: Only discover/start collector if no explicit endpoint was provided
-    // If an endpoint is provided, it means the collector was already set up elsewhere
-    // (e.g., by setupCollectorBeforeLogging in the runtime constructor)
-    if (!endpointUrl && standardOtelEnabled && logger) {
-      // Try to discover existing collector or start a new one (like C# does)
-      try {
-        const discoveredEndpoint = await discoverOrStartCollector(logger, standardOtelEnabled, env);
-        if (discoveredEndpoint) {
-          endpointUrl = discoveredEndpoint;
-        } else {
-          console.error('[OTLP] Standard OTLP is enabled but could not discover or start collector.');
-          return Promise.resolve(null);
-        }
-      } catch (error) {
-        console.error('[OTLP] Failed to discover/start collector:', error instanceof Error ? error.message : String(error));
-        return Promise.resolve(null);
-      }
-    }
-    
-    // If still no endpoint, skip OTLP
-    if (!endpointUrl) {
-      if (standardOtelEnabled) {
-        console.error('[OTLP] Standard OTLP is enabled but no endpoint available. Set BEAM_OTEL_EXPORTER_OTLP_ENDPOINT to enable OTLP logging.');
-      }
-      return Promise.resolve(null);
-    }
-    
-    // Ensure endpoint format is correct based on protocol
-    // C# behavior:
-    // - Http protocol: endpoint should be like "http://127.0.0.1:4348" (with /v1/logs appended)
-    // - Grpc protocol: endpoint should be like "127.0.0.1:4348" (no http:// prefix, no /v1/logs)
-    // For now, we only support HTTP exporter, so we append /v1/logs
-    // If Grpc is specified, we'd need a different exporter package
-    let finalEndpointUrl = endpointUrl;
-    if (otlpProtocol && otlpProtocol.toLowerCase() === 'grpc') {
-      // Grpc protocol - don't modify endpoint (no http://, no /v1/logs)
-      // Note: Grpc exporter not yet implemented, this is for future support
-      console.warn('[OTLP] Grpc protocol specified but not yet supported, using HTTP endpoint format');
-      finalEndpointUrl = endpointUrl.includes('/v1/logs') 
-        ? endpointUrl 
-        : `${endpointUrl.replace(/\/$/, '')}/v1/logs`;
-    } else {
-      // HTTP protocol - ensure /v1/logs suffix
-      finalEndpointUrl = endpointUrl.includes('/v1/logs') 
-        ? endpointUrl 
-        : `${endpointUrl.replace(/\/$/, '')}/v1/logs`;
-    }
-    
-    // Create OTLP HTTP exporter
-    // Beamable uses HttpProtobuf as the standard protocol
-    // C# behavior:
-    // 1. If OtelExporterOtlpEndpoint and OtelExporterOtlpProtocol are provided, use them
-    // 2. Otherwise, always use HttpProtobuf protocol (Beamable's standard)
-    // Node.js: @opentelemetry/exporter-logs-otlp-http uses HTTP/JSON by default
-    // We configure contentType to 'application/x-protobuf' to match Beamable's standard
-    const exporterOptions: {
-      url: string;
-      headers?: Record<string, string>;
-      contentType?: string;
-    } = {
-      url: finalEndpointUrl,
-    };
-    
-    // Configure protocol/contentType (matching C# OtlpExportProtocol)
-    // Beamable uses HttpProtobuf as the default protocol
-    // C# supports: HttpProtobuf, HttpJson, Grpc
-    // If explicit protocol provided, use it; otherwise always default to HttpProtobuf
-    if (otlpProtocol) {
-      // Parse protocol string (HttpProtobuf, HttpJson, or Grpc)
-      const protocol = otlpProtocol.toLowerCase();
-      if (protocol === 'httpprotobuf' || protocol === 'protobuf') {
-        exporterOptions.contentType = 'application/x-protobuf';
-      } else if (protocol === 'httpjson' || protocol === 'json') {
-        exporterOptions.contentType = 'application/json';
-      } else if (protocol === 'grpc') {
-        // Note: Grpc protocol would require a different exporter package
-        // For now, we'll log a warning and fall back to HttpProtobuf
-        console.warn('[OTLP] Grpc protocol is not yet supported in Node.js runtime, falling back to HttpProtobuf');
-        exporterOptions.contentType = 'application/x-protobuf';
-      } else {
-        // Invalid protocol - default to HttpProtobuf (Beamable's standard)
-        console.warn(`[OTLP] Unknown protocol "${otlpProtocol}", defaulting to HttpProtobuf`);
-        exporterOptions.contentType = 'application/x-protobuf';
-      }
-    } else {
-      // No protocol specified - always default to HttpProtobuf (Beamable's standard)
-      exporterOptions.contentType = 'application/x-protobuf';
-    }
-    
-    // Headers if provided (matching C# OtelExporterOtlpHeaders)
-    if (process.env.BEAM_OTEL_EXPORTER_OTLP_HEADERS) {
-      exporterOptions.headers = JSON.parse(process.env.BEAM_OTEL_EXPORTER_OTLP_HEADERS);
-    }
-    
-    const exporter = new OTLPLogExporter(exporterOptions);
-    
-    // Create resource with attributes (merge with default resource)
-    // Note: BEAM_ALLOW_STARTUP_WITHOUT_ATTRIBUTES_RESOURCE is not applicable here
-    // as we always create a resource with attributes
-    const baseResource = defaultResource();
-    const customResource = resourceFromAttributes(resourceAttributes);
-    const resource = baseResource.merge(customResource);
-    
-    // Create log record processor
-    // Note: C# supports retry via BEAM_DISABLE_RETRY_OTEL and BEAM_OTEL_RETRY_MAX_SIZE
-    // SimpleLogRecordProcessor doesn't support retry - would need BatchLogRecordProcessor
-    // For now, we use SimpleLogRecordProcessor (no retry)
-    // TODO: Consider implementing retry logic if BEAM_DISABLE_RETRY_OTEL is not set
-    const processor = new SimpleLogRecordProcessor(exporter);
-    
-    // Create logger provider with resource and processor
-    const loggerProvider = new LoggerProvider({
-      resource: resource,
-      processors: [processor],
-    });
-    
-    // Set as global logger provider
-    logs.setGlobalLoggerProvider(loggerProvider);
-    
-    // Log successful initialization (to stdout for debugging)
-    // This helps diagnose if OTLP is working in deployed environments
-    console.error(`[OTLP] OpenTelemetry logging initialized. Endpoint: ${finalEndpointUrl}, Service: ${serviceName || 'unknown'}`);
-    
-    // CRITICAL: Verify collector is actually ready before returning
-    // If we started a collector, wait for it to be ready (up to 5 seconds)
-    if (standardOtelEnabled && logger) {
-      try {
-        const { isCollectorRunning } = await import('./collector-manager.js');
-        // Wait up to 5 seconds for collector to be ready
-        for (let i = 0; i < 50; i++) {
-          const status = await isCollectorRunning();
-          if (status.isRunning && status.isReady) {
-            if (logger) {
-              logger.info(`[OTLP] Collector confirmed ready at ${status.otlpEndpoint || finalEndpointUrl}`);
-            }
-            break;
-          }
-          // Wait 100ms between checks
-          await new Promise(resolve => setTimeout(resolve, 100));
-        }
-      } catch (error) {
-        // If we can't verify, log but continue
-        if (logger) {
-          logger.warn(`[OTLP] Could not verify collector readiness: ${error instanceof Error ? error.message : String(error)}`);
-        }
-      }
-    }
-    
-    return Promise.resolve(loggerProvider);
-  } catch (error) {
-    // If OTLP initialization fails, log error but continue without OTLP
-    // Don't throw - we still want stdout logging to work
-    // Log to stderr so it's visible in container logs
-    console.error('[OTLP] Failed to initialize OTLP logging:', error instanceof Error ? error.message : String(error));
-    if (error instanceof Error && error.stack) {
-      console.error('[OTLP] Stack trace:', error.stack);
-    }
-    return Promise.resolve(null);
-  }
-}
-
-/**
- * Creates a transform stream that converts Pino JSON logs to Beamable's expected format.
- * Beamable expects logs with __t (timestamp), __l (level), and __m (message) fields.
- * Also includes OpenTelemetry-compatible fields for ClickHouse compatibility.
- * Pino writes JSON strings (one per line) to the stream.
- * 
- * Also sends logs via OTLP if OTLP logger provider is configured.
- */
-function createBeamableLogFormatter(
-  serviceName?: string,
-  qualifiedServiceName?: string,
-  otlpProviderRef?: { provider: LoggerProvider | null }
-): Transform {
-  return new Transform({
-    objectMode: false, // Pino writes strings/Buffers, not objects
-    transform(chunk: Buffer, _encoding, callback) {
-      // Ensure we have a Buffer - Pino may write strings or Buffers
-      const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
-      try {
-        const line = buffer.toString('utf8');
-        // Skip empty lines
-        if (!line.trim()) {
-          callback();
-          return;
-        }
-        
-        // Parse Pino's JSON log line
-        const pinoLog = JSON.parse(line);
-        
-        // Extract timestamp - Pino uses 'time' field (ISO 8601 string or milliseconds)
-        // Convert to ISO 8601 string for Beamable
-        let timestamp: string;
-        if (typeof pinoLog.time === 'string') {
-          timestamp = pinoLog.time;
-        } else if (typeof pinoLog.time === 'number') {
-          timestamp = new Date(pinoLog.time).toISOString();
-        } else {
-          timestamp = new Date().toISOString();
-        }
-        
-        // Map Pino level to Beamable level
-        const level = mapPinoLevelToBeamableLevel(pinoLog.level);
-        
-        // Build the message - combine msg with any additional fields
-        // Pino's 'msg' field contains the log message
-        const messageParts: string[] = [];
-        if (pinoLog.msg) {
-          messageParts.push(pinoLog.msg);
-        }
-        
-        // Include error information if present
-        if (pinoLog.err) {
-          const err = pinoLog.err;
-          const errMsg = err.message || err.msg || 'Error';
-          const errStack = err.stack ? `\n${err.stack}` : '';
-          messageParts.push(`${errMsg}${errStack}`);
-        }
-        
-        // Build the Beamable log format (for CloudWatch Logs Insights)
-        const beamableLog: Record<string, unknown> = {
-          __t: timestamp,
-          __l: level,
-          __m: messageParts.length > 0 ? messageParts.join(' ') : 'No message',
-        };
-        
-        // Include additional context fields that might be useful
-        // These are included in the message object but not as top-level fields
-        const contextFields: Record<string, unknown> = {};
-        if (pinoLog.cid) contextFields.cid = pinoLog.cid;
-        if (pinoLog.pid) contextFields.pid = pinoLog.pid;
-        if (pinoLog.routingKey) contextFields.routingKey = pinoLog.routingKey;
-        if (pinoLog.service) contextFields.service = pinoLog.service;
-        if (pinoLog.component) contextFields.component = pinoLog.component;
-        
-        // Include service name in context for CloudWatch filtering
-        if (serviceName) {
-          contextFields.serviceName = serviceName;
-        }
-        if (qualifiedServiceName) {
-          contextFields.qualifiedServiceName = qualifiedServiceName;
-        }
-        
-        // Include any other fields that aren't standard Pino fields
-        const standardPinoFields = ['level', 'time', 'pid', 'hostname', 'name', 'msg', 'err', 'v', 'cid', 'pid', 'routingKey', 'sdkVersionExecution', 'service', 'component'];
-        for (const [key, value] of Object.entries(pinoLog)) {
-          if (!standardPinoFields.includes(key) && value !== undefined && value !== null) {
-            contextFields[key] = value;
-          }
-        }
-        
-        // If there are context fields, include them in the log
-        if (Object.keys(contextFields).length > 0) {
-          beamableLog.__c = contextFields;
-        }
-        
-        // Add OpenTelemetry-compatible fields for ClickHouse compatibility
-        // These fields allow an OpenTelemetry collector to parse and forward logs to ClickHouse
-        // The Portal's realm-level logs page queries ClickHouse's otel_logs table
-        const otelFields: Record<string, unknown> = {};
-        
-        // ResourceAttributes - service identification (for ClickHouse filtering)
-        const resourceAttributes: Record<string, unknown> = {};
-        // IMPORTANT: The Portal searches for service:ExampleNodeService (just the service name)
-        // So we need to set service.namespace to the service name, NOT the qualified name
-        // The qualified name (micro_ExampleNodeService) is used for CloudWatch log stream filtering
-        // But ClickHouse uses just the service name for filtering
-        if (serviceName) {
-          resourceAttributes['service.namespace'] = serviceName;
-          resourceAttributes['service.name'] = serviceName;
-        }
-        // Also include qualified name for reference
-        if (qualifiedServiceName) {
-          resourceAttributes['service.qualifiedName'] = qualifiedServiceName;
-        }
-        if (pinoLog.cid) {
-          resourceAttributes['beam.cid'] = String(pinoLog.cid);
-        }
-        if (pinoLog.pid) {
-          resourceAttributes['beam.pid'] = String(pinoLog.pid);
-        }
-        if (pinoLog.routingKey) {
-          resourceAttributes['beam.routing_key'] = String(pinoLog.routingKey);
-        }
-        
-        // LogAttributes - log-specific attributes
-        const logAttributes: Record<string, unknown> = {};
-        if (pinoLog.component) {
-          logAttributes['component'] = String(pinoLog.component);
-        }
-        if (pinoLog.err) {
-          const err = pinoLog.err;
-          if (err.message) logAttributes['exception.message'] = String(err.message);
-          if (err.stack) logAttributes['exception.stacktrace'] = String(err.stack);
-          if (err.type) logAttributes['exception.type'] = String(err.type);
-        }
-        
-        // Map Beamable log level to OpenTelemetry SeverityText
-        // Beamable: Debug, Info, Warning, Error, Fatal
-        // OpenTelemetry: Trace, Debug, Info, Warn, Error, Fatal, Unspecified
-        const severityTextMap: Record<string, string> = {
-          'Debug': 'Debug',
-          'Info': 'Information',
-          'Warning': 'Warning',
-          'Error': 'Error',
-          'Fatal': 'Critical',
-        };
-        const severityText = severityTextMap[level] || 'Information';
-        
-        // CRITICAL: ResourceAttributes and LogAttributes MUST always be present (even if empty)
-        // ClickHouse schema expects these fields to exist for proper querying
-        // The Portal queries ResourceAttributes['service.namespace'] - if ResourceAttributes is missing, queries fail
-        
-        // Ensure ResourceAttributes always has service.namespace when serviceName is provided
-        // This is the primary field used by Portal for service filtering
-        if (serviceName && !resourceAttributes['service.namespace']) {
-          resourceAttributes['service.namespace'] = serviceName;
-          resourceAttributes['service.name'] = serviceName;
-        }
-        
-        // Add OpenTelemetry fields to the log
-        // These are in addition to the Beamable format, so both systems can parse the logs
-        // CRITICAL: Always include all required OpenTelemetry fields for ClickHouse compatibility
-        otelFields['Timestamp'] = timestamp; // OpenTelemetry timestamp format (ISO 8601)
-        otelFields['SeverityText'] = severityText;
-        otelFields['Body'] = messageParts.length > 0 ? messageParts.join(' ') : 'No message';
-        // ALWAYS include ResourceAttributes (even if empty) - required for ClickHouse schema
-        otelFields['ResourceAttributes'] = resourceAttributes;
-        // ALWAYS include LogAttributes (even if empty) - required for ClickHouse schema
-        otelFields['LogAttributes'] = logAttributes;
-        
-        // IMPORTANT: For CloudWatch Logs Insights, we need to ensure @message contains valid JSON
-        // The Portal expects @message to be a JSON string that can be parsed to extract __t, __l, __m
-        // We output the Beamable format as the primary format, and include OpenTelemetry fields
-        // CloudWatch will store this as @message, and an OpenTelemetry collector will parse it
-        // and forward to ClickHouse's otel_logs table
-        
-        // Merge OpenTelemetry fields into the log (for ClickHouse compatibility)
-        // An OpenTelemetry collector can parse these fields and forward to ClickHouse
-        // Note: These extra fields won't break CloudWatch - it will just store them in @message
-        Object.assign(beamableLog, otelFields);
-        
-        // Send log via OTLP if configured (similar to C# MicroserviceOtelLogRecordExporter)
-        // Check if provider is available (may be null if still initializing)
-        if (otlpProviderRef?.provider) {
-          try {
-            const otlpLogger = otlpProviderRef.provider.getLogger(
-              serviceName || 'beamable-node-runtime',
-              undefined, // version
-              {
-                schemaUrl: undefined, // optional schema URL
-              }
-            );
-            
-            // Map Beamable level to OpenTelemetry SeverityNumber
-            const severityNumberMap: Record<string, number> = {
-              'Debug': 5,    // SEVERITY_NUMBER_DEBUG
-              'Info': 9,     // SEVERITY_NUMBER_INFO
-              'Warning': 13, // SEVERITY_NUMBER_WARN
-              'Error': 17,   // SEVERITY_NUMBER_ERROR
-              'Fatal': 21,   // SEVERITY_NUMBER_FATAL
-            };
-            
-            // Create log record for OTLP
-            otlpLogger.emit({
-              severityNumber: severityNumberMap[level] || 9,
-              severityText: severityText,
-              body: messageParts.length > 0 ? messageParts.join(' ') : 'No message',
-              attributes: {
-                ...logAttributes,
-                // Include additional context
-                ...(pinoLog.component ? { component: String(pinoLog.component) } : {}),
-              },
-              timestamp: new Date(timestamp).getTime() * 1_000_000, // nanoseconds
-              observedTimestamp: Date.now() * 1_000_000, // nanoseconds
-            });
-          } catch (otlpError) {
-            // If OTLP send fails, continue with stdout logging
-            // Don't block the log output
-            // Note: C# supports retry via BEAM_DISABLE_RETRY_OTEL and BEAM_OTEL_RETRY_MAX_SIZE
-            // SimpleLogRecordProcessor doesn't support retry - would need BatchLogRecordProcessor
-            // For now, we silently continue (retry would be handled at processor level if implemented)
-          }
-        }
-        
-        // Output as a single-line JSON string (required for CloudWatch)
-        // CloudWatch Logs Insights will store this entire JSON string in the @message field
-        const output = JSON.stringify(beamableLog) + '\n';
-        callback(null, Buffer.from(output, 'utf8'));
-      } catch (error) {
-        // If parsing fails, output a fallback log entry
-        const fallbackLog = {
-          __t: new Date().toISOString(),
-          __l: 'Error',
-          __m: `Failed to parse log entry: ${chunk.toString().substring(0, 200)}`,
-        };
-        callback(null, Buffer.from(JSON.stringify(fallbackLog) + '\n', 'utf8'));
-      }
-    },
-  });
-}
-
-
-export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptions = {}): Logger {
-  const configuredDestination = options.destinationPath ?? process.env.LOG_PATH;
-  const usePrettyLogs = shouldUsePrettyLogs();
-  
-  // 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)
-  // 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
-    // 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 OTLP provider asynchronously (non-blocking)
-    // Since endpoint is explicitly provided and collector is already ready,
-    // this should complete quickly, but we don't block for it
-    initializeOtlpLogging(
-      options.serviceName,
-      options.qualifiedServiceName,
-      env,
-      initLogger
-    ).then((provider) => {
-      if (provider) {
-        otlpProviderRef.provider = provider;
-        initLogger.info(`[OTLP] OTLP provider created using existing collector at ${options.otlpEndpoint}`);
-        initLogger.info(`[OTLP] OpenTelemetry logging initialized. Endpoint: ${options.otlpEndpoint}/v1/logs, Service: ${options.serviceName || 'unknown'}`);
-      } else {
-        initLogger.warn('[OTLP] OTLP provider creation returned null, structured logs will not be sent via OTLP');
-        otlpProviderRef.provider = null;
-      }
-    }).catch((error) => {
-      const errorMsg = error instanceof Error ? error.message : String(error);
-      initLogger.error(`[OTLP] Failed to create OTLP provider: ${errorMsg}`);
-      otlpProviderRef.provider = null;
-    });
-    
-    // Don't wait - logger will work immediately with console output,
-    // and OTLP will be added when the provider is ready (very quickly since collector is already running)
-    
-    // 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 - 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
-    }
-  }
-
-  const pinoOptions: LoggerOptions = {
-    name: options.name ?? 'beamable-node-runtime',
-    level: env.logLevel,
-    base: {
-      cid: env.cid,
-      pid: env.pid,
-      routingKey: env.routingKey ?? null,
-      sdkVersionExecution: env.sdkVersionExecution,
-      // Include service name in base fields for filtering
-      serviceName: options.serviceName,
-      qualifiedServiceName: options.qualifiedServiceName,
-    },
-    redact: {
-      paths: ['secret', 'refreshToken'],
-      censor: '***',
-    },
-    // Use timestamp in milliseconds (Pino default) for accurate conversion
-    timestamp: pino.stdTimeFunctions.isoTime,
-  };
-
-  // For deployed services, always log to stdout so container orchestrator can collect logs
-  // For local development, log to stdout unless a specific file path is provided
-  if (!configuredDestination || configuredDestination === '-' || configuredDestination === 'stdout' || configuredDestination === 'console') {
-    if (!usePrettyLogs) {
-      // Deployed/remote: Use Beamable JSON format for log collection
-      // Include OpenTelemetry fields for ClickHouse compatibility
-      // Also send logs via OTLP if configured
-      const beamableFormatter = createBeamableLogFormatter(
-        options.serviceName,
-        options.qualifiedServiceName,
-        otlpProviderRef
-      );
-      beamableFormatter.pipe(process.stdout);
-      return pino(pinoOptions, beamableFormatter);
-    } else {
-      // Local development: Use Pino's pretty printing for human-readable logs
-      // Try to use pino-pretty if available (optional dependency)
-      // If not available, fall back to default Pino JSON output
-      try {
-        // Check if pino-pretty is available
-        // Use getRequire() which handles both CJS and ESM contexts
-        const requireFn = getRequire();
-        const pinoPretty = requireFn('pino-pretty');
-        // Create a pretty stream with formatting options
-        const prettyStream = pinoPretty({
-          colorize: true,
-          translateTime: 'HH:MM:ss.l',
-          ignore: 'pid,hostname',
-          singleLine: false,
-        });
-        // Use pino with the pretty stream
-        return pino(pinoOptions, prettyStream);
-      } catch {
-        // pino-pretty not available, use default Pino output (JSON but readable)
-        // This is expected if pino-pretty isn't installed, so we silently fall back
-        return pino(pinoOptions, process.stdout);
-      }
-    }
-  }
-
-  // For file logging: Use Beamable format if not local, default Pino format if local
-  const resolvedDestination = configuredDestination === 'temp' ? ensureWritableTempDirectory() : configuredDestination;
-  if (!usePrettyLogs) {
-    const beamableFormatter = createBeamableLogFormatter(
-      options.serviceName,
-      options.qualifiedServiceName,
-      otlpProviderRef
-    );
-    const fileStream = destination({ dest: resolvedDestination, mkdir: true, append: true, sync: false });
-    beamableFormatter.pipe(fileStream as unknown as NodeJS.WritableStream);
-    return pino(pinoOptions, beamableFormatter);
-  } else {
-    const fileStream = destination({ dest: resolvedDestination, mkdir: true, append: true, sync: false });
-    return pino(pinoOptions, fileStream);
-  }
-}