@param int $level

@return bool
169655
public function isSuccess($level = HealthCheckTestResultInterface::WARNING)
    {
        /** @var HealthCheckTestResultInterface $result */
        foreach ($this->results as $result) {
            if (true === $result->isError() && $result->getLevel() >= $level){
                return false;
            }
        }

        return true;
    }
426663
public static function toMonologLevel($level)
    {
        if (is_string($level) && defined(__CLASS__.'::'.strtoupper($level))) {
            return constant(__CLASS__.'::'.strtoupper($level));
        }

        return $level;
    }
197281
protected function set_level($level) {
        $this->level = $level;
        foreach ($this->subtree as $tab) {
            $tab->set_level($level + 1);
        }
    }
606653
public function Level($level)
    {
        $parent = $this;
        $stack = array($parent);
        while ($parent = $parent->Parent) {
            array_unshift($stack, $parent);
        }

        return isset($stack[$level-1]) ? $stack[$level-1] : null;
    }
1281143
private function setLevel($level)
    {
        $availableLevels = array_flip(Logger::getLevels());

        if (!isset($availableLevels[$level])) {
            throw new InvalidLoggerLevelException(
                sprintf(
                    'The level: "%d" does not exist. The available levels are: "%s"',
                    $level,
                    implode(', ', array_keys($availableLevels))
                ),
                400
            );
        }
        $this->level = $level;

        return $this;
    }
1116497
protected function write($object, $level)
    {
        if ($this->enabled && $this->writer && $level <= $this->level) {
            return $this->writer->write($object, $level);
        } else {
            return false;
        }
    }
86482
public function setLogLevel($level)
    {
        $this->logLevelSet = true;
        if ($level != $this->getLogLevel()) {
            $this->logLevel = $level;
            $this->info("Setting loglevel to $level");
        }
    }
495664
public function hasCountedLogLevel($logLevel)
    {
        if (isset($this->logLevelCount[$logLevel])) {
            return $this->logLevelCount[$logLevel] > 0;
        }

        return false;
    }
1345172
public function setLevel($level)
    {
        $this->level = $level;

        if (isset($this->nestedSetNode)) {
            $this->nestedSetNode->setLevel($level);
        }
        return $this;
    }
1344420
private function loggerLevel($level)
    {
        switch ($level) {
            case 'trace':
            case 'debug':
                return Logger::DEBUG;
                break;

            case 'info':
                return Logger::INFO;
                break;

            case 'notice':
                return Logger::NOTICE;
                break;

            case 'warn':
            case 'warning':
                return Logger::WARNING;
                break;

            case 'error':
                return Logger::ERROR;
                break;

            case 'crit':
            case 'critical':
                return Logger::CRITICAL;
                break;

            case 'alert':
                return Logger::ALERT;
                break;

            case 'emergency':
                return Logger::EMERGENCY;
                break;

            default:
                throw new \Exception('Unknown Log Level', 1);
                break;
        }
    }
993014
public function level($level, $operator = '>=')
	{
		if (!$this->user())
		{
			return false;
		}

		$userCaps = array_keys($this->getUser()->allcaps);

		foreach ($userCaps as $cap)
		{
			// get just the first, higher
			if (substr($cap, 0, 6) === 'level_')
			{
				return $this->checkWithOperator(substr($cap, 6), $level, $operator);
			}
		}

		return false;
	}
435029
public function rollBack($levels = null): bool
    {
        $this->__tRollBack($levels);
        if(null === $levels)
        {
            return $this->instance->rollback();
        }
        else
        {
            $this->exec('ROLLBACK TO P' . ($this->getTransactionLevels()));
            return true;
        }
    }
1029480
public function setLevel($level)
    {
        if (false === Numeric::isPositiveInteger($level, false)) {
            throw new InvalidArgumentException('A nested level must be a positive integer.');
        }
        $this->_level = $level;
        return $this;
    }
876455
public function setDebug($level)
	{
		$previous    = $this->debug;
		$this->debug = (bool) $level;

		return $previous;
	}
1015371
public function withLevel($level)
    {
        if (!isset(self::$levels[$level])) {
            throw new InvalidArgumentException('Unsupported log level "' . $level . '"');
        }

        $this->level = $level;
    }
455306
public function level($level = null)
    {
        if ($level !== null) {
            $this->_level = $level;
        }

        return $this->_level;
    }
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)
            );
        }
    }