sasai-common-utils 1.0.45 → 1.0.47

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasai-common-utils",
-  "version": "1.0.45",
+  "version": "1.0.47",
   "description": "Reusable utility library for common logging and other shared features.",
   "main": "src/index.js",
   "scripts": {
@@ -11,15 +11,14 @@
   "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",
     "@opentelemetry/sdk-logs": "^0.211.0",
-    "@opentelemetry/semantic-conventions": "^1.39.0",
     "jsonwebtoken": "^9.0.2",
     "klona": "^2.0.6",
     "pino": "^9.6.0",
+    "pino-opentelemetry-transport": "^1.1.0",
     "pino-pretty": "^13.0.0",
     "traverse": "^0.6.11",
     "winston": "^3.17.0"

package/src/features/logger/index.js

@@ -1,20 +1,12 @@
 const jwt = require("jsonwebtoken");
-const { HTTP_STATUS_CODES } = require("./constants");
-const { redactInformation } = require("./redact");
 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 { resourceFromAttributes } = require("@opentelemetry/resources");
-const { ATTR_SERVICE_NAME, ATTR_DEPLOYMENT_ENVIRONMENT } = require("@opentelemetry/semantic-conventions");
-const { SeverityNumber } = require("@opentelemetry/api-logs");
+const { HTTP_STATUS_CODES, DEBUG_MODES } = require("./constants");
+const { redactInformation } = require("./redact");
 
 let contextProvider = () => ({});
 let globalConfig = {};
 let loggerInstance;
 let pinoLogger;
-let otelLoggerProvider;
-let otelLogger;
 
 function setContextProvider(provider) {
   contextProvider = provider;
@@ -31,150 +23,67 @@ function setGlobalConfig(config) {
   };
 }
 
-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 cleanString(str) {
+  return typeof str === "string" ? str.replace(/\\"/g, '"') : str;
 }
 
-function initOTEL() {
-  if (!globalConfig.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) {
-    console.log("[Logger] OTLP endpoint not configured, skipping OTLP logs");
-    return;
-  }
-
-  try {
-    // Create resource with proper attributes
-    const resource = resourceFromAttributes({
-      [ATTR_SERVICE_NAME]: globalConfig.SERVICE_NAME,
-      [ATTR_DEPLOYMENT_ENVIRONMENT]: globalConfig.NODE_ENV,
-    });
-
-    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,
+function initPinoLogger() {
+  const pinoOptions = {
+    timestamp: false,
+    level: globalConfig.DEBUG_MODE === DEBUG_MODES.DISABLE ? "silent" : globalConfig.LOG_LEVEL,
+    base: { service_name: globalConfig.SERVICE_NAME },
+    formatters: {
+      level() {
+        return { level_name: globalConfig.LOG_LEVEL.toUpperCase() };
+      },
+    },
   };
-  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();
-
-      // Use trace/span from data if available, otherwise try to get from active span
-      let traceId = data.trace || spanContext?.traceId || "";
-      let spanId = data.span || spanContext?.spanId || "";
-      
-      const logRecord = {
-        severityNumber: getSeverityNumber(level),
-        severityText: level.toUpperCase(),
-        body: typeof data === "string" ? data : JSON.stringify(data),
-        attributes: {
-          "log.level": level,
-          "service.name": globalConfig.SERVICE_NAME,
-          ...(traceId && { "trace.id": traceId }),
-          ...(spanId && { "span.id": spanId }),
-          ...data,
+  if (globalConfig.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT) {
+    // When OTLP logs endpoint is configured, fan-out to both stdout and OTLP.
+    // Use require.resolve so pino's worker thread can find the transport
+    // regardless of the caller's working directory.
+    const stdoutTarget = {
+      target: require.resolve("pino/file"),
+      options: { destination: 1 }, // stdout
+    };
+    const otelTarget = {
+      target: require.resolve("pino-opentelemetry-transport"),
+      options: {
+        resourceAttributes: {
+          "service.name": globalConfig.SERVICE_NAME ,
         },
-      };
-
-      // Add trace context to log record if available
-      if (traceId) {
-        logRecord.traceId = traceId;
-      }
-      if (spanId) {
-        logRecord.spanId = spanId;
-      }
-      if (spanContext?.traceFlags !== undefined) {
-        logRecord.traceFlags = spanContext.traceFlags;
-      } else if (traceId) {
-        logRecord.traceFlags = 1; // Default to SAMPLED if we have a traceId
-      }
-
-      otelLogger.emit(logRecord);
-    } catch (error) {
-      console.error("[Logger] Failed to send OTLP log:", error);
+      },
+    };
+    const transport = pino.transport({ targets: [stdoutTarget, otelTarget] });
+    pinoLogger = pino(pinoOptions, transport);
+  } else {
+    // No OTLP endpoint — write to stdout or file based on DEBUG_MODE
+    let destination;
+    if (globalConfig.DEBUG_MODE === DEBUG_MODES.FILE) {
+      destination = pino.destination("app.log");
+    } else {
+      destination = pino.destination(1); // stdout (CONSOLE or default)
     }
+    pinoLogger = pino(pinoOptions, destination);
   }
 }
 
-// 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);
-    }
-  }
+function emitLog(level, data) {
+  if (!pinoLogger) return;
+  const { trace, span, message, ...rest } = data;
+  pinoLogger[level]({
+    trace_id: trace || undefined,
+    span_id: span || undefined,
+    message: cleanString(message),
+    ...rest,
+  });
 }
 
-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);
-  initPino();
-  initOTEL();
+  initPinoLogger();
 
   loggerInstance = {
     logInfo: (message, data = {}) => {
@@ -212,8 +121,9 @@ function createLogger(config) {
       const redactedData = redactInformation(logData, {
         sensitiveKeys: globalConfig?.SENSITIVE_KEYS,
       });
-      sendLog("info", redactedData);
+      emitLog("info", redactedData);
     },
+
     logError: (data = {}, req = {}) => {
       const traceContext = contextProvider();
       const errorResponse = data?.error?.response;
@@ -231,30 +141,30 @@ function createLogger(config) {
         message: JSON.stringify({
           step: data?.step || "",
           message: data?.error?.message,
-          method:  errorResponse?.config?.method?.toUpperCase(),
+          method: errorResponse?.config?.method?.toUpperCase(),
           parameters: data?.parameters || "",
           path: errorResponse?.config?.url || req?.originalUrl,
           responseStatus: errorResponse?.status || HTTP_STATUS_CODES.BAD_REQUEST,
           headers: errorResponse?.config?.headers || {},
           requestBody: errorResponse?.config?.body || req?.body,
-          responseBody: errorResponse?.data || {},  
+          responseBody: errorResponse?.data || {},
           stack: data?.error?.stack,
           tokenDetails: {
             customerId: tokenData?.customerId || "",
             mid: tokenData?.mid || "",
             tenantId: tokenData?.tenantId || "",
-          },                  
+          },
         }),
       };
       const redactedData = redactInformation(logData, {
         sensitiveKeys: globalConfig?.SENSITIVE_KEYS,
       });
-      sendLog("error", redactedData);
+      emitLog("error", redactedData);
     },
+
     logDebug: (message, data = {}) => {
-      sendLog("debug", { message, ...data });
+      emitLog("debug", { message, ...data });
     },
-    shutdown, // Expose shutdown method
   };
 
   return loggerInstance;
@@ -264,5 +174,4 @@ module.exports = {
   createLogger,
   setContextProvider,
   logger: loggerInstance,
-  shutdown, // Export shutdown for manual cleanup if needed
 };

package/src/features/logger/logWorker.js

@@ -8,69 +8,29 @@ let otelLoggerProvider = null;
 try {
   const { LoggerProvider, BatchLogRecordProcessor } = require("@opentelemetry/sdk-logs");
   const { OTLPLogExporter } = require("@opentelemetry/exporter-logs-otlp-http");
-  const { resourceFromAttributes } = require("@opentelemetry/resources");
+  const { Resource } = require("@opentelemetry/resources");
   
-  // Create OTLP Log Exporter with collector options
+  // Create OTLP Log Exporter
   const logExporter = new OTLPLogExporter({
-    url: globalConfig.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT || 'http://localhost:4318/v1/logs',
-    concurrencyLimit: 1 // Limit on pending requests
+    url: globalConfig.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT || 'http://localhost:4318/v1/logs'
   });
 
-  // Create batch processor for efficient log export
-  const logRecordProcessor = new BatchLogRecordProcessor(logExporter);
-
-  // Create Logger Provider with resource attributes and processors
+  // Create Logger Provider with resource attributes
   otelLoggerProvider = new LoggerProvider({
-    resource: resourceFromAttributes({
+    resource: new Resource({
       'service.name': globalConfig.SERVICE_NAME || 'sasai-service',
       'deployment.environment': globalConfig.NODE_ENV || ''
-    }),
-    processors: [logRecordProcessor]  // Use 'processors' not 'logRecordProcessors'
+    })
   });
+
+  // Add batch processor for efficient log export
+  otelLoggerProvider.addLogRecordProcessor(new BatchLogRecordProcessor(logExporter));
   
-  console.log('✅ OpenTelemetry Logs SDK initialized', {
-    endpoint: globalConfig.OTEL_EXPORTER_OTLP_LOGS_ENDPOINT || 'http://localhost:4318/v1/logs',
-    serviceName: globalConfig.SERVICE_NAME 
-  });
+  console.log('✅ OpenTelemetry Logs SDK initialized');
 } catch (error) {
   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"
@@ -120,43 +80,24 @@ function sendToOtel(level, logData) {
   if (!otelLoggerProvider) return;
   
   try {
-    const { SeverityNumber } = require('@opentelemetry/api-logs');
-    const otelLogger = otelLoggerProvider.getLogger(globalConfig.SERVICE_NAME, '1.0.0');
-    
-    // Get severity from level
-    const severityMap = {
-      'trace': SeverityNumber.TRACE,
-      'debug': SeverityNumber.DEBUG,
-      'info': SeverityNumber.INFO,
-      'warn': SeverityNumber.WARN,
-      'error': SeverityNumber.ERROR,
-      'fatal': SeverityNumber.FATAL
-    };
+    const otelLogger = otelLoggerProvider.getLogger(globalConfig.SERVICE_NAME);
     
-    // Prepare the log record according to OpenTelemetry Logs spec
-    const logRecord = {
-      timestamp: Date.now() * 1000000, // Convert to nanoseconds
-      severityNumber: severityMap[level] || SeverityNumber.INFO,
+    // Emit log record to OpenTelemetry
+    otelLogger.emit({
+      severityNumber: pinoLevelToOtelSeverity(level),
       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
-      }
-    };
-
-    // 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);
+      },
+      timestamp: Date.now() * 1000000, // Convert to nanoseconds
+    });
   } catch (error) {
     // Silently fail to avoid breaking the logging flow
-    console.error('Failed to send log to OpenTelemetry:', error.message, error.stack);
+    console.error('Failed to send log to OpenTelemetry:', error.message);
   }
 }