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

  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 Symfony\Bridge\Monolog\Formatter\ConsoleFormatter;
  19. use Symfony\Component\Console\ConsoleEvents;
  20. use Symfony\Component\Console\Event\ConsoleCommandEvent;
  21. use Symfony\Component\Console\Event\ConsoleTerminateEvent;
  22. use Symfony\Component\Console\Output\ConsoleOutputInterface;
  23. use Symfony\Component\Console\Output\OutputInterface;
  24. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  25. use Symfony\Component\VarDumper\Dumper\CliDumper;
  27. /**
  28.  * Writes logs to the console output depending on its verbosity setting.
  29.  *
  30.  * It is disabled by default and gets activated as soon as a command is executed.
  31.  * Instead of listening to the console events, the output can also be set manually.
  32.  *
  33.  * The minimum logging level at which this handler will be triggered depends on the
  34.  * verbosity setting of the console output. The default mapping is:
  35.  * - OutputInterface::VERBOSITY_NORMAL will show all WARNING and higher logs
  36.  * - OutputInterface::VERBOSITY_VERBOSE (-v) will show all NOTICE and higher logs
  37.  * - OutputInterface::VERBOSITY_VERY_VERBOSE (-vv) will show all INFO and higher logs
  38.  * - OutputInterface::VERBOSITY_DEBUG (-vvv) will show all DEBUG and higher logs, i.e. all logs
  39.  *
  40.  * This mapping can be customized with the $verbosityLevelMap constructor parameter.
  41.  *
  42.  * @author Tobias Schultze <http://tobion.de>
  43.  */
  44. class ConsoleHandler extends AbstractProcessingHandler implements EventSubscriberInterface
  45. {
  46.     private $output;
  47.     private $verbosityLevelMap = [
  48.         OutputInterface::VERBOSITY_QUIET => Logger::ERROR,
  49.         OutputInterface::VERBOSITY_NORMAL => Logger::WARNING,
  50.         OutputInterface::VERBOSITY_VERBOSE => Logger::NOTICE,
  51.         OutputInterface::VERBOSITY_VERY_VERBOSE => Logger::INFO,
  52.         OutputInterface::VERBOSITY_DEBUG => Logger::DEBUG,
  53.     ];
  54.     private $consoleFormatterOptions;
  56.     /**
  57.      * @param OutputInterface|null $output            The console output to use (the handler remains disabled when passing null
  58.      *                                                until the output is set, e.g. by using console events)
  59.      * @param bool                 $bubble            Whether the messages that are handled can bubble up the stack
  60.      * @param array                $verbosityLevelMap Array that maps the OutputInterface verbosity to a minimum logging
  61.      *                                                level (leave empty to use the default mapping)
  62.      */
  63.     public function __construct(OutputInterface $output = null, bool $bubble = true, array $verbosityLevelMap = [], array $consoleFormatterOptions = [])
  64.     {
  65.         parent::__construct(Logger::DEBUG, $bubble);
  66.         $this->output = $output;
  68.         if ($verbosityLevelMap) {
  69.             $this->verbosityLevelMap = $verbosityLevelMap;
  70.         }
  72.         $this->consoleFormatterOptions = $consoleFormatterOptions;
  73.     }
  75.     /**
  76.      * {@inheritdoc}
  77.      */
  78.     public function isHandling(array $record): bool
  79.     {
  80.         return $this->updateLevel() && parent::isHandling($record);
  81.     }
  83.     /**
  84.      * {@inheritdoc}
  85.      */
  86.     public function handle(array $record): bool
  87.     {
  88.         // we have to update the logging level each time because the verbosity of the
  89.         // console output might have changed in the meantime (it is not immutable)
  90.         return $this->updateLevel() && parent::handle($record);
  91.     }
  93.     /**
  94.      * Sets the console output to use for printing logs.
  95.      */
  96.     public function setOutput(OutputInterface $output)
  97.     {
  98.         $this->output = $output;
  99.     }
  101.     /**
  102.      * Disables the output.
  103.      */
  104.     public function close(): void
  105.     {
  106.         $this->output = null;
  108.         parent::close();
  109.     }
  111.     /**
  112.      * Before a command is executed, the handler gets activated and the console output
  113.      * is set in order to know where to write the logs.
  114.      */
  115.     public function onCommand(ConsoleCommandEvent $event)
  116.     {
  117.         $output = $event->getOutput();
  118.         if ($output instanceof ConsoleOutputInterface) {
  119.             $output = $output->getErrorOutput();
  120.         }
  122.         $this->setOutput($output);
  123.     }
  125.     /**
  126.      * After a command has been executed, it disables the output.
  127.      */
  128.     public function onTerminate(ConsoleTerminateEvent $event)
  129.     {
  130.         $this->close();
  131.     }
  133.     /**
  134.      * {@inheritdoc}
  135.      */
  136.     public static function getSubscribedEvents()
  137.     {
  138.         return [
  139.             ConsoleEvents::COMMAND => ['onCommand', 255],
  140.             ConsoleEvents::TERMINATE => ['onTerminate', -255],
  141.         ];
  142.     }
  144.     /**
  145.      * {@inheritdoc}
  146.      */
  147.     protected function write(array $record): void
  148.     {
  149.         // at this point we've determined for sure that we want to output the record, so use the output's own verbosity
  150.         $this->output->write((string) $record['formatted'], false, $this->output->getVerbosity());
  151.     }
  153.     /**
  154.      * {@inheritdoc}
  155.      */
  156.     protected function getDefaultFormatter(): FormatterInterface
  157.     {
  158.         if (!class_exists(CliDumper::class)) {
  159.             return new LineFormatter();
  160.         }
  161.         if (!$this->output) {
  162.             return new ConsoleFormatter($this->consoleFormatterOptions);
  163.         }
  165.         return new ConsoleFormatter(array_replace([
  166.             'colors' => $this->output->isDecorated(),
  167.             'multiline' => OutputInterface::VERBOSITY_DEBUG <= $this->output->getVerbosity(),
  168.         ], $this->consoleFormatterOptions));
  169.     }
  171.     /**
  172.      * Updates the logging level based on the verbosity setting of the console output.
  173.      *
  174.      * @return bool Whether the handler is enabled and verbosity is not set to quiet
  175.      */
  176.     private function updateLevel(): bool
  177.     {
  178.         if (null === $this->output) {
  179.             return false;
  180.         }
  182.         $verbosity = $this->output->getVerbosity();
  183.         if (isset($this->verbosityLevelMap[$verbosity])) {
  184.             $this->setLevel($this->verbosityLevelMap[$verbosity]);
  185.         } else {
  186.             $this->setLevel(Logger::DEBUG);
  187.         }
  189.         return true;
  190.     }
  191. }