Logger.php

Go to the documentation of this file.

<?php

namespace Elgg;

use Elgg\Cli\Application as CliApplication;
use Elgg\Cli\ErrorFormatter;
use Elgg\Cli\ErrorHandler;
use Elgg\Logger\BacktraceProcessor;
use Elgg\Logger\ElggLogFormatter;
use Monolog\Handler\ErrorLogHandler;
use Monolog\Processor\MemoryPeakUsageProcessor;
use Monolog\Processor\MemoryUsageProcessor;
use Monolog\Processor\ProcessIdProcessor;
use Monolog\Processor\PsrLogMessageProcessor;
use Monolog\Processor\WebProcessor;
use Psr\Log\LogLevel;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Console\Output\OutputInterface;

class Logger extends \Monolog\Logger {

    const CHANNEL = 'ELGG';

    const OFF = 600; // use highest log level for OFF

    protected static $elgg_levels = [
        0 => false,
        100 => LogLevel::DEBUG,
        200 => LogLevel::INFO,
        250 => LogLevel::NOTICE,
        300 => LogLevel::WARNING,
        400 => LogLevel::ERROR,
        500 => LogLevel::CRITICAL,
        550 => LogLevel::ALERT,
        600 => LogLevel::EMERGENCY,
    ];

    protected static $legacy_levels = [
        'OFF' => false,
        'INFO' => LogLevel::INFO,
        'NOTICE' => LogLevel::NOTICE,
        'WARNING' => LogLevel::WARNING,
        'ERROR' => LogLevel::ERROR,
    ];

    protected $level;

    protected $disabled_stack = [];

    public static function factory(InputInterface $input = null, OutputInterface $output = null) {
        $logger = new static(self::CHANNEL);

        if (\Elgg\Application::isCli()) {
            if (is_null($input) || is_null($output)) {
                $input = $input ?: \Elgg\Application::getStdIn();
                $output = $output ?: \Elgg\Application::getStdOut();

                $app = new CliApplication();
                $app->setup($input, $output);
            }

            $handler = new ErrorHandler(
                $output,
                \Elgg\Application::getStdErr(),
                true
            );

            $formatter = new ErrorFormatter();
            $formatter->allowInlineLineBreaks();
            $formatter->ignoreEmptyContextAndExtra();

            $handler->setFormatter($formatter);

            $handler->pushProcessor(new BacktraceProcessor(self::ERROR));
        } else {
            $handler = new ErrorLogHandler();

            $handler->pushProcessor(new WebProcessor());

            $formatter = new ElggLogFormatter();
            $formatter->allowInlineLineBreaks();
            $formatter->ignoreEmptyContextAndExtra();

            $handler->setFormatter($formatter);

            $handler->pushProcessor(new MemoryUsageProcessor());
            $handler->pushProcessor(new MemoryPeakUsageProcessor());
            $handler->pushProcessor(new ProcessIdProcessor());
            $handler->pushProcessor(new BacktraceProcessor(self::WARNING));
        }

        $handler->pushProcessor(new PsrLogMessageProcessor());

        $logger->pushHandler($handler);

        $logger->setLevel();

        return $logger;
    }

    protected function normalizeLevel($level = null) {
        if (!$level) {
            return false;
        }

        if (array_key_exists($level, self::$legacy_levels)) {
            $level = self::$legacy_levels[$level];
            if ($level === false) {
                // can't array_key_exists for false
                return 0;
            }
        }

        if (array_key_exists($level, self::$elgg_levels)) {
            $level = self::$elgg_levels[$level];
        }

        if (!in_array($level, self::$elgg_levels)) {
            $level = false;
        }

        return $level;
    }

    public function setLevel($level = null) {
        if (!isset($level)) {
            $php_error_level = error_reporting();

            $level = false;

            if (($php_error_level & E_NOTICE) == E_NOTICE) {
                $level = LogLevel::NOTICE;
            } else if (($php_error_level & E_WARNING) == E_WARNING) {
                $level = LogLevel::WARNING;
            } else if (($php_error_level & E_ERROR) == E_ERROR) {
                $level = LogLevel::ERROR;
            }
        }

        $this->level = $this->normalizeLevel($level);
    }

    public function getLevel($severity = true) {
        if ($severity) {
            return array_search($this->level, self::$elgg_levels);
        }

        return $this->level;
    }

    public function isLoggable($level) {
        $level = $this->normalizeLevel($level);

        $severity = array_search($level, self::$elgg_levels);
        if (!$this->getLevel() || $severity < $this->getLevel()) {
            return false;
        }

        return true;
    }

    public function log($level, $message, array $context = []): void {

        $level = $this->normalizeLevel($level);

        if (!empty($this->disabled_stack)) {
            // capture to top of stack
            end($this->disabled_stack);
            $key = key($this->disabled_stack);
            $this->disabled_stack[$key][] = [
                'message' => $message,
                'level' => $level,
            ];
        }

        if (!$this->isLoggable($level)) {
            return;
        }

        // when capturing, still use consistent return value
        if (!empty($this->disabled_stack)) {
            return;
        }

        parent::log($level, $message, $context);
    }

    public function emergency($message, array $context = []): void {
        $this->log(LogLevel::EMERGENCY, $message, $context);
    }

    public function alert($message, array $context = []): void {
        $this->log(LogLevel::ALERT, $message, $context);
    }

    public function critical($message, array $context = []): void {
        $this->log(LogLevel::CRITICAL, $message, $context);
    }

    public function error($message, array $context = []): void {
        $this->log(LogLevel::ERROR, $message, $context);
    }

    public function warning($message, array $context = []): void {
        $this->log(LogLevel::WARNING, $message, $context);
    }

    public function notice($message, array $context = []): void {
        $this->log(LogLevel::NOTICE, $message, $context);
    }

    public function info($message, array $context = []): void {
        $this->log(LogLevel::INFO, $message, $context);
    }

    public function debug($message, array $context = []): void {
        $this->log(LogLevel::DEBUG, $message, $context);
    }

    public function dump($data) {
        $this->log(LogLevel::ERROR, $data);
    }

    public function disable() {
        $this->disabled_stack[] = [];
    }

    public function enable() {
        return array_pop($this->disabled_stack);
    }
}