webshell

Ghost Exploiter Team Official

Directory >> /home/softsuitetech/public_html/DEMO/sidebyside/vendor/monolog/monolog/src/Monolog/Handler/

File / Folder	Size	Action
.	-
Curl	--	ren
FingersCrossed	--	ren
Slack	--	ren
SyslogUdp	--	ren
AbstractHandler.php	2.616KB	edt ren
AbstractProcessingHandl...	1.464KB	edt ren
AbstractSyslogHandler.php	3.146KB	edt ren
AmqpHandler.php	4.7KB	edt ren
BrowserConsoleHandler.php	9.021KB	edt ren
BufferHandler.php	4.439KB	edt ren
ChromePHPHandler.php	5.017KB	edt ren
CouchDBHandler.php	2.549KB	edt ren
CubeHandler.php	5.311KB	edt ren
DeduplicationHandler.php	5.803KB	edt ren
DoctrineCouchDBHandler.php	1.123KB	edt ren
DynamoDbHandler.php	1.889KB	edt ren
ElasticaHandler.php	3.584KB	edt ren
ElasticsearchHandler.php	6.79KB	edt ren
ErrorLogHandler.php	2.613KB	edt ren
FallbackGroupHandler.php	1.68KB	edt ren
FilterHandler.php	6.972KB	edt ren
FingersCrossedHandler.php	8.009KB	edt ren
FirePHPHandler.php	5.032KB	edt ren
FleepHookHandler.php	3.44KB	edt ren
FlowdockHandler.php	3.398KB	edt ren
FormattableHandlerInter...	0.739KB	edt ren
FormattableHandlerTrait...	1.238KB	edt ren
GelfHandler.php	1.42KB	edt ren
GroupHandler.php	3.193KB	edt ren
Handler.php	1.214KB	edt ren
HandlerInterface.php	2.721KB	edt ren
HandlerWrapper.php	3.276KB	edt ren
IFTTTHandler.php	2.215KB	edt ren
InsightOpsHandler.php	2.038KB	edt ren
LogEntriesHandler.php	1.861KB	edt ren
LogglyHandler.php	4.046KB	edt ren
LogmaticHandler.php	2.571KB	edt ren
MailHandler.php	2.192KB	edt ren
MandrillHandler.php	2.475KB	edt ren
MissingExtensionExcepti...	0.462KB	edt ren
MongoDBHandler.php	2.309KB	edt ren
NativeMailerHandler.php	4.88KB	edt ren
NewRelicHandler.php	5.694KB	edt ren
NoopHandler.php	0.887KB	edt ren
NullHandler.php	1.3KB	edt ren
OverflowHandler.php	4.208KB	edt ren
PHPConsoleHandler.php	11.923KB	edt ren
ProcessHandler.php	5.058KB	edt ren
ProcessableHandlerInter...	1.157KB	edt ren
ProcessableHandlerTrait...	1.58KB	edt ren
PsrHandler.php	2.3KB	edt ren
PushoverHandler.php	7.937KB	edt ren
RedisHandler.php	2.677KB	edt ren
RedisPubSubHandler.php	1.644KB	edt ren
RollbarHandler.php	3.517KB	edt ren
RotatingFileHandler.php	6.807KB	edt ren
SamplingHandler.php	3.818KB	edt ren
SendGridHandler.php	2.867KB	edt ren
SlackHandler.php	6.987KB	edt ren
SlackWebhookHandler.php	3.895KB	edt ren
SocketHandler.php	11.83KB	edt ren
SqsHandler.php	1.707KB	edt ren
StreamHandler.php	6.484KB	edt ren
SymfonyMailerHandler.php	3.466KB	edt ren
SyslogHandler.php	1.666KB	edt ren
SyslogUdpHandler.php	4.623KB	edt ren
TelegramBotHandler.php	9.194KB	edt ren
TestHandler.php	6.311KB	edt ren
WebRequestRecognizerTra...	0.492KB	edt ren
WhatFailureGroupHandler...	1.866KB	edt ren
ZendMonitorHandler.php	2.783KB	edt ren

<?php declare(strict_types=1);

/*
 * 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 Closure;
use Monolog\Handler\FingersCrossed\ErrorLevelActivationStrategy;
use Monolog\Handler\FingersCrossed\ActivationStrategyInterface;
use Monolog\Level;
use Monolog\Logger;
use Monolog\ResettableInterface;
use Monolog\Formatter\FormatterInterface;
use Psr\Log\LogLevel;
use Monolog\LogRecord;

/**
 * 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.
 *
 * You can then have a passthruLevel as well which means that at the end of the request,
 * even if it did not get activated, it will still send through log records of e.g. at least a
 * warning level.
 *
 * You can find the various activation strategies in the
 * Monolog\Handler\FingersCrossed\ namespace.
 *
 * @author Jordi Boggiano <j.boggiano@seld.be>
 */
