Debug::getCaller() - Code Metrics - Inspection of "调整：trace定位控制" - dxkite/suda - Measure and Improve Code Quality continuously with Scrutinizer

Test Failed

Push — dev ( 3785bc...ce443c )

by 世昌

created 2020-03-01 05:02 UTC

Debug::getCaller() A

↳ Parent: Debug

Complexity

Conditions	3
Paths	2

Size

Total Lines	9
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	3
eloc	6
nc	2
nop	1
dl	0
loc	9
rs	10
c	1
b	0
f	0

<?php

namespace suda\framework\debug;

use Psr\Log\LoggerAwareInterface;
use Psr\Log\LoggerAwareTrait;
use Psr\Log\LoggerInterface;
use Psr\Log\LoggerTrait;
use Psr\Log\LogLevel;
use suda\framework\debug\attach\DumpTrait;
use suda\framework\debug\attach\AttachTrait;
use suda\framework\debug\attach\DumpInterface;
use suda\framework\debug\attach\AttachInterface;

class Debug implements LoggerInterface, LoggerAwareInterface, DumpInterface, AttachInterface, ConfigInterface
{
    use LoggerTrait, LoggerAwareTrait, DumpTrait, AttachTrait, ConfigTrait;

    /**
     * @var array
     */
    protected static $levels = ['debug', 'info', 'notice', 'warning', 'error', 'critical', 'alert', 'emergency'];

    /**
     * 忽略堆栈
     *
     * @var array
     */
    protected $ignoreTraces = [__DIR__];

    /**
     * 时间记录
     *
     * @var array
     */
    protected $timeRecord;

    /**
     * @var array
     */
    protected $timing;

    /**
     * @param mixed $level
     * @param string $message
     * @param array $context
     */
    public function log($level, $message, array $context = [])
    {
        $attribute = $this->getAttribute();

        $caller = $this->getCaller($context);

        [$attach, $replace] = $this->analyse($message, $context);
        $attribute            = array_merge($attribute, $attach);
        $attribute['message'] = strtr($message, $replace);
        $attribute['level']   = $level;
        $attribute['file']    = $caller['file'];
        $attribute['line']    = $caller['line'];

        $attribute = $this->assignAttributes($attribute);
        $this->logger->log($level, $this->interpolate($this->getConfig('log-format'), $attach, $attribute), []);
    }

    private function getCaller(array $context)
    {
        if (array_key_exists('exception', $context) && $context['exception'] instanceof \Throwable) {
            $backtrace = $context['exception']->getTrace();
        } else {
            $backtrace = debug_backtrace();
        }
        $caller = new Caller($backtrace, $this->getIgnoreTraces());
        return $caller->getCallerTrace();
    }

    /**
     * @param string $message
     * @param array $context
     * @return array
     */
    public function analyse(string $message, array $context)
    {
        $replace = [];
        $attach  = [];
        foreach ($context as $key => $val) {
            $replaceKey = '{' . $key . '}';
            if ($this->canBeStringValue($val) && strpos($message, $replaceKey) !== false) {
                $replace['{' . $key . '}'] = $val;
            } else {
                $attach[$key] = $val;
            }
        }
        return [$attach, $replace];
    }

    /**
     * 设置忽略前缀
     *
     * @return array
     */
    public function getIgnoreTraces(): array
    {
        return $this->ignoreTraces;
    }

    /**
     * @return array
     */
    public function getDefaultConfig(): array
    {
        return [
            'log-format'   => '%time-format% - %memory-format% [%level%] %file%:%line% %message%',
            'start-time'   => 0,
            'start-memory' => 0,
        ];
    }

    /**
     * @param $val
     * @return bool
     */
    protected function canBeStringValue($val): bool
    {
        return !is_array($val) && (!is_object($val) || method_exists($val, '__toString'));
    }

    /**
     * @param array $attribute
     * @return array
     */
    protected function assignAttributes(array $attribute): array
    {
        $attribute['current-time']  = number_format(microtime(true), 4, '.', '');
        $time                       = microtime(true) - $this->getConfig('start-time');
        $memory                     = memory_get_usage() - $this->getConfig('start-memory');
        $attribute['time-format']   = number_format($time, 10, '.', '');
        $attribute['memory-format'] = $this->formatBytes($memory, 2);
        $attribute['memory']        = $memory;
        return $attribute;
    }

    /**
     * @param int $bytes
     * @param int $precision
     * @return string
     */
    public static function formatBytes(int $bytes, int $precision = 0)
    {
        $human = ['B', 'KB', 'MB', 'GB', 'TB'];
        $bytes = max($bytes, 0);
        $pow   = floor(($bytes ? log($bytes) : 0) / log(1024));
        $pos   = min($pow, count($human) - 1);
        $bytes /= (1 << (10 * $pos));
        return round($bytes, $precision) . ' ' . $human[$pos];
    }

