Documentation

FingersCrossedHandler extends AbstractHandler
in package

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 find the various activation strategies in the Monolog\Handler\FingersCrossed\ namespace.

Tags
author

Jordi Boggiano j.boggiano@seld.be

Table of Contents

Properties

$activationStrategy  : mixed
$bubble  : mixed
$buffer  : mixed
$buffering  : mixed
$bufferSize  : mixed
$formatter  : FormatterInterface
$handler  : mixed
$level  : mixed
$passthruLevel  : mixed
$processors  : mixed
$stopBuffering  : mixed

Methods

__construct()  : mixed
__destruct()  : mixed
activate()  : mixed
Manually activate this logger regardless of the activation strategy
clear()  : mixed
Clears the buffer without flushing any messages down to the wrapped handler.
close()  : mixed
Closes the handler.
getBubble()  : bool
Gets the bubbling behavior.
getFormatter()  : FormatterInterface
Gets the formatter.
getHandler()  : HandlerInterface
Return the nested handler
getLevel()  : int
Gets minimum logging level at which this handler will be triggered.
handle()  : bool
Handles a record.
handleBatch()  : mixed
Handles a set of records at once.
isHandling()  : bool
Checks whether the given record will be handled by this handler.
popProcessor()  : callable
Removes the processor on top of the stack and returns it.
pushProcessor()  : self
Adds a processor in the stack.
reset()  : mixed
setBubble()  : self
Sets the bubbling behavior.
setFormatter()  : self
Sets the formatter.
setLevel()  : self
Sets minimum logging level at which this handler will be triggered.
getDefaultFormatter()  : FormatterInterface
Gets the default formatter.
flushBuffer()  : mixed
Resets the state of the handler. Stops forwarding records to the wrapped handler.

Properties

Methods

__construct()

public __construct(callable|HandlerInterface $handler[, int|ActivationStrategyInterface $activationStrategy = null ][, int $bufferSize = 0 ][, bool $bubble = true ][, bool $stopBuffering = true ][, int $passthruLevel = null ]) : mixed
Parameters
$handler : callable|HandlerInterface

Handler or factory callable($record|null, $fingersCrossedHandler).

$activationStrategy : int|ActivationStrategyInterface = null

Strategy which determines when this handler takes action

$bufferSize : int = 0

How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.

$bubble : bool = true

Whether the messages that are handled can bubble up the stack or not

$stopBuffering : bool = true

Whether the handler should stop buffering after being triggered (default true)

$passthruLevel : int = null

Minimum level to always flush to handler on close, even if strategy not triggered

activate()

Manually activate this logger regardless of the activation strategy

public activate() : mixed

clear()

Clears the buffer without flushing any messages down to the wrapped handler.

public clear() : mixed

It also resets the handler to its initial buffering state.

getBubble()

Gets the bubbling behavior.

public getBubble() : bool
Return values
bool —

true means that this handler allows bubbling. false means that bubbling is not permitted.

getHandler()

Return the nested handler

public getHandler([array<string|int, mixed> $record = null ]) : HandlerInterface

If the handler was provided as a factory callable, this will trigger the handler's instantiation.

Parameters
$record : array<string|int, mixed> = null
Return values
HandlerInterface

getLevel()

Gets minimum logging level at which this handler will be triggered.

public getLevel() : int
Return values
int

handle()

Handles a record.

public handle(array<string|int, mixed> $record) : bool
Parameters
$record : array<string|int, mixed>

The record to handle

Return values
bool —

true means that this handler handled the record, and that bubbling is not permitted. false means the record was either not processed or that this handler allows bubbling.

handleBatch()

Handles a set of records at once.

public handleBatch(array<string|int, mixed> $records) : mixed
Parameters
$records : array<string|int, mixed>

The records to handle (an array of record arrays)

isHandling()

Checks whether the given record will be handled by this handler.

public isHandling(array<string|int, mixed> $record) : bool
Parameters
$record : array<string|int, mixed>

Partial log record containing only a level key

Return values
bool

popProcessor()

Removes the processor on top of the stack and returns it.

public popProcessor() : callable
Return values
callable

pushProcessor()

Adds a processor in the stack.

public pushProcessor(mixed $callback) : self
Parameters
$callback : mixed
Return values
self

setBubble()

Sets the bubbling behavior.

public setBubble(bool $bubble) : self
Parameters
$bubble : bool

true means that this handler allows bubbling. false means that bubbling is not permitted.

Return values
self

setLevel()

Sets minimum logging level at which this handler will be triggered.

public setLevel(int|string $level) : self
Parameters
$level : int|string

Level or level name

Return values
self

flushBuffer()

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

private flushBuffer() : mixed 

        

        
    




    

    

                                

                

                                
    

        On this page

        
    


                

                            

            

    

        

            
Search results