ErrorHandler::codeToString() - Code Metrics - Inspection of "fixed some problems in plugin rollbar." - JuKu/JuKuCMS - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — master ( cdeef2...f03c61 )

by Justin

created 2018-08-21 23:01 UTC

ErrorHandler::codeToString() C

↳ Parent: ErrorHandler

Complexity

Conditions	16
Paths	16

Size

Total Lines	36
Code Lines	32

Duplication

Lines	0
Ratio	0 %

Importance

Changes

Metric	Value
cc	16
eloc	32
nc	16
nop	1
dl	0
loc	36
rs	5.5666
c	0
b	0
f	0

How to fix Complexity

<?php

/*
 * This file is part of the Monolog package.
 *
 * (c) Jordi Boggiano <[email protected]>
 *
 * For the full copyright and license information, please view the LICENSE
 * file that was distributed with this source code.
 */

namespace Monolog;

use Psr\Log\LoggerInterface;
use Psr\Log\LogLevel;
use Monolog\Handler\AbstractHandler;

/**
 * Monolog error handler
 *
 * A facility to enable logging of runtime errors, exceptions and fatal errors.
 *
 * Quick setup: <code>ErrorHandler::register($logger);</code>
 *
 * @author Jordi Boggiano <[email protected]>
 */
class ErrorHandler
{
    private $logger;

    private $previousExceptionHandler;
    private $uncaughtExceptionLevel;

    private $previousErrorHandler;
    private $errorLevelMap;
    private $handleOnlyReportedErrors;

    private $hasFatalErrorHandler;
    private $fatalLevel;
    private $reservedMemory;
    private static $fatalErrors = array(E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR);

    public function __construct(LoggerInterface $logger)
    {
        $this->logger = $logger;
    }

    /**
     * Registers a new ErrorHandler for a given Logger
     *
     * By default it will handle errors, exceptions and fatal errors
     *
     * @param  LoggerInterface $logger
     * @param  array|false     $errorLevelMap  an array of E_* constant to LogLevel::* constant mapping, or false to disable error handling
     * @param  int|false       $exceptionLevel a LogLevel::* constant, or false to disable exception handling
     * @param  int|false       $fatalLevel     a LogLevel::* constant, or false to disable fatal error handling
     * @return ErrorHandler
     */
    public static function register(LoggerInterface $logger, $errorLevelMap = array(), $exceptionLevel = null, $fatalLevel = null)
    {
        //Forces the autoloader to run for LogLevel. Fixes an autoload issue at compile-time on PHP5.3. See https://github.com/Seldaek/monolog/pull/929
        class_exists('\\Psr\\Log\\LogLevel', true);

        $handler = new static($logger);
        if ($errorLevelMap !== false) {
            $handler->registerErrorHandler($errorLevelMap);
        }
        if ($exceptionLevel !== false) {
            $handler->registerExceptionHandler($exceptionLevel);
        }
        if ($fatalLevel !== false) {
            $handler->registerFatalHandler($fatalLevel);
        }

        return $handler;
    }

    public function registerExceptionHandler($level = null, $callPrevious = true)
    {
        $prev = set_exception_handler(array($this, 'handleException'));
        $this->uncaughtExceptionLevel = $level;
        if ($callPrevious && $prev) {
            $this->previousExceptionHandler = $prev;
        }
    }

    public function registerErrorHandler(array $levelMap = array(), $callPrevious = true, $errorTypes = -1, $handleOnlyReportedErrors = true)
    {
        $prev = set_error_handler(array($this, 'handleError'), $errorTypes);
        $this->errorLevelMap = array_replace($this->defaultErrorLevelMap(), $levelMap);
        if ($callPrevious) {
            $this->previousErrorHandler = $prev ?: true;
        }

        $this->handleOnlyReportedErrors = $handleOnlyReportedErrors;
    }

    public function registerFatalHandler($level = null, $reservedMemorySize = 20)
    {
        register_shutdown_function(array($this, 'handleFatalError'));

        $this->reservedMemory = str_repeat(' ', 1024 * $reservedMemorySize);
        $this->fatalLevel = $level;
        $this->hasFatalErrorHandler = true;
    }

