Checks log level and logs

@param logger the Logger the log to
@param level the severity level
@param message the log message
190946
public static void log(Logger logger,
                           Level level,
                           String message) {
        log(logger, level, message, NO_PARAMETERS);
    }
38242
public function checkMessageLogLevel(string $message_level) : bool
    {
        foreach($this->log_levels as $lvl)
        {
            if ($lvl === 'ALL'){
                return true;
            }
            if (self::compareLogLevel($message_level, $lvl) === 0){
                return true;
            }
        }
        return false;
    }
728780
protected function log($message, $level = Logger::INFO)
    {
        $this->logger->log($message, $level);
    }
169734
public void log(int level, String msg, String extra) {
		if (logLevel >= level) {
			messageListener.debug(msg + extra);
		}
	}
518523
public void debug(final String message, final int level) {
        messages.add(new LogMessage(message, LogMessage.Type.DEBUG, level));
        log.debug(message);
    }
698918
public void error(Object message, Throwable exception) {
    log(Level.ERROR, message, exception);
  }
218130
def setLoggerLevel(self, logger, level):
        
        if level == logging.NOTSET:
            self.removeLogger(logger)
            self.handler().setLoggerLevel(logger, level)
            return
            
        if isinstance(logger, logging.Logger):
            logger = logger.name
        
        if not logger in self._loggers:
            self.addLogger(logger, level)
        else:
            self.handler().setLoggerLevel(logger, level)
248908
public final void debug(Object message) {

        if (isLevelEnabled(SimpleLog.LOG_LEVEL_DEBUG)) {
            log(SimpleLog.LOG_LEVEL_DEBUG, message, null);
        }
    }
397641
@Override
    protected void logImpl(LogLevel level,Object[] message,Throwable throwable)
    {
        //get log level
        int levelValue=level.getValue();
        Level jdkLevel=null;
        switch(levelValue)
        {
            case LogLevel.DEBUG_LOG_LEVEL_VALUE:
                jdkLevel=Level.FINEST;
                break;
            case LogLevel.ERROR_LOG_LEVEL_VALUE:
                jdkLevel=Level.SEVERE;
                break;
            case LogLevel.INFO_LOG_LEVEL_VALUE:
            default:
                jdkLevel=Level.FINE;
                break;
        }

        if(jdkLevel!=null)
        {
            //format log message (without exception)
            String text=this.formatLogMessage(level,message,null);

            //log
            this.JDK_LOGGER.log(jdkLevel,text,throwable);
        }
    }
496518
public static void log(LogLevel logLevel, Class<?> clazz, String message, String... values) {
        switch (logLevel) {
            case WARN:
                warn(clazz, message, values);
                break;
            case ERROR:
                error(clazz, message, values);
                break;
            case FATAL:
                fatal(clazz, message, values);
                break;
            default:
                info(clazz, message, values);
                break;
        }
    }
1035442
private static void writeToLog(Logger logger, Level level, String pattern, Exception exception) {
    if (level == Level.ERROR) {
      logger.error(pattern, exception);
    } else if (level == Level.INFO) {
      logger.info(pattern);
    } else if (level == Level.DEBUG) {
      logger.debug(pattern);
    }
  }
85383
public void log(Level level, String format, Object... args)
    {
        if (isLoggable(level))
        {
            if (format != null)
            {
                logIt(level, String.format(format, args));
            }
            else
            {
                logIt(level, String.format("%s format == null", level));
            }
        }
    }
265534
public void debug(Object message, Throwable exception) {
    log(Level.DEBUG, message, exception);
  }
1077728
@Override
	public void log(Level level, String msg, Throwable thrown) {
		
		super.log(level, maskPassword(msg), thrown);
	}
822811
private static final void log(final String Message, final int level) {
		if ((level == CClassLoader.INFO)
				&& CClassLoader.log.isLoggable(Level.INFO)) {
			CClassLoader.log.info(Message);
		} else if ((level == CClassLoader.DEBUG)
				&& CClassLoader.log.isLoggable(Level.FINE)) {
			CClassLoader.log.fine(Message);
		} else if ((level == CClassLoader.FATAL)
				&& CClassLoader.log.isLoggable(Level.SEVERE)) {
			CClassLoader.log.severe(Message);
		}
	}
763416
public static void log(int logLevel, String format, Object... args) {
    assertInitialization();
    sLogger.log(logLevel, format, args);
  }
1312554
public static void setLoggingLevel(final Level level) {
    final Handler[] handlers = Logger.getLogger("").getHandlers();
    ConsoleHandler ch = null;
    for (final Handler h : handlers) {
      if (h instanceof ConsoleHandler) {
        ch = (ConsoleHandler) h;
        break;
      }
    }
    if (ch == null) {
      ch = new ConsoleHandler();
      Logger.getLogger("").addHandler(ch);
    }
    ch.setLevel(level);
    Logger.getLogger("").setLevel(level);
  }