ErrorHandler::convertExceptionToError() - Code Metrics - Inspection of "Fixes #14711: Fixed `yii\web\ErrorHandler` display..." - yiisoft/yii2 - Measure and Improve Code Quality continuously with Scrutinizer

Completed

Push — 14711-fix-non-debug-expetion-m... ( 23a158 )

by Alexander

created 2018-01-21 22:23 UTC

ErrorHandler::convertExceptionToError() A

↳ Parent: ErrorHandler

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	0
CRAP Score	2

Importance

Changes

Metric	Value
dl	0
loc	4
rs	10
c	0
b	0
f	0
ccs	0
cts	3
cp	0
cc	1
eloc	2
nc	1
nop	1
crap	2

<?php
/**
 * @link http://www.yiiframework.com/
 * @copyright Copyright (c) 2008 Yii Software LLC
 * @license http://www.yiiframework.com/license/
 */

namespace yii\base;

use Yii;
use yii\helpers\VarDumper;
use yii\web\HttpException;

/**
 * ErrorHandler handles uncaught PHP errors and exceptions.
 *
 * ErrorHandler is configured as an application component in [[\yii\base\Application]] by default.
 * You can access that instance via `Yii::$app->errorHandler`.
 *
 * For more details and usage information on ErrorHandler, see the [guide article on handling errors](guide:runtime-handling-errors).
 *
 * @author Qiang Xue <[email protected]>
 * @author Alexander Makarov <[email protected]>
 * @author Carsten Brandt <[email protected]>
 * @since 2.0
 */
abstract class ErrorHandler extends Component
{
    /**
     * @var bool whether to discard any existing page output before error display. Defaults to true.
     */
    public $discardExistingOutput = true;
    /**
     * @var int the size of the reserved memory. A portion of memory is pre-allocated so that
     * when an out-of-memory issue occurs, the error handler is able to handle the error with
     * the help of this reserved memory. If you set this value to be 0, no memory will be reserved.
     * Defaults to 256KB.
     */
    public $memoryReserveSize = 262144;
    /**
     * @var \Exception|null the exception that is being handled currently.
     */
    public $exception;

    /**
     * @var string Used to reserve memory for fatal error handler.
     */
    private $_memoryReserve;
    /**
     * @var \Exception from HHVM error that stores backtrace
     */
    private $_hhvmException;


    /**
     * Register this error handler.
     */
    public function register()
    {
        ini_set('display_errors', false);
        set_exception_handler([$this, 'handleException']);
        if (defined('HHVM_VERSION')) {
            set_error_handler([$this, 'handleHhvmError']);
        } else {
            set_error_handler([$this, 'handleError']);
        }
        if ($this->memoryReserveSize > 0) {
            $this->_memoryReserve = str_repeat('x', $this->memoryReserveSize);
        }
        register_shutdown_function([$this, 'handleFatalError']);
    }

    /**
     * Unregisters this error handler by restoring the PHP error and exception handlers.
     */
    public function unregister()
    {
        restore_error_handler();
        restore_exception_handler();
    }

    /**
     * Handles uncaught PHP exceptions.
     *
     * This method is implemented as a PHP exception handler.
     *
     * @param \Exception $exception the exception that is not caught
     */
    public function handleException($exception)
    {
        if ($exception instanceof ExitException) {
            return;
        }

        $this->exception = $exception;

        // disable error capturing to avoid recursive errors while handling exceptions
        $this->unregister();

        // set preventive HTTP status code to 500 in case error handling somehow fails and headers are sent
        // HTTP exceptions will override this value in renderException()
        if (PHP_SAPI !== 'cli') {
            http_response_code(500);
        }

        try {
            $this->logException($exception);
            if ($this->discardExistingOutput) {
                $this->clearOutput();
            }
            $this->renderException($exception);
            if (!YII_ENV_TEST) {
                \Yii::getLogger()->flush(true);
                if (defined('HHVM_VERSION')) {
                    flush();
                }
                exit(1);
            }
        } catch (\Exception $e) {
            // an other exception could be thrown while displaying the exception
            $this->handleFallbackExceptionMessage($e, $exception);
        } catch (\Throwable $e) {

            // additional check for \Throwable introduced in PHP 7
            $this->handleFallbackExceptionMessage($e, $exception);
        }

        $this->exception = null;
    }