    protected function defaultErrorLevelMap()
    {
        return array(
            E_ERROR             => LogLevel::CRITICAL,
            E_WARNING           => LogLevel::WARNING,
            E_PARSE             => LogLevel::ALERT,
            E_NOTICE            => LogLevel::NOTICE,
            E_CORE_ERROR        => LogLevel::CRITICAL,
            E_CORE_WARNING      => LogLevel::WARNING,
            E_COMPILE_ERROR     => LogLevel::ALERT,
            E_COMPILE_WARNING   => LogLevel::WARNING,
            E_USER_ERROR        => LogLevel::ERROR,
            E_USER_WARNING      => LogLevel::WARNING,
            E_USER_NOTICE       => LogLevel::NOTICE,
            E_STRICT            => LogLevel::NOTICE,
            E_RECOVERABLE_ERROR => LogLevel::ERROR,
            E_DEPRECATED        => LogLevel::NOTICE,
            E_USER_DEPRECATED   => LogLevel::NOTICE,
        );
    }

    /**
     * @private
     */
    public function handleException($e)
    {
        $this->logger->log(
            $this->uncaughtExceptionLevel === null ? LogLevel::ERROR : $this->uncaughtExceptionLevel,
            sprintf('Uncaught Exception %s: "%s" at %s line %s', get_class($e), $e->getMessage(), $e->getFile(), $e->getLine()),
            array('exception' => $e)
        );

        if ($this->previousExceptionHandler) {
            call_user_func($this->previousExceptionHandler, $e);
        }

        exit(255);

    }

    /**
     * @private
     */
    public function handleError($code, $message, $file = '', $line = 0, $context = array())
    {
        if ($this->handleOnlyReportedErrors && !(error_reporting() & $code)) {
            return;
        }

        // fatal error codes are ignored if a fatal error handler is present as well to avoid duplicate log entries
        if (!$this->hasFatalErrorHandler || !in_array($code, self::$fatalErrors, true)) {
            $level = isset($this->errorLevelMap[$code]) ? $this->errorLevelMap[$code] : LogLevel::CRITICAL;
            $this->logger->log($level, self::codeToString($code).': '.$message, array('code' => $code, 'message' => $message, 'file' => $file, 'line' => $line));
        }

        if ($this->previousErrorHandler === true) {
            return false;
        } elseif ($this->previousErrorHandler) {
            return call_user_func($this->previousErrorHandler, $code, $message, $file, $line, $context);
        }
    }

    /**
     * @private
     */
    public function handleFatalError()
    {
        $this->reservedMemory = null;

        $lastError = error_get_last();
        if ($lastError && in_array($lastError['type'], self::$fatalErrors, true)) {

            $this->logger->log(
                $this->fatalLevel === null ? LogLevel::ALERT : $this->fatalLevel,
                'Fatal Error ('.self::codeToString($lastError['type']).'): '.$lastError['message'],
                array('code' => $lastError['type'], 'message' => $lastError['message'], 'file' => $lastError['file'], 'line' => $lastError['line'])
            );

            if ($this->logger instanceof Logger) {
                foreach ($this->logger->getHandlers() as $handler) {
                    if ($handler instanceof AbstractHandler) {
                        $handler->close();
                    }
                }
            }
        }
    }

    private static function codeToString($code)
    {
        switch ($code) {
            case E_ERROR:
                return 'E_ERROR';
            case E_WARNING:
                return 'E_WARNING';
            case E_PARSE:
                return 'E_PARSE';
            case E_NOTICE:
                return 'E_NOTICE';
            case E_CORE_ERROR:
                return 'E_CORE_ERROR';
            case E_CORE_WARNING:
                return 'E_CORE_WARNING';
            case E_COMPILE_ERROR:
                return 'E_COMPILE_ERROR';
            case E_COMPILE_WARNING:
                return 'E_COMPILE_WARNING';
            case E_USER_ERROR:
                return 'E_USER_ERROR';
            case E_USER_WARNING:
                return 'E_USER_WARNING';
            case E_USER_NOTICE:
                return 'E_USER_NOTICE';
            case E_STRICT:
                return 'E_STRICT';
            case E_RECOVERABLE_ERROR:
                return 'E_RECOVERABLE_ERROR';
            case E_DEPRECATED:
                return 'E_DEPRECATED';
            case E_USER_DEPRECATED:
                return 'E_USER_DEPRECATED';
        }

        return 'Unknown PHP error';
    }
}


