midcom_debug::print_r() - Code Metrics - Inspection of "Port to monolog" - flack/openpsa - Measure and Improve Code Quality continuously with Scrutinizer

Passed

Push — master ( f5d0a9...f61cc5 )

by Andreas

created 2020-05-04 14:31 UTC

midcom_debug::print_r() A

↳ Parent: midcom_debug

Complexity

Conditions	2
Paths	2

Size

Total Lines	12
Code Lines	6

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	6
CRAP Score	2.0116

Importance

Changes	1
Bugs	0	Features	0

Metric	Value
cc	2
eloc	6
c	1
b	0
f	0
nc	2
nop	3
dl	0
loc	12
ccs	6
cts	7
cp	0.8571
crap	2.0116
rs	10

<?php
/**
 * @package midcom
 * @author The Midgard Project, http://www.midgard-project.org
 * @copyright The Midgard Project, http://www.midgard-project.org
 * @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public License
 */

use Symfony\Component\VarDumper\Cloner\VarCloner;
use Symfony\Component\VarDumper\Dumper\CliDumper;
use Monolog\Logger;

/**
 * This is a debugger class.
 *
 * Helps in debugging your code. It lets you decide which messages are logged into the
 * logfile by setting loglevels for the debugger and for each message.
 *
 * There are five loglevel constants you can use when setting the loglevel or when
 * logging messages:
 *
 * - MIDCOM_LOG_DEBUG
 * - MIDCOM_LOG_INFO
 * - MIDCOM_LOG_WARN
 * - MIDCOM_LOG_ERROR
 * - MIDCOM_LOG_CRIT
 *
 * @package midcom
 */
class midcom_debug
{
    /**
     * Current loglevel
     *
     * @var int
     */
    private $_loglevel;

    /**
     * Map to Monolog levels
     *
     * @var array
     */
    private $level_map = [
        MIDCOM_LOG_DEBUG => Logger::DEBUG,
        MIDCOM_LOG_INFO  => Logger::INFO,
        MIDCOM_LOG_WARN  => Logger::WARNING,
        MIDCOM_LOG_ERROR => Logger::ERROR,
        MIDCOM_LOG_CRIT  => Logger::CRITICAL
    ];

    /**
     * @var Logger
     */
    private $logger;

    /**
     * Standard constructor
     */
    public function __construct(Logger $logger)
    {
        $this->logger = $logger;
        $this->_loglevel = midcom::get()->config->get('log_level');
    }

    /**
     * Set log level
     *
     * @param int $loglevel        New log level
     */
    public function set_loglevel($loglevel)
    {
        $this->_loglevel = $loglevel;
    }

    /**
     * Get log level
     */
    public function get_loglevel() : int
    {
        return $this->_loglevel;
    }

    public function log_php_error($loglevel)
    {
        $error = error_get_last();
        if (!empty($error['message'])) {
            $this->log('Last PHP error was: ' . $error['message'], $loglevel);
        }
    }

    /**
     * Log a message
     *
     * @param string $message    The message to be logged
     * @param int $loglevel        The log level
     */
    public function log($message, $loglevel = MIDCOM_LOG_DEBUG)
    {
        if (!$this->check_level($loglevel)) {
            return;
        }

        $context = [
            'caller' => $this->_get_caller()
        ];
        if (function_exists('xdebug_memory_usage')) {
            static $lastmem = 0;
            $context['time'] = xdebug_time_index();
            $context['curmem'] = xdebug_memory_usage();
            $context['delta'] = $context['curmem'] - $lastmem;
            $lastmem = $context['curmem'];
        }

        $level = $this->level_map[$loglevel] ?? $loglevel;
        $this->logger->addRecord($level, trim($message), $context);
    }

    private function check_level(int $loglevel) : bool
    {
        return $this->_loglevel >= $loglevel;
    }

    private function _get_caller() : string
    {
        $return = '';
        $bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);

        while ($bt) {

            $caller = array_shift($bt);
            if (   !array_key_exists('class', $caller)
                || $caller['class'] != midcom_debug::class) {
                if (   !array_key_exists('function', $bt[0])
                    || $bt[0]['function'] != 'require') {
                    $caller = array_shift($bt);
                }

                break;
            }
        }

