att-dhs/js/att.dhs.logger.js

AT&T Developer Hosted Server Library

/*jslint browser: true, devel: true, node: true, debug: true, todo: true, indent: 2, maxlen: 150, unparam: true*/
/*global require, exports*/

'use strict';

var loggers = {},
  defaultLogLevel = 'warn',
  logLevel = defaultLogLevel,
  logLevelValues = [
    '[ERROR]',
    '[WARNING]',
    '[INFO]',
    '[DEBUG]',
    '[TRACE]'
  ],
  defaultConfig = {
    'dhs': 'info'
  },
  log;

function getLogLevels() {
  return [
    'error',
    'warn',
    'info',
    'debug',
    'trace'
  ];
}

function getModuleDefaults() {
  return defaultConfig;
}

function setLogLevelForAllModules(level) {
  var key;

  for (key in loggers) {
    if (loggers.hasOwnProperty(key)) {
      loggers[key].setLogLevel(level);
    }
  }
}

// Private method to return the filename and position as <filename>:<position> of log statement.
// Does this by throwing an exception and parsing its stack trace.
// @returns {string} Returns <filename>:<position>
function getLogStatementFilePosition() {
  var fileName = '',
    lineNumber,
    stackLocationString = '',
    splitstr = [],
    rawfile = '',
    splitrawfile = [];

  try {
    throw new Error();
  } catch (err) {
    if (0 === err.stack.split('\n')[0].indexOf('Error')) { // For Chrome
      stackLocationString = err.stack.split('\n')[4];
    } else {
      stackLocationString = err.stack.split('\n')[3]; // This is for FireFox, Safari
    }
    splitstr = stackLocationString.split(':');
    if (5 <= splitstr.length) {
      rawfile = splitstr[2];
      splitrawfile = rawfile === undefined ? [] : rawfile.split('/');
      fileName = splitrawfile[splitrawfile.length - 1];

      // strip off timestamp if it's present.
      if (fileName !== undefined && fileName.indexOf('?') > -1) {
        fileName = fileName.split('?')[0];
      }

      lineNumber = splitstr[3];
    } else {
      rawfile = splitstr[0];
      splitrawfile = rawfile === undefined ? [] : rawfile.split(' ');
      fileName = splitrawfile[splitrawfile.length - 1];

      // strip off timestamp if it's present.
      if (fileName !== undefined && fileName.indexOf('?') > -1) {
        fileName = fileName.split('?')[0];
      }

      lineNumber = splitstr[1];
    }

    return fileName + ':' + lineNumber;
  }
}

function log(level, message, data) {
  var logLevelIndex,
    msgLogLevel,
    traceData,
    dataStr = data || '',
    consoleLevel = level;

  logLevelIndex = getLogLevels().indexOf(level);
  msgLogLevel = logLevelValues[logLevelIndex];

  if (undefined === console[level]) {
    consoleLevel = 'log';
  }

  if (undefined === message
      || 'function' === typeof message) {
    message = '';
  }

  if (undefined === data
      || 'function' === typeof data) {
    dataStr = '';
  }

  if (undefined !== data) {
    if ('object' === typeof data) {
      dataStr = ':';
      traceData = data;
    }
  }

  console[consoleLevel](msgLogLevel, message, dataStr, '[' + getLogStatementFilePosition() + ']');

  if (undefined !== traceData) {
    console[consoleLevel](traceData);
  }
}

function getDefaultLogLevel() {
  return defaultLogLevel;
}

function getGlobalLogLevel() {
  return logLevel;
}

function setGlobalLogLevel(level) {
  if (undefined === level
      || 'string' !== typeof level
      || 0 === level.length) {
    throw new Error('No log level provided');
  }

  if (-1 === getLogLevels().indexOf(level)) {
    throw new Error('Invalid log level provided');
  }

  logLevel = level;
  setLogLevelForAllModules(level);
}

function getLoggers() {
  var key,
    loggersList = [];

  for (key in loggers) {
    if (loggers.hasOwnProperty(key)) {
      loggersList.push(key);
    }
  }

  return loggersList;
}

function resetLogLevels() {
  var key;

  for (key in defaultConfig) {
    if (defaultConfig.hasOwnProperty(key)) {
      if (undefined !== loggers[key]) {
        loggers[key].setLogLevel(defaultConfig[key]);
      }
    }
  }

  for (key in loggers) {
    if (loggers.hasOwnProperty(key)) {
      if (undefined === defaultConfig[key]) {
        loggers[key].setLogLevel(defaultLogLevel);
      }
    }
  }
}

