logging trigger

@param   int     $level
@param   array   $args
174800
protected function _log($level, $args)
    {
        foreach ($args as $message) {
            $this->send($level, $message);
        }
    }
1010033
public function log($level, $message, array $context = array()) {
        $context['fromClass'] = get_called_class();
        foreach ($this->loggersInstances as $logger) {
            $logger->log($level, $message, $context);
        }
    }
743932
public function log($level, $message, $context = [])
    {
        // This will be empty when output messages are triggered by the command
        // when it's NOT called by a worker option
        if (empty($this->logger)) {
            return;
        }

        // Call the logger's level specific methods
        $method = 'add'.ucfirst($level);
        $this->logger->$method($message, $context);
    }
557160
public function log($level, $message, array $context = [])
    {
        /** @var LoggerInterface|AdapterInterface $logTarget */
        foreach ($this->logTargets as $logTarget) {
            if (($logTarget instanceof AdapterInterface)) {
                $logTarget->log($this->getPhalconLoggerLevel($level), $message, $context);
            } else {
                $logTarget->log($level, $message, $context);
            }
        }
    }
394841
public function log($level, $messageOrException, array $context = []): void
    {
        if (null === $this->logger) {
            return;
        }

        if ($messageOrException instanceof Throwable) {
            $exception = $messageOrException;
            $variables = $context;

            $messageOrException = sprintf(
                'Exception %s: "%s" at %s line %s',
                get_class($exception),
                $exception->getMessage(),
                $exception->getFile(),
                $exception->getLine()
            );

            $exceptionIndex = array_search($exception, $variables, true);

            if (false !== $exceptionIndex) {
                unset($variables[$exceptionIndex]);
            }

            $context = [
                'exception' => $exception,
                'variables' => $variables,
            ];
        }

        $this->logger->log($level, $messageOrException, $context);
    }
929396
final protected function log(string $level, string $message, array $context = [])
    {
        $this->provider('logger')->log($level, $message, $context);
    }
706515
public function log($level, $message, array $context = [])
    {
        $context_output = empty($context) ? '' : sprintf(' :: %s', json_encode($context));

        $logline = sprintf("[%s] %s%s\n", strtoupper($level), $message, $context_output);

        $handle = in_array($level, self::ERROR_LEVELS, false) ? STDERR : STDOUT;

        fwrite($handle, $logline);
    }
456858
public function log($message, $level = 0) {
        foreach ($this->_loggers as $logger) {
            try {
                $logger->logMessage($message, $level);
            } catch (LoggerException $e) {
                throw $e;
            }
        }
    }
833567
public function log($level, $message, array $context = array())
    {
        if ($this->outputIsUrgent($level) || $this->isEnabled()) {
            $this->dispatch($message, $context);
        }
    }
1311615
public function log($level, $message, array $context = array())
    {
        $context = array_merge($this->decorations, $context);

        $this->getInnerLogger()->log($level, $message, $context);
    }
1264291
public function log($message, $level = LogLevel::DEBUG)
    {
        if ($this->logger instanceof LoggerInterface) {
            $this->logger->log($level, $message);
        }
    }
1344631
public function log($level, $message, array $context = array()) {
		$message = preg_replace("/[\r\n]+/", $this->replacement, $message);
		$this->logger()->log($level, $message, $context);
	}
1189136
public function log($level, $message, array $context = array())
    {
        $context = $this->parseContext($context);
        $trace = $context['trace'];
        $logTime = time();
        $record = new Record($level, $message, $context, $trace, $logTime);
        foreach($this->handlers as $handler)
        {
            $handler->log($record);
        }
    }
867361
public function log($level, $message, array $context = [])
    {
        if (!isset($this->logLevels[$level])) {
            $level = LogLevel::DEBUG;
        }

        if ($this->logLevels[$level] < $this->level) {
            // do not print.
            return;
        }

        if ($this->level === 3 && $this->logLevels[$level] === 3) {
            $style = 'dim';
        } else {
            $style = $this->levelStyles[$level];
        }

        if ($this->indent) {
            $this->write(\str_repeat($this->indentCharacter, $this->indent));
        }

        if (\is_object($message) || \is_array($message)) {
            $this->writeln(\print_r($message, true), $style);
        } else {
            $this->writeln($message, $style);
        }
    }
660282
public function log($level, $message, array $context = array())
    {
        $message = $this->formatMessage($level, $message, $context);        
        $this->write($message);
    }
1075799
public function log(
        $level,
        $msg,
        array $args = array(),
        \Exception $exception = null
    ) {
        $logger = $this->getIndirectLogger();
        $logger->log($level, $msg, $args, $exception);
        return $this;
    }
377745
public function log($level, $message, array $context = array()) {
        // If the given level is not valid
        if (!LogLevel::isValid($level)) {
            throw new InvalidArgumentException("The given logger level [" . $level . "] is not valid");
        }

        // If the given level is not handled by the logger
        if (!$this->_isEnabledForLevel($level)) {
            return;
        }

        // Create a log event
        $event = LogEvent::create($this->_className, $level);

        // If there is a given context
        if (!empty($context)) {
            $message = $this->_interpolate($message, $context);
        }

        // Set the message
        $event->setMessage($message);

        // Set the exception, if any
        if (isset($context['exception'])) {
            $event->setException($context['exception']);
        }

        // Dispatch the log event to the writers
        $this->_dispatchEventToWriters($event);
    }