Get the logger that logs real-time to the leader.
        
        Note that if the returned logger is used on the leader, you will see the message twice,
        since it still goes to the normal log handlers, too.
347474
def getLogger(cls):
        
        # Only do the setup once, so we don't add a handler every time we log. Use a lock to do
        # so safely even if we're being called in different threads. Use double-checked locking
        # to reduce the overhead introduced by the lock.
        if cls.logger is None:
            with cls.lock:
                if cls.logger is None:
                    cls.logger = logging.getLogger('toil-rt')
                    try:
                        level = os.environ[cls.envPrefix + 'LEVEL']
                    except KeyError:
                        # There is no server running on the leader, so suppress most log messages
                        # and skip the UDP stuff.
                        cls.logger.setLevel(logging.CRITICAL)
                    else:
                        # Adopt the logging level set on the leader.
                        toil.lib.bioio.setLogLevel(level, cls.logger)
                        try:
                            address = os.environ[cls.envPrefix + 'ADDRESS']
                        except KeyError:
                            pass
                        else:
                            # We know where to send messages to, so send them.
                            host, port = address.split(':')
                            cls.logger.addHandler(JSONDatagramHandler(host, int(port)))
        return cls.logger
195793
private static Logger getLogger()
    {
        if(FaxClientSpiFactory.logger==null)
        {
            synchronized(FaxClientSpiFactory.class)
            {
                if(FaxClientSpiFactory.logger==null)
                {
                    //get logger manager
                    LoggerManager loggerManager=LoggerManager.getInstance();

                    //get logger
                    Logger localLogger=loggerManager.getLogger();
                    
                    //print product info
                    localLogger.logDebug(new Object[]{ProductInfo.getProductInfoPrintout()},null);
                    
                    //keep reference
                    FaxClientSpiFactory.logger=localLogger;
                }
            }
        }

        return FaxClientSpiFactory.logger;
    }
963978
public static ThreadBoundJschLogger getInstance(final PluginLogger logger, final int loggingLevel) {
        getInstance();
        instance.setThreadLogger(logger, loggingLevel);
        return instance;
    }
1315837
def loggerLevel(self, logger='root'):
        
        if isinstance(logger, logging.Logger):
            logger = logger.name
        
        return self.handler().loggerLevel(logger)
924644
def get_logger(self, name="deployment-logger", level=logging.DEBUG):
        """"""
        log = logging
        logger = log.getLogger(name)
        fmt = log.Formatter("%(asctime)s %(funcName)s "
                            "%(levelname)s: %(message)s")

        handler = log.StreamHandler(stream=sys.stdout)
        handler.setLevel(level)
        handler.setFormatter(fmt)

        logger.addHandler(handler)
        logger.setLevel(level)

        return logger
1169239
def logger(self):
        
        if not hasattr(self, '_logger') or not self._logger:
            self._logger = ServiceLogger()
        return self._logger
1079570
public static Logger getLogger()
   {
       if (m_logger == null)
       {
           m_logger = Logger.getLogger(Constant.ROOT_PACKAGE.substring(0, Constant.ROOT_PACKAGE.length() - 1));
           try {
               LogManager logManager = LogManager.getLogManager();
               logManager.reset();//removeAllGlobalHandlers();
               ConsoleHandler fh = new ConsoleHandler();
               fh.setFormatter(new SimpleFormatter());
               // Send logger output to our FileHandler.
               m_logger.addHandler(fh);
           } catch (java.security.AccessControlException ex)    {
               // Access error if running in an applet.
        	   m_logger = Logger.getAnonymousLogger();
           } finally {
               try {
	               // Request that every detail gets logged.
//                 m_logger.setLevel(Level.OFF);
//                   m_logger.setLevel(Level.ALL);
	               m_logger.setLevel(Level.WARNING);        	   
               } catch (java.security.AccessControlException ex)    {
            	   ex.printStackTrace();	// Never
               }
           }
       }
       return m_logger;
   }
1267993
def get_logger():
    """"""

    # Grab the logger
    if not hasattr(get_logger, 'logger'):

        # Setup the default logging config
        get_logger.logger = logging.getLogger('chains')
        format_str = '%(asctime)s [%(levelname)s] - %(module)s: %(message)s'
        logging.basicConfig(datefmt='%Y-%m-%d %H:%M:%S', level=logging.INFO, format=format_str)

    # Return the logger
    return get_logger.logger
489718
def getLogger(name):
    """"""
    logger = logging.getLogger(name)
    # note: the level might be adjusted via '-v' option
    logger.setLevel(logging_config['loggers']['gcdt']['level'])
    return logger
1060240
def get_logger(name=None, level=logging.DEBUG, stream=None):
    """"""
    logger = logging.getLogger(name)
    colored = colorize_logger(logger, stream=stream, level=level)
    return colored
1002126
def logger
      return @logger if @logger

      output = nil
      loglevel = Logger::ERROR

      # Figure out where the output should go to.
      if ENV["VEEWEE_LOG"]
        output = STDOUT
        loglevel = Logger.const_get(ENV["VEEWEE_LOG"].upcase)
      end

        # Create the logger and custom formatter
      @logger = ::Logger.new(output)
      @logger.level = loglevel
      @logger.formatter = Proc.new do |severity, datetime, progname, msg|
        "#{datetime} - #{progname} - [#{resource}] #{msg}\n"
      end
      @logger
    end
888639
def get_logger():
    
    root = logging.getLogger()
    root.setLevel(logging.WARNING)
    ch = logging.StreamHandler(sys.stderr)
    ch.setLevel(logging.DEBUG)
    formatter = logging.Formatter('%(message)s')
    ch.setFormatter(formatter)
    root.addHandler(ch)
    return root
1081165
@NotNull
	public static ILogger getLogger(@Nullable ILogger logger) {
		return logger == null ? new NullLogger() : logger;
	}
1297768
def getLogger(name):
    '''  '''

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

    return log
160665
def get_logger(logger_name):
    

    # Use default global logger
    if logger_name is None:
        return __instance

    assert isinstance(logger_name, str), 'Logger name must be a string!'

    with __lock:
        if logger_name in __loggers:
            return __loggers[logger_name]

        logger_instance = LogOne(logger_name=logger_name)
        __loggers[logger_name] = logger_instance
        return logger_instance
280952
def getLogger(name=None, **kwargs):
    
    adapter = _LOGGERS.get(name)
    if not adapter:
        # NOTE(jd) Keep using the `adapter' variable here because so it's not
        # collected by Python since _LOGGERS contains only a weakref
        adapter = KeywordArgumentAdapter(logging.getLogger(name), kwargs)
        _LOGGERS[name] = adapter
    return adapter
1354092
public static Logger getLogger(final String logger)
   {
      LogAdapterFactory adapterFactory = getAdapterFactory();
      return adapterFactory.createLogAdapter(logger);
   }