golden hour

/home/doctorbruno/.trash/google-site-kit/third-party/monolog/monolog/src/Monolog/Handler

File/Folder	Size	Actions
AbstractHandler.php	2.89 KB
AbstractProcessingHandler.php	2.03 KB
AbstractSyslogHandler.php	3.95 KB
AmqpHandler.php	5.24 KB
BrowserConsoleHandler.php	9.77 KB
BufferHandler.php	5.13 KB
ChromePHPHandler.php	5.56 KB
CouchDBHandler.php	2.19 KB
CubeHandler.php	5.6 KB
Curl	-
DeduplicationHandler.php	6.23 KB
DoctrineCouchDBHandler.php	1.47 KB
DynamoDbHandler.php	2.88 KB
ElasticaHandler.php	3.75 KB
ElasticsearchHandler.php	7.17 KB
ErrorLogHandler.php	2.85 KB
FallbackGroupHandler.php	1.79 KB
FilterHandler.php	7.68 KB
FingersCrossed	-
FingersCrossedHandler.php	9.3 KB
FirePHPHandler.php	5.32 KB
FleepHookHandler.php	3.65 KB
FlowdockHandler.php	3.86 KB
FormattableHandlerInterface.php	1.02 KB
FormattableHandlerTrait.php	1.57 KB
GelfHandler.php	1.72 KB
GroupHandler.php	3.58 KB
Handler.php	1.29 KB
HandlerInterface.php	2.99 KB
HandlerWrapper.php	4.15 KB
IFTTTHandler.php	2.37 KB
InsightOpsHandler.php	2.03 KB
LogEntriesHandler.php	1.88 KB
LogglyHandler.php	4.38 KB
LogmaticHandler.php	2.79 KB
MailHandler.php	2.51 KB
MandrillHandler.php	2.71 KB
MissingExtensionException.php	502 B
MongoDBHandler.php	2.91 KB
NativeMailerHandler.php	5.07 KB
NewRelicHandler.php	6.42 KB
NoopHandler.php	958 B
NullHandler.php	1.51 KB
OverflowHandler.php	5.11 KB
PHPConsoleHandler.php	11.14 KB
ProcessHandler.php	5.17 KB
ProcessableHandlerInterface.php	1.27 KB
ProcessableHandlerTrait.php	1.86 KB
PsrHandler.php	2.8 KB
PushoverHandler.php	7.92 KB
RedisHandler.php	3.21 KB
RedisPubSubHandler.php	2.09 KB
RollbarHandler.php	3.68 KB
RotatingFileHandler.php	6.46 KB
SamplingHandler.php	4.8 KB
SendGridHandler.php	3.04 KB
Slack	-
SlackHandler.php	7.08 KB
SlackWebhookHandler.php	4.19 KB
SocketHandler.php	12.09 KB
SqsHandler.php	1.97 KB
StreamHandler.php	8.57 KB
SwiftMailerHandler.php	4.14 KB
SymfonyMailerHandler.php	4.04 KB
SyslogHandler.php	2.08 KB
SyslogUdp	-
SyslogUdpHandler.php	4.66 KB
TelegramBotHandler.php	8.25 KB
TestHandler.php	6.8 KB
WebRequestRecognizerTrait.php	554 B
WhatFailureGroupHandler.php	1.98 KB
ZendMonitorHandler.php	3.78 KB

Edit: 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 Google\Site_Kit_Dependencies\Monolog\Handler;

use Google\Site_Kit_Dependencies\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 \Google\Site_Kit_Dependencies\Monolog\Handler\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 = \Google\Site_Kit_Dependencies\Monolog\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;
    }
}