        if (array_key_exists('class', $caller)) {

            $return .= $caller['class'] . '::';
        }
        if (   array_key_exists('function', $caller)
            && substr($caller['function'], 0, 6) != 'debug_') {
            $return .= $caller['function'];
        } else {
            $return .= $caller['file'] . ' (' . $caller['line']. ')';
        }
        return $return;
    }

    /**
     * Dump a variable
     *
     * @param string $message    The message to be logged
     * @param mixed $variable    The variable to be logged
     * @param int $loglevel        The log level
     */
    public function print_r($message, $variable, $loglevel = MIDCOM_LOG_DEBUG)
    {
        if (!$this->check_level($loglevel)) {
            return;
        }

        $cloner = new VarCloner();
        $dumper = new CliDumper();

        $varstring = $dumper->dump($cloner->cloneVar($variable), true);

        $this->log(trim($message) . ' ' . $varstring, $loglevel);
    }

    /**
     * Dump stack trace, only working when XDebug is present.
     *
     * @param string $message    The message to be logged
     * @param int $loglevel        The log level
     * @link http://www.xdebug.org/ xdebug.org
     */
    public function print_function_stack($message, $loglevel = MIDCOM_LOG_DEBUG)
    {
        if (!$this->check_level($loglevel)) {
            return;
        }

        if (function_exists('xdebug_get_function_stack')) {
            $stack = array_reverse(xdebug_get_function_stack());
        } else {
            $stack = debug_backtrace(0);
        }
        //the last two levels are already inside the debugging system, so skip those
        array_shift($stack);
        array_shift($stack);

        $stacktrace = "";
        foreach ($stack as $number => $frame) {
            $stacktrace .= $number + 1;
            if (isset($frame['file'])) {
                $stacktrace .= ": {$frame['file']}:{$frame['line']} ";
            }
            if (array_key_exists('class', $frame)) {
                if (!array_key_exists('function', $frame)) {
                    // workaround for what is most likely a bug in xdebug 2.4.rc3 and/or PHP 7.0.3
                    continue;
                }

                $stacktrace .= "{$frame['class']}::{$frame['function']}";
            } elseif (array_key_exists('function', $frame)) {
                $stacktrace .= $frame['function'];
            } else {
                $stacktrace .= 'require, include or eval';
            }
            $stacktrace .= "\n";
        }

        $this->log(trim($message) . "\n{$stacktrace}", $loglevel);
    }

    /**
     * Dump a variable's type
     *
     * @param string $message    The message to be logged
     * @param mixed $variable    The variable of which the type should be logged
     * @param int $loglevel        The log level
     */
    public function print_type($message, $variable, $loglevel = MIDCOM_LOG_DEBUG)
    {
        if (!$this->check_level($loglevel)) {
            return;
        }

        $type = gettype($variable);
        if ($type == "object") {
            $type .= ": " . get_class($variable);
        }

        $this->log(trim($message) . "\nVariable Type: $type", $loglevel);
    }

    /**
     * Dump the current memory usage and the delta to the last call of this function.
     * Useful for tracking memory leaks.
     *
     * Format will be:
     *
     * $curmem (delta $delta): $message
     *
     * @param string $message    The message to be logged
     * @param int $loglevel        The log level
     */
    public function print_dump_mem($message, $loglevel)
    {
        if (!$this->check_level($loglevel)) {
            return;
        }

        static $lastmem = 0;
        $curmem = memory_get_usage();
        $delta = $curmem - $lastmem;
        $lastmem = $curmem;

        $curmem = str_pad(number_format($curmem), 10, " ", STR_PAD_LEFT);
        $delta = str_pad(number_format($delta), 10, " ", STR_PAD_LEFT);
        $this->log("{$curmem} (delta {$delta}): {$message}", $loglevel);
    }
}


