oo-logger-mixin.html

<link rel="import" href="../polymer/polymer-element.html">
<link rel="import" href="oo-logger-base.html">

<script>
  // Declare in local function scope to avoid bleeding variables into global `window`.
  (function () {

    // Declare or reuse global namespace.
    window.oo = window.oo || {}

    /**
     * A custom element class mixin that provides a collection of utility methods.
     *
     * @polymerMixin
     * @memberof oo
     */
    oo.LoggerMixin = Polymer.dedupingMixin(function (superClass) {

      /**
       * @polymerMixinClass
       */
      return class LoggerMixin extends superClass {
        constructor() {
          super()
          this._logger = oo.LoggerFactory.getLogger(this.localName)
        }

        _trace(...messages) {
          this._logger.trace(...messages)
        }

        _debug(...messages) {
          this._logger.debug(...messages)
        }

        _info(...messages) {
          this._logger.info(...messages)
        }

        _warn(...messages) {
          this._logger.warn(...messages)
        }

        _error(...messages) {
          this._logger.error(...messages)
        }
      }
    })

    oo.LoggerFactory = class LoggerFactory {
      static getLogger(contextName = ROOT_CONTEXT_NAME) {
        _checkNotNil(contextName, () => "illegal argument: contextName is missing")

        // return root logger.
        if (contextName === ROOT_CONTEXT_NAME) {
          return ROOT_LOGGER
        }

        // return registered logger.
        const logger = LOGGER_CONTEXTS[contextName]
        if (logger) {
          return logger
        }

        // return newly registered logger.
        const newLogger = new oo.Logger(contextName, ROOT_LOGGER)
        LOGGER_CONTEXTS[contextName] = newLogger
        return newLogger
      }

      static getLoggerContexts() {
        return LOGGER_CONTEXTS
      }

      static getLogLevels() {
        return LOG_LEVELS
      }
    }

    oo.Logger = class Logger {
      constructor(contextName, parentLogger = null) {
        _checkNotNil(contextName, () => "illegal argument: contextName is missing")

        this._contextName = contextName
        this._parentLogger = parentLogger
        this._logLevel = null
      }

      error() { this._log(LOG_LEVELS.ERROR, ...arguments) }
      warn() { this._log(LOG_LEVELS.WARN, ...arguments) }
      info() { this._log(LOG_LEVELS.INFO, ...arguments) }
      debug() { this._log(LOG_LEVELS.DEBUG, ...arguments) }
      trace() { this._log(LOG_LEVELS.TRACE, ...arguments) }

      get contextName() {
        return this._contextName
      }

      get logLevel() {
        if (this._logLevel) {
          return this._logLevel
        }

        if (this._parentLogger) {
          return this._parentLogger.logLevel
        }

        return DEFAULT_LOG_LEVEL
      }

      set logLevel(logLevel) {
        this._logLevel = logLevel
      }

      set logLevelByName(logLevelName) {
        _checkNotNil(logLevelName, () => "illegal argument: logLevelName")
        _checkNotNil(LOG_LEVELS[logLevelName], () => "illegal argument: logLevelName")

        this._logLevel = LOG_LEVELS[logLevelName]
      }

      _log(logLevel, ...messages) {
        _checkNotNil(logLevel, () => "illegal argument: logLevel")
        _checkNotNil(logLevel.handler, () => "illegal argument: logLevel.handler")

        if (this.logLevel.level >= logLevel.level) {
          const handler = logLevel.handler
          const timestamp = new Date()
          const contextName = this._contextName
          const levelName = logLevel.name

          const logMessage = oo.buildLog(
            contextName, levelName, timestamp, ...messages
          )
          handler(...logMessage)
        }
      }
    }

    const LOG_LEVELS = {
      ERROR: { level: 1, name: "ERROR", handler: console.error },
      WARN: { level: 2, name: "WARN", handler: console.warn },
      INFO: { level: 3, name: "INFO", handler: console.log },
      DEBUG: { level: 4, name: "DEBUG", handler: console.log },
      TRACE: { level: 5, name: "TRACE", handler: console.log },

      NONE: { level: 0 },
      ALL: { level: 99 }
    }

    const DEFAULT_LOG_LEVEL = LOG_LEVELS.INFO

    const ROOT_CONTEXT_NAME = "ROOT"

    const ROOT_LOGGER = new oo.Logger(ROOT_CONTEXT_NAME, null)

    const LOGGER_CONTEXTS = {}

    function _check(condition, lazyMessage = null) {
      if (!condition) {
        if (lazyMessage) {
          throw new Error(lazyMessage())
        }
        throw new Error("illegal argument")
      }
    }

    function _checkNotNil(value, lazyMessage = null) {
      if (_isNil(value)) {
        if (lazyMessage) {
          throw new Error(lazyMessage())
        }
        throw new Error("illegal argument")
      }
    }

    function _isNil(value) {
      return value === null && value === undefined
    }

  }())
</script>