LoggerConfig::flush() - Code Metrics - Inspection of "Feature swoole" - SeasX/seas-logger - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed
Pull Request — master (#12)

unknown
created 2019-09-12 05:39 UTC
LoggerConfig::flush() A

↳ Parent: LoggerConfig
Complexity

Conditions	6
Paths	3
Size

Total Lines	9
Code Lines	5
Duplication

Lines	0
Ratio	0 %
Importance

Changes	1
Bugs	0	Features	1
Metric	Value
cc	6
eloc	5
c	1
b	0
f	1
nc	3
nop	1
dl	0
loc	9
rs	9.2222
<?php
declare(strict_types=1);

namespace Seasx\SeasLogger;

use Co;
use Exception;
use Psr\Log\InvalidArgumentException;

/**
 * Class LoggerConfig
 * @package Seasx\SeasLogger
 */
class LoggerConfig extends AbstractConfig
{
    /** @var array */
    protected $buffer = [];
    /** @var string */
    protected $datetime_format = "Y-m-d H:i:s";
    /** @var array */
    private static $supportTemplate = [
        '%W',
        '%L',
        '%M',
        '%T',
        '%t',
        '%Q',
        '%H',
        '%P',
        '%D',
        '%R',
        '%m',
        '%I',
        '%F',
        '%U',
        '%u',
        '%C',
        '%A'
    ];
    /** @var int */
    protected $isMicroTime = 3;
    /** @var bool */
    protected $useBasename = true;

    /**
     * LoggerConfig constructor.
     * @param array $target
     * @param array $template
     * @param array $configs
     */
    public function __construct(
        array $target,
        array $configs = [],
        array $template = ['%T', '%L', '%R', '%m', '%I', '%Q', '%F', '%U', '%A', '%M']
    ) {
        foreach ($template as $tmp) {
            if (!in_array($tmp, self::$supportTemplate)) {
                throw new InvalidArgumentException("$tmp not supported!");
            }
        }
        $this->template = $template;
        parent::__construct($target, $configs);
    }

    /**
     * @return string
     */
    public function getDatetimeFormat(): string
    {
        return $this->datetime_format;
    }

    /**
     * @param string $format
     * @return bool
     */
    public function setDatetimeFormat(string $format): bool
    {
        if (date($format, time()) !== false) {
            $this->datetime_format = $format;
            return true;
        }
        return false;
    }

    /**
     * 获得当前日志buffer中的内容.
     *
     * @return array
     */
    public function getBuffer(): array
    {
        return $this->buffer;
    }

    /**
     * @param string $level
     * @param string $message
     * @param array $context
     * @throws Exception
     */
    public function log(string $level, string $message, array $context = []): void
    {
        $template = $this->getUserTemplate();
        $msg = [];
        $module = ArrayHelper::getValue($context, 'module');
        foreach ($this->template as $tmp) {
            switch ($tmp) {
                case '%W':
                    $msg[] = ArrayHelper::getValue($template, $tmp, -1);
                    break;
                case '%L':
                    $msg[] = $level;
                    break;
                case '%M':
                    $msg[] = str_replace($this->split, ' ', empty($context) ? $message : strtr($message, $context));
                    break;
                case '%T':
                case '%t':
                    if ($this->isMicroTime > 0) {
                        $micsec = $this->isMicroTime > 3 ? 3 : $this->isMicroTime;
                        $mtimestamp = sprintf("%.{$micsec}f", microtime(true)); // 带毫秒的时间戳
                        $timestamp = floor(/** @scrutinizer ignore-type */ $mtimestamp); // 时间戳
                        $milliseconds = round(($mtimestamp - $timestamp) * 1000); // 毫秒
                    } else {
                        $timestamp = time();
                        $milliseconds = 0;
                    }
                    if ($tmp === '%T') {
                        $msg[] = date($this->datetime_format, (int)$timestamp) . '.' . (int)$milliseconds;
                    } else {
                        $msg[] = date($this->datetime_format, (int)$timestamp);
                    }
                    break;
                case '%Q':
                    $msg[] = ArrayHelper::getValue($template, $tmp, uniqid());
                    break;
                case '%H':
                    $msg[] = ArrayHelper::getValue($template, $tmp, $_SERVER['HOSTNAME']);
                    break;
                case '%P':
                    $msg[] = ArrayHelper::getValue($template, $tmp, getmypid());
                    break;
                case '%D':
                    $msg[] = ArrayHelper::getValue($template, $tmp, 'cli');
                    break;
                case '%R':
                    $msg[] = ArrayHelper::getValue($template, $tmp, $_SERVER['SCRIPT_NAME']);
                    break;
                case '%m':
                    $method = ArrayHelper::getValue($template, $tmp);
                    $msg[] = $method ? strtoupper($method) : $_SERVER['SHELL'];
                    break;
                case '%I':
                    $msg[] = ArrayHelper::getValue($template, $tmp, 'local');
                    break;
                case '%F':
                case '%C':
                    $trace = Co::getBackTrace(Co::getCid(), /** @scrutinizer ignore-type */ DEBUG_BACKTRACE_IGNORE_ARGS,
class A
{
    function getObject()
    {
        return null;
    }

}

$a = new A();
if ($a->getObject()) {
                        $this->recall_depth + 2);
                    if ($tmp === '%F') {
                        $trace = $trace[$this->recall_depth];
                        $msg[] = $this->useBasename ? basename($trace['file']) . ':' . $trace['line'] : $trace['file'] . ':' . $trace['line'];
                    } else {
                        $trace = $trace[$this->recall_depth + 1];
                        $msg[] = $trace['class'] . $trace['type'] . $trace['function'];
                    }
                    break;
                case '%U':
                    $msg[] = memory_get_usage();
                    break;
                case '%u':
                    $msg[] = memory_get_peak_usage();
                    break;
                case '%A':
                    $customerTemplate = ArrayHelper::getValue($context, 'template',
                            []) ?? ArrayHelper::getValue($template, $tmp,
                            []);
                    switch ($this->customerType) {
                        case AbstractConfig::TYPE_JSON:
                            $msg[] = json_encode($customerTemplate, JSON_UNESCAPED_UNICODE);
                            break;
                        case AbstractConfig::TYPE_FIELD:
                        default:
                            $msg[] = implode($this->split, $customerTemplate);
                            $msg[] = implode($this->split, /** @scrutinizer ignore-type */ $customerTemplate);
                    }
                    break;
            }
        }
        $color = ArrayHelper::getValue($template, '%c');
        $color && $msg['%c'] = $color;
        $key = $this->appName . ($module ? '_' . $module : '');
        $this->buffer[$key][] = $msg;
        $this->flush();
    }

    /**
     * @param bool $flush
     * @throws Exception
     */
    public function flush(bool $flush = false): void
    {
        if (!empty($this->buffer) && $flush || ($this->bufferSize !== 0 && $this->bufferSize <= count($this->buffer))) {

            foreach ($this->targetList as $index => $target) {
                rgo(function () use ($target, $flush) {

                    $target->export($this->buffer);
                });
            }
            array_splice($this->buffer, 0);
        }
    }
}
SeasX / seas-logger

Pull Request — master (#12)

LoggerConfig::flush() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like
