Returns true if a message of the given level would actually
be logged by this logger.
495210
public boolean isLoggable(Level level) {
        if (level == null) {
            throw new NullPointerException();
        }
        // performance-sensitive method: use two monomorphic call-sites
        JavaLoggerProxy jlp = javaLoggerProxy;
        return jlp != null ? jlp.isLoggable(level) : loggerProxy.isLoggable(level);
    }
1286627
public boolean setLevel(String level) {
        boolean isSucceed = true;
        try {
            LoggerContext loggerContext = (LoggerContext) LoggerFactory.getILoggerFactory();
            loggerContext.getLogger("root").setLevel(Level.valueOf(level));
        } catch (Exception e) {
            e.printStackTrace();
            isSucceed = false;
        }
        return isSucceed;
    }
1265612
private static boolean isCoveredByMinimumLevel(final String tag, final Level level) {
		return provider.getMinimumLevel(tag).ordinal() <= level.ordinal();
	}
1087110
def log(self, msg, lvl = 0):
        ''''''
        if self.log_level >= lvl:
            self.log_fn(msg)
733973
public void log(Level level, String msg) {
		logIfEnabled(level, null, msg, UNKNOWN_ARG, UNKNOWN_ARG, UNKNOWN_ARG, null);
	}
457262
public void log(LogLevel level, String msg)
	{
		if (level != LogLevel.OFF && level.level <= logLevel.level)
			logger.add(writers, name, level, msg, null);
	}
20432
public boolean containLogsFrom(LogLevel level)
    {
        for (LogEvent log : this) {
            if (log.getLevel().compareTo(level) <= 0) {
                return true;
            }
        }

        return false;
    }
69526
@Override
  public final boolean isLoggable(Level level)
  {
    if (level == null)
      return false;

    int intValue = level.intValue();
    
    if (intValue < _finestEffectiveLevelValue)
      return false;
    else if (! _hasLocalEffectiveLevel) {
      return true;
    }
    else {
      Integer localValue = _localEffectiveLevel.get();
      
      if (localValue != null) {
        int localIntValue = localValue.intValue();
        
        if (localIntValue == Level.OFF.intValue())
          return false;
        else
          return localIntValue <= intValue;
      }
      else {
        if (_systemEffectiveLevelValue == Level.OFF.intValue())
          return false;
        else
          return _systemEffectiveLevelValue <= intValue;
      }
    }
  }
728725
public static function hasLevel(int $level=null) :bool {
		// if we have said level
		return self::$_account ? 
			self::getAccount()->hasLevel($level) : false;
	}
694347
function messageLog(...messages) {
      if (active) {
        const protectedMessage = messageArrayProtect(messages)
        levelLogger(tag, ...protectedMessage)
      }
      return messages[0]
    }
871281
private function isValidLogLevel($level)
    {
        return in_array($level, array(
                LogLevel::EMERGENCY,
                LogLevel::ALERT,
                LogLevel::CRITICAL,
                LogLevel::ERROR,
                LogLevel::WARNING,
                LogLevel::NOTICE,
                LogLevel::INFO,
                LogLevel::DEBUG,
            )
        );
    }
2166
public boolean isLoggable(Logger logger, Level l) {
        return logger.isLoggable(l) && l.intValue() >= this.logLevel;
    }
971139
public static boolean log(Object context, int level, String message)
    {
        if (ClassServiceUtility.getClassService().getClassFinder(null) != null)
            return ClassServiceUtility.getClassService().getClassFinder(null).log(context, level, message);
        // TODO Use system logging!
        return false;
    }
475603
def level=(new_level)
      if new_level.respond_to?(:to_int)
        new_level = STD_LOGGER_LEVELS[new_level]
      end

      LogbackUtil.set_log_level(@logger, new_level)
    end
1196987
private boolean checkMisroutedIv2IntiateTaskMessage(Iv2InitiateTaskMessage message) {
        if (message.isForReplica()) {
            return false;
        }

        if (m_scheduler.isLeader() && m_migratePartitionLeaderStatus != MigratePartitionLeaderStatus.TXN_RESTART) {
            //At this point, the message is sent to partition leader
            return false;
        }

        //At this point, the message is misrouted.
        //(1) If a site has been demoted via @MigratePartitionLeader, the messages which are sent to the leader will be restarted.
        //(2) If a site becomes new leader via @MigratePartitionLeader. Transactions will be restarted before it gets notification from old
        //    leader that transactions on older leader have been drained.
        InitiateResponseMessage response = new InitiateResponseMessage(message);
        response.setMisrouted(message.getStoredProcedureInvocation());
        response.m_sourceHSId = getHSId();
        deliver(response);
        if (tmLog.isDebugEnabled()) {
            tmLog.debug("Sending message back on:" + CoreUtils.hsIdToString(m_hsId) + " isLeader:" + m_scheduler.isLeader() +
                    " status:" + m_migratePartitionLeaderStatus + "\n" + message);
        }
        //notify the new partition leader that the old leader has completed the Txns if needed.
        notifyNewLeaderOfTxnDoneIfNeeded();
        return true;
    }
18815
def setLoggerLevel(self, logger, level):
        
        if logger == 'root':
            _log = logging.getLogger()
        else:
            _log = logging.getLogger(logger)
        
        _log.setLevel(level)
        
        if level == logging.NOTSET:
            self._loggerLevels.pop(logger, None)
        else:
            self._loggerLevels[logger] = level
917949
def set_log_level(self, level, keep=True):
        
        self._set_log_level(level)
        self._log_level_set_explicitly = keep