vendor/monolog/monolog/src/Monolog/Handler/BufferHandler.php line 26

Open in your IDE?
  1. <?php
  3. /*
  4.  * This file is part of the Monolog package.
  5.  *
  6.  * (c) Jordi Boggiano <j.boggiano@seld.be>
  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 Monolog\Handler;
  14. use Monolog\Logger;
  15. use Monolog\ResettableInterface;
  16. use Monolog\Formatter\FormatterInterface;
  18. /**
  19.  * Buffers all records until closing the handler and then pass them as batch.
  20.  *
  21.  * This is useful for a MailHandler to send only one mail per request instead of
  22.  * sending one per log message.
  23.  *
  24.  * @author Christophe Coevoet <stof@notk.org>
  25.  */
  26. class BufferHandler extends AbstractHandler
  27. {
  28.     protected $handler;
  29.     protected $bufferSize = 0;
  30.     protected $bufferLimit;
  31.     protected $flushOnOverflow;
  32.     protected $buffer = array();
  33.     protected $initialized = false;
  35.     /**
  36.      * @param HandlerInterface $handler         Handler.
  37.      * @param int              $bufferLimit     How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
  38.      * @param int              $level           The minimum logging level at which this handler will be triggered
  39.      * @param bool             $bubble          Whether the messages that are handled can bubble up the stack or not
  40.      * @param bool             $flushOnOverflow If true, the buffer is flushed when the max size has been reached, by default oldest entries are discarded
  41.      */
  42.     public function __construct(HandlerInterface $handler, $bufferLimit = 0, $level = Logger::DEBUG, $bubble = true, $flushOnOverflow = false)
  43.     {
  44.         parent::__construct($level, $bubble);
  45.         $this->handler = $handler;
  46.         $this->bufferLimit = (int) $bufferLimit;
  47.         $this->flushOnOverflow = $flushOnOverflow;
  48.     }
  50.     /**
  51.      * {@inheritdoc}
  52.      */
  53.     public function handle(array $record)
  54.     {
  55.         if ($record['level'] < $this->level) {
  56.             return false;
  57.         }
  59.         if (!$this->initialized) {
  60.             // __destructor() doesn't get called on Fatal errors
  61.             register_shutdown_function(array($this, 'close'));
  62.             $this->initialized = true;
  63.         }
  65.         if ($this->bufferLimit > 0 && $this->bufferSize === $this->bufferLimit) {
  66.             if ($this->flushOnOverflow) {
  67.                 $this->flush();
  68.             } else {
  69.                 array_shift($this->buffer);
  70.                 $this->bufferSize--;
  71.             }
  72.         }
  74.         if ($this->processors) {
  75.             foreach ($this->processors as $processor) {
  76.                 $record = call_user_func($processor, $record);
  77.             }
  78.         }
  80.         $this->buffer[] = $record;
  81.         $this->bufferSize++;
  83.         return false === $this->bubble;
  84.     }
  86.     public function flush()
  87.     {
  88.         if ($this->bufferSize === 0) {
  89.             return;
  90.         }
  92.         $this->handler->handleBatch($this->buffer);
  93.         $this->clear();
  94.     }
  96.     public function __destruct()
  97.     {
  98.         // suppress the parent behavior since we already have register_shutdown_function()
  99.         // to call close(), and the reference contained there will prevent this from being
  100.         // GC'd until the end of the request
  101.     }
  103.     /**
  104.      * {@inheritdoc}
  105.      */
  106.     public function close()
  107.     {
  108.         $this->flush();
  109.     }
  111.     /**
  112.      * Clears the buffer without flushing any messages down to the wrapped handler.
  113.      */
  114.     public function clear()
  115.     {
  116.         $this->bufferSize = 0;
  117.         $this->buffer = array();
  118.     }
  120.     public function reset()
  121.     {
  122.         $this->flush();
  124.         parent::reset();
  126.         if ($this->handler instanceof ResettableInterface) {
  127.             $this->handler->reset();
  128.         }
  129.     }
  131.     /**
  132.      * {@inheritdoc}
  133.      */
  134.     public function setFormatter(FormatterInterface $formatter)
  135.     {
  136.         $this->handler->setFormatter($formatter);
  138.         return $this;
  139.     }
  141.     /**
  142.      * {@inheritdoc}
  143.      */
  144.     public function getFormatter()
  145.     {
  146.         return $this->handler->getFormatter();
  147.     }
  148. }