class FingersCrossedHandler extends Handler implements ProcessableHandlerInterface, ResettableInterface, FormattableHandlerInterface
{
    use ProcessableHandlerTrait;

/**
     * Handler or factory Closure($record, $this)
     *
     * @phpstan-var (Closure(LogRecord|null, HandlerInterface): HandlerInterface)|HandlerInterface
     */
    protected Closure|HandlerInterface $handler;

protected ActivationStrategyInterface $activationStrategy;

protected bool $buffering = true;

protected int $bufferSize;

/** @var LogRecord[] */
    protected array $buffer = [];

protected bool $stopBuffering;

protected Level|null $passthruLevel = null;

protected bool $bubble;

/**
     * @phpstan-param (Closure(LogRecord|null, HandlerInterface): HandlerInterface)|HandlerInterface $handler
     *
     * @param Closure|HandlerInterface                    $handler            Handler or factory Closure($record|null, $fingersCrossedHandler).
     * @param int|string|Level|LogLevel::*      $activationStrategy Strategy which determines when this handler takes action, or a level name/value at which the handler is activated
     * @param int                                         $bufferSize         How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
     * @param bool                                        $bubble             Whether the messages that are handled can bubble up the stack or not
     * @param bool                                        $stopBuffering      Whether the handler should stop buffering after being triggered (default true)
     * @param int|string|Level|LogLevel::*|null $passthruLevel      Minimum level to always flush to handler on close, even if strategy not triggered
     *
     * @phpstan-param value-of<Level::VALUES>|value-of<Level::NAMES>|Level|LogLevel::*|ActivationStrategyInterface $activationStrategy
     * @phpstan-param value-of<Level::VALUES>|value-of<Level::NAMES>|Level|LogLevel::* $passthruLevel
     */
    public function __construct(Closure|HandlerInterface $handler, int|string|Level|ActivationStrategyInterface $activationStrategy = null, int $bufferSize = 0, bool $bubble = true, bool $stopBuffering = true, int|string|Level|null $passthruLevel = null)
    {
        if (null === $activationStrategy) {
            $activationStrategy = new ErrorLevelActivationStrategy(Level::Warning);
        }

// convert simple int activationStrategy to an object
        if (!$activationStrategy instanceof ActivationStrategyInterface) {
            $activationStrategy = new ErrorLevelActivationStrategy($activationStrategy);
        }

$this->handler = $handler;
        $this->activationStrategy = $activationStrategy;
        $this->bufferSize = $bufferSize;
        $this->bubble = $bubble;
        $this->stopBuffering = $stopBuffering;

if ($passthruLevel !== null) {
            $this->passthruLevel = Logger::toMonologLevel($passthruLevel);
        }
    }

/**
     * @inheritDoc
     */
    public function isHandling(LogRecord $record): bool
    {
        return true;
    }

/**
     * Manually activate this logger regardless of the activation strategy
     */
    public function activate(): void
    {
        if ($this->stopBuffering) {
            $this->buffering = false;
        }

$this->getHandler(end($this->buffer) ?: null)->handleBatch($this->buffer);
        $this->buffer = [];
    }

/**
     * @inheritDoc
     */
    public function handle(LogRecord $record): bool
    {
        if (\count($this->processors) > 0) {
            $record = $this->processRecord($record);
        }

if ($this->buffering) {
            $this->buffer[] = $record;
            if ($this->bufferSize > 0 && count($this->buffer) > $this->bufferSize) {
                array_shift($this->buffer);
            }
            if ($this->activationStrategy->isHandlerActivated($record)) {
                $this->activate();
            }
        } else {
            $this->getHandler($record)->handle($record);
        }

return false === $this->bubble;
    }

/**
     * @inheritDoc
     */
    public function close(): void
    {
        $this->flushBuffer();

$this->getHandler()->close();
    }

public function reset(): void
    {
        $this->flushBuffer();

$this->resetProcessors();

if ($this->getHandler() instanceof ResettableInterface) {
            $this->getHandler()->reset();
        }
    }

/**
     * Clears the buffer without flushing any messages down to the wrapped handler.
     *
     * It also resets the handler to its initial buffering state.
     */
    public function clear(): void
    {
        $this->buffer = [];
        $this->reset();
    }

/**
     * Resets the state of the handler. Stops forwarding records to the wrapped handler.
     */
    private function flushBuffer(): void
    {
        if (null !== $this->passthruLevel) {
            $passthruLevel = $this->passthruLevel;
            $this->buffer = array_filter($this->buffer, static function ($record) use ($passthruLevel) {
                return $passthruLevel->includes($record->level);
            });
            if (count($this->buffer) > 0) {
                $this->getHandler(end($this->buffer))->handleBatch($this->buffer);
            }
        }

$this->buffer = [];
        $this->buffering = true;
    }

/**
     * Return the nested handler
     *
     * If the handler was provided as a factory, this will trigger the handler's instantiation.
     */
    public function getHandler(LogRecord $record = null): HandlerInterface
    {
        if (!$this->handler instanceof HandlerInterface) {
            $handler = ($this->handler)($record, $this);
            if (!$handler instanceof HandlerInterface) {
                throw new \RuntimeException("The factory Closure should return a HandlerInterface");
            }
            $this->handler = $handler;
        }

return $this->handler;
    }

/**
     * @inheritDoc
     */
    public function setFormatter(FormatterInterface $formatter): HandlerInterface
    {
        $handler = $this->getHandler();
        if ($handler instanceof FormattableHandlerInterface) {
            $handler->setFormatter($formatter);

return $this;
        }

throw new \UnexpectedValueException('The nested handler of type '.get_class($handler).' does not support formatters.');
    }

/**
     * @inheritDoc
     */
    public function getFormatter(): FormatterInterface
    {
        $handler = $this->getHandler();
        if ($handler instanceof FormattableHandlerInterface) {
            return $handler->getFormatter();
        }

throw new \UnexpectedValueException('The nested handler of type '.get_class($handler).' does not support formatters.');
    }
}

<=Back