@param \Throwable|string $message
@param array             $context

@return mixed|void
771258
public function error($message, array $context = [])
    {
        if ($message instanceof \Throwable) {
            $m = "[{$message->getCode()}] " . $message->getMessage();
            $m .= "\n";
            $m .= $message->getTraceAsString();
            $this->error($m, $context); // calling back this method with string argument
            return;
        }

        $this->log(LogLevel::ERROR, $message, $context);
    }
289470
public function warning($message, array $context = array())
    {
        if (self::isSetLogger()) {
            return self::$logger->warning($message, $context);
        }

        return false;
    }
227478
public function beginDebug(string $message, array $context = []) {
        return $this->begin(LogLevel::DEBUG, $message, $context);
    }
1218894
public function pushErrorLog($message, array $context = [])
    {
        if ($this->logFile) {
            Log::getInstance([
                'channel' => 'ERROR-SQL',
                'level' => 'info',
                'maxSize' => 1000000, // default
            ])->pushInfo($message, $context);
        }
    }
969567
public function makeLog($message, array $context = [])
    {
        $this->log($this->defaultParams['level'], $message, $context);

        return $this;
    }
529371
public function emergency($message, array $context = array()) {
        $context['fromClass'] = get_called_class();
        foreach ($this->loggersInstances as $logger) {
            $logger->emergency($message, $context);
        }
    }
1279407
public function emergency($message, array $context = array())
    {
        // TODO: Implement emergency() method.
        return $this->addRecord(\Psr\Log\LogLevel::EMERGENCY, $message, $context);
    }
178482
protected function logInfo($message, array $context = [])
    {
        $this->hasLogger() === true ?: $this->logger->info($message, $context);
    }
353724
public function debug($message, array $context = []) {
        $this->logger->debug($this->prefixMessage($message), $context);
    }
516860
public function critical($message, array $context = [])
    {
        $this->checkInitialized();

        foreach ($this->loggers as $logger) {
            $logger->critical($message, $context);
        }
    }
372040
public function warn($message, array $context = array())
    {
        return $this->_instance->addRecord(\Monolog\Logger::WARNING, $message, $context);
    }
1324079
public function info(string $message, array $context = []){
        if($this->logger !== null){
            $this->logger->info($message, $context);
        }

        if($this->messagePanel !== null){
            $this->messagePanel->addMessage($message, LogLevel::INFO);
        }
    }
1067139
public function log($level, $message, array $context = array()) {
		if(is_object($message) && is_callable($message, '__toString')) {
			$message = (string)$message;
		}
		$message = $this->fetchMessageContext($message, $context);

		if(isset(static::$debugLevels[$level])) {
			$this->connector->getDebugDispatcher()->dispatchDebug($message, static::$debugLevels[$level], $this->ignoreTraceCalls);
		}
		elseif(isset(static::$errorsLevels[$level])) {
			if(isset($context['exception']) && ($context['exception'] instanceof \Exception || $context['exception'] instanceof \Throwable)) {
				$this->connector->getErrorsDispatcher()->dispatchException($context['exception']);
			}
			else {
				$this->connector->getErrorsDispatcher()->dispatchError(static::$errorsLevels[$level], $message, null, null, $this->ignoreTraceCalls);
			}
		}
		else {
			throw new InvalidArgumentException('Unknown log level "' . $level . '"');
		}
	}
1334139
public function debug($message, array $context = array())
    {
        // TODO: Implement debug() method.
        return $this->addRecord(\Psr\Log\LogLevel::DEBUG, $message, $context);
    }
1014921
public function send(string $priority, string $message, array $context = [])
    {
        if (! $this->contextContainsException($context)) {
            $data = [
                'extra' => $this->sanitizer->sanitize($context),
                'level' => $priority,
            ];

            $this->client->captureMessage(
                $message,
                [],
                $data,
                $this->stackTrace->cleanBacktrace(debug_backtrace())
            );

            return;
        }

        /** @var \Exception $exception */
        $exception = $context['exception'];
        unset($context['exception']);

        $exceptionsStack = $this->stackTrace->getExceptions($exception);

        // Adding a first fake exception to log the message
        $stack = $this->stackTrace->cleanBacktrace(debug_backtrace());
        $exceptionsStack[] = [
            'value' => $message,
            'type' => get_class($exception),
            'stacktrace' => [
                'frames' => $this->stackTrace->getStackTraceFrames($stack),
            ],
        ];

        $data = [
            'extra' => $this->sanitizer->sanitize($context),
            'level' => $priority,
            'exception' => [
                'values' => $exceptionsStack,
            ],
        ];

        $this->client->captureMessage($message, [], $data);
    }
150095
public function notice($message, array $context = []) : void
    {
        /** @psalm-suppress UndefinedClass */
        SspLogger::notice($message.($context ? " ".var_export($context, true) : ""));
    }
721093
public function debug($message, array $context = array())
    {
        if ($this->logger) {
            $context = $this->getLoggerContext($context);

            $this->logger->debug($message, $context);
        }
    }