Set the notifyLevel of the logger, as defined in Psr\Log\LogLevel.

@param string $notifyLevel

@return void
484364
public function setNotifyLevel($notifyLevel)
    {
        if (!in_array($notifyLevel, $this->getLogLevelOrder())) {
            syslog(LOG_WARNING, 'Bugsnag Warning: Invalid notify level supplied to Bugsnag Logger');
        } else {
            $this->notifyLevel = $notifyLevel;
        }
    }
600024
public function notify(NotificationInterface $notification, $level = self::INFO)
    {
        if (!$this->handlers)
        {
            $this->addHandler(new NullHandler());
        }

        foreach ($this->getHandlers() as $handler)
        {
            if ($handler->shouldHandle($notification, $level))
            {
                if (false === $handler->handle($notification, $level))
                {
                    return false;
                }
            }
        }

        return true;
    }
353580
public function log($level, $message, array $context = array())
    {
        if (!array_key_exists($level, $this->levels)) {
            $level = $this->defaultLevel;
        }
        
        $level = \LoggerLevel::toLevel($this->levels[$level], $this->defaultLevel);
        
        $message = $this->formatter->format($level, $message, $context);

        $this->logger->log($level, $message);
    }
820100
def set_log_level(self, level):
        """"""
        if level == 'info':
            level = logging.INFO
        if level == 'debug':
            level = logging.DEBUG
        if level == 'error':
            level = logging.ERROR
        self._log.setLevel(level)
1059971
private void setThreadLogger(BaseLogger logger, int loggingLevel) {
        baseLogger.set(logger);
        logLevel.set(loggingLevel);
        JSch.setLogger(this);
    }
506526
public function setMinimalLogLevel($minLevel)
    {
        $this->logger->setMinLevel($minLevel);
        $this->commandHandler->setMinimalLogLevel($minLevel);
        $this->commandQueue->setMinimalLogLevel($minLevel);
    }
158151
public function log($msg, array $data = [], $level = Logger::INFO): void
    {
        $this->mgr->log($msg, $data, $level);
    }
883843
public function handle(NotificationInterface $notification, $level)
    {
        if ($notification instanceof TitleAwareInterface)
        {
            $command = $this->shellCommand . ' ' . escapeshellarg($notification->message()) . ' ' . escapeshellarg($notification->title());
        }
        else
        {
            $command = $this->shellCommand . ' ' . escapeshellarg($notification->message());
        }

        if ($notification instanceof AttributeAwareInterface)
        {
            $expiry = (int) $notification->attribute('expiry');

            if ($expiry)
            {
                $command .= "-t " . $expiry . " ";
            }

            $icon = $notification->attribute('icon');

            if ($expiry)
            {
                $command .= "-i " . $icon . " ";
            }
        }

        $command .= "-u " . $this->levelMapping[$level] . " ";

        exec($command . ' > /dev/null', $output, $code);

        return $code === 0;
    }
1246428
public void setWarningLevel(int level) {
        if (level < WarningMessage.NONE || level > WarningMessage.PARANOIA) {
            this.warningLevel = WarningMessage.LIKELY_ERRORS;
        }
        else {
            this.warningLevel = level;
        }
    }
122030
def set_level(self, level):
        
        for handler in self.__coloredlogs_handlers:
            handler.setLevel(level=level)

        self.logger.setLevel(level=level)
58064
private function log($level, $message, array $context = array())
    {
        if (isset($this->logger)) {
            $this->logger->log($level, $message, $context);
        }
    }
1031038
public function handle(NotificationInterface $notification, $level)
    {
        if ($notification instanceof AttributeAwareInterface)
        {
            $notify = $notification->attribute('notify');
            $format = $notification->attribute('format') ?: HipChat::FORMAT_HTML;
        }
        else
        {
            $format = HipChat::FORMAT_HTML;
            $notify = true;
        }

        return $this->hipchat->message_room(
            $this->room,
            $this->from,
            $notification->message(),
            $notify,
            $this->levelMapping[$level],
            $format
        );
    }
988366
final public function setMinLevel($minLevel)
    {
        if (isset($this->levels[$minLevel])) {
            $this->minLevel = $this->levels[$minLevel];
        }
        
        return $this;
    }
1343907
public function setEventsLogLevel($eventsLogLevel)
    {
        if (!in_array($eventsLogLevel, $this->getAvailableEventsLogLevel())) {
            throw new \InvalidArgumentException(
                sprintf(
                    'Unsupported events log level "%s". Use one of supported log levels: [%s].',
                    $eventsLogLevel,
                    implode(', ', $this->getAvailableEventsLogLevel())
                )
            );
        }

        $this->eventsLogLevel = $eventsLogLevel;
    }
744412
public function addNotifier(Notifier $notifier, bool $setLogger = true)
    {
        if ($notifier instanceof self) {
            throw new LogicException('Cannot add self');
        }

        if ($setLogger) {
            $notifier->setLogger($this->getLogger());
        }
        $this->notifiers[] = $notifier;
    }
298308
protected function _setupLogging($loglevel)
    {
        // Backwards compatibility
        if (file_exists(JPATH_LIBRARIES . '/src/Log/Log.php')) {
          require_once JPATH_LIBRARIES . '/src/Log/Log.php';
        } else {
          require_once JPATH_LIBRARIES . '/joomla/log/log.php';
        }

        if ($loglevel == OutputInterface::VERBOSITY_NORMAL) {
            return;
        }

        switch ($loglevel)
        {
            case OutputInterface::VERBOSITY_DEBUG:
                $priority = JLog::ALL;
                break;
            case OutputInterface::VERBOSITY_VERY_VERBOSE:
                $priority = JLog::ALL & ~JLog::DEBUG;
                break;
            case OutputInterface::VERBOSITY_VERBOSE:
                $priority = JLog::ALL & ~JLog::DEBUG & ~JLog::INFO & ~JLog::NOTICE;
                break;
        }

        if ($this->_is_platform === true || version_compare(JVERSION, '3.0.0', '>='))
        {
            $callback = function ($entry) {
                $priorities = array(
                    JLog::EMERGENCY => 'EMERGENCY',
                    JLog::ALERT => 'ALERT',
                    JLog::CRITICAL => 'CRITICAL',
                    JLog::ERROR => 'ERROR',
                    JLog::WARNING => 'WARNING',
                    JLog::NOTICE => 'NOTICE',
                    JLog::INFO => 'INFO',
                    JLog::DEBUG => 'DEBUG'
                );

                $message = $priorities[$entry->priority] . ': ' . $entry->message . (empty($entry->category) ? '' : ' [' . $entry->category . ']') . "\n";

                fwrite(STDERR, $message);
            };

            $options = array('logger' => 'callback', 'callback' => $callback);
        }
        else
        {
            require_once dirname(__DIR__) . '/Joomla/Legacy/JLoggerStderr.php';

            $options = array('logger' => 'stderr');
        }


        JLog::addLogger($options, $priority);
    }
633752
public function setLogLevel($level = 0)
    {
        if (is_string($level)) {
            $level = defined('Horde_Log::' . $level)
                ? constant('Horde_Log::' . $level)
                : 0;
        }

        $this->_logLevel = $level;
    }