Checks whether the Logger has a handler that listens on the given level

@param integer $level
@return Boolean
976476
public function isHandling($level)
    {
        $record = array(
            'message' => '',
            'context' => array(),
            'level' => $level,
            'level_name' => self::getLevelName($level),
            'channel' => $this->name,
            'datetime' => new \DateTime(),
            'extra' => array(),
        );

        foreach ($this->handlers as $key => $handler) {
            if ($handler->isHandling($record)) {
                return true;
            }
        }

        return false;
    }
756584
public static function caller($level = 0)
    {
        $trace = debug_backtrace(0);

        if ($level < 0) {
            return $trace;
        } elseif (empty($trace[$level])) {
            return null;
        } elseif (empty($trace[$level]['file'])) {
            $level = 1;
        }

        $file = $trace[$level]['file'];
        $line = $trace[$level]['line'];

        $trace = null;

        return array(
            'file' => $file,
            'line' => $line
        );
    }
187074
public function PerformantLevel($level) {
		$menuNode = $this->asDataNode();
		$stack = array();
		if ($menuNode) {
			$parent = $menuNode;
			$stack[] = $parent;
			while ($parent = $parent->getParent()) {
				array_unshift($stack, $parent);
			}
		}
		return isset($stack[$level - 1]) ? $stack[$level - 1] : null;
	}
355
private function checkLevel(int $level)
    {
        if ($level <= 0 || $level > self::MAX_LEVEL_DEPTH) {
            throw new OutOfBounds(
                sprintf('Administrative level should be an integer in [1,%d], %d given', self::MAX_LEVEL_DEPTH, $level)
            );
        }
    }
983150
protected function createHandler($level)
    {
        $handler = new DatabaseHandler($level);
        // set a more basic formatter.
        $output = '%message%';
        $formatter = new LineFormatter($output, null, true);
        $handler->setFormatter($formatter);

        return $handler;
    }
646650
private function prepareLogLevels(string $level)
    {
        $levels = [
            LogLevel::EMERGENCY,
            LogLevel::ALERT,
            LogLevel::CRITICAL,
            LogLevel::ERROR,
            LogLevel::WARNING,
            LogLevel::NOTICE,
            LogLevel::INFO,
            LogLevel::DEBUG,
        ];

        $key = array_search($level, $levels);

        if (null !== $key) {
            $this->levels = array_slice($levels, 0, $key + 1);
        }
    }
8238
public function isDisabled(\n2n\log4php\LoggerLevel $level) {
		return ($this->threshold->toInt() > $level->toInt());
	}
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;
    }
1282558
protected function fireLogEvent( $level, $message, array $context = [] )
	{
		// If the event dispatcher is set, we will pass along the parameters to the
		// log listeners. These are useful for building profilers or other tools
		// that aggregate all of the log messages for a given "request" cycle.
		if ( isset( $this->dispatcher ) )
			Hooks::trigger( 'logger.' . $level, compact( 'level', 'message', 'context' ) );
	}
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,
            )
        );
    }
1281260
private static function log(string $message, int $level) {
        \Logger::configure(self::getConfiguration());
        $logger = \Logger::getRootLogger();
        $logger->setLevel(self::getLoggerLevel());

        switch ($level) {
            case Logger::DEBUG:
                $logger->debug($message);
                break;
            case Logger::INFO:
                $logger->info($message);
                break;
            case Logger::WARN:
                $logger->warn($message);
                break;
            case Logger::ERROR:
                $logger->error($message);
                break;
            case Logger::FATAL:
                $logger->fatal($message);
                break;
            case Logger::TRACE:
                $logger->trace($message);
                break;
            default:
        }
    }
1162784
public function getLogger(string $channel, ?string $level = null): LoggerInterface
    {
        $channel = strtolower($channel);

        if (!isset($this->loggers[$channel])) {
            if (class_exists(Monolog::class)) {
                $this->loggers[$channel] = $this->createLogger($channel, $level);

                return $this->loggers[$channel];
            }

            return $this->getNullLogger();
        }

        return $this->loggers[$channel];
    }
1234856
protected function _checkLogLevel( $level )
	{
		switch( $level )
		{
			case MW_Logger_Abstract::EMERG:
			case MW_Logger_Abstract::ALERT:
			case MW_Logger_Abstract::CRIT:
			case MW_Logger_Abstract::ERR:
			case MW_Logger_Abstract::WARN:
			case MW_Logger_Abstract::NOTICE:
			case MW_Logger_Abstract::INFO:
			case MW_Logger_Abstract::DEBUG:
				break;
			default:
				throw new MW_Logger_Exception( sprintf( 'Invalid log level constant "%1$d"', $level ) );
		}
	}
1144412
public function log($message, $level)
    {
        Injector::inst()->get(LoggerInterface::class)->log($level, $message);
    }
1089652
protected function parseLevel( $level )
	{
		if ( isset( $this->levels[$level] ) )
			return $this->levels[$level];

		throw new InvalidArgumentException( 'Invalid log level.' );
	}
495664
public function hasCountedLogLevel($logLevel)
    {
        if (isset($this->logLevelCount[$logLevel])) {
            return $this->logLevelCount[$logLevel] > 0;
        }

        return false;
    }
1164351
public static function isSessionHandler($handler)
    {
        $config = Config::getInstance();
        return !isset($config->General['session_save_handler'])
        || $config->General['session_save_handler'] === $handler;
    }