FM / Handler

/home/desid573/public_html/tollster/vendor/monolog/monolog/src/Monolog/Handler/

/home/desid573/public_html/tollster/vendor/monolog/monolog/src/Monolog/Handler

Name	Size	Mode	Actions
Curl/	-	0755	rm
FingersCrossed/	-	0755	rm
Slack/	-	0755	rm
SyslogUdp/	-	0755	rm
AbstractHandler.php	4127	0644	edit dl rm
AbstractProcessingHandler.php	1498	0644	edit dl rm
AbstractSyslogHandler.php	3382	0644	edit dl rm
AmqpHandler.php	3866	0644	edit dl rm
BrowserConsoleHandler.php	7162	0644	edit dl rm
BufferHandler.php	3436	0644	edit dl rm
ChromePHPHandler.php	5623	0644	edit dl rm
CouchDBHandler.php	1953	0644	edit dl rm
CubeHandler.php	4631	0644	edit dl rm
DeduplicationHandler.php	5479	0644	edit dl rm
DoctrineCouchDBHandler.php	1000	0644	edit dl rm
DynamoDbHandler.php	2440	0644	edit dl rm
ElasticSearchHandler.php	3417	0644	edit dl rm
ErrorLogHandler.php	2380	0644	edit dl rm
FilterHandler.php	4425	0644	edit dl rm
FingersCrossedHandler.php	5637	0644	edit dl rm
FirePHPHandler.php	5466	0644	edit dl rm
FleepHookHandler.php	3363	0644	edit dl rm
FlowdockHandler.php	3357	0644	edit dl rm
GelfHandler.php	2068	0644	edit dl rm
GroupHandler.php	2496	0644	edit dl rm
HandlerInterface.php	2597	0644	edit dl rm
HandlerWrapper.php	2156	0644	edit dl rm
HipChatHandler.php	10347	0644	edit dl rm
IFTTTHandler.php	2118	0644	edit dl rm
LogEntriesHandler.php	1601	0644	edit dl rm
LogglyHandler.php	2619	0644	edit dl rm
MailHandler.php	1622	0644	edit dl rm
MandrillHandler.php	2156	0644	edit dl rm
MissingExtensionException.php	450	0644	edit dl rm
MongoDBHandler.php	1606	0644	edit dl rm
NativeMailerHandler.php	5206	0644	edit dl rm
NewRelicHandler.php	6015	0644	edit dl rm
NullHandler.php	953	0644	edit dl rm
PHPConsoleHandler.php	9990	0644	edit dl rm
PsrHandler.php	1433	0644	edit dl rm
PushoverHandler.php	6629	0644	edit dl rm
RavenHandler.php	7115	0644	edit dl rm
RedisHandler.php	2889	0644	edit dl rm
RollbarHandler.php	3812	0644	edit dl rm
RotatingFileHandler.php	5687	0644	edit dl rm
SamplingHandler.php	2674	0644	edit dl rm
SlackbotHandler.php	2029	0644	edit dl rm
SlackHandler.php	6381	0644	edit dl rm
SlackWebhookHandler.php	3737	0644	edit dl rm
SocketHandler.php	8884	0644	edit dl rm
StreamHandler.php	5203	0644	edit dl rm
SwiftMailerHandler.php	3095	0644	edit dl rm
SyslogHandler.php	1848	0644	edit dl rm
SyslogUdpHandler.php	2580	0644	edit dl rm
TestHandler.php	4676	0644	edit dl rm
WhatFailureGroupHandler.php	1485	0644	edit dl rm
ZendMonitorHandler.php	2240	0644	edit dl rm

Edit: /home/desid573/public_html/tollster/vendor/monolog/monolog/src/Monolog/Handler/SocketHandler.php (8884B)

<?php

/*
 * 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 Monolog\Handler;

use 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
 */
