code: function (name, loggerContext) {
      /**
       * Logger name
       */
      this.name = name;
  
      /**
       * Reference to the logger context that created this logger
       *
       * The reference is used to create appenders and layouts when
       * configuration is applied.
       */
      this.loggerContext = loggerContext;
  
      /**
       * Parent logger. All loggers have a parent except the root logger
       */
      this.parent = null;
  
      /**
       * Children loggers. Mostly used during initialization to propagate
       * the configuration.
       */
      this.children = [];
  
      /**
       * Appenders associated with the logger. Set during initialization
       */
      this.appenders = [];
  
      /**
       * Logger filter. Set during initialization
       */
      this.filter = null;
  
      /**
       * The trace level of the logger. Log events whose level is below that
       * level are logged. Others are discarded.
       */
      this.level = 'inherit';
  
      /**
       * Additivity flag. Log events are not propagated to the parent logger
       * if the flag is not set.
       */
      this.additive = true;
  
      /**
       * Function used to determine whether a log level is below the
       * trace level of the logger
       */
      if (this.loggerContext) {
        this.isBelow = function (level, referenceLevel) {
          return this.loggerContext.logLevel.isBelow(level, referenceLevel);
        };
  
        // Set trace functions for all registered levels
        utils.each(this.loggerContext.logLevel.getLevels(), function (level) {
          var self = this;
          if (!this[level]) {
            this[level] = function () {
              self.traceAtLevel(level, arguments);
            };
          }
        }, this);
      }
      else {
        this.isBelow = function () {
          return true;
        };
      }
    }
docs: Definition of the Logger class
  
  @constructor