function Logger(custom) {
  var loggerLevel = '',
    logUtility = log,
    isCustom = custom || false;

  function isCustomType() {
    return isCustom;
  }

  function getLogLevel() {
    return loggerLevel;
  }

  function setLogLevel(level) {
    if (undefined === level
        || 'string' !== typeof level
        || 0 === level.length) {
      throw new Error('No log level provided');
    }

    if (-1 === getLogLevels().indexOf(level)) {
      throw new Error('Invalid log level provided');
    }

    loggerLevel = level;
  }

  function logError(message) {
    var logLevels = getLogLevels(),
      level = this.getLogLevel();

    if (logLevels.indexOf('error') <= logLevels.indexOf(level)) {
      logUtility('error', message);
    }
  }

  function logWarn(message) {
    var logLevels = getLogLevels(),
      level = this.getLogLevel();

    if (logLevels.indexOf('warn') <= logLevels.indexOf(level)) {
      logUtility('warn', message);
    }
  }

  function logInfo(message) {
    var logLevels = getLogLevels(),
      level = this.getLogLevel();

    if (logLevels.indexOf('info') <= logLevels.indexOf(level)) {
      logUtility('info', message);
    }
  }

  function logDebug(message) {
    var logLevels = getLogLevels(),
      level = this.getLogLevel();

    if (logLevels.indexOf('debug') <= logLevels.indexOf(level)) {
      logUtility('debug', message);
    }
  }

  function logTrace(message, data) {
    var logLevels = getLogLevels(),
      level = this.getLogLevel();

    if (logLevels.indexOf('trace') <= logLevels.indexOf(level)) {
      logUtility('trace', message, data);
    }
  }

  function setLogUtility(method) {
    logUtility = method;
  }

  this.isCustomType = isCustomType;
  this.setLogLevel = setLogLevel;
  this.getLogLevel = getLogLevel;
  this.logError = logError;
  this.logWarn = logWarn;
  this.logInfo = logInfo;
  this.logDebug = logDebug;
  this.logTrace = logTrace;
  this.setLogUtility = setLogUtility;
}

function createLogger(module, custom) {
  if (undefined === module
      || 'string' !== typeof module
      || 0 === module.length) {
    throw new Error('No module name provided');
  }
  if (loggers[module]) {
    throw new Error('logger is already defined');
  }

  loggers[module] = new Logger(custom);

  if (undefined !== defaultConfig[module]) {
    loggers[module].setLogLevel(defaultConfig[module]);
  } else {
    loggers[module].setLogLevel(defaultLogLevel);
  }

  return loggers[module];
}

function createCustomLogger(module) {
  return createLogger(module, true);
}

function deleteCustomLogger(module) {
  if (undefined === module
      || 'string' !== typeof module
      || 0 === module.length) {
    throw new Error('No module name provided');
  }
  if (!loggers[module]) {
    throw new Error('Invalid module name provided');
  }
  if (loggers[module].isCustomType() !== true) {
    throw new Error('Cannot delete ' + module + ' logger');
  }

  delete loggers[module];
}

function getLogger(module) {
  if (undefined === module
      || 'string' !== typeof module
      || 0 === module.length) {
    throw new Error('No module name provided');
  }

  if (undefined === loggers[module]) {
    throw new Error('Logger ' + module + ' not found');
  }

  return loggers[module];
}

function getCurrentModuleLogLevels() {
  var i,
    currentModuleLogLevels = {},
    currentModules = getLoggers();

  for (i = 0; i < currentModules.length; i += 1) {
    currentModuleLogLevels[currentModules[i]] = getLogger(currentModules[i]).getLogLevel();
  }
  return currentModuleLogLevels;
}

exports.attLogManager = {
  getLogLevels: getLogLevels,
  getCurrentModuleLogLevels: getCurrentModuleLogLevels,
  getLoggers: getLoggers,
  getLogger: getLogger,
  getDefaultLogLevel: getDefaultLogLevel,
  getGlobalLogLevel: getGlobalLogLevel,
  setGlobalLogLevel: setGlobalLogLevel,
  resetLogLevels: resetLogLevels,
  createLogger: createLogger,
  createCustomLogger: createCustomLogger,
  deleteCustomLogger: deleteCustomLogger,
  getModuleDefaults: getModuleDefaults
};