Documentation

OverflowHandler extends AbstractHandler
in package
implements FormattableHandlerInterface

Handler to only pass log messages when a certain threshold of number of messages is reached.

This can be useful in cases of processing a batch of data, but you're for example only interested in case it fails catastrophically instead of a warning for 1 or 2 events. Worse things can happen, right?

Usage example:

  $log = new Logger('application');
  $handler = new SomeHandler(...)

  // Pass all warnings to the handler when more than 10 & all error messages when more then 5
  $overflow = new OverflowHandler($handler, [Logger::WARNING => 10, Logger::ERROR => 5]);

  $log->pushHandler($overflow);
Tags
author

Kris Buist krisbuist@gmail.com

Table of Contents

Interfaces

FormattableHandlerInterface
Interface to describe loggers that have a formatter

Properties

$bubble  : bool
$level  : int
$buffer  : array<string|int, array<string|int, mixed>>
Buffer of all messages passed to the handler before the threshold was reached
$handler  : HandlerInterface
$thresholdMap  : array<string|int, int>

Methods

__construct()  : mixed
__destruct()  : mixed
__sleep()  : mixed
close()  : void
Closes the handler.
getBubble()  : bool
Gets the bubbling behavior.
getFormatter()  : FormatterInterface
Gets the formatter.
getLevel()  : int
Gets minimum logging level at which this handler will be triggered.
handle()  : bool
Handles a record.
handleBatch()  : void
Handles a set of records at once.
isHandling()  : bool
{@inheritDoc}
reset()  : void
setBubble()  : self
Sets the bubbling behavior.
setFormatter()  : HandlerInterface
Sets the formatter.
setLevel()  : self
Sets minimum logging level at which this handler will be triggered.

Properties

$level

protected int $level = \Monolog\Logger::DEBUG
Tags
phpstan-var

Level

$buffer

Buffer of all messages passed to the handler before the threshold was reached

private array<string|int, array<string|int, mixed>> $buffer = []

$thresholdMap

private array<string|int, int> $thresholdMap = [\Monolog\Logger::DEBUG => 0, \Monolog\Logger::INFO => 0, \Monolog\Logger::NOTICE => 0, \Monolog\Logger::WARNING => 0, \Monolog\Logger::ERROR => 0, \Monolog\Logger::CRITICAL => 0, \Monolog\Logger::ALERT => 0, \Monolog\Logger::EMERGENCY => 0]

Methods

__construct()

public __construct(HandlerInterface $handler[, array<string|int, int> $thresholdMap = [] ][, mixed $level = Logger::DEBUG ][, bool $bubble = true ]) : mixed
Parameters
$handler : HandlerInterface
$thresholdMap : array<string|int, int> = []

Dictionary of logger level => threshold

$level : mixed = Logger::DEBUG

The minimum logging level at which this handler will be triggered

$bubble : bool = true

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

__destruct()

public __destruct() : mixed

close()

Closes the handler.

public close() : void

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.

getLevel()

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

public getLevel() : int
Tags
phpstan-return

Level

Return values
int

handle()

Handles a record.

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

All records may be passed to this method, and the handler should discard those that it does not want to handle.

The return value of this function controls the bubbling process of the handler stack. Unless the bubbling is interrupted (by returning true), the Logger class will keep on calling further handlers in the stack with a given log record.

Parameters
$record : array<string|int, mixed>
Return values
bool

handleBatch()

Handles a set of records at once.

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

The records to handle (an array of record arrays)

isHandling()

{@inheritDoc}

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

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(Level|LevelName|LogLevel::* $level) : self
Parameters
$level : Level|LevelName|LogLevel::*

Level or level name

Return values
self 

        

        
    




    

    

                                

                

                                
    

        On this page

        
    


                

                            

            

    

        

            
Search results