Initial Commit

test/logger/Logger.ts

@@ -0,0 +1,120 @@
+import IAppender from './appenders/IAppender';
+import {LoggingLevel, LoggingLevelMapping} from './LoggingLevel';
+import type {Threshold} from './Threshold';
+
+export class Logger {
+  private readonly _category: string;
+  private readonly _threshold: Threshold;
+  private readonly _appenders: IAppender[];
+
+  constructor({category, threshold, appenders}: {category: string; threshold: Threshold; appenders: IAppender[]}) {
+    this._category = category;
+    this._threshold = threshold;
+    this._appenders = appenders;
+  }
+
+  public info(message: string, ...optionalParameters: unknown[]): void {
+    if (this._threshold.value < LoggingLevel.Info) {
+      return;
+    }
+
+    this.log(LoggingLevel.Info, message, ...optionalParameters);
+  }
+
+  public warn(message: string, ...optionalParameters: unknown[]): void {
+    if (this._threshold.value < LoggingLevel.Warning) {
+      return;
+    }
+
+    this.log(LoggingLevel.Warning, message, ...optionalParameters);
+  }
+
+  public error(message: string, ...optionalParameters: unknown[]): void {
+    if (this._threshold.value < LoggingLevel.Error) {
+      return;
+    }
+
+    this.log(LoggingLevel.Error, message, ...optionalParameters);
+  }
+
+  public fatal(message: string, ...optionalParameters: unknown[]): void {
+    if (this._threshold.value < LoggingLevel.Fatal) {
+      return;
+    }
+
+    this.log(LoggingLevel.Fatal, message, ...optionalParameters);
+  }
+
+  public debug(message: string, ...optionalParameters: unknown[]): void {
+    if (this._threshold.value < LoggingLevel.Debug) {
+      return;
+    }
+
+    this.log(LoggingLevel.Debug, message, ...optionalParameters);
+  }
+
+  public trace(message: string, ...optionalParameters: unknown[]): void {
+    if (this._threshold.value < LoggingLevel.Trace) {
+      return;
+    }
+
+    this.log(LoggingLevel.Trace, message, ...optionalParameters);
+  }
+
+  private log(level: LoggingLevel, message: string, ...optionalParameters: unknown[]): void {
+    const timestamp = new Date().toISOString();
+    const formattedMessage = this.formatMessage(message, ...optionalParameters);
+    const levelString = LoggingLevelMapping.convertLoggingLevelToLoggingLevelType(level);
+    
+    // Safely call appenders with error handling
+    this._appenders.forEach(appender => {
+      try {
+        appender.append(timestamp, level, this._category, `[${levelString}] ${formattedMessage}`);
+      } catch (error) {
+        // Fallback to console if appender fails
+        console.error(`[Logger] Appender failed for category ${this._category}:`, error);
+        console.log(`${timestamp} [${this._category}] [${levelString}] ${formattedMessage}`);
+      }
+    });
+  }
+
+  private formatMessage(message: string, ...optionalParameters: unknown[]): string {
+    if (optionalParameters.length === 0) {
+      return message;
+    }
+
+    // More efficient parameter substitution
+    let result = message;
+    let paramIndex = 0;
+    
+    // Replace all {} placeholders with parameters
+    while (result.includes('{}') && paramIndex < optionalParameters.length) {
+      const paramString = this.parameterToString(optionalParameters[paramIndex]);
+      result = result.replace('{}', paramString);
+      paramIndex++;
+    }
+    
+    // Append remaining parameters if any
+    if (paramIndex < optionalParameters.length) {
+      const remainingParams = optionalParameters.slice(paramIndex)
+        .map(param => this.parameterToString(param))
+        .join(' ');
+      result += ` ${remainingParams}`;
+    }
+    
+    return result;
+  }
+
+  private parameterToString(param: unknown): string {
+    if (param === null) return 'null';
+    if (param === undefined) return 'undefined';
+    if (typeof param === 'object') {
+      try {
+        return JSON.stringify(param);
+      } catch {
+        return String(param);
+      }
+    }
+    return String(param);
+  }
+}