1		<?php
2		/**
3		* @package midcom
4		* @author The Midgard Project, http://www.midgard-project.org
5		* @copyright The Midgard Project, http://www.midgard-project.org
6		* @license http://www.gnu.org/licenses/lgpl.html GNU Lesser General Public License
7		*/
8
9		use Symfony\Component\VarDumper\Cloner\VarCloner;
10		use Symfony\Component\VarDumper\Dumper\CliDumper;
11		use Monolog\Logger;
12
13		/**
14		* This is a debugger class.
15		*
16		* Helps in debugging your code. It lets you decide which messages are logged into the
17		* logfile by setting loglevels for the debugger and for each message.
18		*
19		* There are five loglevel constants you can use when setting the loglevel or when
20		* logging messages:
21		*
22		* - MIDCOM_LOG_DEBUG
23		* - MIDCOM_LOG_INFO
24		* - MIDCOM_LOG_WARN
25		* - MIDCOM_LOG_ERROR
26		* - MIDCOM_LOG_CRIT
27		*
28		* @package midcom
29		*/
30		class midcom_debug
31		{
32		/**
33		* Current loglevel
34		*
35		* @var int
36		*/
37		private $_loglevel;
38
39		/**
40		* Map to Monolog levels
41		*
42		* @var array
43		*/
44		private $level_map = [
45		MIDCOM_LOG_DEBUG => Logger::DEBUG,
46		MIDCOM_LOG_INFO => Logger::INFO,
47		MIDCOM_LOG_WARN => Logger::WARNING,
48		MIDCOM_LOG_ERROR => Logger::ERROR,
49		MIDCOM_LOG_CRIT => Logger::CRITICAL
50		];
51
52		/**
53		* @var Logger
54		*/
55		private $logger;
56
57		/**
58		* Standard constructor
59		*/
60		public function __construct(Logger $logger)
61		{
62		$this->logger = $logger;
63		$this->_loglevel = midcom::get()->config->get('log_level');
64		}
65
66		/**
67		* Set log level
68		*
69		* @param int $loglevel New log level
70		*/
71		public function set_loglevel($loglevel)
72		{
73		$this->_loglevel = $loglevel;
74		}
75
76		/**
77		* Get log level
78		*/
79		public function get_loglevel() : int
80		{
81		return $this->_loglevel;
82		}
83
84		public function log_php_error($loglevel)
85		{
86		$error = error_get_last();
87		if (!empty($error['message'])) {
88		$this->log('Last PHP error was: ' . $error['message'], $loglevel);
89		}
90		}
91
92		/**
93		* Log a message
94		*
95		* @param string $message The message to be logged
96		* @param int $loglevel The log level
97		*/
98	737	public function log($message, $loglevel = MIDCOM_LOG_DEBUG)
99		{
100	737	if (!$this->check_level($loglevel)) {
101		return;
102		}
103
104		$context = [
105	737	'caller' => $this->_get_caller()
106		];
107	737	if (function_exists('xdebug_memory_usage')) {
108	737	static $lastmem = 0;
109	737	$context['time'] = xdebug_time_index();
110	737	$context['curmem'] = xdebug_memory_usage();
111	737	$context['delta'] = $context['curmem'] - $lastmem;
112	737	$lastmem = $context['curmem'];
113		}
114
115	737	$level = $this->level_map[$loglevel] ?? $loglevel;
116	737	$this->logger->addRecord($level, trim($message), $context);
117	737	}
118
119	737	private function check_level(int $loglevel) : bool
120		{
121	737	return $this->_loglevel >= $loglevel;
122		}
123
124	737	private function _get_caller() : string
125		{
126	737	$return = '';
127	737	$bt = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
128
129	737	while ($bt) {
		0 ignored issues – show Bug Best Practice introduced 2018-01-08 16:22 UTC by Report Bug Copy Issue Report The expression `$bt` of type `array` is implicitly converted to a boolean; are you sure this is intended? If so, consider using `! empty($expr)` instead to make it clear that you intend to check for an array without elements. This check marks implicit conversions of arrays to boolean values in a comparison. While in PHP an empty array is considered to be equal (but not identical) to false, this is not always apparent. Consider making the comparison explicit by using `empty(..)` or `! empty(...)` instead. Loading history...
130	737	$caller = array_shift($bt);
131	737	if ( !array_key_exists('class', $caller)
132	737	\|\| $caller['class'] != midcom_debug::class) {
133	737	if ( !array_key_exists('function', $bt[0])
134	737	\|\| $bt[0]['function'] != 'require') {
135	737	$caller = array_shift($bt);
136		}
137
138	737	break;
139		}
140		}
141
142	737	if (array_key_exists('class', $caller)) {
		0 ignored issues – show Comprehensibility Best Practice introduced 2018-01-08 16:22 UTC by Report Bug Copy Issue Report The variable `$caller` does not seem to be defined for all execution paths leading up to this point. Loading history...
143	737	$return .= $caller['class'] . '::';
144		}
145	737	if ( array_key_exists('function', $caller)
146	737	&& substr($caller['function'], 0, 6) != 'debug_') {
147	737	$return .= $caller['function'];
148		} else {
149		$return .= $caller['file'] . ' (' . $caller['line']. ')';
150		}
151	737	return $return;
152		}
153
154		/**
155		* Dump a variable
156		*
157		* @param string $message The message to be logged
158		* @param mixed $variable The variable to be logged
159		* @param int $loglevel The log level
160		*/
161	22	public function print_r($message, $variable, $loglevel = MIDCOM_LOG_DEBUG)
162		{
163	22	if (!$this->check_level($loglevel)) {
164		return;
165		}
166
167	22	$cloner = new VarCloner();
168	22	$dumper = new CliDumper();
169
170	22	$varstring = $dumper->dump($cloner->cloneVar($variable), true);
171
172	22	$this->log(trim($message) . ' ' . $varstring, $loglevel);
173	22	}
174
175		/**
176		* Dump stack trace, only working when XDebug is present.
177		*
178		* @param string $message The message to be logged
179		* @param int $loglevel The log level
180		* @link http://www.xdebug.org/ xdebug.org
181		*/
182	25	public function print_function_stack($message, $loglevel = MIDCOM_LOG_DEBUG)
183		{
184	25	if (!$this->check_level($loglevel)) {
185		return;
186		}
187
188	25	if (function_exists('xdebug_get_function_stack')) {
189	25	$stack = array_reverse(xdebug_get_function_stack());
190		} else {
191		$stack = debug_backtrace(0);
192		}
193		//the last two levels are already inside the debugging system, so skip those
194	25	array_shift($stack);
195	25	array_shift($stack);
196
197	25	$stacktrace = "";
198	25	foreach ($stack as $number => $frame) {
199	25	$stacktrace .= $number + 1;
200	25	if (isset($frame['file'])) {
201	25	$stacktrace .= ": {$frame['file']}:{$frame['line']} ";
202		}
203	25	if (array_key_exists('class', $frame)) {
204	25	if (!array_key_exists('function', $frame)) {
205		// workaround for what is most likely a bug in xdebug 2.4.rc3 and/or PHP 7.0.3
206		continue;
207		}
208
209	25	$stacktrace .= "{$frame['class']}::{$frame['function']}";
210	25	} elseif (array_key_exists('function', $frame)) {
211	25	$stacktrace .= $frame['function'];
212		} else {
213		$stacktrace .= 'require, include or eval';
214		}
215	25	$stacktrace .= "\n";
216		}
217
218	25	$this->log(trim($message) . "\n{$stacktrace}", $loglevel);
219	25	}
220
221		/**
222		* Dump a variable's type
223		*
224		* @param string $message The message to be logged
225		* @param mixed $variable The variable of which the type should be logged
226		* @param int $loglevel The log level
227		*/
228		public function print_type($message, $variable, $loglevel = MIDCOM_LOG_DEBUG)
229		{
230		if (!$this->check_level($loglevel)) {
231		return;
232		}
233
234		$type = gettype($variable);
235		if ($type == "object") {
236		$type .= ": " . get_class($variable);
237		}
238
239		$this->log(trim($message) . "\nVariable Type: $type", $loglevel);
240		}
241
242		/**
243		* Dump the current memory usage and the delta to the last call of this function.
244		* Useful for tracking memory leaks.
245		*
246		* Format will be:
247		*
248		* $curmem (delta $delta): $message
249		*
250		* @param string $message The message to be logged
251		* @param int $loglevel The log level
252		*/
253		public function print_dump_mem($message, $loglevel)
254		{
255		if (!$this->check_level($loglevel)) {
256		return;
257		}
258
259		static $lastmem = 0;
260		$curmem = memory_get_usage();
261		$delta = $curmem - $lastmem;
262		$lastmem = $curmem;
263
264		$curmem = str_pad(number_format($curmem), 10, " ", STR_PAD_LEFT);
265		$delta = str_pad(number_format($delta), 10, " ", STR_PAD_LEFT);
266		$this->log("{$curmem} (delta {$delta}): {$message}", $loglevel);
267		}
268		}
269

flack / openpsa

Push — master ( f5d0a9...f61cc5 )

midcom_debug::print_r() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like