Merge pull request #280 from sonofflynn89/f/130847-log-wrapper

Add a logger wrapper class

CHANGELOG.md

@@ -6,6 +6,8 @@ The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased][HEAD]
+* New Feature
+  * **hub-common**: Added a static logger wrapper class that logs based on the set level [130847](https://esriarlington.tpondemand.com/entity/130847-add-a-hub-logger-wrapper-method)
 
 ## [4.4.0] - June 30th 2020
 

packages/common/src/utils/index.ts

@@ -10,5 +10,6 @@ export * from "./slugify";
 export * from "./without-by-prop";
 export * from "./propify-string";
 export * from "./increment-string";
+export * from "./logger";
 export * from "./is-update-group";
 export * from "./revertable-tasks";

packages/common/src/utils/logger.ts

@@ -0,0 +1,109 @@
+
+/**
+ * Enum for Logger Levels
+ */
+export enum Level {
+  all,
+  debug,
+  info,
+  warn,
+  error,
+  off,
+} 
+
+/**
+ * ```js
+ * import { Logger, Level } from '@esri/hub-common'
+ * ```
+ * Functions share the console interface
+ * ```js
+ * Logger.log('My Message');
+ * Logger.warn('Watch out!', { threat: 'Charizard' });
+ * // etc, etc
+ * ```
+ * Available logging levels are specified in the Level enum. The hierarchy is as follows:
+ * ```
+ * off > error > warn > info > debug > all
+ * ```
+ * Logger only sends messages whose level is greater than or equal to the global log level
+ * ```js
+ * // Global level is 'warn'
+ * Logger.info('This message won't log');
+ * Logger.error('But this one will!');
+ * ```
+ * Logger's default level is 'off', so set desired level before use
+ * ```js
+ * Logger.setLogLevel(Level.all);
+ * ```
+ */
+export class Logger {
+
+  private static logLevel = Level.off;
+
+  private static isLevelPermitted(level: Level) {
+    return this.logLevel <= level;
+  }
+
+  /**
+ * Sets the global log level 
+ * @param {Level} level
+ */
+  public static setLogLevel(level: Level) {
+    this.logLevel = level;
+  }
+
+  /**
+ * Logs to debug if level is enabled
+ * @param {string} message
+ * @param {...*} objects additional objects to log (optional rest parameter)
+ */
+  public static log(message: string, ...objects: any[]) {
+    if (this.isLevelPermitted(Level.debug)) {
+      console.log(message, ...objects);
+    }
+  }
+
+  /**
+ * Logs to debug if level is enabled
+ * @param {string} message
+ * @param {...*} objects additional objects to log (optional rest parameter)
+ */
+  public static debug(message: string, ...objects: any[]) {
+    if (this.isLevelPermitted(Level.debug)) {
+      console.debug(message, ...objects);
+    }
+  }
+
+  /**
+ * Logs to info if level is enabled
+ * @param {string} message
+ * @param {...*} objects additional objects to log (optional rest parameter) 
+ */
+  public static info(message: string, ...objects: any[]) {
+    if (this.isLevelPermitted(Level.info)) {
+      console.info(message, ...objects);
+    }
+  }
+
+  /**
+ * Logs to warn if level is enabled
+ * @param {string} message
+ * @param {...*} objects additional objects to log (optional rest parameter) 
+ */
+  public static warn(message: string, ...objects: any[]) {
+    if (this.isLevelPermitted(Level.warn)) {
+      console.warn(message, ...objects);
+    }
+  }
+
+  /**
+ * Logs to error if level is enabled
+ * @param {string} message
+ * @param {...*} objects additional objects to log (optional rest parameter) 
+ */
+  public static error(message: string, ...objects: any[]) {
+    if (this.isLevelPermitted(Level.error)) {
+      console.error(message, ...objects);
+    }
+  }
+}

packages/common/test/utils/logger.test.ts

@@ -0,0 +1,50 @@
+
+import { Logger, Level } from "../../src/utils/logger";
+
+describe("Logger |", function() {
+    beforeEach(() => {
+      spyOn(console, 'log').and.stub().calls.reset();
+      spyOn(console, 'debug').and.stub().calls.reset();
+      spyOn(console, 'info').and.stub().calls.reset();
+      spyOn(console, 'warn').and.stub().calls.reset();
+      spyOn(console, 'error').and.stub().calls.reset();
+    });
+
+    const levels: Level[] = [Level.all, Level.debug, Level.warn, Level.info, Level.error, Level.off];
+    levels.forEach((level: Level) => testLogLevel(level));
+});
+
+function testLogLevel(testLevel: Level) {
+  const isAvailable = (fnLevel: Level) => testLevel <= fnLevel; 
+  describe(`Test ${Level[testLevel]} Log Level |`, () => {
+    beforeEach(() => {
+      Logger.setLogLevel(testLevel);
+    });
+    it(`Logger.log ${isAvailable(Level.debug) ? 'does' : 'does not'} log when level set to ${Level[testLevel]}`, () => {
+      const numCalls = +isAvailable(Level.debug);
+      Logger.log("message");
+      expect(console.log).toHaveBeenCalledTimes(numCalls);  
+    });
+    it(`Logger.debug ${isAvailable(Level.debug) ? 'does' : 'does not'} log when level set to ${Level[testLevel]}`, () => {
+      const numCalls = +isAvailable(Level.debug);
+      Logger.debug("message");
+      expect(console.debug).toHaveBeenCalledTimes(numCalls);
+    });
+    it(`Logger.info ${isAvailable(Level.info) ? 'does' : 'does not'} log when level set to ${Level[testLevel]}`, () => {
+      const numCalls = +isAvailable(Level.info);
+      Logger.info("message");
+      expect(console.info).toHaveBeenCalledTimes(numCalls);
+    });
+    it(`Logger.warn ${isAvailable(Level.warn) ? 'does' : 'does not'} log when level set to ${Level[testLevel]}`, () => {
+      const numCalls = +isAvailable(Level.warn);
+      Logger.warn("message");
+      expect(console.warn).toHaveBeenCalledTimes(numCalls);
+    });
+    it(`Logger.error ${isAvailable(Level.error) ? 'does' : 'does not'} log when level set to ${Level[testLevel]}`, () => {
+      const numCalls = +isAvailable(Level.error);
+      Logger.error("message");
+      expect(console.error).toHaveBeenCalledTimes(numCalls);
+    });
+
+  })
+}