Documentation

SocketHandler extends AbstractProcessingHandler
in package

Stores to any socket - uses fsockopen() or pfsockopen().

Tags
author

Pablo de Leon Belloc pablolb@gmail.com

see
http://php.net/manual/en/function.fsockopen.php
phpstan-import-type

Record from \Monolog\Logger

phpstan-import-type

FormattedRecord from AbstractProcessingHandler

Table of Contents

Properties

$bubble  : bool
$formatter  : FormatterInterface|null
$level  : int
$processors  : array<string|int, callable>
$chunkSize  : int|null
$connectionString  : string
$connectionTimeout  : float
$errno  : int|null
$errstr  : string|null
$lastSentBytes  : int|null
$lastWritingAt  : float|null
$persistent  : bool
$resource  : resource|null
$timeout  : float
$writingTimeout  : float

Methods

__construct()  : mixed
__destruct()  : mixed
__sleep()  : mixed
close()  : void
We will not close a PersistentSocket instance so it can be reused in other requests.
closeSocket()  : void
Close socket, if open
getBubble()  : bool
Gets the bubbling behavior.
getChunkSize()  : int|null
Get current chunk size
getConnectionString()  : string
Get current connection string
getConnectionTimeout()  : float
Get current connection timeout setting
getFormatter()  : FormatterInterface
{@inheritDoc}
getLevel()  : int
Gets minimum logging level at which this handler will be triggered.
getTimeout()  : float
Get current in-transfer timeout
getWritingTimeout()  : float
Get current local writing timeout
handle()  : bool
{@inheritDoc}
handleBatch()  : void
Handles a set of records at once.
isConnected()  : bool
Check to see if the socket is currently available.
isHandling()  : bool
{@inheritDoc}
isPersistent()  : bool
Get persistent setting
popProcessor()  : callable
{@inheritDoc}
pushProcessor()  : HandlerInterface
{@inheritDoc}
reset()  : void
setBubble()  : self
Sets the bubbling behavior.
setChunkSize()  : self
Set chunk size. Only has effect during connection in the writing cycle.
setConnectionTimeout()  : self
Set connection timeout. Only has effect before we connect.
setFormatter()  : HandlerInterface
{@inheritDoc}
setLevel()  : self
Sets minimum logging level at which this handler will be triggered.
setPersistent()  : self
Set socket connection to be persistent. It only has effect before the connection is initiated.
setTimeout()  : self
Set write timeout. Only has effect before we connect.
setWritingTimeout()  : self
Set writing timeout. Only has effect during connection in the writing cycle.
fsockopen()  : resource|false
Wrapper to allow mocking
fwrite()  : int|bool
Wrapper to allow mocking
generateDataStream()  : string
getDefaultFormatter()  : FormatterInterface
Gets the default formatter.
getResource()  : resource|null
pfsockopen()  : resource|false
Wrapper to allow mocking
processRecord()  : array<string|int, mixed>
Processes a record.
resetProcessors()  : void
streamGetMetadata()  : array<string|int, mixed>|bool
Wrapper to allow mocking
streamSetChunkSize()  : int|bool
Wrapper to allow mocking
streamSetTimeout()  : bool
Wrapper to allow mocking
write()  : void
Connect (if necessary) and write to the socket
connect()  : void
connectIfNotConnected()  : void
createSocketResource()  : void
setSocketTimeout()  : void
setStreamChunkSize()  : void
validateTimeout()  : void
writeToSocket()  : void
writingIsTimedOut()  : bool

Properties

$level

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

Level

$processors

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

array<ProcessorInterface|callable(Record): Record>

Methods

__construct()

public __construct(string $connectionString[, mixed $level = Logger::DEBUG ][, bool $bubble = true ][, bool $persistent = false ][, float $timeout = 0.0 ][, float $writingTimeout = 10.0 ][, float|null $connectionTimeout = null ][, int|null $chunkSize = null ]) : mixed
Parameters
$connectionString : string

Socket connection string

