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. // forwarding to $this->customErrorHandler using a closure to make the
  152. // private method accessible, see https://github.com/Seldaek/monolog/issues/1866
  153. set_error_handler(function (int $code, string $msg) {
  154. return $this->customErrorHandler($code, $msg);
  155. });
  157. try {
  158. $stream = fopen($url, $this->fileOpenMode);
  159. if ($this->filePermission !== null) {
  160. @chmod($url, $this->filePermission);
  161. }
  162. } finally {
  163. restore_error_handler();
  164. }
  165. if (!\is_resource($stream)) {
  166. $this->stream = null;
  168. throw new \UnexpectedValueException(sprintf('The stream or file "%s" could not be opened in append mode: '.$this->errorMessage, $url) . Utils::getRecordMessageForException($record));
  169. }
  170. stream_set_chunk_size($stream, $this->streamChunkSize);
  171. $this->stream = $stream;
  172. $this->inodeUrl = $this->getInodeFromUrl();
  173. }
  175. $stream = $this->stream;
  176. if ($this->useLocking) {
  177. // ignoring errors here, there's not much we can do about them
  178. flock($stream, LOCK_EX);
  179. }
  181. $this->errorMessage = null;
  182. // forwarding to $this->customErrorHandler using a closure to make the
  183. // private method accessible, see https://github.com/Seldaek/monolog/issues/1866
  184. set_error_handler(function (int $code, string $msg) {
  185. return $this->customErrorHandler($code, $msg);
  186. });
  187. try {
  188. $this->streamWrite($stream, $record);
  189. } finally {
  190. restore_error_handler();
  191. }
  192. if ($this->errorMessage !== null) {
  193. $error = $this->errorMessage;
  194. // close the resource if possible to reopen it, and retry the failed write
  195. if (!$this->retrying && $this->url !== null && $this->url !== 'php://memory') {
  196. $this->retrying = true;
  197. $this->close();
  198. $this->write($record);
  200. return;
  201. }
  203. throw new \UnexpectedValueException('Writing to the log file failed: '.$error . Utils::getRecordMessageForException($record));
  204. }
  206. $this->retrying = false;
  207. if ($this->useLocking) {
  208. flock($stream, LOCK_UN);
  209. }
  210. }
  212. /**
  213. * Write to stream
  214. * @param resource $stream
  215. */
  216. protected function streamWrite($stream, LogRecord $record): void
  217. {
  218. $data = (string) $record->formatted;
  219. $length = \strlen($data);
  220. $written = 0;
  222. // fwrite() may write only part of the data on non-blocking streams, so loop until it is all written, see https://github.com/Seldaek/monolog/issues/2011
  223. while ($written < $length) {
  224. $result = fwrite($stream, substr($data, $written));
  225. if ($result === false) {
  226. // write failed, let the customErrorHandler/errorMessage logic in write() report and retry it
  227. break;
  228. }
  229. if ($result === 0) {
  230. // the non-blocking stream's buffer is full, wait until it can be written to again instead of busy-looping or dropping the rest of the record
  231. $write = [$stream];
  232. $read = $except = [];
  233. stream_select($read, $write, $except, null);
  234. continue;
  235. }
  236. $written += $result;
  237. }
  238. }
  240. /**
  241. * @return true
  242. */
  243. private function customErrorHandler(int $code, string $msg): bool
  244. {
  245. $this->errorMessage = preg_replace('{^(fopen|mkdir|fwrite)\(.*?\): }', '', $msg);
  247. return true;
  248. }
  250. private function getDirFromStream(string $stream): ?string
  251. {
  252. $pos = strpos($stream, '://');
  253. if ($pos === false) {
  254. return \dirname($stream);
  255. }
  257. if ('file://' === substr($stream, 0, 7)) {
  258. return \dirname(substr($stream, 7));
  259. }
  261. return null;
  262. }
  264. private function createDir(string $url): void
  265. {
  266. // Do not try to create dir if it has already been tried.
  267. if (true === $this->dirCreated) {
  268. return;
  269. }
  271. $dir = $this->getDirFromStream($url);
  272. if (null !== $dir && !is_dir($dir)) {
  273. $this->errorMessage = null;
  274. // forwarding to $this->customErrorHandler using a closure to make the
  275. // private method accessible, see https://github.com/Seldaek/monolog/issues/1866
  276. set_error_handler(function (int $code, string $msg) {
  277. return $this->customErrorHandler($code, $msg);
  278. });
  279. $status = mkdir($dir, 0777, true);
  280. restore_error_handler();
  281. if (false === $status && !is_dir($dir) && strpos((string) $this->errorMessage, 'File exists') === false) {
  282. throw new \UnexpectedValueException(sprintf('There is no existing directory at "%s" and it could not be created: '.$this->errorMessage, $dir));
  283. }
  284. }
  285. $this->dirCreated = true;
  286. }
  288. private function getInodeFromUrl(): ?int
  289. {
  290. if ($this->url === null || str_starts_with($this->url, 'php://')) {
  291. return null;
  292. }
  294. $inode = @fileinode($this->url);
  296. return $inode === false ? null : $inode;
  297. }
  299. private function hasUrlInodeWasChanged(): bool
  300. {
  301. if ($this->inodeUrl === null || $this->retrying || $this->inodeUrl === $this->getInodeFromUrl()) {
  302. return false;
  303. }
  305. $this->retrying = true;
  307. return true;
  308. }
  309. }