    /**
     * Handles exception thrown during exception processing in [[handleException()]].
     * @param \Exception|\Throwable $exception Exception that was thrown during main exception processing.
     * @param \Exception $previousException Main exception processed in [[handleException()]].
     * @since 2.0.11
     */
    protected function handleFallbackExceptionMessage($exception, $previousException)
    {
        $msg = "An Error occurred while handling another error:\n";
        $msg .= (string) $exception;
        $msg .= "\nPrevious exception:\n";
        $msg .= (string) $previousException;
        if (YII_DEBUG) {
            if (PHP_SAPI === 'cli') {
                echo $msg . "\n";
            } else {
                echo '<pre>' . htmlspecialchars($msg, ENT_QUOTES, Yii::$app->charset) . '</pre>';
            }
        } else {
            echo 'An internal server error occurred.';
        }
        $msg .= "\n\$_SERVER = " . VarDumper::export($_SERVER);
        error_log($msg);
        if (defined('HHVM_VERSION')) {
            flush();
        }
        exit(1);
    }

    /**
     * Handles HHVM execution errors such as warnings and notices.
     *
     * This method is used as a HHVM error handler. It will store exception that will
     * be used in fatal error handler
     *
     * @param int $code the level of the error raised.
     * @param string $message the error message.
     * @param string $file the filename that the error was raised in.
     * @param int $line the line number the error was raised at.
     * @param mixed $context
     * @param mixed $backtrace trace of error
     * @return bool whether the normal error handler continues.
     *
     * @throws ErrorException
     * @since 2.0.6
     */
    public function handleHhvmError($code, $message, $file, $line, $context, $backtrace)
    {
        if ($this->handleError($code, $message, $file, $line)) {
            return true;
        }
        if (E_ERROR & $code) {
            $exception = new ErrorException($message, $code, $code, $file, $line);
            $ref = new \ReflectionProperty('\Exception', 'trace');
            $ref->setAccessible(true);
            $ref->setValue($exception, $backtrace);
            $this->_hhvmException = $exception;
        }

        return false;
    }

    /**
     * Handles PHP execution errors such as warnings and notices.
     *
     * This method is used as a PHP error handler. It will simply raise an [[ErrorException]].
     *
     * @param int $code the level of the error raised.
     * @param string $message the error message.
     * @param string $file the filename that the error was raised in.
     * @param int $line the line number the error was raised at.
     * @return bool whether the normal error handler continues.
     *
     * @throws ErrorException
     */
    public function handleError($code, $message, $file, $line)
    {
        if (error_reporting() & $code) {
            // load ErrorException manually here because autoloading them will not work
            // when error occurs while autoloading a class
            if (!class_exists('yii\\base\\ErrorException', false)) {
                require_once __DIR__ . '/ErrorException.php';
            }
            $exception = new ErrorException($message, $code, $code, $file, $line);

            // in case error appeared in __toString method we can't throw any exception
            $trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
            array_shift($trace);
            foreach ($trace as $frame) {
                if ($frame['function'] === '__toString') {
                    $this->handleException($exception);
                    if (defined('HHVM_VERSION')) {
                        flush();
                    }
                    exit(1);
                }
            }

            throw $exception;
        }

        return false;
    }

    /**
     * Handles fatal PHP errors.
     */
    public function handleFatalError()
    {
        unset($this->_memoryReserve);

        // load ErrorException manually here because autoloading them will not work
        // when error occurs while autoloading a class
        if (!class_exists('yii\\base\\ErrorException', false)) {
            require_once __DIR__ . '/ErrorException.php';
        }

        $error = error_get_last();

        if (ErrorException::isFatalError($error)) {
            if (!empty($this->_hhvmException)) {
                $exception = $this->_hhvmException;
            } else {
                $exception = new ErrorException($error['message'], $error['type'], $error['type'], $error['file'], $error['line']);
            }
            $this->exception = $exception;

            $this->logException($exception);

            if ($this->discardExistingOutput) {
                $this->clearOutput();
            }
            $this->renderException($exception);

            // need to explicitly flush logs because exit() next will terminate the app immediately
            Yii::getLogger()->flush(true);
            if (defined('HHVM_VERSION')) {
                flush();
            }
            exit(1);
        }
    }

    /**
     * Renders the exception.
     * @param \Exception $exception the exception to be rendered.
     */
    abstract protected function renderException($exception);

    /**
     * Logs the given exception.
     * @param \Exception $exception the exception to be logged
     * @since 2.0.3 this method is now public.
     */
    public function logException($exception)
    {
        $category = get_class($exception);
        if ($exception instanceof HttpException) {
            $category = 'yii\\web\\HttpException:' . $exception->statusCode;
        } elseif ($exception instanceof \ErrorException) {
            $category .= ':' . $exception->getSeverity();
        }
        Yii::error($exception, $category);
    }

