BufferHandler
extends AbstractHandler
in package
implements
ProcessableHandlerInterface, FormattableHandlerInterface
Uses
ProcessableHandlerTrait
Buffers all records until closing the handler and then pass them as batch.
This is useful for a MailHandler to send only one mail per request instead of sending one per log message.
Tags
Interfaces, Classes, Traits and Enums
- ProcessableHandlerInterface
- Interface to describe loggers that have processors
- FormattableHandlerInterface
- Interface to describe loggers that have a formatter
Table of Contents
- $bubble : bool
- $buffer : array<string|int, Record>
- $bufferLimit : int
- $bufferSize : int
- $flushOnOverflow : bool
- $handler : HandlerInterface
- $initialized : bool
- $level : int
- $processors : array<string|int, callable>
- __construct() : mixed
- __destruct() : mixed
- __sleep() : mixed
- clear() : void
- Clears the buffer without flushing any messages down to the wrapped handler.
- close() : void
- {@inheritDoc}
- flush() : void
- 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
- {@inheritDoc}
- handleBatch() : void
- Handles a set of records at once.
- isHandling() : bool
- {@inheritDoc}
- popProcessor() : callable
- {@inheritDoc}
- pushProcessor() : HandlerInterface
- {@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.
- processRecord() : array<string|int, mixed>
- Processes a record.
- resetProcessors() : void
Properties
$bubble
protected
bool
$bubble
= true
$buffer
protected
array<string|int, Record>
$buffer
= []
$bufferLimit
protected
int
$bufferLimit
$bufferSize
protected
int
$bufferSize
= 0
$flushOnOverflow
protected
bool
$flushOnOverflow
$handler
protected
HandlerInterface
$handler
$initialized
protected
bool
$initialized
= false
$level
protected
int
$level
= \Monolog\Logger::DEBUG
Tags
$processors
protected
array<string|int, callable>
$processors
= []
Tags
Methods
__construct()
public
__construct(HandlerInterface $handler, int $bufferLimit[, mixed $level = Logger::DEBUG ][, bool $bubble = true ][, bool $flushOnOverflow = false ]) : mixed
Parameters
- $handler : HandlerInterface
-
Handler.
- $bufferLimit : int
-
How many entries should be buffered at most, beyond that the oldest items are removed from the buffer.
- $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
- $flushOnOverflow : bool = false
-
If true, the buffer is flushed when the max size has been reached, by default oldest entries are discarded
Return values
mixed —__destruct()
public
__destruct() : mixed
Return values
mixed —__sleep()
public
__sleep() : mixed
Return values
mixed —clear()
Clears the buffer without flushing any messages down to the wrapped handler.
public
clear() : void
Return values
void —close()
{@inheritDoc}
public
close() : void
Return values
void —flush()
public
flush() : void
Return values
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.
getFormatter()
Gets the formatter.
public
getFormatter() : FormatterInterface
Return values
FormatterInterface —getLevel()
Gets minimum logging level at which this handler will be triggered.
public
getLevel() : int
Tags
Return values
int —handle()
{@inheritDoc}
public
handle(array<string|int, mixed> $record) : bool
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)
Return values
void —isHandling()
{@inheritDoc}
public
isHandling(array<string|int, mixed> $record) : bool
Parameters
- $record : array<string|int, mixed>
Return values
bool —popProcessor()
{@inheritDoc}
public
popProcessor() : callable
Return values
callable —pushProcessor()
{@inheritDoc}
public
pushProcessor(callable $callback) : HandlerInterface
Parameters
- $callback : callable
Return values
HandlerInterface —reset()
public
reset() : void
Return values
void —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 —setFormatter()
Sets the formatter.
public
setFormatter(FormatterInterface $formatter) : HandlerInterface
Parameters
- $formatter : FormatterInterface
Return values
HandlerInterface —self
setLevel()
Sets minimum logging level at which this handler will be triggered.
public
setLevel(mixed $level) : self
Parameters
- $level : mixed
Return values
self —processRecord()
Processes a record.
protected
processRecord(array<string|int, mixed> $record) : array<string|int, mixed>
Parameters
- $record : array<string|int, mixed>
Tags
Return values
array<string|int, mixed> —resetProcessors()
protected
resetProcessors() : void