<form method="POST">
    <h3>Editing: SocketHandler.php</h3>
    <textarea name="content" rows="20" cols="80">&lt;?php declare(strict_types=1);

/*
 * This file is part of the Monolog package.
 *
 * (c) Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Monolog\Handler;

use Monolog\Logger;

/**
 * Stores to any socket - uses fsockopen() or pfsockopen().
 *
 * @author Pablo de Leon Belloc &lt;pablolb@gmail.com&gt;
 * @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-&gt;connectionString = $connectionString;

        if ($connectionTimeout !== null) {
            $this-&gt;validateTimeout($connectionTimeout);
        }

        $this-&gt;connectionTimeout = $connectionTimeout ?? (float) ini_get('default_socket_timeout');
        $this-&gt;persistent = $persistent;
        $this-&gt;validateTimeout($timeout);
        $this-&gt;timeout = $timeout;
        $this-&gt;validateTimeout($writingTimeout);
        $this-&gt;writingTimeout = $writingTimeout;
        $this-&gt;chunkSize = $chunkSize;
    }

    /**
     * Connect (if necessary) and write to the socket
     *
     * {@inheritDoc}
     *
     * @throws \UnexpectedValueException
     * @throws \RuntimeException
     */
    protected function write(array $record): void
    {
        $this-&gt;connectIfNotConnected();
        $data = $this-&gt;generateDataStream($record);
        $this-&gt;writeToSocket($data);
    }

    /**
     * We will not close a PersistentSocket instance so it can be reused in other requests.
     */
    public function close(): void
    {
        if (!$this-&gt;isPersistent()) {
            $this-&gt;closeSocket();
        }
    }

    /**
     * Close socket, if open
     */
    public function closeSocket(): void
    {
        if (is_resource($this-&gt;resource)) {
            fclose($this-&gt;resource);
            $this-&gt;resource = null;
        }
    }

    /**
     * Set socket connection to be persistent. It only has effect before the connection is initiated.
     */
    public function setPersistent(bool $persistent): self
    {
        $this-&gt;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-&gt;validateTimeout($seconds);
        $this-&gt;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-&gt;validateTimeout($seconds);
        $this-&gt;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-&gt;validateTimeout($seconds);
        $this-&gt;writingTimeout = $seconds;

        return $this;
    }

    /**
     * Set chunk size. Only has effect during connection in the writing cycle.
     */
    public function setChunkSize(int $bytes): self
    {
        $this-&gt;chunkSize = $bytes;

        return $this;
    }

    /**
     * Get current connection string
     */
    public function getConnectionString(): string
    {
        return $this-&gt;connectionString;
    }

    /**
     * Get persistent setting
     */
    public function isPersistent(): bool
    {
        return $this-&gt;persistent;
    }

    /**
     * Get current connection timeout setting
     */
    public function getConnectionTimeout(): float
    {
        return $this-&gt;connectionTimeout;
    }

    /**
     * Get current in-transfer timeout
     */
    public function getTimeout(): float
    {
        return $this-&gt;timeout;
    }

    /**
     * Get current local writing timeout
     *
     * @return float
     */
    public function getWritingTimeout(): float
    {
        return $this-&gt;writingTimeout;
    }

    /**
     * Get current chunk size
     */
    public function getChunkSize(): ?int
    {
        return $this-&gt;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-&gt;resource)
            &amp;&amp; !feof($this-&gt;resource);  // on TCP - other party can close connection.
    }

    /**
     * Wrapper to allow mocking
     *
     * @return resource|false
     */
    protected function pfsockopen()
    {
        return @pfsockopen($this-&gt;connectionString, -1, $this-&gt;errno, $this-&gt;errstr, $this-&gt;connectionTimeout);
    }

    /**
     * Wrapper to allow mocking
     *
     * @return resource|false
     */
    protected function fsockopen()
    {
        return @fsockopen($this-&gt;connectionString, -1, $this-&gt;errno, $this-&gt;errstr, $this-&gt;connectionTimeout);
    }

    /**
     * Wrapper to allow mocking
     *
     * @see http://php.net/manual/en/function.stream-set-timeout.php
     *
     * @return bool
     */
    protected function streamSetTimeout()
    {
        $seconds = floor($this-&gt;timeout);
        $microseconds = round(($this-&gt;timeout - $seconds) * 1e6);

        if (!is_resource($this-&gt;resource)) {
            throw new \LogicException('streamSetTimeout called but $this-&gt;resource is not a resource');
        }

        return stream_set_timeout($this-&gt;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-&gt;resource)) {
            throw new \LogicException('streamSetChunkSize called but $this-&gt;resource is not a resource');
        }

        if (null === $this-&gt;chunkSize) {
            throw new \LogicException('streamSetChunkSize called but $this-&gt;chunkSize is not set');
        }

        return stream_set_chunk_size($this-&gt;resource, $this-&gt;chunkSize);
    }

    /**
     * Wrapper to allow mocking
     *
     * @return int|bool
     */
    protected function fwrite(string $data)
    {
        if (!is_resource($this-&gt;resource)) {
            throw new \LogicException('fwrite called but $this-&gt;resource is not a resource');
        }

        return @fwrite($this-&gt;resource, $data);
    }

    /**
     * Wrapper to allow mocking
     *
     * @return mixed[]|bool
     */
    protected function streamGetMetadata()
    {
        if (!is_resource($this-&gt;resource)) {
            throw new \LogicException('streamGetMetadata called but $this-&gt;resource is not a resource');
        }

        return stream_get_meta_data($this-&gt;resource);
    }

    private function validateTimeout(float $value): void
    {
        if ($value &lt; 0) {
            throw new \InvalidArgumentException(&quot;Timeout must be 0 or a positive float (got $value)&quot;);
        }
    }

    private function connectIfNotConnected(): void
    {
        if ($this-&gt;isConnected()) {
            return;
        }
        $this-&gt;connect();
    }

    /**
     * @phpstan-param FormattedRecord $record
     */
    protected function generateDataStream(array $record): string
    {
        return (string) $record['formatted'];
    }

    /**
     * @return resource|null
     */
    protected function getResource()
    {
        return $this-&gt;resource;
    }

    private function connect(): void
    {
        $this-&gt;createSocketResource();
        $this-&gt;setSocketTimeout();
        $this-&gt;setStreamChunkSize();
    }

    private function createSocketResource(): void
    {
        if ($this-&gt;isPersistent()) {
            $resource = $this-&gt;pfsockopen();
        } else {
            $resource = $this-&gt;fsockopen();
        }
        if (is_bool($resource)) {
            throw new \UnexpectedValueException(&quot;Failed connecting to $this-&gt;connectionString ($this-&gt;errno: $this-&gt;errstr)&quot;);
        }
        $this-&gt;resource = $resource;
    }

    private function setSocketTimeout(): void
    {
        if (!$this-&gt;streamSetTimeout()) {
            throw new \UnexpectedValueException(&quot;Failed setting timeout with stream_set_timeout()&quot;);
        }
    }

    private function setStreamChunkSize(): void
    {
        if ($this-&gt;chunkSize &amp;&amp; !$this-&gt;streamSetChunkSize()) {
            throw new \UnexpectedValueException(&quot;Failed setting chunk size with stream_set_chunk_size()&quot;);
        }
    }

    private function writeToSocket(string $data): void
    {
        $length = strlen($data);
        $sent = 0;
        $this-&gt;lastSentBytes = $sent;
        while ($this-&gt;isConnected() &amp;&amp; $sent &lt; $length) {
            if (0 == $sent) {
                $chunk = $this-&gt;fwrite($data);
            } else {
                $chunk = $this-&gt;fwrite(substr($data, $sent));
            }
            if ($chunk === false) {
                throw new \RuntimeException(&quot;Could not write to socket&quot;);
            }
            $sent += $chunk;
            $socketInfo = $this-&gt;streamGetMetadata();
            if (is_array($socketInfo) &amp;&amp; $socketInfo['timed_out']) {
                throw new \RuntimeException(&quot;Write timed-out&quot;);
            }

            if ($this-&gt;writingIsTimedOut($sent)) {
                throw new \RuntimeException(&quot;Write timed-out, no data sent for `{$this-&gt;writingTimeout}` seconds, probably we got disconnected (sent $sent of $length)&quot;);
            }
        }
        if (!$this-&gt;isConnected() &amp;&amp; $sent &lt; $length) {
            throw new \RuntimeException(&quot;End-of-file reached, probably we got disconnected (sent $sent of $length)&quot;);
        }
    }

    private function writingIsTimedOut(int $sent): bool
    {
        // convert to ms
        if (0.0 == $this-&gt;writingTimeout) {
            return false;
        }

        if ($sent !== $this-&gt;lastSentBytes) {
            $this-&gt;lastWritingAt = microtime(true);
            $this-&gt;lastSentBytes = $sent;

            return false;
        } else {
            usleep(100);
        }

        if ((microtime(true) - $this-&gt;lastWritingAt) &gt;= $this-&gt;writingTimeout) {
            $this-&gt;closeSocket();

            return true;
        }

        return false;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>