    /**
     * Removes all output echoed before calling this method.
     */
    public function clearOutput()
    {
        // the following manual level counting is to deal with zlib.output_compression set to On
        for ($level = ob_get_level(); $level > 0; --$level) {
            if (!@ob_end_clean()) {
                ob_clean();
            }
        }
    }

    /**
     * Converts an exception into a PHP error.
     *
     * This method can be used to convert exceptions inside of methods like `__toString()`
     * to PHP errors because exceptions cannot be thrown inside of them.
     * @param \Exception $exception the exception to convert to a PHP error.
     */
    public static function convertExceptionToError($exception)
    {
        trigger_error(static::convertExceptionToString($exception), E_USER_ERROR);
    }

    /**
     * Converts an exception into a simple string.
     * @param \Exception|\Error $exception the exception being converted
     * @return string the string representation of the exception.
     */
    public static function convertExceptionToString($exception)
    {
        if ($exception instanceof UserException) {
            return "{$exception->getName()}: {$exception->getMessage()}";
        }

        if (YII_DEBUG) {
            return static::convertExceptionToVerboseString($exception);
        }

        return 'An internal server error occurred.';
    }

    /**
     * Converts an exception into a string that has verbose information about the exception and its trace.
     * @param \Exception|\Error $exception the exception being converted
     * @return string the string representation of the exception.
     *
     * @since 2.0.14
     */
    public static function convertExceptionToVerboseString($exception)
    {
        if ($exception instanceof Exception) {
            $message = "Exception ({$exception->getName()})";
        } elseif ($exception instanceof ErrorException) {
            $message = "{$exception->getName()}";
        } else {
            $message = 'Exception';
        }
        $message .= " '" . get_class($exception) . "' with message '{$exception->getMessage()}' \n\nin "
            . $exception->getFile() . ':' . $exception->getLine() . "\n\n"
            . "Stack trace:\n" . $exception->getTraceAsString();

        return $message;
    }
}


