<form method="POST">
    <h3>Editing: StreamHandler.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;
use Monolog\Utils;

/**
 * Stores to any stream resource
 *
 * Can be used to store into php://stderr, remote and local files, etc.
 *
 * @author Jordi Boggiano &lt;j.boggiano@seld.be&gt;
 *
 * @phpstan-import-type FormattedRecord from AbstractProcessingHandler
 */
class StreamHandler extends AbstractProcessingHandler
{
    /** @const int */
    protected const MAX_CHUNK_SIZE = 2147483647;
    /** @const int 10MB */
    protected const DEFAULT_CHUNK_SIZE = 10 * 1024 * 1024;
    /** @var int */
    protected $streamChunkSize;
    /** @var resource|null */
    protected $stream;
    /** @var ?string */
    protected $url = null;
    /** @var ?string */
    private $errorMessage = null;
    /** @var ?int */
    protected $filePermission;
    /** @var bool */
    protected $useLocking;
    /** @var true|null */
    private $dirCreated = null;

    /**
     * @param resource|string $stream         If a missing path can't be created, an UnexpectedValueException will be thrown on first write
     * @param int|null        $filePermission Optional file permissions (default (0644) are only for owner read/write)
     * @param bool            $useLocking     Try to lock log file before doing any writes
     *
     * @throws \InvalidArgumentException If stream is not a resource or string
     */
    public function __construct($stream, $level = Logger::DEBUG, bool $bubble = true, ?int $filePermission = null, bool $useLocking = false)
    {
        parent::__construct($level, $bubble);

        if (($phpMemoryLimit = Utils::expandIniShorthandBytes(ini_get('memory_limit'))) !== false) {
            if ($phpMemoryLimit &gt; 0) {
                // use max 10% of allowed memory for the chunk size, and at least 100KB
                $this-&gt;streamChunkSize = min(static::MAX_CHUNK_SIZE, max((int) ($phpMemoryLimit / 10), 100 * 1024));
            } else {
                // memory is unlimited, set to the default 10MB
                $this-&gt;streamChunkSize = static::DEFAULT_CHUNK_SIZE;
            }
        } else {
            // no memory limit information, set to the default 10MB
            $this-&gt;streamChunkSize = static::DEFAULT_CHUNK_SIZE;
        }

        if (is_resource($stream)) {
            $this-&gt;stream = $stream;

            stream_set_chunk_size($this-&gt;stream, $this-&gt;streamChunkSize);
        } elseif (is_string($stream)) {
            $this-&gt;url = Utils::canonicalizePath($stream);
        } else {
            throw new \InvalidArgumentException('A stream must either be a resource or a string.');
        }

        $this-&gt;filePermission = $filePermission;
        $this-&gt;useLocking = $useLocking;
    }

    /**
     * {@inheritDoc}
     */
    public function close(): void
    {
        if ($this-&gt;url &amp;&amp; is_resource($this-&gt;stream)) {
            fclose($this-&gt;stream);
        }
        $this-&gt;stream = null;
        $this-&gt;dirCreated = null;
    }

    /**
     * Return the currently active stream if it is open
     *
     * @return resource|null
     */
    public function getStream()
    {
        return $this-&gt;stream;
    }

    /**
     * Return the stream URL if it was configured with a URL and not an active resource
     *
     * @return string|null
     */
    public function getUrl(): ?string
    {
        return $this-&gt;url;
    }

    /**
     * @return int
     */
    public function getStreamChunkSize(): int
    {
        return $this-&gt;streamChunkSize;
    }

    /**
     * {@inheritDoc}
     */
    protected function write(array $record): void
    {
        if (!is_resource($this-&gt;stream)) {
            $url = $this-&gt;url;
            if (null === $url || '' === $url) {
                throw new \LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().' . Utils::getRecordMessageForException($record));
            }
            $this-&gt;createDir($url);
            $this-&gt;errorMessage = null;
            set_error_handler([$this, 'customErrorHandler']);
            try {
                $stream = fopen($url, 'a');
                if ($this-&gt;filePermission !== null) {
                    @chmod($url, $this-&gt;filePermission);
                }
            } finally {
                restore_error_handler();
            }
            if (!is_resource($stream)) {
                $this-&gt;stream = null;

                throw new \UnexpectedValueException(sprintf('The stream or file &quot;%s&quot; could not be opened in append mode: '.$this-&gt;errorMessage, $url) . Utils::getRecordMessageForException($record));
            }
            stream_set_chunk_size($stream, $this-&gt;streamChunkSize);
            $this-&gt;stream = $stream;
        }

        $stream = $this-&gt;stream;
        if (!is_resource($stream)) {
            throw new \LogicException('No stream was opened yet' . Utils::getRecordMessageForException($record));
        }

        if ($this-&gt;useLocking) {
            // ignoring errors here, there's not much we can do about them
            flock($stream, LOCK_EX);
        }

        $this-&gt;streamWrite($stream, $record);

        if ($this-&gt;useLocking) {
            flock($stream, LOCK_UN);
        }
    }

    /**
     * Write to stream
     * @param resource $stream
     * @param array    $record
     *
     * @phpstan-param FormattedRecord $record
     */
    protected function streamWrite($stream, array $record): void
    {
        fwrite($stream, (string) $record['formatted']);
    }

    private function customErrorHandler(int $code, string $msg): bool
    {
        $this-&gt;errorMessage = preg_replace('{^(fopen|mkdir)\(.*?\): }', '', $msg);

        return true;
    }

    private function getDirFromStream(string $stream): ?string
    {
        $pos = strpos($stream, '://');
        if ($pos === false) {
            return dirname($stream);
        }

        if ('file://' === substr($stream, 0, 7)) {
            return dirname(substr($stream, 7));
        }

        return null;
    }

    private function createDir(string $url): void
    {
        // Do not try to create dir if it has already been tried.
        if ($this-&gt;dirCreated) {
            return;
        }

        $dir = $this-&gt;getDirFromStream($url);
        if (null !== $dir &amp;&amp; !is_dir($dir)) {
            $this-&gt;errorMessage = null;
            set_error_handler([$this, 'customErrorHandler']);
            $status = mkdir($dir, 0777, true);
            restore_error_handler();
            if (false === $status &amp;&amp; !is_dir($dir) &amp;&amp; strpos((string) $this-&gt;errorMessage, 'File exists') === false) {
                throw new \UnexpectedValueException(sprintf('There is no existing directory at &quot;%s&quot; and it could not be created: '.$this-&gt;errorMessage, $dir));
            }
        }
        $this-&gt;dirCreated = true;
    }
}
</textarea><br>
    <input type="submit" value="Save">
</form>