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

Open in your IDE?
  1. <?php
  2. /*
  3.  * This file is part of the Monolog package.
  4.  *
  5.  * (c) Jordi Boggiano <j.boggiano@seld.be>
  6.  *
  7.  * For the full copyright and license information, please view the LICENSE
  8.  * file that was distributed with this source code.
  9.  */
  10. namespace Monolog\Handler;
  11. use Monolog\Logger;
  12. use Monolog\Utils;
  13. /**
  14.  * Stores to any stream resource
  15.  *
  16.  * Can be used to store into php://stderr, remote and local files, etc.
  17.  *
  18.  * @author Jordi Boggiano <j.boggiano@seld.be>
  19.  */
  20. class StreamHandler extends AbstractProcessingHandler
  21. {
  22.     protected $stream;
  23.     protected $url;
  24.     private $errorMessage;
  25.     protected $filePermission;
  26.     protected $useLocking;
  27.     private $dirCreated;
  28.     /**
  29.      * @param resource|string $stream
  30.      * @param int             $level          The minimum logging level at which this handler will be triggered
  31.      * @param bool            $bubble         Whether the messages that are handled can bubble up the stack or not
  32.      * @param int|null        $filePermission Optional file permissions (default (0644) are only for owner read/write)
  33.      * @param bool            $useLocking     Try to lock log file before doing any writes
  34.      *
  35.      * @throws \Exception                If a missing directory is not buildable
  36.      * @throws \InvalidArgumentException If stream is not a resource or string
  37.      */
  38.     public function __construct($stream$level Logger::DEBUG$bubble true$filePermission null$useLocking false)
  39.     {
  40.         parent::__construct($level$bubble);
  41.         if (is_resource($stream)) {
  42.             $this->stream $stream;
  43.         } elseif (is_string($stream)) {
  44.             $this->url Utils::canonicalizePath($stream);
  45.         } else {
  46.             throw new \InvalidArgumentException('A stream must either be a resource or a string.');
  47.         }
  48.         $this->filePermission $filePermission;
  49.         $this->useLocking $useLocking;
  50.     }
  51.     /**
  52.      * {@inheritdoc}
  53.      */
  54.     public function close()
  55.     {
  56.         if ($this->url && is_resource($this->stream)) {
  57.             fclose($this->stream);
  58.         }
  59.         $this->stream null;
  60.         $this->dirCreated null;
  61.     }
  62.     /**
  63.      * Return the currently active stream if it is open
  64.      *
  65.      * @return resource|null
  66.      */
  67.     public function getStream()
  68.     {
  69.         return $this->stream;
  70.     }
  71.     /**
  72.      * Return the stream URL if it was configured with a URL and not an active resource
  73.      *
  74.      * @return string|null
  75.      */
  76.     public function getUrl()
  77.     {
  78.         return $this->url;
  79.     }
  80.     /**
  81.      * {@inheritdoc}
  82.      */
  83.     protected function write(array $record)
  84.     {
  85.         if (!is_resource($this->stream)) {
  86.             if (null === $this->url || '' === $this->url) {
  87.                 throw new \LogicException('Missing stream url, the stream can not be opened. This may be caused by a premature call to close().');
  88.             }
  89.             $this->createDir();
  90.             $this->errorMessage null;
  91.             set_error_handler(array($this'customErrorHandler'));
  92.             $this->stream fopen($this->url'a');
  93.             if ($this->filePermission !== null) {
  94.                 @chmod($this->url$this->filePermission);
  95.             }
  96.             restore_error_handler();
  97.             if (!is_resource($this->stream)) {
  98.                 $this->stream null;
  99.                 throw new \UnexpectedValueException(sprintf('The stream or file "%s" could not be opened in append mode: '.$this->errorMessage$this->url));
  100.             }
  101.         }
  102.         if ($this->useLocking) {
  103.             // ignoring errors here, there's not much we can do about them
  104.             flock($this->streamLOCK_EX);
  105.         }
  106.         $this->streamWrite($this->stream$record);
  107.         if ($this->useLocking) {
  108.             flock($this->streamLOCK_UN);
  109.         }
  110.     }
  111.     /**
  112.      * Write to stream
  113.      * @param resource $stream
  114.      * @param array $record
  115.      */
  116.     protected function streamWrite($stream, array $record)
  117.     {
  118.         fwrite($stream, (string) $record['formatted']);
  119.     }
  120.     private function customErrorHandler($code$msg)
  121.     {
  122.         $this->errorMessage preg_replace('{^(fopen|mkdir)\(.*?\): }'''$msg);
  123.     }
  124.     /**
  125.      * @param string $stream
  126.      *
  127.      * @return null|string
  128.      */
  129.     private function getDirFromStream($stream)
  130.     {
  131.         $pos strpos($stream'://');
  132.         if ($pos === false) {
  133.             return dirname($stream);
  134.         }
  135.         if ('file://' === substr($stream07)) {
  136.             return dirname(substr($stream7));
  137.         }
  138.         return;
  139.     }
  140.     private function createDir()
  141.     {
  142.         // Do not try to create dir if it has already been tried.
  143.         if ($this->dirCreated) {
  144.             return;
  145.         }
  146.         $dir $this->getDirFromStream($this->url);
  147.         if (null !== $dir && !is_dir($dir)) {
  148.             $this->errorMessage null;
  149.             set_error_handler(array($this'customErrorHandler'));
  150.             $status mkdir($dir0777true);
  151.             restore_error_handler();
  152.             if (false === $status && !is_dir($dir)) {
  153.                 throw new \UnexpectedValueException(sprintf('There is no existing directory at "%s" and its not buildable: '.$this->errorMessage$dir));
  154.             }
  155.         }
  156.         $this->dirCreated true;
  157.     }
  158. }