Gets the string representation of the log level.

@param logLevel Level of the log message.
@return String representation of the log level.
8042
static String getLevelTag(final int logLevel) {

        switch (logLevel) {

            case LogLevelConst.FATAL:
                return LogConstants.TAG_FATAL;

            case LogLevelConst.ERROR:
                return LogConstants.TAG_ERROR;

            case LogLevelConst.WARNING:
                return LogConstants.TAG_WARNING;

            case LogLevelConst.INFO:
                return LogConstants.TAG_INFO;

            case LogLevelConst.DEBUG:
                return LogConstants.TAG_DEBUG;

            default:
                return "[DEFAULT]";

        }
    }
778633
def log_level(self,
              level: typing.Union[str, int]=None,
              *args,
              **kwargs) -> typing.Union[None, str]:
    
    if level is None:
        return self.root_logger.getEffectiveLevel()
    # NOTE: `setLevel` takes both string and integers. Try to cast to an integer first
    try:
        value = int(level)
    # if we can't cast to an int, it's probably a string
    except ValueError:
        pass

    self.root_logger.setLevel(value)
966054
public static void printStackTrace(final Logger logger, final LogLevel logLevel) {
        printStackTrace((String) null, logger, logLevel);
    }
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;
    }
720493
def getLevelName(lvl):
    
    lvl = _ocrdLevel2pythonLevel.get(lvl, lvl)
    return logging.getLevelName(lvl)
60699
public static int getIsolationLevelFor(String isoLevel)
    {
        if(isoLevel == null || StringUtils.isEmpty(isoLevel))
        {
            LoggerFactory.getDefaultLogger().debug(
                    "[LockHelper] Specified isolation level string is 'null', using the default isolation level");
            return IsolationLevels.IL_DEFAULT;
        }
        if (isoLevel.equalsIgnoreCase(IsolationLevels.LITERAL_IL_READ_UNCOMMITTED))
        {
            return IsolationLevels.IL_READ_UNCOMMITTED;
        }
        else if (isoLevel.equalsIgnoreCase(IsolationLevels.LITERAL_IL_READ_COMMITTED))
        {
            return IsolationLevels.IL_READ_COMMITTED;
        }
        else if (isoLevel.equalsIgnoreCase(IsolationLevels.LITERAL_IL_REPEATABLE_READ))
        {
            return IsolationLevels.IL_REPEATABLE_READ;
        }
        else if (isoLevel.equalsIgnoreCase(IsolationLevels.LITERAL_IL_SERIALIZABLE))
        {
            return IsolationLevels.IL_SERIALIZABLE;
        }
        else if (isoLevel.equalsIgnoreCase(IsolationLevels.LITERAL_IL_OPTIMISTIC))
        {
            return IsolationLevels.IL_OPTIMISTIC;
        }
        else if (isoLevel.equalsIgnoreCase(IsolationLevels.LITERAL_IL_NONE))
        {
            return IsolationLevels.IL_NONE;
        }
        LoggerFactory.getDefaultLogger().warn("[LockHelper] Unknown isolation-level '" + isoLevel + "', using default isolation level");
        return IsolationLevels.IL_DEFAULT;
    }
227772
private Level getLogLevel() {
        return isQuiet() ? Level.OFF : isVerbose() ? Level.DEBUG : Level.INFO;
    }
1089831
private static org.tinylog.Level translateLevel(final Level level) {
		switch (level) {
			case TRACE:
				return org.tinylog.Level.TRACE;
			case DEBUG:
				return org.tinylog.Level.DEBUG;
			case INFO:
				return org.tinylog.Level.INFO;
			case WARN:
				return org.tinylog.Level.WARN;
			case ERROR:
			case FATAL:
				return org.tinylog.Level.ERROR;
			default:
				throw new IllegalArgumentException("Unknown JBoss Logging severity level \"" + level + "\"");
		}
	}
251807
public Logger get_logger() {
	if (logger == null) {
	    logger = Logger.getLogger(get_name().toLowerCase());
	    logger.setAdditivity(false);
	    logger.setLevel(Level.WARN);
	    last_level = Level.WARN;
	}
	return logger;
    }
447195
private function getLogLevel()
    {
        switch (Environment::LOG_LEVEL) {
            case "emergency":
                $this->logLevel = 8;
                break;
            case "alert":
                $this->logLevel = 7;
                break;
            case "critical":
                $this->logLevel = 6;
                break;
            case "error":
                $this->logLevel = 5;
                break;
            case "warning":
                $this->logLevel = 4;
                break;
            case "notice":
                $this->logLevel = 3;
                break;
            case "info":
                $this->logLevel = 2;
                break;
            case "debug":
                $this->logLevel = 1;
                break;
            default:
                $this->logLevel = 1;
                break;
        }
    }
1027447
public static Level getLoggingLevelFromProperties() {
		if (levelFromProperties == null) {
			final String verboseLevel = JanusConfig.getSystemProperty(JanusConfig.VERBOSE_LEVEL_NAME, JanusConfig.VERBOSE_LEVEL_VALUE);
			levelFromProperties = parseLoggingLevel(verboseLevel);
		}
		return levelFromProperties;
	}
1355796
def get_loglevel(level):
    
    if level == 'debug':
        return logging.DEBUG
    elif level == 'notice':
        return logging.INFO
    elif level == 'info':
        return logging.INFO
    elif level == 'warning' or level == 'warn':
        return logging.WARNING
    elif level == 'error' or level == 'err':
        return logging.ERROR
    elif level == 'critical' or level == 'crit':
        return logging.CRITICAL
    elif level == 'alert':
        return logging.CRITICAL
    elif level == 'emergency' or level == 'emerg':
        return logging.CRITICAL
    else:
        return logging.INFO
521504
public function getLogLevelName($level):string
    {
        return isset(self::$levels[$level])?self::$levels[$level]:'';
    }
778765
public String getNameAt(int level) {
    return this.levelwiseNames[level] instanceof Integer ? this.levelwiseNames[level].toString() : (String) this.levelwiseNames[level];
  }
597931
private Level createLevelByString(String levelString) throws IllegalArgumentException {
        try {
            return Level.parse(levelString.toUpperCase());
            //return WsLevel.parse(levelString.toUpperCase());
        } catch (Exception npe) {
            throw new IllegalArgumentException(getLocalizedParmString("CWTRA0013E", new Object[] { levelString }));
        }

    }
971621
public final void setLogLevel(LogLevel logLevel)
    {
        LogLevel updatedLogLevel=logLevel;
        if(updatedLogLevel==null)
        {
            updatedLogLevel=LogLevel.NONE;
        }
        
        this.logLevel=updatedLogLevel;
    }
200999
func LogLevel(levelString string) (LoggingLevel, error) {
	l, err := logging.LogLevel(levelString)
	level := LoggingLevel(l)
	if err != nil {
		level = LogError
	}
	return level, err
}