(#371) Restructured logging code, extended functionality of ConsoleLogProvider for timestamps and log levels

Author: s1hofmann

Diff for: lib/logging.function.ts

@@ -0,0 +1,13 @@
+import { LogProviderInterface } from "./provider/log-provider.interface";
+import { ConsoleLogLevel, ConsoleLogProvider, ConsoleLogProviderConfig } from "./provider/io/console-log-provider.class";
+import providerRegistry from "./provider/provider-registry.class";
+
+export const useLogger = (logger: LogProviderInterface) => {
+  providerRegistry.registerLogProvider(logger);
+};
+
+export const useConsoleLogger = (config?: ConsoleLogProviderConfig) => {
+  providerRegistry.registerLogProvider(new ConsoleLogProvider(config));
+}
+
+export { ConsoleLogLevel }

Diff for: lib/provider/io/console-log-provider.class.ts

@@ -0,0 +1,91 @@
+import { LogProviderInterface } from "../log-provider.interface";
+
+export enum ConsoleLogLevel {
+  TRACE,
+  DEBUG,
+  INFO,
+  WARN,
+  ERROR,
+}
+  
+export interface ConsoleLogProviderConfig {
+  logLevel: ConsoleLogLevel,
+  withTimeStamp: boolean,
+}
+
+const defaultConfig: ConsoleLogProviderConfig = {
+  logLevel: ConsoleLogLevel.INFO,
+  withTimeStamp: true
+}
+
+export class ConsoleLogProvider implements LogProviderInterface {
+  constructor(private config: ConsoleLogProviderConfig = defaultConfig) {
+    this.trace = this.trace.bind(this);
+    this.debug = this.debug.bind(this);
+    this.info = this.info.bind(this);
+    this.warn = this.warn.bind(this);
+    this.error = this.error.bind(this);
+  }
+
+  private log(logLevel: ConsoleLogLevel, message: string | Error, data?: {}) {
+    if (logLevel >= this.config.logLevel) {
+      const timeStampPrefix = `${new Date().toISOString()} - `;
+      const extendedMessage = `${(this.config.withTimeStamp == null || this.config.withTimeStamp) ? timeStampPrefix : ''}${ConsoleLogLevel[logLevel]} - ${(message instanceof Error) ? message.message : message}`;
+      switch (logLevel) {
+        case ConsoleLogLevel.TRACE:
+          if (data) {
+            console.trace(extendedMessage, data);
+          } else {
+            console.trace(extendedMessage);
+          }
+          break;
+        case ConsoleLogLevel.DEBUG:
+          if (data) {
+            console.debug(extendedMessage, data);
+          } else {
+            console.debug(extendedMessage);
+          }
+          break;
+        case ConsoleLogLevel.INFO:
+          if (data) {
+            console.info(extendedMessage, data);
+          } else {
+            console.info(extendedMessage);
+          }
+          break;
+        case ConsoleLogLevel.WARN:
+          if (data) {
+            console.warn(extendedMessage, data);
+          } else {
+            console.warn(extendedMessage);
+          }
+          break;
+        case ConsoleLogLevel.ERROR:
+          (message as Error).message = extendedMessage;
+          if (data) {
+            console.error(message, data);
+          } else {
+            console.error(message);
+          }
+          break;
+      }
+    }
+  }
+
+  public trace(message: string, data?: {}) {
+    this.log(ConsoleLogLevel.TRACE, message, data);
+  }
+  public debug(message: string, data?: {}) {
+    this.log(ConsoleLogLevel.DEBUG, message, data);
+  }
+  public info(message: string, data?: {}) {
+    this.log(ConsoleLogLevel.INFO, message, data);
+  }
+  public warn(message: string, data?: {}) {
+    this.log(ConsoleLogLevel.WARN, message, data);
+  }
+  public error(message: Error, data?: {}) {
+    this.log(ConsoleLogLevel.ERROR, message, data);
+  }
+}
+

Diff for: lib/provider/io/noop-log-provider.class.ts

@@ -0,0 +1,14 @@
+import { LogProviderInterface } from "../log-provider.interface";
+
+export class NoopLogProvider implements LogProviderInterface {
+  public trace(_: string, __?: {}) {
+  }
+  public debug(_: string, __?: {}) {
+  }
+  public info(_: string, __?: {}) {
+  }
+  public warn(_: string, __?: {}) {
+  }
+  public error(_: Error, __?: {}) {
+  }
+}

Diff for: lib/provider/log-provider.interface.ts

@@ -11,24 +11,6 @@ export interface LogProviderInterface {
     error: ErrorLogFunction;
 }
 
-export class ConsoleLogger implements LogProviderInterface {
-  public trace(message: string, data?: {}) {
-    console.trace(message, data);
-  }
-  public debug(message: string, data?: {}) {
-    console.debug(message, data);
-  }
-  public info(message: string, data?: {}) {
-    console.info(message, data);
-  }
-  public warn(message: string, data?: {}) {
-    console.warn(message, data);
-  }
-  public error(message: Error, data?: {}) {
-    console.error(message, data);
-  }
-}
-
 const nonErrorLevels = ['info', 'warn', 'debug', 'trace'];
 const errorLevels = ['error'];