Sets the lifecycle logging level.
971672
public void setLevel(Level level)
  {
    _level = level;

    if (level.intValue() < _lowLevel.intValue())
      _lowLevel = level;
  }
201276
public void setLog( Log log )
    {
        this.mavenLogger = log;
        
        //Match the log level of the Java logger with that set in the Maven logger 
        if ( log.isDebugEnabled() ) 
        {
            javaLogger.setLevel( Level.FINE );
        } 
        else if ( log.isInfoEnabled() ) 
        {
            javaLogger.setLevel( Level.INFO );
        } 
        else if ( log.isWarnEnabled() ) 
        {
            javaLogger.setLevel( Level.WARNING );
        } 
        else 
        {
            javaLogger.setLevel( Level.SEVERE );
        }
    }
124601
public static void setLogging(boolean logging) {
        if (logging) {
            logger.setLevel(debugging ? Level.FINE : Level.INFO);
        } else {
            logger.setLevel(Level.OFF);
        }
    }
1315604
protected void setupLogging(@Nullable final Level level) {
    // install JUL adapter
    SLF4JBridgeHandler.removeHandlersForRootLogger();
    SLF4JBridgeHandler.install();

    // conifgure gossip bootstrap loggers with target factory
    Log.configure(LoggerFactory.getILoggerFactory());
    log.debug("Logging setup; level: {}", level);
  }
954437
def set_log_level(logger_name: str, log_level: str, propagate: bool = False):
    """"""
    log = logging.getLogger(logger_name)
    log.propagate = propagate
    log.setLevel(log_level)
387499
def set_level_for_logger_and_its_handlers(log: logging.Logger,
                                          level: int) -> None:
    
    log.setLevel(level)
    for h in log.handlers:  # type: logging.Handler
        h.setLevel(level)
254676
private static void initializeLogging() {
        try {
            String mdwLogLevel = LoggerUtil.initializeLogging();
            if (mdwLogLevel != null) {
                LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
                loggerContext.getLogger("com.centurylink.mdw").setLevel(Level.toLevel(mdwLogLevel.toLowerCase()));
            }
        }
        catch (IOException ex) {
            ex.printStackTrace();
        }
    }
302328
def _init_logging(verbose):
    """"""
    hdlr = logging.StreamHandler()
    hdlr.setFormatter(logging.Formatter(
        '%(asctime)s [%(levelname)s] [%(module)s] %(message)s'))
    LOG.addHandler(hdlr)
    if verbose:
        LOG.setLevel(logging.DEBUG)
        LOG.debug('Verbose output enabled.')
    else:
        LOG.setLevel(logging.INFO)
1326491
def set_logger_level(logger_name, log_level='error'):
    '''
    
    '''
    logging.getLogger(logger_name).setLevel(
        LOG_LEVELS.get(log_level.lower(), logging.ERROR)
    )
768384
def _set_debug_level(self, debug_level):
    
    mapping = {
        0: logging.ERROR,
        1: logging.INFO,
        2: logging.DEBUG,
    }

    self.setLevel(
        mapping[min(debug_level, 2)],
    )
971621
public final void setLogLevel(LogLevel logLevel)
    {
        LogLevel updatedLogLevel=logLevel;
        if(updatedLogLevel==null)
        {
            updatedLogLevel=LogLevel.NONE;
        }
        
        this.logLevel=updatedLogLevel;
    }
654405
def set_log_level(debug, verbose):
    
    if debug:
        logging.basicConfig(level=logging.DEBUG)
    elif verbose:
        logging.basicConfig(level=logging.INFO)
760457
public void setRootLoggingLevel(final int loggingLevel) {
        rootLoggingLevel = loggingLevel;
        if (rootLoggerBack != null) {
            rootLoggerBack.setLevel(LoggingLevel.getLevelFromInt(loggingLevel));
        }
    }
490152
def add_log_level(value, name):
    
    logging.addLevelName(value, name)
    setattr(logging, name, value)
576585
def set_log_level(self):
        

        if self.options.debug:
            self.logger.setLevel(logging.DEBUG)
        elif self.options.quiet:
            self.logger.setLevel(logging.ERROR)
        else:
            self.logger.setLevel(logging.INFO)
        self.logger.addHandler(logging.StreamHandler())
        return self.logger
950690
def set_log_level(level):
    
    from .._connect import main as _glconnect
    unity = _glconnect.get_unity()
    return unity.set_log_level(level)
742091
def set_log_level(self, level):
        
        self._log_level = level
        if self._python_logger:
            try:
                level = self.PYTHON_LEVEL.get(level)
            except ValueError as err:
                raise FailReply("Unknown logging level '%s'" % (level))
            self._python_logger.setLevel(level)