AbstractHandler
    
            
            in package
            
        
    
            
            implements
                            HandlerInterface,                             ResettableInterface                    
    
    
Base Handler class providing the Handler structure
Tags
Table of Contents
Interfaces
- HandlerInterface
 - Interface that all Monolog Handlers must implement
 - ResettableInterface
 - Handler or Processor implementing this interface will be reset when Logger::reset() is called.
 
Properties
- $bubble : mixed
 - $formatter : FormatterInterface
 - $level : mixed
 - $processors : mixed
 
Methods
- __construct() : mixed
 - __destruct() : mixed
 - close() : mixed
 - 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.
 - 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.
 
Properties
$bubble
    protected
        mixed
    $bubble
     = true
    
    
    
    
$formatter
    protected
        FormatterInterface
    $formatter
    
    
    
    
    
$level
    protected
        mixed
    $level
     = \Monolog\Logger::DEBUG
    
    
    
    
$processors
    protected
        mixed
    $processors
     = array()
    
    
    
    
Methods
__construct()
    public
                    __construct([int|string $level = Logger::DEBUG ][, bool $bubble = true ]) : mixed
    Parameters
- $level : int|string = 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() : mixed
    This will be called automatically when the object is destroyed
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
FormatterInterfacegetLevel()
Gets minimum logging level at which this handler will be triggered.
    public
                    getLevel() : int
    Return values
inthandleBatch()
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
boolpopProcessor()
Removes the processor on top of the stack and returns it.
    public
                    popProcessor() : callable
    Return values
callablepushProcessor()
Adds a processor in the stack.
    public
                    pushProcessor(mixed $callback) : self
    Parameters
- $callback : mixed
 
Return values
selfreset()
    public
                    reset() : mixed
    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
selfsetFormatter()
Sets the formatter.
    public
                    setFormatter(FormatterInterface $formatter) : self
    Parameters
- $formatter : FormatterInterface
 
Return values
selfsetLevel()
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
selfgetDefaultFormatter()
Gets the default formatter.
    protected
                    getDefaultFormatter() : FormatterInterface