@zebpay/colt/logger.js

LoggerSDK for Microservices with multiple adapters eg: Pino, Winston, Bunyan with support for [Mapped Diagnostics Context](http://logback.qos.ch/manual/mdc.html).

const { sep } = require('path');
const LoggerFactory = require('./factory/LoggerFactory');

/**
 * Logger class should be used to configure the adapters. It is the main entry point of SDK.
 * @exports Logger
 * @class
 */
class Logger {
  /**
   * Creates instance of Logger
   *
   * @constructor
   * @param {scope} [scope=app] scope file scope
   * @param {object} [context={}] correlationIds in json.
   */
  constructor(scope, context = {}) {
    this.scope = Logger.parsePathToScope(scope || Logger.defaultScope);
    this.context = (context && typeof context === 'object' && !Array.isArray(context)) ? context : {};
    this.level = Logger.LogOptions.level;
  }

  /**
   * Adds the adapter to Logger's AdapterMap
   *
   * @static
   * @param {string} adapterName name of adapter
   * @param {LogAdapter} adapterInstance instance of adapter
   * @memberof Logger
   * @return {void}
   */
  static addAdapter(adapterName, adapterInstance) {
    Logger.AdapterMap.set(adapterName, adapterInstance);
  }

  /**
  * Creates and sets the Adapter with Logger
  *
  * @static
  * @param {string} adapterName name of dapter
  * @memberof Logger
  * @return {LogAdapter} Instance of adapter
  */
  static setAdapter(adapterName = 'pino') {
    Logger.AdapterName = adapterName;
    Logger.Adapter = LoggerFactory.getAdapter(adapterName, Logger.LogOptions);
    return Logger.Adapter;
  }

  /**
  * Will set the loggerOptions once should be called once
  *
  * @static
  * @param {LogOptions} logOptions logOptions
  * @memberof Logger
  * @return {void}
  */
  static setLoggerOptions(logOptions) {
    if (!logOptions.logPath || !logOptions.logFile || !logOptions.level) {
      throw new Error('LoggerException: Missing logOptions logPath, logFilePath or level');
    }
    Logger.LogOptions = logOptions;
  }

  /**
   * Parses the path to scope string
   *
   * @static
   * @param {string} scopePath scope or filename upto 6 chars to be used.
   * @memberof Logger
   * @return {string} return the scope string
   */
  static parsePathToScope(scopePath) {
    return scopePath.replace(process.cwd(), '')
      .replace(`${sep}src${sep}`, '')
      .replace(`${sep}dist${sep}`, '')
      .replace('.js', '')
      .replace(sep, '')
      .split('/')
      .pop();
  }

  /**
  * Gets the name of Adapter configured
  *
  * @static
  * @return {string}
  * @memberof Logger
  * @return {LogAdapter} instance of LogAdapter
  */
  static getAdapter() {
    return Logger.AdapterName;
  }

  /**
   * Returns log Level
   *
   * @static
   * @return {*} return the level if Logger is initialized or null.
   * @memberof Logger
   */
  getLevel() {
    if (this.level) {
      return this.level;
    }
    return null;
  }

  /**
   * Sends a debug log to be printed.
   *
   * @param {any} msg message to be logged
   * @param {any} arg any event data to be logged
   * @memberof Logger
   * @return {void}
   */
  debug(msg, ...arg) {
    this.log('debug', msg, arg, arg.pop());
  }

  /**
   * Sends a info log to be printed.
   *
   * @param {any} msg message to be logged
   * @param {any} arg any event data to be logged
   * @memberof Logger
   * @return {void}
   */

  info(msg, ...arg) {
    this.log('info', msg, arg, arg.pop());
  }

  /**
   * Sends a error log to be printed.
   *
   * @param {any} msg message to be logged
   * @param {Error} error Error stack to be displayed
   * @param {any} arg any event data to be logged
   * @memberof Logger
   * @return {void}
   */
  error(msg, error, ...arg) {
    this.log('error', msg, error, arg.pop());
  }

  /**
   * Sends a error log to be printed.
   *
   * @param {any} msg message to be logged
   * @param {Error} error Error stack to be displayed
   * @param {any} arg any event data to be logged
   * @memberof Logger
   * @return {void}
   */
  fatal(msg, error, ...arg) {
    this.log('fatal', msg, error, arg.pop());
  }

  /**
   * Will log the events to be recorded.
   *
   * @param {string} level log level to be used for a log.
   * @param {any} msg log message to be recorded.
   * @param {any} args [payload, correlationIds]
   * @memberof Logger
   * @return {void}
   */
  log(level, msg, ...args) {
    if (!Logger.Adapter) {
      throw new Error('Logger not configured');
    }
    if (Logger.Adapter && !this.adapter) {
      this.adapter = Logger.AdapterMap.get(Logger.AdapterName);
    }
    if (process.env.LOGS_SILENT === 'true') {
      return;
    }
    if (!level) {
      throw new Error('Missing level value');
    }
    this.adapter[level](msg, this.scope, args, { ...args.pop(), ...this.context });
  }
}

/**
  *
  * defaultScope for Logger
  *
  * @type {scope}
  * @static
  * @memberof Logger
  */

Logger.defaultScope = 'app';

/**
 *
 * Map containing adapter instances
 * @type {Map<LogAdapter>}
 * @static
 * @memberof Logger
 */
Logger.AdapterMap = new Map();

/**
 * LogOptions to use for creating logs
 *
 * @static
 * @type {LogOptions}
 * @memberof Logger
 */
Logger.LogOptions = {};

/**
* Adapter Name to be used for Logging
*
* @static
* @type {string}
* @memberof Logger
*/
Logger.AdapterName = '';

/**
* @type {LogAdapter}
* @static
*/
Logger.Adapter = null;

module.exports = {
  Logger,
};