1			<?php
2
3			/*
4			* This file is part of the Monolog package.
5			*
6			* (c) Jordi Boggiano <[email protected]>
7			*
8			* For the full copyright and license information, please view the LICENSE
9			* file that was distributed with this source code.
10			*/
11
12			namespace Monolog;
13
14			use Psr\Log\LoggerInterface;
15			use Psr\Log\LogLevel;
16			use Monolog\Handler\AbstractHandler;
17
18			/**
19			* Monolog error handler
20			*
21			* A facility to enable logging of runtime errors, exceptions and fatal errors.
22			*
23			* Quick setup: <code>ErrorHandler::register($logger);</code>
24			*
25			* @author Jordi Boggiano <[email protected]>
26			*/
27			class ErrorHandler
28			{
29			private $logger;
30
31			private $previousExceptionHandler;
32			private $uncaughtExceptionLevel;
33
34			private $previousErrorHandler;
35			private $errorLevelMap;
36			private $handleOnlyReportedErrors;
37
38			private $hasFatalErrorHandler;
39			private $fatalLevel;
40			private $reservedMemory;
41			private static $fatalErrors = array(E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR);
42
43			public function __construct(LoggerInterface $logger)
44			{
45			$this->logger = $logger;
46			}
47
48			/**
49			* Registers a new ErrorHandler for a given Logger
50			*
51			* By default it will handle errors, exceptions and fatal errors
52			*
53			* @param LoggerInterface $logger
54			* @param array\|false $errorLevelMap an array of E_* constant to LogLevel::* constant mapping, or false to disable error handling
55			* @param int\|false $exceptionLevel a LogLevel::* constant, or false to disable exception handling
56			* @param int\|false $fatalLevel a LogLevel::* constant, or false to disable fatal error handling
57			* @return ErrorHandler
58			*/
59			public static function register(LoggerInterface $logger, $errorLevelMap = array(), $exceptionLevel = null, $fatalLevel = null)
60			{
61			//Forces the autoloader to run for LogLevel. Fixes an autoload issue at compile-time on PHP5.3. See https://github.com/Seldaek/monolog/pull/929
62			class_exists('\\Psr\\Log\\LogLevel', true);
63
64			$handler = new static($logger);
65			if ($errorLevelMap !== false) {
66			$handler->registerErrorHandler($errorLevelMap);
67			}
68			if ($exceptionLevel !== false) {
69			$handler->registerExceptionHandler($exceptionLevel);
70			}
71			if ($fatalLevel !== false) {
72			$handler->registerFatalHandler($fatalLevel);
73			}
74
75			return $handler;
76			}
77
78			public function registerExceptionHandler($level = null, $callPrevious = true)
79			{
80			$prev = set_exception_handler(array($this, 'handleException'));
81			$this->uncaughtExceptionLevel = $level;
82			if ($callPrevious && $prev) {
83			$this->previousExceptionHandler = $prev;
84			}
85			}
86
87			public function registerErrorHandler(array $levelMap = array(), $callPrevious = true, $errorTypes = -1, $handleOnlyReportedErrors = true)
88			{
89			$prev = set_error_handler(array($this, 'handleError'), $errorTypes);
90			$this->errorLevelMap = array_replace($this->defaultErrorLevelMap(), $levelMap);
91			if ($callPrevious) {
92			$this->previousErrorHandler = $prev ?: true;
93			}
94
95			$this->handleOnlyReportedErrors = $handleOnlyReportedErrors;
96			}
97
98			public function registerFatalHandler($level = null, $reservedMemorySize = 20)
99			{
100			register_shutdown_function(array($this, 'handleFatalError'));
101
102			$this->reservedMemory = str_repeat(' ', 1024 * $reservedMemorySize);
103			$this->fatalLevel = $level;
104			$this->hasFatalErrorHandler = true;
105			}
106
107			protected function defaultErrorLevelMap()
108			{
109			return array(
110			E_ERROR => LogLevel::CRITICAL,
111			E_WARNING => LogLevel::WARNING,
112			E_PARSE => LogLevel::ALERT,
113			E_NOTICE => LogLevel::NOTICE,
114			E_CORE_ERROR => LogLevel::CRITICAL,
115			E_CORE_WARNING => LogLevel::WARNING,
116			E_COMPILE_ERROR => LogLevel::ALERT,
117			E_COMPILE_WARNING => LogLevel::WARNING,
118			E_USER_ERROR => LogLevel::ERROR,
119			E_USER_WARNING => LogLevel::WARNING,
120			E_USER_NOTICE => LogLevel::NOTICE,
121			E_STRICT => LogLevel::NOTICE,
122			E_RECOVERABLE_ERROR => LogLevel::ERROR,
123			E_DEPRECATED => LogLevel::NOTICE,
124			E_USER_DEPRECATED => LogLevel::NOTICE,
125			);
126			}
127
128			/**
129			* @private
130			*/
131			public function handleException($e)
132			{
133			$this->logger->log(
134			$this->uncaughtExceptionLevel === null ? LogLevel::ERROR : $this->uncaughtExceptionLevel,
135			sprintf('Uncaught Exception %s: "%s" at %s line %s', get_class($e), $e->getMessage(), $e->getFile(), $e->getLine()),
136			array('exception' => $e)
137			);
138
139			if ($this->previousExceptionHandler) {
140			call_user_func($this->previousExceptionHandler, $e);
141			}
142
143			exit(255);
			0 ignored issues – show Best Practice introduced 2018-08-21 23:04 UTC by Report Bug Copy Issue Report Using `exit` here is not recommended. In general, usage of exit should be done with care and only when running in a scripting context like a CLI script. Loading history...
144			}
145
146			/**
147			* @private
148			*/
149			public function handleError($code, $message, $file = '', $line = 0, $context = array())
150			{
151			if ($this->handleOnlyReportedErrors && !(error_reporting() & $code)) {
152			return;
153			}
154
155			// fatal error codes are ignored if a fatal error handler is present as well to avoid duplicate log entries
156			if (!$this->hasFatalErrorHandler \|\| !in_array($code, self::$fatalErrors, true)) {
157			$level = isset($this->errorLevelMap[$code]) ? $this->errorLevelMap[$code] : LogLevel::CRITICAL;
158			$this->logger->log($level, self::codeToString($code).': '.$message, array('code' => $code, 'message' => $message, 'file' => $file, 'line' => $line));
159			}
160
161			if ($this->previousErrorHandler === true) {
162			return false;
163			} elseif ($this->previousErrorHandler) {
164			return call_user_func($this->previousErrorHandler, $code, $message, $file, $line, $context);
165			}
166			}
167
168			/**
169			* @private
170			*/
171			public function handleFatalError()
172			{
173			$this->reservedMemory = null;
174
175			$lastError = error_get_last();
176			if ($lastError && in_array($lastError['type'], self::$fatalErrors, true)) {
			0 ignored issues – show Bug Best Practice introduced 2018-08-21 23:04 UTC by Report Bug Copy Issue Report The expression `$lastError` 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...
177			$this->logger->log(
178			$this->fatalLevel === null ? LogLevel::ALERT : $this->fatalLevel,
179			'Fatal Error ('.self::codeToString($lastError['type']).'): '.$lastError['message'],
180			array('code' => $lastError['type'], 'message' => $lastError['message'], 'file' => $lastError['file'], 'line' => $lastError['line'])
181			);
182
183			if ($this->logger instanceof Logger) {
184			foreach ($this->logger->getHandlers() as $handler) {
185			if ($handler instanceof AbstractHandler) {
186			$handler->close();
187			}
188			}
189			}
190			}
191			}
192
193			private static function codeToString($code)
194			{
195			switch ($code) {
196			case E_ERROR:
197			return 'E_ERROR';
198			case E_WARNING:
199			return 'E_WARNING';
200			case E_PARSE:
201			return 'E_PARSE';
202			case E_NOTICE:
203			return 'E_NOTICE';
204			case E_CORE_ERROR:
205			return 'E_CORE_ERROR';
206			case E_CORE_WARNING:
207			return 'E_CORE_WARNING';
208			case E_COMPILE_ERROR:
209			return 'E_COMPILE_ERROR';
210			case E_COMPILE_WARNING:
211			return 'E_COMPILE_WARNING';
212			case E_USER_ERROR:
213			return 'E_USER_ERROR';
214			case E_USER_WARNING:
215			return 'E_USER_WARNING';
216			case E_USER_NOTICE:
217			return 'E_USER_NOTICE';
218			case E_STRICT:
219			return 'E_STRICT';
220			case E_RECOVERABLE_ERROR:
221			return 'E_RECOVERABLE_ERROR';
222			case E_DEPRECATED:
223			return 'E_DEPRECATED';
224			case E_USER_DEPRECATED:
225			return 'E_USER_DEPRECATED';
226			}
227
228			return 'Unknown PHP error';
229			}
230			}
231

JuKu / JuKuCMS

Push — master ( cdeef2...f03c61 )

ErrorHandler::codeToString() C

Complexity

Size

Duplication

Importance

How to fix Complexity

Long Method

Duplication Side-by-Side

Filter issues like