Documentation

ProcessHandler extends AbstractProcessingHandler
in package

Stores to STDIN of any process, specified by a command.

Usage example:

$log = new Logger('myLogger');
$log->pushHandler(new ProcessHandler('/usr/bin/php /var/www/monolog/someScript.php'));
Tags
author

Kolja Zuelsdorf koljaz@web.de

Table of Contents

Constants

DESCRIPTOR_SPEC  = [ 0 => ['pipe', 'r'], // STDIN is a pipe that the child will read from 1 => ['pipe', 'w'], // STDOUT is a pipe that the child will write to 2 => ['pipe', 'w'], ]

Properties

$bubble  : bool
$formatter  : FormatterInterface|null
$level  : Level
$processors  : array<string|int, callable>
$command  : string
$cwd  : string|null
$pipes  : array<string|int, resource>
$process  : resource|bool|null
Holds the process to receive data on its STDIN.

Methods

__construct()  : mixed
__destruct()  : mixed
__sleep()  : mixed
close()  : void
Closes the handler.
getBubble()  : bool
Gets the bubbling behavior.
getFormatter()  : FormatterInterface
getLevel()  : Level
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
Checks whether the given record will be handled by this handler.
popProcessor()  : callable
pushProcessor()  : HandlerInterface
reset()  : void
setBubble()  : $this
Sets the bubbling behavior.
setFormatter()  : HandlerInterface
setLevel()  : $this
Sets minimum logging level at which this handler will be triggered.
getDefaultFormatter()  : FormatterInterface
Gets the default formatter.
processRecord()  : LogRecord
readProcessErrors()  : string
Reads the errors of the process, if there are any.
resetProcessors()  : void
selectErrorStream()  : int|bool
Selects the STDERR stream.
write()  : void
Writes the record down to the log of the implementing handler
writeProcessInput()  : void
Writes to the input stream of the opened process.
ensureProcessIsStarted()  : void
Makes sure that the process is actually started, and if not, starts it, assigns the stream pipes, and handles startup errors, if any.
handleStartupErrors()  : void
Selects the STDERR stream, handles upcoming startup errors, and throws an exception, if any.
startProcess()  : void
Starts the actual process and sets all streams to non-blocking.

Constants

DESCRIPTOR_SPEC

protected array<int, array<string|int, string>> DESCRIPTOR_SPEC = [ 0 => ['pipe', 'r'], // STDIN is a pipe that the child will read from 1 => ['pipe', 'w'], // STDOUT is a pipe that the child will write to 2 => ['pipe', 'w'], ]

Properties

$processors

protected array<string|int, callable> $processors = []
Tags
phpstan-var

array<(callable(LogRecord): LogRecord)|ProcessorInterface>

$process

Holds the process to receive data on its STDIN.

private resource|bool|null $process

Methods

__construct()

public __construct(string $command[, int|string|Level $level = Level::Debug ][, bool $bubble = true ][, string|null $cwd = null ]) : mixed
Parameters
$command : string

Command for the process to start. Absolute paths are recommended, especially if you do not use the $cwd parameter.

$level : int|string|Level = Level::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

$cwd : string|null = null

"Current working directory" (CWD) for the process to be executed in.

Tags
throws
InvalidArgumentException

__destruct()

public __destruct() : mixed

close()

Closes the handler.

public close() : void
Tags
inheritDoc

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() : Level
Return values
Level

handle()

Handles a record.

public handle(LogRecord $record) : bool
Parameters
$record : LogRecord

The record to handle

Tags
inheritDoc
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) : void
Parameters
$records : array<string|int, mixed>

The records to handle

Tags
inheritDoc

isHandling()

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

public isHandling(LogRecord $record) : bool
Parameters
$record : LogRecord

Partial log record having only a level initialized

Tags
inheritDoc
Return values
bool

setBubble()

Sets the bubbling behavior.

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

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

Return values
$this

setLevel()

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

public setLevel(Level|LogLevel::* $level) : $this
Parameters
$level : Level|LogLevel::*

Level or level name

Tags
phpstan-param

value-ofLevel::VALUES|value-ofLevel::NAMES|Level|LogLevel::* $level

Return values
$this

readProcessErrors()

Reads the errors of the process, if there are any.

protected readProcessErrors() : string
Tags
codeCoverageIgnore
Return values
string —

Empty string if there are no errors.

selectErrorStream()

Selects the STDERR stream.

protected selectErrorStream() : int|bool
Return values
int|bool

write()

Writes the record down to the log of the implementing handler

protected write(LogRecord $record) : void
Parameters
$record : LogRecord
Tags
throws
UnexpectedValueException

writeProcessInput()

Writes to the input stream of the opened process.

protected writeProcessInput(string $string) : void
Parameters
$string : string
Tags
codeCoverageIgnore

ensureProcessIsStarted()

Makes sure that the process is actually started, and if not, starts it, assigns the stream pipes, and handles startup errors, if any.

private ensureProcessIsStarted() : void

handleStartupErrors()

Selects the STDERR stream, handles upcoming startup errors, and throws an exception, if any.

private handleStartupErrors() : void
Tags
throws
UnexpectedValueException

startProcess()

Starts the actual process and sets all streams to non-blocking.

private startProcess() : void 

        

        
    




    

    

                                

                

                                
    

        On this page

        
    


                

                            

            

    

        

            
Search results