class SocketHandler extends AbstractProcessingHandler
{
    private $connectionString;
    private $connectionTimeout;
    private $resource;
    private $timeout = 0;
    private $writingTimeout = 10;
    private $lastSentBytes = null;
    private $persistent = false;
    private $errno;
    private $errstr;
    private $lastWritingAt;

/**
     * @param string  $connectionString Socket connection string
     * @param int     $level            The minimum logging level at which this handler will be triggered
     * @param Boolean $bubble           Whether the messages that are handled can bubble up the stack or not
     */
    public function __construct($connectionString, $level = Logger::DEBUG, $bubble = true)
    {
        parent::__construct($level, $bubble);
        $this->connectionString = $connectionString;
        $this->connectionTimeout = (float) ini_get('default_socket_timeout');
    }

/**
     * Connect (if necessary) and write to the socket
     *
     * @param array $record
     *
     * @throws \UnexpectedValueException
     * @throws \RuntimeException
     */
    protected function write(array $record)
    {
        $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()
    {
        if (!$this->isPersistent()) {
            $this->closeSocket();
        }
    }

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

/**
     * Set socket connection to nbe persistent. It only has effect before the connection is initiated.
     *
     * @param bool $persistent
     */
    public function setPersistent($persistent)
    {
        $this->persistent = (boolean) $persistent;
    }

/**
     * Set connection timeout.  Only has effect before we connect.
     *
     * @param float $seconds
     *
     * @see http://php.net/manual/en/function.fsockopen.php
     */
    public function setConnectionTimeout($seconds)
    {
        $this->validateTimeout($seconds);
        $this->connectionTimeout = (float) $seconds;
    }

/**
     * Set write timeout. Only has effect before we connect.
     *
     * @param float $seconds
     *
     * @see http://php.net/manual/en/function.stream-set-timeout.php
     */
    public function setTimeout($seconds)
    {
        $this->validateTimeout($seconds);
        $this->timeout = (float) $seconds;
    }

/**
     * Set writing timeout. Only has effect during connection in the writing cycle.
     *
     * @param float $seconds 0 for no timeout
     */
    public function setWritingTimeout($seconds)
    {
        $this->validateTimeout($seconds);
        $this->writingTimeout = (float) $seconds;
    }

/**
     * Get current connection string
     *
     * @return string
     */
    public function getConnectionString()
    {
        return $this->connectionString;
    }

/**
     * Get persistent setting
     *
     * @return bool
     */
    public function isPersistent()
    {
        return $this->persistent;
    }

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

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

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

/**
     * 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.
     *
     * @return bool
     */
    public function isConnected()
    {
        return is_resource($this->resource)
            && !feof($this->resource);  // on TCP - other party can close connection.
    }

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

/**
     * Wrapper to allow mocking
     */
    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
     */
    protected function streamSetTimeout()
    {
        $seconds = floor($this->timeout);
        $microseconds = round(($this->timeout - $seconds) * 1e6);

return stream_set_timeout($this->resource, $seconds, $microseconds);
    }

/**
     * Wrapper to allow mocking
     */
    protected function fwrite($data)
    {
        return @fwrite($this->resource, $data);
    }

/**
     * Wrapper to allow mocking
     */
    protected function streamGetMetadata()
    {
        return stream_get_meta_data($this->resource);
    }

private function validateTimeout($value)
    {
        $ok = filter_var($value, FILTER_VALIDATE_FLOAT);
        if ($ok === false || $value < 0) {
            throw new \InvalidArgumentException("Timeout must be 0 or a positive float (got $value)");
        }
    }

private function connectIfNotConnected()
    {
        if ($this->isConnected()) {
            return;
        }
        $this->connect();
    }

protected function generateDataStream($record)
    {
        return (string) $record['formatted'];
    }

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

private function connect()
    {
        $this->createSocketResource();
        $this->setSocketTimeout();
    }

private function createSocketResource()
    {
        if ($this->isPersistent()) {
            $resource = $this->pfsockopen();
        } else {
            $resource = $this->fsockopen();
        }
        if (!$resource) {
            throw new \UnexpectedValueException("Failed connecting to $this->connectionString ($this->errno: $this->errstr)");
        }
        $this->resource = $resource;
    }

private function setSocketTimeout()
    {
        if (!$this->streamSetTimeout()) {
            throw new \UnexpectedValueException("Failed setting timeout with stream_set_timeout()");
        }
    }

private function writeToSocket($data)
    {
        $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 ($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($sent)
    {
        $writingTimeout = (int) floor($this->writingTimeout);
        if (0 === $writingTimeout) {
            return false;
        }

if ($sent !== $this->lastSentBytes) {
            $this->lastWritingAt = time();
            $this->lastSentBytes = $sent;

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

if ((time() - $this->lastWritingAt) >= $writingTimeout) {
            $this->closeSocket();

return true;
        }

return false;
    }
}

cmd: