sasai-common-utils 1.0.41 → 1.0.43

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasai-common-utils",
-  "version": "1.0.41",
+  "version": "1.0.43",
   "description": "Reusable utility library for common logging and other shared features.",
   "main": "src/index.js",
   "scripts": {
@@ -11,6 +11,7 @@
   "license": "ISC",
   "dependencies": {
     "@elastic/ecs-winston-format": "^1.5.3",
+    "@opentelemetry/api": "^1.9.0",
     "@opentelemetry/api-logs": "^0.211.0",
     "@opentelemetry/exporter-logs-otlp-http": "^0.211.0",
     "@opentelemetry/resources": "^2.5.0",

package/src/features/logger/index.js

@@ -1,23 +1,24 @@
 const jwt = require("jsonwebtoken");
 const { HTTP_STATUS_CODES } = require("./constants");
 const { redactInformation } = require("./redact");
-const { Worker } = require("worker_threads");
-const path = require("path");
+const pino = require("pino");
+const { trace, context } = require("@opentelemetry/api");
+const { LoggerProvider, BatchLogRecordProcessor } = require("@opentelemetry/sdk-logs");
+const { OTLPLogExporter } = require("@opentelemetry/exporter-logs-otlp-http");
+const { Resource } = require("@opentelemetry/resources");
+const { SeverityNumber } = require("@opentelemetry/api-logs");
+
 let contextProvider = () => ({});
 let globalConfig = {};
 let loggerInstance;
+let pinoLogger;
+let otelLoggerProvider;
+let otelLogger;
 
 function setContextProvider(provider) {
   contextProvider = provider;
 }
-let loggerWorker;
-
 
-function initLoggerWorker() {
-  loggerWorker = new Worker(path.join(__dirname, "logWorker.js"), {
-    workerData: { globalConfig }
-});
-}
 function setGlobalConfig(config) {
   globalConfig = {
     SERVICE_NAME: config?.SERVICE_NAME,
@@ -29,18 +30,138 @@ function setGlobalConfig(config) {
   };
 }
 
-function sendToWorker(level, data) {
-  if (loggerWorker) {
-    loggerWorker.postMessage({ level, data });
+function initPino() {
+  const pinoConfig = {
+    level: globalConfig.LOG_LEVEL || "info",
+    transport:
+      globalConfig.DEBUG_MODE === "true"
+        ? { target: "pino-pretty", options: { colorize: true } }
+        : undefined,
+  };
+  pinoLogger = pino(pinoConfig);
+}
+
+function initOTEL() {
+  if (!globalConfig.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) {
+    console.log("[Logger] OTLP endpoint not configured, skipping OTLP logs");
+    return;
+  }
+
+  try {
+    const resource = new Resource({
+      "service.name": globalConfig.SERVICE_NAME || "unknown-service",
+      "deployment.environment": globalConfig.NODE_ENV || "unknown",
+    });
+
+    const logExporter = new OTLPLogExporter({
+      url: globalConfig.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT,
+      headers: {},
+    });
+
+    const logRecordProcessor = new BatchLogRecordProcessor(logExporter, {
+      maxQueueSize: 2048,
+      maxExportBatchSize: 512,
+      scheduledDelayMillis: 5000,
+      exportTimeoutMillis: 30000,
+    });
+
+    otelLoggerProvider = new LoggerProvider({
+      resource,
+      logRecordProcessors: [logRecordProcessor],
+    });
+
+    otelLogger = otelLoggerProvider.getLogger(
+      globalConfig.SERVICE_NAME || "default-logger",
+      "1.0.0"
+    );
+
+    console.log("[Logger] OTLP logs initialized successfully");
+  } catch (error) {
+    console.error("[Logger] Failed to initialize OTLP:", error);
+  }
+}
+
+function getSeverityNumber(level) {
+  const severityMap = {
+    trace: SeverityNumber.TRACE,
+    debug: SeverityNumber.DEBUG,
+    info: SeverityNumber.INFO,
+    warn: SeverityNumber.WARN,
+    error: SeverityNumber.ERROR,
+    fatal: SeverityNumber.FATAL,
+  };
+  return severityMap[level] || SeverityNumber.INFO;
+}
+
+function sendLog(level, data) {
+  // Send to Pino (console/file)
+  if (pinoLogger) {
+    pinoLogger[level](data);
+  }
+
+  // Send to OTLP
+  if (otelLogger) {
+    try {
+      const activeSpan = trace.getSpan(context.active());
+      const spanContext = activeSpan?.spanContext();
+
+      const logRecord = {
+        severityNumber: getSeverityNumber(level),
+        severityText: level.toUpperCase(),
+        body: typeof data === "string" ? data : JSON.stringify(data),
+        attributes: {
+          "log.level": level,
+          ...(data.trace && { "trace.id": data.trace }),
+          ...(data.span && { "span.id": data.span }),
+          ...data,
+        },
+        ...(spanContext?.traceId && { traceId: spanContext.traceId }),
+        ...(spanContext?.spanId && { spanId: spanContext.spanId }),
+        ...(spanContext?.traceFlags !== undefined && {
+          traceFlags: spanContext.traceFlags,
+        }),
+      };
+
+      otelLogger.emit(logRecord);
+    } catch (error) {
+      console.error("[Logger] Failed to send OTLP log:", error);
+    }
+  }
+}
+
+// Graceful shutdown
+async function shutdown() {
+  if (otelLoggerProvider) {
+    console.log("[Logger] Shutting down OTLP logger...");
+    try {
+      await otelLoggerProvider.shutdown();
+      console.log("[Logger] OTLP logger shutdown complete");
+    } catch (error) {
+      console.error("[Logger] Error during OTLP shutdown:", error);
+    }
   }
 }
 
+process.on("beforeExit", () => {
+  shutdown().catch(console.error);
+});
+
+process.on("SIGTERM", () => {
+  shutdown().then(() => process.exit(0));
+});
+
+process.on("SIGINT", () => {
+  shutdown().then(() => process.exit(0));
+});
+
 function createLogger(config) {
   if (loggerInstance) return loggerInstance;
+  
   setGlobalConfig(config);
-  initLoggerWorker();
+  initPino();
+  initOTEL();
 
-  return {
+  loggerInstance = {
     logInfo: (message, data = {}) => {
       const traceContext = contextProvider();
       const authHeader =
@@ -76,7 +197,7 @@ function createLogger(config) {
       const redactedData = redactInformation(logData, {
         sensitiveKeys: globalConfig?.SENSITIVE_KEYS,
       });
-      sendToWorker("info", redactedData);
+      sendLog("info", redactedData);
     },
     logError: (data = {}, req = {}) => {
       const traceContext = contextProvider();
@@ -113,16 +234,20 @@ function createLogger(config) {
       const redactedData = redactInformation(logData, {
         sensitiveKeys: globalConfig?.SENSITIVE_KEYS,
       });
-      sendToWorker("error", redactedData);
+      sendLog("error", redactedData);
     },
     logDebug: (message, data = {}) => {
-      sendToWorker("debug", { message, ...data });
+      sendLog("debug", { message, ...data });
     },
+    shutdown, // Expose shutdown method
   };
+
+  return loggerInstance;
 }
 
 module.exports = {
   createLogger,
   setContextProvider,
   logger: loggerInstance,
+  shutdown, // Export shutdown for manual cleanup if needed
 };

package/src/features/logger/logWorker.js

@@ -36,6 +36,41 @@ try {
   console.warn('⚠️ OpenTelemetry Logs SDK not available, logs will only write locally:', error.message);
 }
 
+// Graceful shutdown handlers for OpenTelemetry Logger Provider
+// CRITICAL: Without this, batched logs will be lost when worker exits
+process.on('beforeExit', async () => {
+  if (otelLoggerProvider) {
+    try {
+      await otelLoggerProvider.shutdown();
+      console.log('✅ OpenTelemetry Logs SDK gracefully shutdown');
+    } catch (error) {
+      console.error('❌ Error shutting down OpenTelemetry Logs SDK:', error.message);
+    }
+  }
+});
+
+process.on('SIGTERM', async () => {
+  if (otelLoggerProvider) {
+    try {
+      await otelLoggerProvider.shutdown();
+      console.log('✅ OpenTelemetry Logs SDK shutdown on SIGTERM');
+    } catch (error) {
+      console.error('❌ Error shutting down OpenTelemetry Logs SDK on SIGTERM:', error.message);
+    }
+  }
+});
+
+process.on('SIGINT', async () => {
+  if (otelLoggerProvider) {
+    try {
+      await otelLoggerProvider.shutdown();
+      console.log('✅ OpenTelemetry Logs SDK shutdown on SIGINT');
+    } catch (error) {
+      console.error('❌ Error shutting down OpenTelemetry Logs SDK on SIGINT:', error.message);
+    }
+  }
+});
+
 // Initialize Pino logger inside the worker
 function cleanString(str) {
   return typeof str === "string"
@@ -85,24 +120,43 @@ function sendToOtel(level, logData) {
   if (!otelLoggerProvider) return;
   
   try {
-    const otelLogger = otelLoggerProvider.getLogger(globalConfig.SERVICE_NAME);
+    const { SeverityNumber } = require('@opentelemetry/api-logs');
+    const otelLogger = otelLoggerProvider.getLogger(globalConfig.SERVICE_NAME, '1.0.0');
     
-    // Emit log record to OpenTelemetry
-    otelLogger.emit({
-      severityNumber: pinoLevelToOtelSeverity(level),
+    // Get severity from level
+    const severityMap = {
+      'trace': SeverityNumber.TRACE,
+      'debug': SeverityNumber.DEBUG,
+      'info': SeverityNumber.INFO,
+      'warn': SeverityNumber.WARN,
+      'error': SeverityNumber.ERROR,
+      'fatal': SeverityNumber.FATAL
+    };
+    
+    // Prepare the log record according to OpenTelemetry Logs spec
+    const logRecord = {
+      timestamp: Date.now() * 1000000, // Convert to nanoseconds
+      severityNumber: severityMap[level] || SeverityNumber.INFO,
       severityText: level.toUpperCase(),
       body: logData.message || JSON.stringify(logData),
       attributes: {
-        'trace.id': logData.trace_id,
-        'span.id': logData.span_id,
         'service.name': globalConfig.SERVICE_NAME,
         ...logData
-      },
-      timestamp: Date.now() * 1000000, // Convert to nanoseconds
-    });
+      }
+    };
+
+    // Add trace context if available
+    if (logData.trace_id && logData.trace_id !== '') {
+      logRecord.traceId = logData.trace_id;
+      logRecord.spanId = logData.span_id || '';
+      logRecord.traceFlags = 1; // SAMPLED
+    }
+
+    // Emit log record to OpenTelemetry
+    otelLogger.emit(logRecord);
   } catch (error) {
     // Silently fail to avoid breaking the logging flow
-    console.error('Failed to send log to OpenTelemetry:', error.message);
+    console.error('Failed to send log to OpenTelemetry:', error.message, error.stack);
   }
 }