    /**
     * @param string $name
     * @param string $type
     */
    public function time(string $name, string $type = LogLevel::INFO)
    {
        $this->timeRecord[$name] = ['time' => microtime(true), 'level' => $type];
    }

    /**
     * @param string $name
     * @return float
     */
    public function timeEnd(string $name)
    {
        if (array_key_exists($name, $this->timeRecord)) {
            $pass = microtime(true) - $this->timeRecord[$name]['time'];
            $this->log(
                $this->timeRecord[$name]['level'],
                sprintf("process %s cost %ss", $name, number_format($pass, 5, '.', ''))
            );
            unset($this->timeRecord[$name]);
            return $pass;
        }
        return 0;
    }

    /**
     * @param string $name
     * @param float $time
     * @param string $description
     */
    public function recordTiming(string $name, float $time, string $description = '')
    {
        if (array_key_exists($name, $this->timing)) {
            $this->timing[$name]['time'] += $time;
        } else {
            $this->timing[$name]['time'] = $time;
        }
        $this->timing[$name]['description'] = $description;
    }

    /**
     * @return array
     */
    public function getTiming(): array
    {
        return $this->timing;
    }

    /**
     * @param array $ignoreTraces
     * @return $this
     */
    public function setIgnoreTraces(array $ignoreTraces)
    {
        $this->ignoreTraces = $ignoreTraces;
        return $this;
    }


    /**
     * 比较优先级
     *
     * @param string $a
     * @param string $b
     * @return integer
     */
    public static function compare(string $a, string $b): int
    {
        $indexA = array_search($a, static::$levels);
        $indexB = array_search($b, static::$levels);
        return $indexA - $indexB;
    }

    /**
     * 添加忽略路径
     * @param string $path
     * @return $this
     */
    public function addIgnorePath(string $path)
    {
        $this->ignoreTraces[] = $path;
        return $this;
    }
}