$level : mixed = Logger::DEBUG
$bubble : bool = true
$persistent : bool = false

Flag to enable/disable persistent connections

$timeout : float = 0.0

Socket timeout to wait until the request is being aborted

$writingTimeout : float = 10.0

Socket timeout to wait until the request should've been sent/written

$connectionTimeout : float|null = null

Socket connect timeout to wait until the connection should've been established

$chunkSize : int|null = null

Sets the chunk size. Only has effect during connection in the writing cycle

Tags
throws
InvalidArgumentException

If an invalid timeout value (less than 0) is passed.

__destruct()

public __destruct() : mixed

close()

We will not close a PersistentSocket instance so it can be reused in other requests.

public close() : void

closeSocket()

Close socket, if open

public closeSocket() : 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.

getChunkSize()

Get current chunk size

public getChunkSize() : int|null
Return values
int|null

getConnectionString()

Get current connection string

public getConnectionString() : string
Return values
string

getConnectionTimeout()

Get current connection timeout setting

public getConnectionTimeout() : float
Return values
float

getLevel()

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

public getLevel() : int
Tags
phpstan-return

Level

Return values
int

getTimeout()

Get current in-transfer timeout

public getTimeout() : float
Return values
float

getWritingTimeout()

Get current local writing timeout

public getWritingTimeout() : float
Return values
float

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)

isConnected()

Check to see if the socket is currently available.

public isConnected() : bool

UDP might appear to be connected but might fail when writing. See http://php.net/fsockopen for details.

Return values
bool

isHandling()

{@inheritDoc}

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

isPersistent()

Get persistent setting

public isPersistent() : bool
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

setChunkSize()

Set chunk size. Only has effect during connection in the writing cycle.

public setChunkSize(int $bytes) : self
Parameters
$bytes : int
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

setPersistent()

Set socket connection to be persistent. It only has effect before the connection is initiated.

public setPersistent(bool $persistent) : self
Parameters
$persistent : bool
Return values
self

setWritingTimeout()

Set writing timeout. Only has effect during connection in the writing cycle.

public setWritingTimeout(float $seconds) : self
Parameters
$seconds : float

0 for no timeout

Return values
self

fsockopen()

Wrapper to allow mocking

protected fsockopen() : resource|false
Return values
resource|false

fwrite()

Wrapper to allow mocking

protected fwrite(string $data) : int|bool
Parameters
$data : string
Return values
int|bool

generateDataStream()

protected generateDataStream(array<string|int, mixed> $record) : string
Parameters
$record : array<string|int, mixed>
Tags
phpstan-param

FormattedRecord $record

Return values
string

getResource()

protected getResource() : resource|null
Return values
resource|null

pfsockopen()

Wrapper to allow mocking

protected pfsockopen() : resource|false
Return values
resource|false

processRecord()

Processes a record.

protected processRecord(array<string|int, mixed> $record) : array<string|int, mixed>
Parameters
$record : array<string|int, mixed>
Tags
phpstan-param

Record $record

phpstan-return

Record

Return values
array<string|int, mixed>

streamGetMetadata()

Wrapper to allow mocking

protected streamGetMetadata() : array<string|int, mixed>|bool
Return values
array<string|int, mixed>|bool

write()

Connect (if necessary) and write to the socket

protected write(array<string|int, mixed> $record) : void
Parameters
$record : array<string|int, mixed>
Tags
throws
UnexpectedValueException
throws
RuntimeException

connectIfNotConnected()

private connectIfNotConnected() : void

createSocketResource()

private createSocketResource() : void

validateTimeout()

private validateTimeout(float $value) : void
Parameters
$value : float

writeToSocket()

private writeToSocket(string $data) : void
Parameters
$data : string

writingIsTimedOut()

private writingIsTimedOut(int $sent) : bool
Parameters
$sent : int
Return values
bool 

        

        
    




    

    

                                

                

                                
    

        On this page

        
    


                

                            

            

    

        

            
Search results