vendor/symfony/monolog-bridge/Handler/ConsoleHandler.php line 164

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Symfony package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bridge\Monolog\Handler;
  14. use Monolog\Formatter\FormatterInterface;
  15. use Monolog\Formatter\LineFormatter;
  16. use Monolog\Handler\AbstractProcessingHandler;
  17. use Monolog\Logger;
  18. use Monolog\LogRecord;
  19. use Symfony\Bridge\Monolog\Formatter\ConsoleFormatter;
  20. use Symfony\Component\Console\ConsoleEvents;
  21. use Symfony\Component\Console\Event\ConsoleCommandEvent;
  22. use Symfony\Component\Console\Event\ConsoleTerminateEvent;
  23. use Symfony\Component\Console\Output\ConsoleOutputInterface;
  24. use Symfony\Component\Console\Output\OutputInterface;
  25. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  26. use Symfony\Component\VarDumper\Dumper\CliDumper;
  28. if (Logger::API >= 3) {
  29.     /**
  30.      * The base class for compatibility between Monolog 3 LogRecord and Monolog 1/2 array records.
  31.      *
  32.      * @author Jordi Boggiano <j.boggiano@seld.be>
  33.      *
  34.      * @internal
  35.      */
  36.     trait CompatibilityIsHandlingHandler
  37.     {
  38.         abstract private function doIsHandling(array|LogRecord $record): bool;
  40.         /**
  41.          * {@inheritdoc}
  42.          */
  43.         public function isHandling(LogRecord $record): bool
  44.         {
  45.             return $this->doIsHandling($record);
  46.         }
  47.     }
  48. } else {
  49.     /**
  50.      * The base class for compatibility between Monolog 3 LogRecord and Monolog 1/2 array records.
  51.      *
  52.      * @author Jordi Boggiano <j.boggiano@seld.be>
  53.      *
  54.      * @internal
  55.      */
  56.     trait CompatibilityIsHandlingHandler
  57.     {
  58.         abstract private function doIsHandling(array|LogRecord $record): bool;
  60.         /**
  61.          * {@inheritdoc}
  62.          */
  63.         public function isHandling(array $record): bool
  64.         {
  65.             return $this->doIsHandling($record);
  66.         }
  67.     }
  68. }
  70. /**
  71.  * Writes logs to the console output depending on its verbosity setting.
  72.  *
  73.  * It is disabled by default and gets activated as soon as a command is executed.
  74.  * Instead of listening to the console events, the output can also be set manually.
  75.  *
  76.  * The minimum logging level at which this handler will be triggered depends on the
  77.  * verbosity setting of the console output. The default mapping is:
  78.  * - OutputInterface::VERBOSITY_NORMAL will show all WARNING and higher logs
  79.  * - OutputInterface::VERBOSITY_VERBOSE (-v) will show all NOTICE and higher logs
  80.  * - OutputInterface::VERBOSITY_VERY_VERBOSE (-vv) will show all INFO and higher logs
  81.  * - OutputInterface::VERBOSITY_DEBUG (-vvv) will show all DEBUG and higher logs, i.e. all logs
  82.  *
  83.  * This mapping can be customized with the $verbosityLevelMap constructor parameter.
  84.  *
  85.  * @author Tobias Schultze <http://tobion.de>
  86.  *
  87.  * @final since Symfony 6.1
  88.  */
  89. class ConsoleHandler extends AbstractProcessingHandler implements EventSubscriberInterface
  90. {
  91.     use CompatibilityHandler;
  92.     use CompatibilityIsHandlingHandler;
  93.     use CompatibilityProcessingHandler;
  95.     private ?OutputInterface $output;
  96.     private array $verbosityLevelMap = [
  97.         OutputInterface::VERBOSITY_QUIET => Logger::ERROR,
  98.         OutputInterface::VERBOSITY_NORMAL => Logger::WARNING,
  99.         OutputInterface::VERBOSITY_VERBOSE => Logger::NOTICE,
  100.         OutputInterface::VERBOSITY_VERY_VERBOSE => Logger::INFO,
  101.         OutputInterface::VERBOSITY_DEBUG => Logger::DEBUG,
  102.     ];
  103.     private array $consoleFormatterOptions;
  105.     /**
  106.      * @param OutputInterface|null $output            The console output to use (the handler remains disabled when passing null
  107.      *                                                until the output is set, e.g. by using console events)
  108.      * @param bool                 $bubble            Whether the messages that are handled can bubble up the stack
  109.      * @param array                $verbosityLevelMap Array that maps the OutputInterface verbosity to a minimum logging
  110.      *                                                level (leave empty to use the default mapping)
  111.      */
  112.     public function __construct(OutputInterface $output = null, bool $bubble = true, array $verbosityLevelMap = [], array $consoleFormatterOptions = [])
  113.     {
  114.         parent::__construct(Logger::DEBUG, $bubble);
  115.         $this->output = $output;
  117.         if ($verbosityLevelMap) {
  118.             $this->verbosityLevelMap = $verbosityLevelMap;
  119.         }
  121.         $this->consoleFormatterOptions = $consoleFormatterOptions;
  122.     }
  124.     /**
  125.      * {@inheritdoc}
  126.      */
  127.     private function doIsHandling(array|LogRecord $record): bool
  128.     {
  129.         return $this->updateLevel() && parent::isHandling($record);
  130.     }
  132.     /**
  133.      * {@inheritdoc}
  134.      */
  135.     private function doHandle(array|LogRecord $record): bool
  136.     {
  137.         // we have to update the logging level each time because the verbosity of the
  138.         // console output might have changed in the meantime (it is not immutable)
  139.         return $this->updateLevel() && parent::handle($record);
  140.     }
  142.     /**
  143.      * Sets the console output to use for printing logs.
  144.      */
  145.     public function setOutput(OutputInterface $output)
  146.     {
  147.         $this->output = $output;
  148.     }
  150.     /**
  151.      * Disables the output.
  152.      */
  153.     public function close(): void
  154.     {
  155.         $this->output = null;
  157.         parent::close();
  158.     }
  160.     /**
  161.      * Before a command is executed, the handler gets activated and the console output
  162.      * is set in order to know where to write the logs.
  163.      */
  164.     public function onCommand(ConsoleCommandEvent $event)
  165.     {
  166.         $output = $event->getOutput();
  167.         if ($output instanceof ConsoleOutputInterface) {
  168.             $output = $output->getErrorOutput();
  169.         }
  171.         $this->setOutput($output);
  172.     }
  174.     /**
  175.      * After a command has been executed, it disables the output.
  176.      */
  177.     public function onTerminate(ConsoleTerminateEvent $event)
  178.     {
  179.         $this->close();
  180.     }
  182.     /**
  183.      * {@inheritdoc}
  184.      */
  185.     public static function getSubscribedEvents(): array
  186.     {
  187.         return [
  188.             ConsoleEvents::COMMAND => ['onCommand', 255],
  189.             ConsoleEvents::TERMINATE => ['onTerminate', -255],
  190.         ];
  191.     }
  193.     private function doWrite(array|LogRecord $record): void
  194.     {
  195.         // at this point we've determined for sure that we want to output the record, so use the output's own verbosity
  196.         $this->output->write((string) $record['formatted'], false, $this->output->getVerbosity());
  197.     }
  199.     /**
  200.      * {@inheritdoc}
  201.      */
  202.     protected function getDefaultFormatter(): FormatterInterface
  203.     {
  204.         if (!class_exists(CliDumper::class)) {
  205.             return new LineFormatter();
  206.         }
  207.         if (!$this->output) {
  208.             return new ConsoleFormatter($this->consoleFormatterOptions);
  209.         }
  211.         return new ConsoleFormatter(array_replace([
  212.             'colors' => $this->output->isDecorated(),
  213.             'multiline' => OutputInterface::VERBOSITY_DEBUG <= $this->output->getVerbosity(),
  214.         ], $this->consoleFormatterOptions));
  215.     }
  217.     /**
  218.      * Updates the logging level based on the verbosity setting of the console output.
  219.      *
  220.      * @return bool Whether the handler is enabled and verbosity is not set to quiet
  221.      */
  222.     private function updateLevel(): bool
  223.     {
  224.         if (null === $this->output) {
  225.             return false;
  226.         }
  228.         $verbosity = $this->output->getVerbosity();
  229.         if (isset($this->verbosityLevelMap[$verbosity])) {
  230.             $this->setLevel($this->verbosityLevelMap[$verbosity]);
  231.         } else {
  232.             $this->setLevel(Logger::DEBUG);
  233.         }
  235.         return true;
  236.     }
  237. }