1			<?php
2			/**
3			* @link http://www.yiiframework.com/
4			* @copyright Copyright (c) 2008 Yii Software LLC
5			* @license http://www.yiiframework.com/license/
6			*/
7
8			namespace yii\base;
9
10			use Yii;
11			use yii\helpers\VarDumper;
12			use yii\web\HttpException;
13
14			/**
15			* ErrorHandler handles uncaught PHP errors and exceptions.
16			*
17			* ErrorHandler is configured as an application component in [[\yii\base\Application]] by default.
18			* You can access that instance via `Yii::$app->errorHandler`.
19			*
20			* For more details and usage information on ErrorHandler, see the [guide article on handling errors](guide:runtime-handling-errors).
21			*
22			* @author Qiang Xue <[email protected]>
23			* @author Alexander Makarov <[email protected]>
24			* @author Carsten Brandt <[email protected]>
25			* @since 2.0
26			*/
27			abstract class ErrorHandler extends Component
28			{
29			/**
30			* @var bool whether to discard any existing page output before error display. Defaults to true.
31			*/
32			public $discardExistingOutput = true;
33			/**
34			* @var int the size of the reserved memory. A portion of memory is pre-allocated so that
35			* when an out-of-memory issue occurs, the error handler is able to handle the error with
36			* the help of this reserved memory. If you set this value to be 0, no memory will be reserved.
37			* Defaults to 256KB.
38			*/
39			public $memoryReserveSize = 262144;
40			/**
41			* @var \Exception\|null the exception that is being handled currently.
42			*/
43			public $exception;
44
45			/**
46			* @var string Used to reserve memory for fatal error handler.
47			*/
48			private $_memoryReserve;
49			/**
50			* @var \Exception from HHVM error that stores backtrace
51			*/
52			private $_hhvmException;
53
54
55			/**
56			* Register this error handler.
57			*/
58			public function register()
59			{
60			ini_set('display_errors', false);
61			set_exception_handler([$this, 'handleException']);
62			if (defined('HHVM_VERSION')) {
63			set_error_handler([$this, 'handleHhvmError']);
64			} else {
65			set_error_handler([$this, 'handleError']);
66			}
67			if ($this->memoryReserveSize > 0) {
68			$this->_memoryReserve = str_repeat('x', $this->memoryReserveSize);
69			}
70			register_shutdown_function([$this, 'handleFatalError']);
71			}
72
73			/**
74			* Unregisters this error handler by restoring the PHP error and exception handlers.
75			*/
76			public function unregister()
77			{
78			restore_error_handler();
79			restore_exception_handler();
80			}
81
82			/**
83			* Handles uncaught PHP exceptions.
84			*
85			* This method is implemented as a PHP exception handler.
86			*
87			* @param \Exception $exception the exception that is not caught
88			*/
89			public function handleException($exception)
90			{
91			if ($exception instanceof ExitException) {
92			return;
93			}
94
95			$this->exception = $exception;
96
97			// disable error capturing to avoid recursive errors while handling exceptions
98			$this->unregister();
99
100			// set preventive HTTP status code to 500 in case error handling somehow fails and headers are sent
101			// HTTP exceptions will override this value in renderException()
102			if (PHP_SAPI !== 'cli') {
103			http_response_code(500);
104			}
105
106			try {
107			$this->logException($exception);
108			if ($this->discardExistingOutput) {
109			$this->clearOutput();
110			}
111			$this->renderException($exception);
112			if (!YII_ENV_TEST) {
113			\Yii::getLogger()->flush(true);
114			if (defined('HHVM_VERSION')) {
115			flush();
116			}
117			exit(1);
118			}
119			} catch (\Exception $e) {
120			// an other exception could be thrown while displaying the exception
121			$this->handleFallbackExceptionMessage($e, $exception);
122			} catch (\Throwable $e) {
			0 ignored issues – show Bug introduced 2016-10-08 11:06 UTC by Report Bug Copy Issue Report The class `Throwable` does not exist. Did you forget a USE statement, or did you not list all dependencies? Scrutinizer analyzes your `composer.json`/`composer.lock` file if available to determine the classes, and functions that are defined by your dependencies. It seems like the listed class was neither found in your dependencies, nor was it found in the analyzed files in your repository. If you are using some other form of dependency management, you might want to disable this analysis. Loading history...
123			// additional check for \Throwable introduced in PHP 7
124			$this->handleFallbackExceptionMessage($e, $exception);
125			}
126
127			$this->exception = null;
128			}
129
130			/**
131			* Handles exception thrown during exception processing in [[handleException()]].
132			* @param \Exception\|\Throwable $exception Exception that was thrown during main exception processing.
133			* @param \Exception $previousException Main exception processed in [[handleException()]].
134			* @since 2.0.11
135			*/
136			protected function handleFallbackExceptionMessage($exception, $previousException)
137			{
138			$msg = "An Error occurred while handling another error:\n";
139			$msg .= (string) $exception;
140			$msg .= "\nPrevious exception:\n";
141			$msg .= (string) $previousException;
142			if (YII_DEBUG) {
143			if (PHP_SAPI === 'cli') {
144			echo $msg . "\n";
145			} else {
146			echo '<pre>' . htmlspecialchars($msg, ENT_QUOTES, Yii::$app->charset) . '</pre>';
147			}
148			} else {
149			echo 'An internal server error occurred.';
150			}
151			$msg .= "\n\$_SERVER = " . VarDumper::export($_SERVER);
152			error_log($msg);
153			if (defined('HHVM_VERSION')) {
154			flush();
155			}
156			exit(1);
157			}
158
159			/**
160			* Handles HHVM execution errors such as warnings and notices.
161			*
162			* This method is used as a HHVM error handler. It will store exception that will
163			* be used in fatal error handler
164			*
165			* @param int $code the level of the error raised.
166			* @param string $message the error message.
167			* @param string $file the filename that the error was raised in.
168			* @param int $line the line number the error was raised at.
169			* @param mixed $context
170			* @param mixed $backtrace trace of error
171			* @return bool whether the normal error handler continues.
172			*
173			* @throws ErrorException
174			* @since 2.0.6
175			*/
176			public function handleHhvmError($code, $message, $file, $line, $context, $backtrace)
177			{
178			if ($this->handleError($code, $message, $file, $line)) {
179			return true;
180			}
181			if (E_ERROR & $code) {
182			$exception = new ErrorException($message, $code, $code, $file, $line);
183			$ref = new \ReflectionProperty('\Exception', 'trace');
184			$ref->setAccessible(true);
185			$ref->setValue($exception, $backtrace);
186			$this->_hhvmException = $exception;
187			}
188
189			return false;
190			}
191
192			/**
193			* Handles PHP execution errors such as warnings and notices.
194			*
195			* This method is used as a PHP error handler. It will simply raise an [[ErrorException]].
196			*
197			* @param int $code the level of the error raised.
198			* @param string $message the error message.
199			* @param string $file the filename that the error was raised in.
200			* @param int $line the line number the error was raised at.
201			* @return bool whether the normal error handler continues.
202			*
203			* @throws ErrorException
204			*/
205			public function handleError($code, $message, $file, $line)
206			{
207			if (error_reporting() & $code) {
208			// load ErrorException manually here because autoloading them will not work
209			// when error occurs while autoloading a class
210			if (!class_exists('yii\\base\\ErrorException', false)) {
211			require_once __DIR__ . '/ErrorException.php';
212			}
213			$exception = new ErrorException($message, $code, $code, $file, $line);
214
215			// in case error appeared in __toString method we can't throw any exception
216			$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS);
217			array_shift($trace);
218			foreach ($trace as $frame) {
219			if ($frame['function'] === '__toString') {
220			$this->handleException($exception);
221			if (defined('HHVM_VERSION')) {
222			flush();
223			}
224			exit(1);
225			}
226			}
227
228			throw $exception;
229			}
230
231			return false;
232			}
233
234			/**
235			* Handles fatal PHP errors.
236			*/
237			public function handleFatalError()
238			{
239			unset($this->_memoryReserve);
240
241			// load ErrorException manually here because autoloading them will not work
242			// when error occurs while autoloading a class
243			if (!class_exists('yii\\base\\ErrorException', false)) {
244			require_once __DIR__ . '/ErrorException.php';
245			}
246
247			$error = error_get_last();
248
249			if (ErrorException::isFatalError($error)) {
250			if (!empty($this->_hhvmException)) {
251			$exception = $this->_hhvmException;
252			} else {
253			$exception = new ErrorException($error['message'], $error['type'], $error['type'], $error['file'], $error['line']);
254			}
255			$this->exception = $exception;
256
257			$this->logException($exception);
258
259			if ($this->discardExistingOutput) {
260			$this->clearOutput();
261			}
262			$this->renderException($exception);
263
264			// need to explicitly flush logs because exit() next will terminate the app immediately
265			Yii::getLogger()->flush(true);
266			if (defined('HHVM_VERSION')) {
267			flush();
268			}
269			exit(1);
270			}
271			}
272
273			/**
274			* Renders the exception.
275			* @param \Exception $exception the exception to be rendered.
276			*/
277			abstract protected function renderException($exception);
278
279			/**
280			* Logs the given exception.
281			* @param \Exception $exception the exception to be logged
282			* @since 2.0.3 this method is now public.
283			*/
284			public function logException($exception)
285			{
286			$category = get_class($exception);
287			if ($exception instanceof HttpException) {
288			$category = 'yii\\web\\HttpException:' . $exception->statusCode;
289			} elseif ($exception instanceof \ErrorException) {
290			$category .= ':' . $exception->getSeverity();
291			}
292			Yii::error($exception, $category);
293			}
294
295			/**
296			* Removes all output echoed before calling this method.
297			*/
298			public function clearOutput()
299			{
300			// the following manual level counting is to deal with zlib.output_compression set to On
301			for ($level = ob_get_level(); $level > 0; --$level) {
302			if (!@ob_end_clean()) {
303			ob_clean();
304			}
305			}
306			}
307
308			/**
309			* Converts an exception into a PHP error.
310			*
311			* This method can be used to convert exceptions inside of methods like `__toString()`
312			* to PHP errors because exceptions cannot be thrown inside of them.
313			* @param \Exception $exception the exception to convert to a PHP error.
314			*/
315			public static function convertExceptionToError($exception)
316			{
317			trigger_error(static::convertExceptionToString($exception), E_USER_ERROR);
318			}
319
320			/**
321			* Converts an exception into a simple string.
322			* @param \Exception\|\Error $exception the exception being converted
323			* @return string the string representation of the exception.
324			*/
325			public static function convertExceptionToString($exception)
326			{
327			if ($exception instanceof UserException) {
328			return "{$exception->getName()}: {$exception->getMessage()}";
329			}
330
331			if (YII_DEBUG) {
332			return static::convertExceptionToVerboseString($exception);
333			}
334
335			return 'An internal server error occurred.';
336			}
337
338			/**
339			* Converts an exception into a string that has verbose information about the exception and its trace.
340			* @param \Exception\|\Error $exception the exception being converted
341			* @return string the string representation of the exception.
342			*
343			* @since 2.0.14
344			*/
345			public static function convertExceptionToVerboseString($exception)
346			{
347			if ($exception instanceof Exception) {
348			$message = "Exception ({$exception->getName()})";
349			} elseif ($exception instanceof ErrorException) {
350			$message = "{$exception->getName()}";
351			} else {
352			$message = 'Exception';
353			}
354			$message .= " '" . get_class($exception) . "' with message '{$exception->getMessage()}' \n\nin "
355			. $exception->getFile() . ':' . $exception->getLine() . "\n\n"
356			. "Stack trace:\n" . $exception->getTraceAsString();
357
358			return $message;
359			}
360			}
361

yiisoft / yii2

Push — 14711-fix-non-debug-expetion-m... ( 23a158 )

ErrorHandler::convertExceptionToError() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like