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

Open in your IDE?
  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.     protected string $fileOpenMode;
  38.     /** @var true|null */
  39.     private bool|null $dirCreated = null;
  40.     private bool $retrying = false;
  41.     private int|null $inodeUrl = null;
  43.     /**
  44.      * @param resource|string $stream         If a missing path can't be created, an UnexpectedValueException will be thrown on first write
  45.      * @param int|null        $filePermission Optional file permissions (default (0644) are only for owner read/write)
  46.      * @param bool            $useLocking     Try to lock log file before doing any writes
  47.      * @param string          $fileOpenMode   The fopen() mode used when opening a file, if $stream is a file path
  48.      *
  49.      * @throws \InvalidArgumentException If stream is not a resource or string
  50.      */
  51.     public function __construct($stream, int|string|Level $level = Level::Debug, bool $bubble = true, ?int $filePermission = null, bool $useLocking = false, string $fileOpenMode = 'a')
  52.     {
  53.         parent::__construct($level, $bubble);
  55.         if (($phpMemoryLimit = Utils::expandIniShorthandBytes(\ini_get('memory_limit'))) !== false) {
  56.             if ($phpMemoryLimit > 0) {
  57.                 // use max 10% of allowed memory for the chunk size, and at least 100KB
  58.                 $this->streamChunkSize = min(static::MAX_CHUNK_SIZE, max((int) ($phpMemoryLimit / 10), 100 * 1024));
  59.             } else {
  60.                 // memory is unlimited, set to the default 10MB
  61.                 $this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
  62.             }
  63.         } else {
  64.             // no memory limit information, set to the default 10MB
  65.             $this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
  66.         }
  68.         if (\is_resource($stream)) {
  69.             $this->stream = $stream;
  71.             stream_set_chunk_size($this->stream, $this->streamChunkSize);
  72.         } elseif (\is_string($stream)) {
  73.             $this->url = Utils::canonicalizePath($stream);
  74.         } else {
  75.             throw new \InvalidArgumentException('A stream must either be a resource or a string.');
  76.         }
  78.         $this->fileOpenMode = $fileOpenMode;
  79.         $this->filePermission = $filePermission;
  80.         $this->useLocking = $useLocking;
  81.     }
  83.     /**
  84.      * @inheritDoc
  85.      */
  86.     public function reset(): void
  87.     {
  88.         parent::reset();
  90.         // auto-close on reset to make sure we periodically close the file in long running processes
  91.         // as long as they correctly call reset() between jobs
  92.         if ($this->url !== null && $this->url !== 'php://memory') {
  93.             $this->close();
  94.         }
  95.     }
  97.     /**
  98.      * @inheritDoc
  99.      */
  100.     public function close(): void
  101.     {
  102.         if (null !== $this->url && \is_resource($this->stream)) {
  103.             fclose($this->stream);
  104.         }
  105.         $this->stream = null;
  106.         $this->dirCreated = null;
  107.     }
  109.     /**
  110.      * Return the currently active stream if it is open
  111.      *
  112.      * @return resource|null
  113.      */
  114.     public function getStream()
  115.     {
  116.         return $this->stream;
  117.     }
  119.     /**
  120.      * Return the stream URL if it was configured with a URL and not an active resource
  121.      */
  122.     public function getUrl(): ?string
  123.     {
  124.         return $this->url;
  125.     }
  127.     public function getStreamChunkSize(): int
  128.     {
  129.         return $this->streamChunkSize;
  130.     }
  132.     /**
  133.      * @inheritDoc
  134.      */
  135.     protected function write(LogRecord $record): void
  136.     {
  137.         if ($this->hasUrlInodeWasChanged()) {
  138.             $this->close();
  139.             $this->write($record);
  141.             return;
  142.         }
  144.         if (!\is_resource($this->stream)) {
  145.             $url = $this->url;
  146.             if (null === $url || '' === $url) {
  147.                 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));
  148.             }
  149.             $this->createDir($url);
  150.             $this->errorMessage = null;
  151.             set_error_handler($this->customErrorHandler(...));
  153.             try {
  154.                 $stream = fopen($url, $this->fileOpenMode);
  155.                 if ($this->filePermission !== null) {
  156.                     @chmod($url, $this->filePermission);
  157.                 }
  158.             } finally {
  159.                 restore_error_handler();
  160.             }
  161.             if (!\is_resource($stream)) {
  162.                 $this->stream = null;
  164.                 throw new \UnexpectedValueException(sprintf('The stream or file "%s" could not be opened in append mode: '.$this->errorMessage, $url) . Utils::getRecordMessageForException($record));
  165.             }
  166.             stream_set_chunk_size($stream, $this->streamChunkSize);
  167.             $this->stream = $stream;
  168.             $this->inodeUrl = $this->getInodeFromUrl();
  169.         }
  171.         $stream = $this->stream;
  172.         if ($this->useLocking) {
  173.             // ignoring errors here, there's not much we can do about them
  174.             flock($stream, LOCK_EX);
  175.         }
  177.         $this->errorMessage = null;
  178.         set_error_handler($this->customErrorHandler(...));
  179.         try {
  180.             $this->streamWrite($stream, $record);
  181.         } finally {
  182.             restore_error_handler();
  183.         }
  184.         if ($this->errorMessage !== null) {
  185.             $error = $this->errorMessage;
  186.             // close the resource if possible to reopen it, and retry the failed write
  187.             if (!$this->retrying && $this->url !== null && $this->url !== 'php://memory') {
  188.                 $this->retrying = true;
  189.                 $this->close();
  190.                 $this->write($record);
  192.                 return;
  193.             }
  195.             throw new \UnexpectedValueException('Writing to the log file failed: '.$error . Utils::getRecordMessageForException($record));
  196.         }
  198.         $this->retrying = false;
  199.         if ($this->useLocking) {
  200.             flock($stream, LOCK_UN);
  201.         }
  202.     }
  204.     /**
  205.      * Write to stream
  206.      * @param resource $stream
  207.      */
  208.     protected function streamWrite($stream, LogRecord $record): void
  209.     {
  210.         fwrite($stream, (string) $record->formatted);
  211.     }
  213.     /**
  214.      * @return true
  215.      */
  216.     private function customErrorHandler(int $code, string $msg): bool
  217.     {
  218.         $this->errorMessage = preg_replace('{^(fopen|mkdir|fwrite)\(.*?\): }', '', $msg);
  220.         return true;
  221.     }
  223.     private function getDirFromStream(string $stream): ?string
  224.     {
  225.         $pos = strpos($stream, '://');
  226.         if ($pos === false) {
  227.             return \dirname($stream);
  228.         }
  230.         if ('file://' === substr($stream, 0, 7)) {
  231.             return \dirname(substr($stream, 7));
  232.         }
  234.         return null;
  235.     }
  237.     private function createDir(string $url): void
  238.     {
  239.         // Do not try to create dir if it has already been tried.
  240.         if (true === $this->dirCreated) {
  241.             return;
  242.         }
  244.         $dir = $this->getDirFromStream($url);
  245.         if (null !== $dir && !is_dir($dir)) {
  246.             $this->errorMessage = null;
  247.             set_error_handler(function (...$args) {
  248.                 return $this->customErrorHandler(...$args);
  249.             });
  250.             $status = mkdir($dir, 0777, true);
  251.             restore_error_handler();
  252.             if (false === $status && !is_dir($dir) && strpos((string) $this->errorMessage, 'File exists') === false) {
  253.                 throw new \UnexpectedValueException(sprintf('There is no existing directory at "%s" and it could not be created: '.$this->errorMessage, $dir));
  254.             }
  255.         }
  256.         $this->dirCreated = true;
  257.     }
  259.     private function getInodeFromUrl(): ?int
  260.     {
  261.         if ($this->url === null || str_starts_with($this->url, 'php://')) {
  262.             return null;
  263.         }
  265.         $inode = @fileinode($this->url);
  267.         return $inode === false ? null : $inode;
  268.     }
  270.     private function hasUrlInodeWasChanged(): bool
  271.     {
  272.         if ($this->inodeUrl === null || $this->retrying || $this->inodeUrl === $this->getInodeFromUrl()) {
  273.             return false;
  274.         }
  276.         $this->retrying = true;
  278.         return true;
  279.     }
  280. }