added logger

libs/logger/src/logger.ts

@@ -0,0 +1,358 @@
+/**
+ * Enhanced logger with Loki integration for Stock Bot platform
+ * 
+ * Features:
+ * - Multiple log levels (debug, info, warn, error)
+ * - Console and file logging
+ * - Loki integration for centralized logging
+ * - Structured logging with metadata
+ * - Performance optimized with batching
+ * - Service-specific context
+ */
+
+import winston from 'winston';
+import LokiTransport from 'winston-loki';
+import DailyRotateFile from 'winston-daily-rotate-file';
+import { loggingConfig, lokiConfig } from '@stock-bot/config';
+import type { LogLevel, LogContext, LogMetadata } from './types';
+
+// Global logger instances cache
+const loggerInstances = new Map<string, winston.Logger>();
+
+/**
+ * Create or retrieve a logger instance for a specific service
+ */
+export function createLogger(serviceName: string, options?: {
+  level?: LogLevel;
+  enableLoki?: boolean;
+  enableFile?: boolean;
+  enableConsole?: boolean;
+}): winston.Logger {
+  const key = `${serviceName}-${JSON.stringify(options || {})}`;
+  
+  if (loggerInstances.has(key)) {
+    return loggerInstances.get(key)!;
+  }
+
+  const logger = buildLogger(serviceName, options);
+  loggerInstances.set(key, logger);
+  
+  return logger;
+}
+
+/**
+ * Build a winston logger with all configured transports
+ */
+function buildLogger(serviceName: string, options?: {
+  level?: LogLevel;
+  enableLoki?: boolean;
+  enableFile?: boolean;
+  enableConsole?: boolean;
+}): winston.Logger {
+  const {
+    level = loggingConfig.LOG_LEVEL as LogLevel,
+    enableLoki = true,
+    enableFile = loggingConfig.LOG_FILE,
+    enableConsole = loggingConfig.LOG_CONSOLE
+  } = options || {};  // Base logger configuration
+  const transports: winston.transport[] = [];
+
+  // Console transport
+  if (enableConsole) {
+    transports.push(new winston.transports.Console({
+      format: winston.format.combine(
+        winston.format.colorize(),
+        winston.format.simple(),
+        winston.format.printf(({ timestamp, level, service, message, metadata }) => {
+          const meta = metadata && Object.keys(metadata).length > 0 
+            ? `\n${JSON.stringify(metadata, null, 2)}` 
+            : '';
+          return `${timestamp} [${level}] [${service}] ${message}${meta}`;
+        })
+      )
+    }));
+  }
+
+  // File transport with daily rotation
+  if (enableFile) {
+    // General log file
+    transports.push(new DailyRotateFile({
+      filename: `${loggingConfig.LOG_FILE_PATH}/${serviceName}-%DATE%.log`,
+      datePattern: loggingConfig.LOG_FILE_DATE_PATTERN,
+      zippedArchive: true,
+      maxSize: loggingConfig.LOG_FILE_MAX_SIZE,
+      maxFiles: loggingConfig.LOG_FILE_MAX_FILES,
+      format: winston.format.combine(
+        winston.format.timestamp(),
+        winston.format.json()
+      )
+    }));
+
+    // Separate error log file
+    if (loggingConfig.LOG_ERROR_FILE) {
+      transports.push(new DailyRotateFile({
+        level: 'error',
+        filename: `${loggingConfig.LOG_FILE_PATH}/${serviceName}-error-%DATE%.log`,
+        datePattern: loggingConfig.LOG_FILE_DATE_PATTERN,
+        zippedArchive: true,
+        maxSize: loggingConfig.LOG_FILE_MAX_SIZE,
+        maxFiles: loggingConfig.LOG_FILE_MAX_FILES,
+        format: winston.format.combine(
+          winston.format.timestamp(),
+          winston.format.json()
+        )
+      }));
+    }
+  }
+
+  // Loki transport for centralized logging
+  if (enableLoki && lokiConfig.LOKI_HOST) {
+    try {
+      const lokiTransport = new LokiTransport({
+        host: lokiConfig.LOKI_URL || `http://${lokiConfig.LOKI_HOST}:${lokiConfig.LOKI_PORT}`,
+        labels: {
+          service: serviceName,
+          environment: lokiConfig.LOKI_ENVIRONMENT_LABEL,
+          ...(lokiConfig.LOKI_DEFAULT_LABELS ? JSON.parse(lokiConfig.LOKI_DEFAULT_LABELS) : {})
+        },
+        json: true,
+        batching: true,
+        interval: lokiConfig.LOKI_FLUSH_INTERVAL_MS,
+        timeout: lokiConfig.LOKI_PUSH_TIMEOUT,
+        basicAuth: lokiConfig.LOKI_USERNAME && lokiConfig.LOKI_PASSWORD 
+          ? `${lokiConfig.LOKI_USERNAME}:${lokiConfig.LOKI_PASSWORD}`
+          : undefined,
+        onConnectionError: (err) => {
+          console.error('Loki connection error:', err);
+        }
+      });
+
+      transports.push(lokiTransport);
+    } catch (error) {
+      console.warn('Failed to initialize Loki transport:', error);
+    }
+  }
+
+  const loggerConfig: winston.LoggerOptions = {
+    level,
+    format: winston.format.combine(
+      winston.format.timestamp({ format: 'YYYY-MM-DD HH:mm:ss.SSS' }),
+      winston.format.errors({ stack: true }),
+      winston.format.metadata({
+        fillExcept: ['message', 'level', 'timestamp', 'service']
+      }),
+      winston.format.json()
+    ),
+    defaultMeta: {
+      service: serviceName,
+      environment: loggingConfig.LOG_ENVIRONMENT,
+      version: loggingConfig.LOG_SERVICE_VERSION
+    },
+    transports
+  };
+
+  return winston.createLogger(loggerConfig);
+}
+
+/**
+ * Enhanced Logger class with convenience methods
+ */
+export class Logger {
+  private winston: winston.Logger;
+  private serviceName: string;
+  private context: LogContext;
+
+  constructor(serviceName: string, context: LogContext = {}, options?: {
+    level?: LogLevel;
+    enableLoki?: boolean;
+    enableFile?: boolean;
+    enableConsole?: boolean;
+  }) {
+    this.serviceName = serviceName;
+    this.context = context;
+    this.winston = createLogger(serviceName, options);
+  }
+
+  /**
+   * Debug level logging
+   */
+  debug(message: string, metadata?: LogMetadata): void {
+    this.log('debug', message, metadata);
+  }
+
+  /**
+   * Info level logging
+   */
+  info(message: string, metadata?: LogMetadata): void {
+    this.log('info', message, metadata);
+  }
+
+  /**
+   * Warning level logging
+   */
+  warn(message: string, metadata?: LogMetadata): void {
+    this.log('warn', message, metadata);
+  }
+
+  /**
+   * Error level logging
+   */
+  error(message: string, error?: Error | any, metadata?: LogMetadata): void {
+    const logData: LogMetadata = { ...metadata };
+    
+    if (error) {
+      if (error instanceof Error) {
+        logData.error = {
+          name: error.name,
+          message: error.message,
+          stack: loggingConfig.LOG_ERROR_STACK ? error.stack : undefined
+        };
+      } else {
+        logData.error = error;
+      }
+    }
+
+    this.log('error', message, logData);
+  }
+
+  /**
+   * HTTP request logging
+   */
+  http(message: string, requestData?: {
+    method?: string;
+    url?: string;
+    statusCode?: number;
+    responseTime?: number;
+    userAgent?: string;
+    ip?: string;
+  }): void {
+    if (!loggingConfig.LOG_HTTP_REQUESTS) return;
+
+    this.log('http', message, {
+      request: requestData,
+      type: 'http_request'
+    });
+  }
+
+  /**
+   * Performance/timing logging
+   */
+  performance(message: string, timing: {
+    operation: string;
+    duration: number;
+    startTime?: number;
+    endTime?: number;
+  }): void {
+    if (!loggingConfig.LOG_PERFORMANCE) return;
+
+    this.log('info', message, {
+      performance: timing,
+      type: 'performance'
+    });
+  }
+
+  /**
+   * Business event logging
+   */
+  business(message: string, event: {
+    type: string;
+    entity?: string;
+    action?: string;
+    result?: 'success' | 'failure' | 'partial';
+    amount?: number;
+    symbol?: string;
+  }): void {
+    this.log('info', message, {
+      business: event,
+      type: 'business_event'
+    });
+  }
+
+  /**
+   * Security event logging
+   */
+  security(message: string, event: {
+    type: 'authentication' | 'authorization' | 'access' | 'vulnerability';
+    user?: string;
+    resource?: string;
+    action?: string;
+    result?: 'success' | 'failure';
+    ip?: string;
+    severity?: 'low' | 'medium' | 'high' | 'critical';
+  }): void {
+    this.log('warn', message, {
+      security: event,
+      type: 'security_event'
+    });
+  }
+
+  /**
+   * Create a child logger with additional context
+   */
+  child(context: LogContext): Logger {
+    return new Logger(this.serviceName, { ...this.context, ...context });
+  }
+
+  /**
+   * Add persistent context to this logger
+   */
+  addContext(context: LogContext): void {
+    this.context = { ...this.context, ...context };
+  }
+
+  /**
+   * Internal logging method
+   */
+  private log(level: LogLevel, message: string, metadata?: LogMetadata): void {
+    const logData = {
+      ...this.context,
+      ...metadata,
+      timestamp: new Date().toISOString()
+    };
+
+    this.winston.log(level, message, logData);
+  }
+
+  /**
+   * Get the underlying winston logger
+   */
+  getWinstonLogger(): winston.Logger {
+    return this.winston;
+  }
+  /**
+   * Gracefully close all transports
+   */
+  async close(): Promise<void> {
+    return new Promise((resolve) => {
+      this.winston.end(() => {
+        resolve();
+      });
+    });
+  }
+}
+
+/**
+ * Create a default logger instance for a service
+ */
+export function getLogger(serviceName: string, context?: LogContext): Logger {
+  return new Logger(serviceName, context);
+}
+
+/**
+ * Shutdown all logger instances gracefully
+ */
+export async function shutdownLoggers(): Promise<void> {
+  const closePromises = Array.from(loggerInstances.values()).map(logger => 
+    new Promise<void>((resolve) => {
+      logger.end(() => {
+        resolve();
+      });
+    })
+  );
+  
+  await Promise.all(closePromises);
+  loggerInstances.clear();
+}
+
+// Export types for convenience
+export type { LogLevel, LogContext, LogMetadata } from './types';