Gets the default Mongoid logger - stdout.

 @api private

 @example Get the default logger.
   Loggable.default_logger

 @return [ Logger ] The default logger.

 @since 3.0.0
168985
def default_logger
      logger = Logger.new($stdout)
      logger.level = Mongoid::Config.log_level
      logger
    end
720608
def get_logger(cls):
        
        if cls.logger is None:
            cls.logger = logging.getLogger("django_auth_ldap")
            cls.logger.addHandler(logging.NullHandler())

        return cls.logger
1373738
public function getDafaultLogger () {
    if (null === $this->root) {
      $this->root = new HierarchialLogger(null);
    }
    return $this->root;
  }
187588
function getLogger(name) {
	name = name || '';

	if (!name) {
		return Manager.root;
	} else {
		return Manager.getLogger(name);
	}
}
37971
def getLogger(name=None, filename=None, filemode=None, level=WARNING):
    
    warnings.warn("getLogger is deprecated, Use get_logger instead.",
                  DeprecationWarning, stacklevel=2)
    return get_logger(name, filename, filemode, level)
250803
def logger=(logger)
      case logger
      when false, nil then @logger = NullLogger.new
      when true then @logger = default_logger
      else
        @logger = logger if logger.respond_to?(:info)
      end
    end
1286531
public static function getLogger()
    {
        if (self::$logger === null)
        {
            try
            {
                $result = Hook::execute(
                    "Wedeto.Util.GetLogger", 
                    ["logger" => null, "class" => static::class]
                );
            }
            catch (RecursionException $e)
            {
                // Apparently the hook is calling getLogger which is failing, so
                // use an emergency logger to log anyway.
                $result = ['logger' => new EmergencyLogger];
            }

            self::$logger = $result['logger'] ?? new NullLogger();
        }
        return self::$logger;
    }
81837
public function logger()
    {
        if (is_null($this->logger)) {
            $this->logger = app(Logger::class);
        }

        return $this->logger;
    }
1203239
def get_logger(name):
    """"""
    import logging
    import sys
    logger = logging.getLogger(name)
    logger.setLevel(logging.DEBUG)
    shandler = logging.StreamHandler(sys.stdout)
    fmt = ""
    fmt += '\033[1;32m%(levelname)-5s %(module)s:%(funcName)s():'
    fmt += '%(lineno)d %(asctime)s\033[0m| %(message)s'
    fmtr = logging.Formatter(fmt)
    shandler.setFormatter(fmtr)
    logger.addHandler(shandler)
    return logger
1297768
def getLogger(name):
    '''  '''

    # Create logger and add a default NULL handler
    log = logging.getLogger(name)
    log.addHandler(_NullHandler())

    return log
1120373
def get_logger(name=None):
    '''
    
    '''
    logger = logging.getLogger(name)
    if len(logger.handlers) == 0:
        logger = add_stream_handler(logger)
    return logger
1229222
def logger!(progname: self.class.name, target: LOG_TARGET, level: nil, debug: false)
      @logger = Logger.new(target).tap do |logger|
        level = Logger::DEBUG if debug

        logger.progname = "#{self.class.name}<#{progname}>"
        logger.level = level || self.class.log_level || K8s::Logging.log_level || LOG_LEVEL
      end
    end
243986
def rails_logger
      if instance_variable_defined?(k = :@rails_logger)
        instance_variable_get(k)
      else
        instance_variable_set(k, conf.rails && conf.rails.logger)
      end
    end
171994
def get_logfile(logger=None):
    
    logger = logger or logging.getLogger()
    handlers = [i for i in logger.handlers if isinstance(i, logging.FileHandler)]
    return handlers[0].baseFilename if handlers else None
859104
def get_logger(self):
        
        if Global.LOGGER:
            Global.LOGGER.debug('configuring a logger')
        if self._logger_instance is not None:
            return self._logger_instance

        self._logger_instance = logging.getLogger("flowsLogger")
        self._logger_instance.setLevel(logging.DEBUG)

        log_format = '%(asctime)s - [%(levelname)s]|%(thread)d\t%(message)s'
        log_date_format = '%Y-%m-%d %H:%M:%S'
        formatter = logging.Formatter(log_format, log_date_format)

        new_log_stream_handler = logging.StreamHandler()
        new_log_stream_handler.setFormatter(formatter)
        new_log_stream_handler.setLevel(logging.INFO)

        self._logger_instance.addHandler(new_log_stream_handler)

        return self._logger_instance
199867
def getLogger(*args, **kwargs):
    
    logger = logging.getLogger(*args, **kwargs)
    if _overrideLogLevel is not None:
        logger.setLevel(logging.NOTSET)
    return logger
557762
public function getLogger()
    {
        if (!$this->logger) {
            $this->logger = $this->getClient()->getLogger();
        }
        return $this->logger;
    }