vendor/monolog/monolog/src/Monolog/Handler/StreamHandler.php line 157

  1. <?php declare(strict_types=1);
  3. /*
  4.  * This file is part of the Monolog package.
  5.  *
  6.  * (c) Jordi Boggiano <j.boggiano@seld.be>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Monolog\Handler;
  14. use Monolog\Level;
  15. use Monolog\Utils;
  16. use Monolog\LogRecord;
  18. /**
  19.  * Stores to any stream resource
  20.  *
  21.  * Can be used to store into php://stderr, remote and local files, etc.
  22.  *
  23.  * @author Jordi Boggiano <j.boggiano@seld.be>
  24.  */
  25. class StreamHandler extends AbstractProcessingHandler
  26. {
  27.     protected const MAX_CHUNK_SIZE = 2147483647;
  28.     /** 10MB */
  29.     protected const DEFAULT_CHUNK_SIZE = 10 * 1024 * 1024;
  30.     protected int $streamChunkSize;
  31.     /** @var resource|null */
  32.     protected $stream;
  33.     protected string|null $url = null;
  34.     private string|null $errorMessage = null;
  35.     protected int|null $filePermission;
  36.     protected bool $useLocking;
  37.     /** @var true|null */
  38.     private bool|null $dirCreated = null;
  40.     /**
  41.      * @param resource|string $stream         If a missing path can't be created, an UnexpectedValueException will be thrown on first write
  42.      * @param int|null        $filePermission Optional file permissions (default (0644) are only for owner read/write)
  43.      * @param bool            $useLocking     Try to lock log file before doing any writes
  44.      *
  45.      * @throws \InvalidArgumentException If stream is not a resource or string
  46.      */
  47.     public function __construct($stream, int|string|Level $level = Level::Debug, bool $bubble = true, ?int $filePermission = null, bool $useLocking = false)
  48.     {
  49.         parent::__construct($level, $bubble);
  51.         if (($phpMemoryLimit = Utils::expandIniShorthandBytes(ini_get('memory_limit'))) !== false) {
  52.             if ($phpMemoryLimit > 0) {
  53.                 // use max 10% of allowed memory for the chunk size, and at least 100KB
  54.                 $this->streamChunkSize = min(static::MAX_CHUNK_SIZE, max((int) ($phpMemoryLimit / 10), 100 * 1024));
  55.             } else {
  56.                 // memory is unlimited, set to the default 10MB
  57.                 $this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
  58.             }
  59.         } else {
  60.             // no memory limit information, set to the default 10MB
  61.             $this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
  62.         }
  64.         if (is_resource($stream)) {
  65.             $this->stream = $stream;
  67.             stream_set_chunk_size($this->stream, $this->streamChunkSize);
  68.         } elseif (is_string($stream)) {
  69.             $this->url = Utils::canonicalizePath($stream);
  70.         } else {
  71.             throw new \InvalidArgumentException('A stream must either be a resource or a string.');
  72.         }
  74.         $this->filePermission = $filePermission;
  75.         $this->useLocking = $useLocking;
  76.     }
  78.     /**
  79.      * @inheritDoc
  80.      */
  81.     public function close(): void
  82.     {
  83.         if (null !== $this->url && is_resource($this->stream)) {
  84.             fclose($this->stream);
  85.         }
  86.         $this->stream = null;
  87.         $this->dirCreated = null;
  88.     }
  90.     /**
  91.      * Return the currently active stream if it is open
  92.      *
  93.      * @return resource|null
  94.      */
  95.     public function getStream()
  96.     {
  97.         return $this->stream;
  98.     }
  100.     /**
  101.      * Return the stream URL if it was configured with a URL and not an active resource
  102.      */
  103.     public function getUrl(): ?string
  104.     {
  105.         return $this->url;
  106.     }
  108.     public function getStreamChunkSize(): int
  109.     {
  110.         return $this->streamChunkSize;
  111.     }
  113.     /**
  114.      * @inheritDoc
  115.      */
  116.     protected function write(LogRecord $record): void
  117.     {
  118.         if (!is_resource($this->stream)) {
  119.             $url = $this->url;
  120.             if (null === $url || '' === $url) {
  121.                 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));
  122.             }
  123.             $this->createDir($url);
  124.             $this->errorMessage = null;
  125.             set_error_handler([$this, 'customErrorHandler']);
  126.             $stream = fopen($url, 'a');
  127.             if ($this->filePermission !== null) {
  128.                 @chmod($url, $this->filePermission);
  129.             }
  130.             restore_error_handler();
  131.             if (!is_resource($stream)) {
  132.                 $this->stream = null;
  134.                 throw new \UnexpectedValueException(sprintf('The stream or file "%s" could not be opened in append mode: '.$this->errorMessage, $url) . Utils::getRecordMessageForException($record));
  135.             }
  136.             stream_set_chunk_size($stream, $this->streamChunkSize);
  137.             $this->stream = $stream;
  138.         }
  140.         $stream = $this->stream;
  141.         if ($this->useLocking) {
  142.             // ignoring errors here, there's not much we can do about them
  143.             flock($stream, LOCK_EX);
  144.         }
  146.         $this->streamWrite($stream, $record);
  148.         if ($this->useLocking) {
  149.             flock($stream, LOCK_UN);
  150.         }
  151.     }
  153.     /**
  154.      * Write to stream
  155.      * @param resource $stream
  156.      */
  157.     protected function streamWrite($stream, LogRecord $record): void
  158.     {
  159.         fwrite($stream, (string) $record->formatted);
  160.     }
  162.     private function customErrorHandler(int $code, string $msg): bool
  163.     {
  164.         $this->errorMessage = preg_replace('{^(fopen|mkdir)\(.*?\): }', '', $msg);
  166.         return true;
  167.     }
  169.     private function getDirFromStream(string $stream): ?string
  170.     {
  171.         $pos = strpos($stream, '://');
  172.         if ($pos === false) {
  173.             return dirname($stream);
  174.         }
  176.         if ('file://' === substr($stream, 0, 7)) {
  177.             return dirname(substr($stream, 7));
  178.         }
  180.         return null;
  181.     }
  183.     private function createDir(string $url): void
  184.     {
  185.         // Do not try to create dir if it has already been tried.
  186.         if (true === $this->dirCreated) {
  187.             return;
  188.         }
  190.         $dir = $this->getDirFromStream($url);
  191.         if (null !== $dir && !is_dir($dir)) {
  192.             $this->errorMessage = null;
  193.             set_error_handler([$this, 'customErrorHandler']);
  194.             $status = mkdir($dir, 0777, true);
  195.             restore_error_handler();
  196.             if (false === $status && !is_dir($dir) && strpos((string) $this->errorMessage, 'File exists') === false) {
  197.                 throw new \UnexpectedValueException(sprintf('There is no existing directory at "%s" and it could not be created: '.$this->errorMessage, $dir));
  198.             }
  199.         }
  200.         $this->dirCreated = true;
  201.     }
  202. }