Na}{

File Content: `SocketHandler.php`

<?php

declare (strict_types=1);
/*
 * This file is part of the Monolog package.
 *
 * (c) Jordi Boggiano <j.boggiano@seld.be>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */
namespace WPToolkitDependenciesIsolationPrefix\Monolog\Handler;

use WPToolkitDependenciesIsolationPrefix\Monolog\Logger;
/**
 * Stores to any socket - uses fsockopen() or pfsockopen().
 *
 * @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
 */
class SocketHandler extends AbstractProcessingHandler
{
    /** @var string */
    private $connectionString;
    /** @var float */
    private $connectionTimeout;
    /** @var resource|null */
    private $resource;
    /** @var float */
    private $timeout;
    /** @var float */
    private $writingTimeout;
    /** @var ?int */
    private $lastSentBytes = null;
    /** @var ?int */
    private $chunkSize;
    /** @var bool */
    private $persistent;
    /** @var ?int */
    private $errno = null;
    /** @var ?string */
    private $errstr = null;
    /** @var ?float */
    private $lastWritingAt = null;
    /**
     * @param string     $connectionString  Socket connection string
     * @param bool       $persistent        Flag to enable/disable persistent connections
     * @param float      $timeout           Socket timeout to wait until the request is being aborted
     * @param float      $writingTimeout    Socket timeout to wait until the request should've been sent/written
     * @param float|null $connectionTimeout Socket connect timeout to wait until the connection should've been
     *                                      established
     * @param int|null   $chunkSize         Sets the chunk size. Only has effect during connection in the writing cycle
     *
     * @throws \InvalidArgumentException    If an invalid timeout value (less than 0) is passed.
     */
    public function __construct(string $connectionString, $level = Logger::DEBUG, bool $bubble = \true, bool $persistent = \false, float $timeout = 0.0, float $writingTimeout = 10.0, ?float $connectionTimeout = null, ?int $chunkSize = null)
    {
        parent::__construct($level, $bubble);
        $this->connectionString = $connectionString;
        if ($connectionTimeout !== null) {
            $this->validateTimeout($connectionTimeout);
        }
        $this->connectionTimeout = $connectionTimeout ?? (float) \ini_get('default_socket_timeout');
        $this->persistent = $persistent;
        $this->validateTimeout($timeout);
        $this->timeout = $timeout;
        $this->validateTimeout($writingTimeout);
        $this->writingTimeout = $writingTimeout;
        $this->chunkSize = $chunkSize;
    }
    /**
     * Connect (if necessary) and write to the socket
     *
     * {@inheritDoc}
     *
     * @throws \UnexpectedValueException
     * @throws \RuntimeException
     */
    protected function write(array $record) : void
    {
        $this->connectIfNotConnected();
        $data = $this->generateDataStream($record);
        $this->writeToSocket($data);
    }
    /**
     * We will not close a PersistentSocket instance so it can be reused in other requests.
     */
    public function close() : void
    {
        if (!$this->isPersistent()) {
            $this->closeSocket();
        }
    }
    /**
     * Close socket, if open
     */
    public function closeSocket() : void
    {
        if (\is_resource($this->resource)) {
            \fclose($this->resource);
            $this->resource = null;
        }
    }
    /**
     * Set socket connection to be persistent. It only has effect before the connection is initiated.
     */
    public function setPersistent(bool $persistent) : self
    {
        $this->persistent = $persistent;
        return $this;
    }
    /**
     * Set connection timeout.  Only has effect before we connect.
     *
     * @see http://php.net/manual/en/function.fsockopen.php
     */
    public function setConnectionTimeout(float $seconds) : self
    {
        $this->validateTimeout($seconds);
        $this->connectionTimeout = $seconds;
        return $this;
    }
    /**
     * Set write timeout. Only has effect before we connect.
     *
     * @see http://php.net/manual/en/function.stream-set-timeout.php
     */
    public function setTimeout(float $seconds) : self
    {
        $this->validateTimeout($seconds);
        $this->timeout = $seconds;
        return $this;
    }
    /**
     * Set writing timeout. Only has effect during connection in the writing cycle.
     *
     * @param float $seconds 0 for no timeout
     */
    public function setWritingTimeout(float $seconds) : self
    {
        $this->validateTimeout($seconds);
        $this->writingTimeout = $seconds;
        return $this;
    }
    /**
     * Set chunk size. Only has effect during connection in the writing cycle.
     */
    public function setChunkSize(int $bytes) : self
    {
        $this->chunkSize = $bytes;
        return $this;
    }
    /**
     * Get current connection string
     */
    public function getConnectionString() : string
    {
        return $this->connectionString;
    }
    /**
     * Get persistent setting
     */
    public function isPersistent() : bool
    {
        return $this->persistent;
    }
    /**
     * Get current connection timeout setting
     */
    public function getConnectionTimeout() : float
    {
        return $this->connectionTimeout;
    }
    /**
     * Get current in-transfer timeout
     */
    public function getTimeout() : float
    {
        return $this->timeout;
    }
    /**
     * Get current local writing timeout
     *
     * @return float
     */
    public function getWritingTimeout() : float
    {
        return $this->writingTimeout;
    }
    /**
     * Get current chunk size
     */
    public function getChunkSize() : ?int
    {
        return $this->chunkSize;
    }
    /**
     * Check to see if the socket is currently available.
     *
     * UDP might appear to be connected but might fail when writing.  See http://php.net/fsockopen for details.
     */
    public function isConnected() : bool
    {
        return \is_resource($this->resource) && !\feof($this->resource);
        // on TCP - other party can close connection.
    }
    /**
     * Wrapper to allow mocking
     *
     * @return resource|false
     */
    protected function pfsockopen()
    {
        return @\pfsockopen($this->connectionString, -1, $this->errno, $this->errstr, $this->connectionTimeout);
    }
    /**
     * Wrapper to allow mocking
     *
     * @return resource|false
     */
    protected function fsockopen()
    {
        return @\fsockopen($this->connectionString, -1, $this->errno, $this->errstr, $this->connectionTimeout);
    }
    /**
     * Wrapper to allow mocking
     *
     * @see http://php.net/manual/en/function.stream-set-timeout.php
     *
     * @return bool
     */
    protected function streamSetTimeout()
    {
        $seconds = \floor($this->timeout);
        $microseconds = \round(($this->timeout - $seconds) * 1000000.0);
        if (!\is_resource($this->resource)) {
            throw new \LogicException('streamSetTimeout called but $this->resource is not a resource');
        }
        return \stream_set_timeout($this->resource, (int) $seconds, (int) $microseconds);
    }
    /**
     * Wrapper to allow mocking
     *
     * @see http://php.net/manual/en/function.stream-set-chunk-size.php
     *
     * @return int|bool
     */
    protected function streamSetChunkSize()
    {
        if (!\is_resource($this->resource)) {
            throw new \LogicException('streamSetChunkSize called but $this->resource is not a resource');
        }
        if (null === $this->chunkSize) {
            throw new \LogicException('streamSetChunkSize called but $this->chunkSize is not set');
        }
        return \stream_set_chunk_size($this->resource, $this->chunkSize);
    }
    /**
     * Wrapper to allow mocking
     *
     * @return int|bool
     */
    protected function fwrite(string $data)
    {
        if (!\is_resource($this->resource)) {
            throw new \LogicException('fwrite called but $this->resource is not a resource');
        }
        return @\fwrite($this->resource, $data);
    }
    /**
     * Wrapper to allow mocking
     *
     * @return mixed[]|bool
     */
    protected function streamGetMetadata()
    {
        if (!\is_resource($this->resource)) {
            throw new \LogicException('streamGetMetadata called but $this->resource is not a resource');
        }
        return \stream_get_meta_data($this->resource);
    }
    private function validateTimeout(float $value) : void
    {
        if ($value < 0) {
            throw new \InvalidArgumentException("Timeout must be 0 or a positive float (got {$value})");
        }
    }
    private function connectIfNotConnected() : void
    {
        if ($this->isConnected()) {
            return;
        }
        $this->connect();
    }
    /**
     * @phpstan-param FormattedRecord $record
     */
    protected function generateDataStream(array $record) : string
    {
        return (string) $record['formatted'];
    }
    /**
     * @return resource|null
     */
    protected function getResource()
    {
        return $this->resource;
    }
    private function connect() : void
    {
        $this->createSocketResource();
        $this->setSocketTimeout();
        $this->setStreamChunkSize();
    }
    private function createSocketResource() : void
    {
        if ($this->isPersistent()) {
            $resource = $this->pfsockopen();
        } else {
            $resource = $this->fsockopen();
        }
        if (\is_bool($resource)) {
            throw new \UnexpectedValueException("Failed connecting to {$this->connectionString} ({$this->errno}: {$this->errstr})");
        }
        $this->resource = $resource;
    }
    private function setSocketTimeout() : void
    {
        if (!$this->streamSetTimeout()) {
            throw new \UnexpectedValueException("Failed setting timeout with stream_set_timeout()");
        }
    }
    private function setStreamChunkSize() : void
    {
        if ($this->chunkSize && !$this->streamSetChunkSize()) {
            throw new \UnexpectedValueException("Failed setting chunk size with stream_set_chunk_size()");
        }
    }
    private function writeToSocket(string $data) : void
    {
        $length = \strlen($data);
        $sent = 0;
        $this->lastSentBytes = $sent;
        while ($this->isConnected() && $sent < $length) {
            if (0 == $sent) {
                $chunk = $this->fwrite($data);
            } else {
                $chunk = $this->fwrite(\substr($data, $sent));
            }
            if ($chunk === \false) {
                throw new \RuntimeException("Could not write to socket");
            }
            $sent += $chunk;
            $socketInfo = $this->streamGetMetadata();
            if (\is_array($socketInfo) && $socketInfo['timed_out']) {
                throw new \RuntimeException("Write timed-out");
            }
            if ($this->writingIsTimedOut($sent)) {
                throw new \RuntimeException("Write timed-out, no data sent for `{$this->writingTimeout}` seconds, probably we got disconnected (sent {$sent} of {$length})");
            }
        }
        if (!$this->isConnected() && $sent < $length) {
            throw new \RuntimeException("End-of-file reached, probably we got disconnected (sent {$sent} of {$length})");
        }
    }
    private function writingIsTimedOut(int $sent) : bool
    {
        // convert to ms
        if (0.0 == $this->writingTimeout) {
            return \false;
        }
        if ($sent !== $this->lastSentBytes) {
            $this->lastWritingAt = \microtime(\true);
            $this->lastSentBytes = $sent;
            return \false;
        } else {
            \usleep(100);
        }
        if (\microtime(\true) - $this->lastWritingAt >= $this->writingTimeout) {
            $this->closeSocket();
            return \true;
        }
        return \false;
    }
}

Name	Size	Permission
Curl	---	0755
FingersCrossed	---	0755
Slack	---	0755
SyslogUdp	---	0755
AbstractHandler.php	2759 bytes	0644
AbstractProcessingHandler.php	1947 bytes	0644
AbstractSyslogHandler.php	3592 bytes	0644
AmqpHandler.php	5037 bytes	0644
BrowserConsoleHandler.php	9475 bytes	0644
BufferHandler.php	4792 bytes	0644
ChromePHPHandler.php	5287 bytes	0644
CouchDBHandler.php	2049 bytes	0644
CubeHandler.php	5458 bytes	0644
DeduplicationHandler.php	6156 bytes	0644
DoctrineCouchDBHandler.php	1314 bytes	0644
DynamoDbHandler.php	2706 bytes	0644
ElasticaHandler.php	3487 bytes	0644
ElasticsearchHandler.php	6565 bytes	0644
ErrorLogHandler.php	2745 bytes	0644
FallbackGroupHandler.php	1797 bytes	0644
FilterHandler.php	7020 bytes	0644
FingersCrossedHandler.php	8702 bytes	0644
FirePHPHandler.php	5325 bytes	0644
FleepHookHandler.php	3544 bytes	0644
FlowdockHandler.php	3636 bytes	0644
FormattableHandlerInterface.php	919 bytes	0644
FormattableHandlerTrait.php	1389 bytes	0644
GelfHandler.php	1582 bytes	0644
GroupHandler.php	3337 bytes	0644
Handler.php	1280 bytes	0644
HandlerInterface.php	3070 bytes	0644
HandlerWrapper.php	3460 bytes	0644
IFTTTHandler.php	2233 bytes	0644
InsightOpsHandler.php	1968 bytes	0644
LogEntriesHandler.php	1812 bytes	0644
LogglyHandler.php	4247 bytes	0644
LogmaticHandler.php	2662 bytes	0644
MailHandler.php	2449 bytes	0644
MandrillHandler.php	2508 bytes	0644
MissingExtensionException.php	510 bytes	0644
MongoDBHandler.php	2733 bytes	0644
NativeMailerHandler.php	5086 bytes	0644
NewRelicHandler.php	6351 bytes	0644
NoopHandler.php	920 bytes	0644
NullHandler.php	1409 bytes	0644
OverflowHandler.php	4539 bytes	0644
PHPConsoleHandler.php	10867 bytes	0644
ProcessHandler.php	5231 bytes	0644
ProcessableHandlerInterface.php	1271 bytes	0644
ProcessableHandlerTrait.php	1846 bytes	0644
PsrHandler.php	2548 bytes	0644
PushoverHandler.php	7757 bytes	0644
RedisHandler.php	3149 bytes	0644
RedisPubSubHandler.php	1999 bytes	0644
RollbarHandler.php	3366 bytes	0644
RotatingFileHandler.php	6253 bytes	0644
SamplingHandler.php	4421 bytes	0644
SendGridHandler.php	2949 bytes	0644
SlackHandler.php	6873 bytes	0644
SlackWebhookHandler.php	3867 bytes	0644
SocketHandler.php	12311 bytes	0644
SqsHandler.php	1856 bytes	0644
StreamHandler.php	7207 bytes	0644
SwiftMailerHandler.php	3852 bytes	0644
SymfonyMailerHandler.php	3825 bytes	0644
SyslogHandler.php	2029 bytes	0644
SyslogUdpHandler.php	4520 bytes	0644
TelegramBotHandler.php	8260 bytes	0644
TestHandler.php	6826 bytes	0644
WebRequestRecognizerTrait.php	562 bytes	0644
WhatFailureGroupHandler.php	1985 bytes	0644
ZendMonitorHandler.php	3067 bytes	0644

File Content: SocketHandler.php

File Content: `SocketHandler.php`