suda\framework\debug\log\logger\FileLogger

Complexity

Total Complexity

42

Size/Duplication

Total Lines	299
Duplicated Lines	0 %

Importance

Changes	7
Bugs	0	Features	0

16 Methods

Rating	Name	Duplication	Size	Complexity
A	getAvailableWrite()	0	7	2
A	set()	0	6	1
A	getDefaultConfig()	0	10	1
A	__construct()	0	4	1
A	removePackFiles()	0	8	4
A	rollLatest()	0	16	4
A	clearContent()	0	3	1
A	write()	0	7	2
A	prepareWrite()	0	12	2
A	log()	0	9	2
A	getZipArchive()	0	10	3
A	shutdown()	0	6	2
A	checkSize()	0	9	3
B	packLogFile()	0	33	8
A	interpolate()	0	12	5
A	safeMoveKeep()	0	12	1

<?php

namespace suda\framework\debug\log\logger;

use ZipArchive;
use RecursiveIteratorIterator;
use RecursiveDirectoryIterator;
use suda\framework\debug\ConfigTrait;
use suda\framework\debug\log\LogLevel;
use suda\framework\debug\ConfigInterface;
use suda\framework\filesystem\FileSystem;
use suda\framework\debug\log\AbstractLogger;
use suda\framework\debug\log\logger\exception\FileLoggerException;

/**
 * Class FileLogger
 * @package suda\framework\debug\log\logger
 */
class FileLogger extends AbstractLogger implements ConfigInterface
{
    use ConfigTrait;

    /**
     * 文件
     *
     * @var resource
     */
    protected $temp;

    /**
     * 临时文件名
     *
     * @var string
     */
    protected $tempName;

    /**
     * 移除文件
     *
     * @var array
     */
    protected $removeFiles = [];

    /**
     * 最后的日志
     *
     * @var string
     */
    protected $latest;

    /**
     * 构建文件日志
     *
     * @param array $config
     */
    public function __construct(array $config = [])
    {
        $this->set($config);
        register_shutdown_function([$this, 'shutdown']);
    }

    /**
     * 设置配置
     * @param array $config
     */
    public function set(array $config)
    {
        $this->applyConfig($config);
        FileSystem::make($this->getConfig('save-path'));
        FileSystem::make($this->getConfig('save-dump-path'));
        FileSystem::make($this->getConfig('save-zip-path'));
    }

    /**
     * @return resource
     * @throws FileLoggerException
     */
    public function getAvailableWrite()
    {
        if (is_resource($this->temp)) {
            return $this->temp;
        }
        $this->prepareWrite();
        return $this->temp;
    }

    /**
     * @throws FileLoggerException
     */
    private function prepareWrite()
    {
        $unique = substr(md5(uniqid()), 0, 8);
        $save = $this->getConfig('save-path');
        $this->tempName = $save . '/' . date('YmdHis') . '.' . $unique . '.log';
        $temp = fopen($this->tempName, 'w+');
        if ($temp !== false) {
            $this->temp = $temp;
        } else {
            throw new FileLoggerException(__METHOD__ . ':' . sprintf('cannot create log file'));
        }
        $this->latest = $save . '/' . $this->getConfig('file-name');
    }

    /**
     * @return array
     */
    public function getDefaultConfig(): array
    {
        return [
            'save-path' => './logs',
            'save-zip-path' => './logs/zip',
            'save-dump-path' => './logs/dump',
            'max-file-size' => 2097152,
            'file-name' => 'latest.log',
            'log-level' => 'debug',
            'log-format' => '[%level%] %message%',
        ];
    }

    /**
     * 打包文件
     */
    private function packLogFile()
    {
        $logFile = $this->latest;
        $path = preg_replace(
            '/[\\\\]+/',
            '/',
            $this->getConfig('save-zip-path') . '/' . date('Y-m-d') . '.zip'
        );
        $zip = $this->getZipArchive($path);
        if ($zip !== null) {
            $add = $zip->addFile($logFile, date('Y-m-d') . '-' . $zip->numFiles . '.log');
            if (is_dir($this->getConfig('save-dump-path'))) {
                $it = new RecursiveIteratorIterator(new RecursiveDirectoryIterator(
                    $this->getConfig('save-dump-path'),
                    RecursiveDirectoryIterator::SKIP_DOTS
                ));
                foreach ($it as $dumpLog) {
                    if ($zip->addFile($dumpLog, 'dump/' . basename($dumpLog))) {
                        array_push($this->removeFiles, $dumpLog);
                    }
                }
            }
            $zip->close();
            if ($add) {
                $this->clearContent($logFile);
            }
        } else {
            if (is_file($logFile) && file_exists($logFile)) {
                $this->safeMoveKeep(
                    $logFile,
                    $this->getConfig('save-path')
                    . '/' . date('Y-m-d')
                    . '-' . substr(md5(uniqid()), 0, 8). '.log'
                );
            }
        }
    }

