<?php

/*

 * This file is part of the Monolog package.

 *

 * (c) Jordi Boggiano <j.boggiano@seld.be>

 *

 * For the full copyright and license information, please view the LICENSE

 * file that was distributed with this source code.

 */

namespace Monolog\Handler;

use Monolog\Logger;

/**

 * Buffers all records until a certain level is reached

 *

 * The advantage of this approach is that you don't get any clutter in your log files.

 * Only requests which actually trigger an error (or whatever your actionLevel is) will be

 * in the logs, but they will contain all records, not only those above the level threshold.

 *

 * @author Jordi Boggiano <j.boggiano@seld.be>

 */

class FingersCrossedHandler extends AbstractHandler

{

    protected $handler;

    protected $actionLevel;

    protected $buffering = true;

    protected $bufferSize;

    protected $buffer = array();

    protected $stopBuffering;

    /**

     * @param callback|HandlerInterface $handler Handler or factory callback($record, $fingersCrossedHandler).

     * @param int $actionLevel The minimum logging level at which this handler will be triggered

     * @param int $bufferSize How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.

     * @param Boolean $bubble Whether the messages that are handled can bubble up the stack or not

     * @param Boolean $stopBuffering Whether the handler should stop buffering after being triggered (default true)

     */

    public function __construct($handler, $actionLevel = Logger::WARNING, $bufferSize = 0, $bubble = true, $stopBuffering = true)

    {

        $this->handler = $handler;

        $this->actionLevel = $actionLevel;

        $this->bufferSize = $bufferSize;

        $this->bubble = $bubble;

        $this->stopBuffering = $stopBuffering;

    }

    /**

     * {@inheritdoc}

     */

    public function isHandling(array $record)

    {

        return true;

    }

    /**

     * {@inheritdoc}

     */

    public function handle(array $record)

    {

        if ($this->buffering) {

            $this->buffer[] = $record;

            if ($this->bufferSize > 0 && count($this->buffer) > $this->bufferSize) {

                array_shift($this->buffer);

            }

            if ($record['level'] >= $this->actionLevel) {

                if ($this->stopBuffering) {

                    $this->buffering = false;

                }

                if (!$this->handler instanceof HandlerInterface) {

                    $this->handler = call_user_func($this->handler, $record, $this);

                }

                if (!$this->handler instanceof HandlerInterface) {

                    throw new \RuntimeException("The factory callback should return a HandlerInterface");

                }

                $this->handler->handleBatch($this->buffer);

                $this->buffer = array();

            }

        } else {

            $this->handler->handle($record);

        }

        return false === $this->bubble;

    }

    /**

     * Resets the state of the handler. Stops forwarding records to the wrapped handler.

     */

    public function reset()

    {

        $this->buffering = true;

    }

}