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

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;
  16. /**
  17.  * Stores to any stream resource
  18.  *
  19.  * Can be used to store into php://stderr, remote and local files, etc.
  20.  *
  21.  * @author Jordi Boggiano <j.boggiano@seld.be>
  22.  */
  23. class StreamHandler extends AbstractProcessingHandler
  24. {
  25.     /** @var resource|null */
  26.     protected $stream;
  27.     protected $url;
  28.     /** @var string|null */
  29.     private $errorMessage;
  30.     protected $filePermission;
  31.     protected $useLocking;
  32.     private $dirCreated;
  34.     /**
  35.      * @param resource|string $stream
  36.      * @param string|int      $level          The minimum logging level at which this handler will be triggered
  37.      * @param bool            $bubble         Whether the messages that are handled can bubble up the stack or not
  38.      * @param int|null        $filePermission Optional file permissions (default (0644) are only for owner read/write)
  39.      * @param bool            $useLocking     Try to lock log file before doing any writes
  40.      *
  41.      * @throws \Exception                If a missing directory is not buildable
  42.      * @throws \InvalidArgumentException If stream is not a resource or string
  43.      */
  44.     public function __construct($stream, $level = Logger::DEBUG, bool $bubble = true, ?int $filePermission = null, bool $useLocking = false)
  45.     {
  46.         parent::__construct($level, $bubble);
  47.         if (is_resource($stream)) {
  48.             $this->stream = $stream;
  49.         } elseif (is_string($stream)) {
  50.             $this->url = $stream;
  51.         } else {
  52.             throw new \InvalidArgumentException('A stream must either be a resource or a string.');
  53.         }
  55.         $this->filePermission = $filePermission;
  56.         $this->useLocking = $useLocking;
  57.     }
  59.     /**
  60.      * {@inheritdoc}
  61.      */
  62.     public function close(): void
  63.     {
  64.         if ($this->url && is_resource($this->stream)) {
  65.             fclose($this->stream);
  66.         }
  67.         $this->stream = null;
  68.         $this->dirCreated = null;
  69.     }
  71.     /**
  72.      * Return the currently active stream if it is open
  73.      *
  74.      * @return resource|null
  75.      */
  76.     public function getStream()
  77.     {
  78.         return $this->stream;
  79.     }
  81.     /**
  82.      * Return the stream URL if it was configured with a URL and not an active resource
  83.      *
  84.      * @return string|null
  85.      */
  86.     public function getUrl(): ?string
  87.     {
  88.         return $this->url;
  89.     }
  91.     /**
  92.      * {@inheritdoc}
  93.      */
  94.     protected function write(array $record): void
  95.     {
  96.         if (!is_resource($this->stream)) {
  97.             if (null === $this->url || '' === $this->url) {
  98.                 throw new \LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().');
  99.             }
  100.             $this->createDir();
  101.             $this->errorMessage = null;
  102.             set_error_handler([$this, 'customErrorHandler']);
  103.             $this->stream = fopen($this->url, 'a');
  104.             if ($this->filePermission !== null) {
  105.                 @chmod($this->url, $this->filePermission);
  106.             }
  107.             restore_error_handler();
  108.             if (!is_resource($this->stream)) {
  109.                 $this->stream = null;
  111.                 throw new \UnexpectedValueException(sprintf('The stream or file "%s" could not be opened: '.$this->errorMessage, $this->url));
  112.             }
  113.         }
  115.         if ($this->useLocking) {
  116.             // ignoring errors here, there's not much we can do about them
  117.             flock($this->stream, LOCK_EX);
  118.         }
  120.         $this->streamWrite($this->stream, $record);
  122.         if ($this->useLocking) {
  123.             flock($this->stream, LOCK_UN);
  124.         }
  125.     }
  127.     /**
  128.      * Write to stream
  129.      * @param resource $stream
  130.      * @param array    $record
  131.      */
  132.     protected function streamWrite($stream, array $record): void
  133.     {
  134.         fwrite($stream, (string) $record['formatted']);
  135.     }
  137.     private function customErrorHandler($code, $msg): bool
  138.     {
  139.         $this->errorMessage = preg_replace('{^(fopen|mkdir)\(.*?\): }', '', $msg);
  141.         return true;
  142.     }
  144.     private function getDirFromStream(string $stream): ?string
  145.     {
  146.         $pos = strpos($stream, '://');
  147.         if ($pos === false) {
  148.             return dirname($stream);
  149.         }
  151.         if ('file://' === substr($stream, 0, 7)) {
  152.             return dirname(substr($stream, 7));
  153.         }
  155.         return null;
  156.     }
  158.     private function createDir(): void
  159.     {
  160.         // Do not try to create dir if it has already been tried.
  161.         if ($this->dirCreated) {
  162.             return;
  163.         }
  165.         $dir = $this->getDirFromStream($this->url);
  166.         if (null !== $dir && !is_dir($dir)) {
  167.             $this->errorMessage = null;
  168.             set_error_handler([$this, 'customErrorHandler']);
  169.             $status = mkdir($dir, 0777, true);
  170.             restore_error_handler();
  171.             if (false === $status && !is_dir($dir)) {
  172.                 throw new \UnexpectedValueException(sprintf('There is no existing directory at "%s" and its not buildable: '.$this->errorMessage, $dir));
  173.             }
  174.         }
  175.         $this->dirCreated = true;
  176.     }
  177. }