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

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\Logger;
  15. use Monolog\Utils;
  17. /**
  18.  * Stores to any stream resource
  19.  *
  20.  * Can be used to store into php://stderr, remote and local files, etc.
  21.  *
  22.  * @author Jordi Boggiano <j.boggiano@seld.be>
  23.  *
  24.  * @phpstan-import-type FormattedRecord from AbstractProcessingHandler
  25.  */
  26. class StreamHandler extends AbstractProcessingHandler
  27. {
  28.     /** @const int */
  29.     protected const MAX_CHUNK_SIZE = 2147483647;
  30.     /** @const int 10MB */
  31.     protected const DEFAULT_CHUNK_SIZE = 10 * 1024 * 1024;
  32.     /** @var int */
  33.     protected $streamChunkSize;
  34.     /** @var resource|null */
  35.     protected $stream;
  36.     /** @var ?string */
  37.     protected $url = null;
  38.     /** @var ?string */
  39.     private $errorMessage = null;
  40.     /** @var ?int */
  41.     protected $filePermission;
  42.     /** @var bool */
  43.     protected $useLocking;
  44.     /** @var string */
  45.     protected $fileOpenMode;
  46.     /** @var true|null */
  47.     private $dirCreated = null;
  48.     /** @var bool */
  49.     private $retrying = false;
  51.     /**
  52.      * @param resource|string $stream         If a missing path can't be created, an UnexpectedValueException will be thrown on first write
  53.      * @param int|null        $filePermission Optional file permissions (default (0644) are only for owner read/write)
  54.      * @param bool            $useLocking     Try to lock log file before doing any writes
  55.      * @param string          $fileOpenMode   The fopen() mode used when opening a file, if $stream is a file path
  56.      *
  57.      * @throws \InvalidArgumentException If stream is not a resource or string
  58.      */
  59.     public function __construct($stream, $level = Logger::DEBUG, bool $bubble = true, ?int $filePermission = null, bool $useLocking = false, $fileOpenMode = 'a')
  60.     {
  61.         parent::__construct($level, $bubble);
  63.         if (($phpMemoryLimit = Utils::expandIniShorthandBytes(ini_get('memory_limit'))) !== false) {
  64.             if ($phpMemoryLimit > 0) {
  65.                 // use max 10% of allowed memory for the chunk size, and at least 100KB
  66.                 $this->streamChunkSize = min(static::MAX_CHUNK_SIZE, max((int) ($phpMemoryLimit / 10), 100 * 1024));
  67.             } else {
  68.                 // memory is unlimited, set to the default 10MB
  69.                 $this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
  70.             }
  71.         } else {
  72.             // no memory limit information, set to the default 10MB
  73.             $this->streamChunkSize = static::DEFAULT_CHUNK_SIZE;
  74.         }
  76.         if (is_resource($stream)) {
  77.             $this->stream = $stream;
  79.             stream_set_chunk_size($this->stream, $this->streamChunkSize);
  80.         } elseif (is_string($stream)) {
  81.             $this->url = Utils::canonicalizePath($stream);
  82.         } else {
  83.             throw new \InvalidArgumentException('A stream must either be a resource or a string.');
  84.         }
  86.         $this->fileOpenMode = $fileOpenMode;
  87.         $this->filePermission = $filePermission;
  88.         $this->useLocking = $useLocking;
  89.     }
  91.     /**
  92.      * {@inheritDoc}
  93.      */
  94.     public function close(): void
  95.     {
  96.         if ($this->url && is_resource($this->stream)) {
  97.             fclose($this->stream);
  98.         }
  99.         $this->stream = null;
  100.         $this->dirCreated = null;
  101.     }
  103.     /**
  104.      * Return the currently active stream if it is open
  105.      *
  106.      * @return resource|null
  107.      */
  108.     public function getStream()
  109.     {
  110.         return $this->stream;
  111.     }
  113.     /**
  114.      * Return the stream URL if it was configured with a URL and not an active resource
  115.      *
  116.      * @return string|null
  117.      */
  118.     public function getUrl(): ?string
  119.     {
  120.         return $this->url;
  121.     }
  123.     /**
  124.      * @return int
  125.      */
  126.     public function getStreamChunkSize(): int
  127.     {
  128.         return $this->streamChunkSize;
  129.     }
  131.     /**
  132.      * {@inheritDoc}
  133.      */
  134.     protected function write(array $record): void
  135.     {
  136.         if (!is_resource($this->stream)) {
  137.             $url = $this->url;
  138.             if (null === $url || '' === $url) {
  139.                 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));
  140.             }
  141.             $this->createDir($url);
  142.             $this->errorMessage = null;
  143.             set_error_handler(function (...$args) {
  144.                 return $this->customErrorHandler(...$args);
  145.             });
  146.             try {
  147.                 $stream = fopen($url, $this->fileOpenMode);
  148.                 if ($this->filePermission !== null) {
  149.                     @chmod($url, $this->filePermission);
  150.                 }
  151.             } finally {
  152.                 restore_error_handler();
  153.             }
  154.             if (!is_resource($stream)) {
  155.                 $this->stream = null;
  157.                 throw new \UnexpectedValueException(sprintf('The stream or file "%s" could not be opened in append mode: '.$this->errorMessage, $url) . Utils::getRecordMessageForException($record));
  158.             }
  159.             stream_set_chunk_size($stream, $this->streamChunkSize);
  160.             $this->stream = $stream;
  161.         }
  163.         $stream = $this->stream;
  164.         if (!is_resource($stream)) {
  165.             throw new \LogicException('No stream was opened yet' . Utils::getRecordMessageForException($record));
  166.         }
  168.         if ($this->useLocking) {
  169.             // ignoring errors here, there's not much we can do about them
  170.             flock($stream, LOCK_EX);
  171.         }
  173.         $this->errorMessage = null;
  174.         set_error_handler(function (...$args) {
  175.             return $this->customErrorHandler(...$args);
  176.         });
  177.         try {
  178.             $this->streamWrite($stream, $record);
  179.         } finally {
  180.             restore_error_handler();
  181.         }
  182.         if ($this->errorMessage !== null) {
  183.             $error = $this->errorMessage;
  184.             // close the resource if possible to reopen it, and retry the failed write
  185.             if (!$this->retrying && $this->url !== null && $this->url !== 'php://memory') {
  186.                 $this->retrying = true;
  187.                 $this->close();
  188.                 $this->write($record);
  190.                 return;
  191.             }
  193.             throw new \UnexpectedValueException('Writing to the log file failed: '.$error . Utils::getRecordMessageForException($record));
  194.         }
  196.         $this->retrying = false;
  197.         if ($this->useLocking) {
  198.             flock($stream, LOCK_UN);
  199.         }
  200.     }
  202.     /**
  203.      * Write to stream
  204.      * @param resource $stream
  205.      * @param array    $record
  206.      *
  207.      * @phpstan-param FormattedRecord $record
  208.      */
  209.     protected function streamWrite($stream, array $record): void
  210.     {
  211.         fwrite($stream, (string) $record['formatted']);
  212.     }
  214.     private function customErrorHandler(int $code, string $msg): bool
  215.     {
  216.         $this->errorMessage = preg_replace('{^(fopen|mkdir|fwrite)\(.*?\): }', '', $msg);
  218.         return true;
  219.     }
  221.     private function getDirFromStream(string $stream): ?string
  222.     {
  223.         $pos = strpos($stream, '://');
  224.         if ($pos === false) {
  225.             return dirname($stream);
  226.         }
  228.         if ('file://' === substr($stream, 0, 7)) {
  229.             return dirname(substr($stream, 7));
  230.         }
  232.         return null;
  233.     }
  235.     private function createDir(string $url): void
  236.     {
  237.         // Do not try to create dir if it has already been tried.
  238.         if ($this->dirCreated) {
  239.             return;
  240.         }
  242.         $dir = $this->getDirFromStream($url);
  243.         if (null !== $dir && !is_dir($dir)) {
  244.             $this->errorMessage = null;
  245.             set_error_handler(function (...$args) {
  246.                 return $this->customErrorHandler(...$args);
  247.             });
  248.             $status = mkdir($dir, 0777, true);
  249.             restore_error_handler();
  250.             if (false === $status && !is_dir($dir) && strpos((string) $this->errorMessage, 'File exists') === false) {
  251.                 throw new \UnexpectedValueException(sprintf('There is no existing directory at "%s" and it could not be created: '.$this->errorMessage, $dir));
  252.             }
  253.         }
  254.         $this->dirCreated = true;
  255.     }
  256. }