1			<?php
2
3			namespace suda\framework\debug;
4
5			use Psr\Log\LoggerAwareInterface;
6			use Psr\Log\LoggerAwareTrait;
7			use Psr\Log\LoggerInterface;
8			use Psr\Log\LoggerTrait;
9			use Psr\Log\LogLevel;
10			use suda\framework\debug\attach\DumpTrait;
11			use suda\framework\debug\attach\AttachTrait;
12			use suda\framework\debug\attach\DumpInterface;
13			use suda\framework\debug\attach\AttachInterface;
14
15			class Debug implements LoggerInterface, LoggerAwareInterface, DumpInterface, AttachInterface, ConfigInterface
16			{
17			use LoggerTrait, LoggerAwareTrait, DumpTrait, AttachTrait, ConfigTrait;
18
19			/**
20			* @var array
21			*/
22			protected static $levels = ['debug', 'info', 'notice', 'warning', 'error', 'critical', 'alert', 'emergency'];
23
24			/**
25			* 忽略堆栈
26			*
27			* @var array
28			*/
29			protected $ignoreTraces = [__DIR__];
30
31			/**
32			* 时间记录
33			*
34			* @var array
35			*/
36			protected $timeRecord;
37
38			/**
39			* @var array
40			*/
41			protected $timing;
42
43			/**
44			* @param mixed $level
45			* @param string $message
46			* @param array $context
47			*/
48			public function log($level, $message, array $context = [])
49			{
50			$attribute = $this->getAttribute();
51
52			$caller = $this->getCaller($context);
53
54			[$attach, $replace] = $this->analyse($message, $context);
55			$attribute = array_merge($attribute, $attach);
56			$attribute['message'] = strtr($message, $replace);
57			$attribute['level'] = $level;
58			$attribute['file'] = $caller['file'];
59			$attribute['line'] = $caller['line'];
60
61			$attribute = $this->assignAttributes($attribute);
62			$this->logger->log($level, $this->interpolate($this->getConfig('log-format'), $attach, $attribute), []);
63			}
64
65			private function getCaller(array $context)
66			{
67			if (array_key_exists('exception', $context) && $context['exception'] instanceof \Throwable) {
68			$backtrace = $context['exception']->getTrace();
69			} else {
70			$backtrace = debug_backtrace();
71			}
72			$caller = new Caller($backtrace, $this->getIgnoreTraces());
73			return $caller->getCallerTrace();
74			}
75
76			/**
77			* @param string $message
78			* @param array $context
79			* @return array
80			*/
81			public function analyse(string $message, array $context)
82			{
83			$replace = [];
84			$attach = [];
85			foreach ($context as $key => $val) {
86			$replaceKey = '{' . $key . '}';
87			if ($this->canBeStringValue($val) && strpos($message, $replaceKey) !== false) {
88			$replace['{' . $key . '}'] = $val;
89			} else {
90			$attach[$key] = $val;
91			}
92			}
93			return [$attach, $replace];
94			}
95
96			/**
97			* 设置忽略前缀
98			*
99			* @return array
100			*/
101			public function getIgnoreTraces(): array
102			{
103			return $this->ignoreTraces;
104			}
105
106			/**
107			* @return array
108			*/
109			public function getDefaultConfig(): array
110			{
111			return [
112			'log-format' => '%time-format% - %memory-format% [%level%] %file%:%line% %message%',
113			'start-time' => 0,
114			'start-memory' => 0,
115			];
116			}
117
118			/**
119			* @param $val
120			* @return bool
121			*/
122			protected function canBeStringValue($val): bool
123			{
124			return !is_array($val) && (!is_object($val) \|\| method_exists($val, '__toString'));
125			}
126
127			/**
128			* @param array $attribute
129			* @return array
130			*/
131			protected function assignAttributes(array $attribute): array
132			{
133			$attribute['current-time'] = number_format(microtime(true), 4, '.', '');
134			$time = microtime(true) - $this->getConfig('start-time');
135			$memory = memory_get_usage() - $this->getConfig('start-memory');
136			$attribute['time-format'] = number_format($time, 10, '.', '');
137			$attribute['memory-format'] = $this->formatBytes($memory, 2);
138			$attribute['memory'] = $memory;
139			return $attribute;
140			}
141
142			/**
143			* @param int $bytes
144			* @param int $precision
145			* @return string
146			*/
147			public static function formatBytes(int $bytes, int $precision = 0)
148			{
149			$human = ['B', 'KB', 'MB', 'GB', 'TB'];
150			$bytes = max($bytes, 0);
151			$pow = floor(($bytes ? log($bytes) : 0) / log(1024));
152			$pos = min($pow, count($human) - 1);
153			$bytes /= (1 << (10 * $pos));
154			return round($bytes, $precision) . ' ' . $human[$pos];
155			}
156
157			/**
158			* @param string $name
159			* @param string $type
160			*/
161			public function time(string $name, string $type = LogLevel::INFO)
162			{
163			$this->timeRecord[$name] = ['time' => microtime(true), 'level' => $type];
164			}
165
166			/**
167			* @param string $name
168			* @return float
169			*/
170			public function timeEnd(string $name)
171			{
172			if (array_key_exists($name, $this->timeRecord)) {
173			$pass = microtime(true) - $this->timeRecord[$name]['time'];
174			$this->log(
175			$this->timeRecord[$name]['level'],
176			sprintf("process %s cost %ss", $name, number_format($pass, 5, '.', ''))
177			);
178			unset($this->timeRecord[$name]);
179			return $pass;
180			}
181			return 0;
182			}
183
184			/**
185			* @param string $name
186			* @param float $time
187			* @param string $description
188			*/
189			public function recordTiming(string $name, float $time, string $description = '')
190			{
191			if (array_key_exists($name, $this->timing)) {
192			$this->timing[$name]['time'] += $time;
193			} else {
194			$this->timing[$name]['time'] = $time;
195			}
196			$this->timing[$name]['description'] = $description;
197			}
198
199			/**
200			* @return array
201			*/
202			public function getTiming(): array
203			{
204			return $this->timing;
205			}
206
207			/**
208			* @param array $ignoreTraces
209			* @return $this
210			*/
211			public function setIgnoreTraces(array $ignoreTraces)
212			{
213			$this->ignoreTraces = $ignoreTraces;
214			return $this;
215			}
216
217
218			/**
219			* 比较优先级
220			*
221			* @param string $a
222			* @param string $b
223			* @return integer
224			*/
225			public static function compare(string $a, string $b): int
226			{
227			$indexA = array_search($a, static::$levels);
228			$indexB = array_search($b, static::$levels);
229			return $indexA - $indexB;
230			}
231
232			/**
233			* 添加忽略路径
234			* @param string $path
235			* @return $this
236			*/
237			public function addIgnorePath(string $path)
238			{
239			$this->ignoreTraces[] = $path;
240			return $this;
241			}
242			}
243

dxkite / suda

Push — dev ( 3785bc...ce443c )

Debug::getCaller() A

Complexity

Size

Duplication

Importance

Duplication Side-by-Side

Filter issues like