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

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