@omen.foundation/node-microservice-runtime 0.1.10 → 0.1.12

package/src/logger.ts

@@ -32,6 +32,8 @@ function shouldUsePrettyLogs(): boolean {
 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")
 }
 
 /**
@@ -61,9 +63,10 @@ function mapPinoLevelToBeamableLevel(level: number): string {
 /**
  * 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.
  */
-function createBeamableLogFormatter(): Transform {
+function createBeamableLogFormatter(serviceName?: string, qualifiedServiceName?: string): Transform {
   return new Transform({
     objectMode: false, // Pino writes strings, not objects
     transform(chunk: Buffer, _encoding, callback) {
@@ -107,7 +110,7 @@ function createBeamableLogFormatter(): Transform {
           messageParts.push(`${errMsg}${errStack}`);
         }
         
-        // Build the Beamable log format
+        // Build the Beamable log format (for CloudWatch Logs Insights)
         const beamableLog: Record<string, unknown> = {
           __t: timestamp,
           __l: level,
@@ -123,6 +126,14 @@ function createBeamableLogFormatter(): Transform {
         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)) {
@@ -136,6 +147,70 @@ function createBeamableLogFormatter(): Transform {
           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> = {};
+        if (qualifiedServiceName) {
+          // ClickHouse expects service.namespace to match the service name format
+          resourceAttributes['service.namespace'] = qualifiedServiceName;
+        }
+        if (serviceName) {
+          resourceAttributes['service.name'] = serviceName;
+        }
+        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';
+        
+        // Add OpenTelemetry fields to the log
+        // These are in addition to the Beamable format, so both systems can parse the logs
+        otelFields['Timestamp'] = timestamp; // OpenTelemetry timestamp format
+        otelFields['SeverityText'] = severityText;
+        otelFields['Body'] = messageParts.length > 0 ? messageParts.join(' ') : 'No message';
+        if (Object.keys(resourceAttributes).length > 0) {
+          otelFields['ResourceAttributes'] = resourceAttributes;
+        }
+        if (Object.keys(logAttributes).length > 0) {
+          otelFields['LogAttributes'] = logAttributes;
+        }
+        
+        // Merge OpenTelemetry fields into the log (for ClickHouse compatibility)
+        // An OpenTelemetry collector can parse these fields and forward to ClickHouse
+        Object.assign(beamableLog, otelFields);
+        
         // Output as a single-line JSON string (required for CloudWatch)
         const output = JSON.stringify(beamableLog) + '\n';
         callback(null, Buffer.from(output, 'utf8'));
@@ -164,6 +239,9 @@ export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptio
       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'],
@@ -178,7 +256,8 @@ export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptio
   if (!configuredDestination || configuredDestination === '-' || configuredDestination === 'stdout' || configuredDestination === 'console') {
     if (!usePrettyLogs) {
       // Deployed/remote: Use Beamable JSON format for log collection
-      const beamableFormatter = createBeamableLogFormatter();
+      // Include OpenTelemetry fields for ClickHouse compatibility
+      const beamableFormatter = createBeamableLogFormatter(options.serviceName, options.qualifiedServiceName);
       beamableFormatter.pipe(process.stdout);
       return pino(pinoOptions, beamableFormatter);
     } else {
@@ -210,7 +289,7 @@ export function createLogger(env: EnvironmentConfig, options: LoggerFactoryOptio
   // 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();
+    const beamableFormatter = createBeamableLogFormatter(options.serviceName, options.qualifiedServiceName);
     const fileStream = destination({ dest: resolvedDestination, mkdir: true, append: true, sync: false });
     beamableFormatter.pipe(fileStream as unknown as NodeJS.WritableStream);
     return pino(pinoOptions, beamableFormatter);

package/src/runtime.ts

@@ -58,13 +58,24 @@ export class MicroserviceRuntime {
 
   constructor(env?: EnvironmentConfig) {
     this.env = env ?? loadEnvironmentConfig();
-    this.logger = createLogger(this.env, { name: 'beamable-node-microservice' });
-    this.serviceManager = new BeamableServiceManager(this.env, this.logger);
-
+    
+    // Get registered services first to extract service name for logger
     const registered = listRegisteredServices();
     if (registered.length === 0) {
       throw new Error('No microservices registered. Use the @Microservice decorator to register at least one class.');
     }
+    
+    // Use the first service's name for the main logger (for CloudWatch filtering and ClickHouse compatibility)
+    const primaryService = registered[0];
+    const qualifiedServiceName = `micro_${primaryService.qualifiedName}`;
+    
+    this.logger = createLogger(this.env, {
+      name: 'beamable-node-microservice',
+      serviceName: primaryService.name,
+      qualifiedServiceName: qualifiedServiceName,
+    });
+    this.serviceManager = new BeamableServiceManager(this.env, this.logger);
+
     this.services = registered.map((definition) => {
       const instance = new definition.ctor() as Record<string, unknown>;
       const configureHandlers = getConfigureServicesHandlers(definition.ctor);
@@ -92,8 +103,9 @@ export class MicroserviceRuntime {
     this.authManager = new AuthManager(this.env, this.requester);
     this.requester.on('event', (envelope) => this.handleEvent(envelope));
 
-    // Discovery broadcaster only runs in local development
-    if ((process.env.IS_LOCAL === '1' || process.env.IS_LOCAL === 'true') && this.services.length > 0) {
+    // Discovery broadcaster only runs in local development (not in containers)
+    // This allows the portal to detect that the service is running locally
+    if (!isRunningInContainer() && this.services.length > 0) {
       this.discovery = new DiscoveryBroadcaster({
         env: this.env,
         serviceName: this.services[0].definition.name,
@@ -803,27 +815,30 @@ function debugLog(...args: unknown[]): void {
   }
 }
 
+/**
+ * Determines if we're running in a deployed container.
+ * Used for service registration logic (routing key handling, discovery broadcaster, etc.)
+ * 
+ * Note: For log formatting, use IS_LOCAL env var instead.
+ */
 function isRunningInContainer(): boolean {
-  // Check for Docker container first (most reliable indicator)
-  // Docker creates /.dockerenv file in containers
+  // Check for Docker container
   try {
     const fs = require('fs');
     if (fs.existsSync('/.dockerenv')) {
-      return true; // Definitely in Docker
+      return true;
     }
   } catch {
-    // fs might not be available, continue with other checks
+    // fs might not be available
   }
   
-  // Check for Docker container hostname pattern
-  // Docker containers often have hostnames that are just hex strings (12 chars)
+  // Check for Docker container hostname pattern (12 hex chars)
   const hostname = process.env.HOSTNAME || '';
   if (hostname && /^[a-f0-9]{12}$/i.test(hostname)) {
-    // This looks like a Docker container ID as hostname
     return true;
   }
   
-  // Explicit container indicators (highest priority after Docker checks)
+  // Explicit container indicators
   if (
     process.env.DOTNET_RUNNING_IN_CONTAINER === 'true' ||
     process.env.CONTAINER === 'beamable' ||
@@ -833,18 +848,7 @@ function isRunningInContainer(): boolean {
     return true;
   }
   
-  // If we have Beamable env vars AND no routing key from process.env (not auto-generated)
-  // This indicates a deployed container (Beamable sets these but not routing key)
-  const hasBeamableEnvVars = !!(process.env.CID && process.env.PID && process.env.HOST && process.env.SECRET);
-  const hasExplicitRoutingKey = !!(process.env.NAME_PREFIX || process.env.ROUTING_KEY);
-  
-  if (hasBeamableEnvVars && !hasExplicitRoutingKey) {
-    // We have Beamable env vars but no explicit routing key from env
-    // This means we're in a deployed container (routing key would be auto-generated, but we're in container)
-    return true;
-  }
-  
-  // Default: assume local development (npm run dev)
+  // Default: assume local development
   return false;
 }