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\Level;
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);
 
            if ($output->isVeryVerbose()) {
                $handler->pushProcessor(new BacktraceProcessor(Level::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(Level::Warning));
        }
 
        $handler->pushProcessor(new PsrLogMessageProcessor());
 
        $logger->pushHandler($handler);
 
        $logger->setLevel();
 
        return $logger;
    }
 
    protected function normalizeLevel($level = null) {
        if (!is_string($level) || !in_array($level, self::$elgg_levels)) {
            $level_value = $level;
            if ($level === false) {
                $level_value = 'false';
            }
            
            $this->warning("Deprecated in 6.1: Using the log level '{$level_value}' has been deprecated. Use the \Psr\Log\LogLevel constants.");
        }
        
        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) {
        // TODO: In Elgg 7 we should throw exceptions if level is not a Psr/Log/LogLevel
        
        if (!isset($level)) {
            $php_error_level = error_reporting();
 
            $level = LogLevel::CRITICAL;
 
            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,
            ];
            
            return;
        }
 
        if (!$this->isLoggable($level)) {
            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->warning('Deprecated in 6.3: ' . __METHOD__ . ' has been deprecated use ->error()');
        
        $this->log(LogLevel::ERROR, $data);
    }
 
    public function disable() {
        $this->disabled_stack[] = [];
    }
 
    public function enable() {
        return array_pop($this->disabled_stack);
    }
}