    /**
     * @param string $from
     * @param string $to
     */
    private function safeMoveKeep(string $from, string $to)
    {
        $fromR = fopen($from, 'r');
        $toR = fopen($to, 'w+');
        flock($toR, LOCK_EX);

It seems like $toR can also be of type false; however, parameter $handle of flock() does only seem to accept resource, maybe add an additional type check?

        // 复制内容
        stream_copy_to_stream($fromR, $toR);

It seems like $toR can also be of type false; however, parameter $dest of stream_copy_to_stream() does only seem to accept resource, maybe add an additional type check?

It seems like $fromR can also be of type false; however, parameter $source of stream_copy_to_stream() does only seem to accept resource, maybe add an additional type check?

        flock($toR, LOCK_UN);
        fclose($toR);

It seems like $toR can also be of type false; however, parameter $handle of fclose() does only seem to accept resource, maybe add an additional type check?

        fclose($fromR);
        // 清空内容
        $this->clearContent($from);
    }

    /**
     * 清空内容
     * @param string $path
     */
    private function clearContent(string $path)
    {
        fclose(fopen($path, 'w'));

It seems like fopen($path, 'w') can also be of type false; however, parameter $handle of fclose() does only seem to accept resource, maybe add an additional type check?

    }

    /**
     * 获取压缩
     *
     * @param string $path
     * @return ZipArchive|null
     */
    private function getZipArchive(string $path)
    {
        if (class_exists('ZipArchive')) {
            $zip = new ZipArchive;
            $res = $zip->open($path, ZipArchive::CREATE);
            if ($res === true) {
                return $zip;
            }
        }
        return null;
    }

    /**
     * 检查日志文件大小
     *
     * @return boolean
     */
    private function checkSize(): bool
    {
        $logFile = $this->latest;
        if (file_exists($logFile)) {
            if (filesize($logFile) > $this->getConfig('max-file-size')) {
                return true;
            }
        }
        return false;
    }


    /**
     * @param string $level
     * @param string $message
     * @param array $context
     * @return mixed|void
     * @throws FileLoggerException
     */
    public function log($level, string $message, array $context = [])
    {
        if (LogLevel::compare($level, $this->getConfig('log-level')) >= 0) {
            $replace = [];
            $message = $this->interpolate($message, $context);
            $replace['%level%'] = $level;
            $replace['%message%'] = $message;
            $write = strtr($this->getConfig('log-format'), $replace);
            fwrite($this->getAvailableWrite(), $write . PHP_EOL);
        }
    }


    /**
     * 将临时文件写入最后日志
     */
    private function rollLatest()
    {
        if (isset($this->latest)) {
            $latest = fopen($this->latest, 'a+');
            if (flock($latest, LOCK_EX)) {

It seems like $latest can also be of type false; however, parameter $handle of flock() does only seem to accept resource, maybe add an additional type check?

                rewind($this->temp);
                stream_copy_to_stream($this->temp, $latest);

It seems like $latest can also be of type false; however, parameter $dest of stream_copy_to_stream() does only seem to accept resource, maybe add an additional type check?

                flock($latest, LOCK_UN);
                if (file_exists($this->tempName)) {
                    unlink($this->tempName);
                }
            }
            fclose($latest);

It seems like $latest can also be of type false; however, parameter $handle of fclose() does only seem to accept resource, maybe add an additional type check?

            fclose($this->temp);
            $this->temp = null;
            $this->tempName = null;
        }
    }

    /**
     * 删除已经压缩的文件
     */
    private function removePackFiles()
    {
        foreach ($this->removeFiles as $file) {
            if (is_file($file) && file_exists($file)) {
                unlink($file);
            }
        }
        $this->removeFiles = [];
    }

    /**
     * 即时写入日志
     */
    public function write()
    {
        if ($this->checkSize()) {
            $this->packLogFile();
        }
        $this->rollLatest();
        $this->removePackFiles();
    }

    /**
     * 程序关闭时调用
     */
    public function shutdown()
    {
        if (function_exists('fastcgi_finish_request')) {
            fastcgi_finish_request();
        }
        $this->write();
    }

    /**
     * @param string $message
     * @param array $context
     * @return string
     */
    public function interpolate(string $message, array $context)
    {
        $replace = [];
        foreach ($context as $key => $val) {
            if (is_bool($val)) {
                $val = $val ? 'true' : 'false';
            } elseif (null === $val) {
                $val = 'null';
            }
            $replace['{' . $key . '}'] = $val;
        }
        return strtr($message, $replace);
    }
}