Jasny\ErrorHandler

Complexity

Total Complexity

57

Size/Duplication

Total Lines	416
Duplicated Lines	0 %

Coupling/Cohesion

Components	2
Dependencies	3

Test Coverage

Coverage

100%

Importance

Changes	1
Bugs	0	Features	0

25 Methods

Rating	Name	Duplication	Size	Complexity
A	reserveMemory()	0	4	1
A	initShutdownFunction()	0	9	3
B	shutdownFunction()	0	21	5
B	setError()	0	10	5
A	getError()	0	4	1
A	getChainedErrorHandler()	0	4	1
A	getChainedExceptionHandler()	0	4	1
A	getLoggedErrorTypes()	0	4	1
A	getLoggedExceptionClasses()	0	4	1
A	converErrorsToExceptions()	0	5	1
A	logUncaught()	0	10	3
A	logUncaughtException()	0	8	2
A	logUncaughtErrors()	0	14	3
A	onFatalError()	0	11	2
A	asMiddleware()	0	4	1
A	initErrorHandler()	0	6	3
B	handleError()	0	18	6
A	initExceptionHandler()	0	6	3
C	handleException()	0	31	7
A	clearOutputBuffer()	0	6	2
A	errorReporting()	0	4	1
A	errorGetLast()	0	4	1
A	setErrorHandler()	0	4	1
A	setExceptionHandler()	0	4	1
A	registerShutdownFunction()	0	4	1

<?php

namespace Jasny;

use Jasny\ErrorHandler\ErrorCodes;
use Jasny\ErrorHandler\Logging;
use Jasny\ErrorHandler\Middleware;
use Psr\Log\LoggerAwareInterface;

/**
 * Handle error in following middlewares/app actions
 */
class ErrorHandler implements LoggerAwareInterface
{
    use Logging;
    use ErrorCodes;
    
    /**
     * @var \Exception|\Error
     */
    protected $error;
    
    /**
     * @var callable|false
     */
    protected $chainedErrorHandler;

    /**
     * @var callable|false
     */
    protected $chainedExceptionHandler;

    /**
     * @var boolean
     */
    protected $registeredShutdown = false;
    
    /**
     * Convert fatal errors to exceptions
     * @var boolean
     */
    protected $convertFatalErrors = false;
    
    /**
     * Log the following error types (in addition to caugth errors)
     * @var int
     */
    protected $logErrorTypes = 0;
    
    /**
     * Log the following exception classes (and subclasses)
     * @var array
     */
    protected $logExceptionClasses = [];
    
    /**
     * A string which reserves memory that can be used to log the error in case of an out of memory fatal error
     * @var string
     */
    protected $reservedMemory;
    
    /**
     * @var callback
     */
    protected $onFatalError;

    
    /**
     * Set the caught error
     * 
     * @param \Throwable|\Exception|\Error
     */
    public function setError($error)
    {
        if (isset($error) && !$error instanceof \Error && !$error instanceof \Exception) {
            $type = (is_object($error) ? get_class($error) . ' ' : '') . gettype($error);
            trigger_error("Excpeted an Error or Exception, got a $type", E_USER_WARNING);
            return;
        }
        
        $this->error = $error;
    }
    
    /**
     * Get the caught error
     * 
     * @return \Throwable|\Exception|\Error
     */
    public function getError()
    {
        return $this->error;
    }
    
    
    /**
     * Get the error handler that has been replaced.
     * 
     * @return callable|false|null
     */
    public function getChainedErrorHandler()
    {
        return $this->chainedErrorHandler;
    }
    
    /**
     * Get the error handler that has been replaced.
     * 
     * @return callable|false|null
     */
    public function getChainedExceptionHandler()
    {
        return $this->chainedExceptionHandler;
    }
    
    /**
     * Get the types of errors that will be logged
     * 
     * @return int  Binary set of E_* constants
     */
    public function getLoggedErrorTypes()
    {
        return $this->logErrorTypes;
    }
    
    /**
     * Get a list of Exception and other Throwable classes that will be logged
     * @return array
     */
    public function getLoggedExceptionClasses()
    {
        return $this->logExceptionClasses;
    }
    
    
    /**
     * Use the global error handler to convert E_USER_ERROR and E_RECOVERABLE_ERROR to an ErrorException
     */
    public function converErrorsToExceptions()
    {
        $this->convertFatalErrors = true;
        $this->initErrorHandler();
    }
    
    /**
     * Log these types of errors or exceptions
     * 
     * @param int|string $type  E_* contants as binary set OR Exception class name
     */
    public function logUncaught($type)
    {
        if (is_int($type)) {
            $this->logUncaughtErrors($type);
        } elseif (is_string($type)) {
            $this->logUncaughtException($type);
        } else {
            throw new \InvalidArgumentException("Type should be an error code (int) or Exception class (string)");
        }
    }
    
    /**
     * Log these types of errors or exceptions
     * 
     * @param string $class  Exception class name
     */
    protected function logUncaughtException($class)
    {
        if (!in_array($class, $this->logExceptionClasses)) {
            $this->logExceptionClasses[] = $class;
        }

        $this->initExceptionHandler();
    }
    
    /**
     * Log these types of errors or exceptions
     * 
     * @param int $type  E_* contants as binary set
     */
    protected function logUncaughtErrors($type)
    {
        $this->logErrorTypes |= $type;

        $unhandled = E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR;

        if ($type & ~$unhandled) {
            $this->initErrorHandler();
        }

        if ($type & $unhandled) {
            $this->initShutdownFunction();
        }
    }

    
    /**
     * Set a callback for when the script dies because of a fatal, non-catchable error.
     * The callback should have an `ErrorException` as only argument.
     * 
     * @param callable $callback
     * @param boolean  $clearOutput  Clear the output buffer before calling the callback
     */
    public function onFatalError($callback, $clearOutput = false)
    {
        if (!$clearOutput) {
            $this->onFatalError = $callback;
        } else {
            $this->onFatalError = function ($error) use ($callback) {
                $this->clearOutputBuffer();
                $callback($error);
            };
        }
    }
    
    /**
     * Use this error handler as middleware
     */
    public function asMiddleware()
    {
        return new Middleware($this);
    }
    
    
    /**
     * Use the global error handler
     */
    protected function initErrorHandler()
    {
        if (!isset($this->chainedErrorHandler)) {
            $this->chainedErrorHandler = $this->setErrorHandler([$this, 'handleError']) ?: false;
        }
    }
    
    /**
     * Uncaught error handler
     * @ignore
     * 
     * @param int    $type
     * @param string $message
     * @param string $file
     * @param int    $line
     * @param array  $context
     */
    public function handleError($type, $message, $file, $line, $context)
    {
        if ($this->errorReporting() & $type) {
            $error = new \ErrorException($message, 0, $type, $file, $line);

            if ($this->convertFatalErrors && ($type & (E_RECOVERABLE_ERROR | E_USER_ERROR))) {
                throw $error;
            }

            if ($this->logErrorTypes & $type) {
                $this->log($error);
            }
        }
        
        return $this->chainedErrorHandler
            ? call_user_func($this->chainedErrorHandler, $type, $message, $file, $line, $context)
            : false;
    }

    
    /**
     * Use the global error handler
     */
    protected function initExceptionHandler()
    {
        if (!isset($this->chainedExceptionHandler)) {
            $this->chainedExceptionHandler = $this->setExceptionHandler([$this, 'handleException']) ?: false;
        }
    }
    
    /**
     * Uncaught exception handler
     * @ignore
     * 
     * @param \Exception|\Error $exception
     */
    public function handleException($exception)
    {
        $this->setExceptionHandler(null);

null is of type null, but the function expects a callable.

        $this->setErrorHandler(null);

null is of type null, but the function expects a callable.

        
        $isInstanceOf = array_map(function($class) use ($exception) {

Expected 1 space after FUNCTION keyword; 0 found

            return is_a($exception, $class);
        }, $this->logExceptionClasses);
        
        if ($exception instanceof \Error || $exception instanceof \ErrorException) {
            $type = $exception instanceof \Error ? $exception->getCode() : $exception->getSeverity();
            $shouldLog = $this->logErrorTypes & $type;
        } else {
            $shouldLog = array_sum($isInstanceOf) > 0;
        }
        
        if ($shouldLog) {
            $this->log($exception);
        }
        
        if ($this->onFatalError) {
            call_user_func($this->onFatalError, $exception);
        }
        
        if ($this->chainedExceptionHandler) {
            call_user_func($this->chainedExceptionHandler, $exception);
        }
        
        
        throw $exception; // This is now handled by the default exception and error handler
    }

    
    /**
     * Reserve memory for shutdown function in case of out of memory
     */
    protected function reserveMemory()
    {
        $this->reservedMemory = str_repeat(' ', 10 * 1024);
    }
    
    /**
     * Register a shutdown function
     */
    protected function initShutdownFunction()
    {
        if (!$this->registeredShutdown) {
            $this->registerShutdownFunction([$this, 'shutdownFunction']) ?: false;
            $this->registeredShutdown = true;
            
            $this->reserveMemory();
        }
    }
    
    /**
     * Called when the script has ends
     * @ignore
     */
    public function shutdownFunction()
    {
        $this->reservedMemory = null;
        
        $err = $this->errorGetLast();
        $unhandled = E_ERROR | E_PARSE | E_CORE_ERROR | E_COMPILE_ERROR;
        
        if (!$err || !($err['type'] & $unhandled)) {

The expression $err 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.

            return;
        }
        
        $error = new \ErrorException($err['message'], 0, $err['type'], $err['file'], $err['line']);
        
        if ($err['type'] & $this->logErrorTypes) {
            $this->log($error);
        }
        
        if ($this->onFatalError) {
            call_user_func($this->onFatalError, $error);
        }
    }
    
   
    /**
     * Clear and destroy all the output buffers
     * @codeCoverageIgnore
     */
    protected function clearOutputBuffer()
    {
        while (ob_get_level() > 0) {
            ob_end_clean();
        }
    }
    
    /**
     * Wrapper method for `error_reporting`
     * @codeCoverageIgnore
     * 
     * @return int
     */
    protected function errorReporting()
    {
        return error_reporting();
    }

    /**
     * Wrapper method for `error_get_last`
     * @codeCoverageIgnore
     * 
     * @return array
     */
    protected function errorGetLast()
    {
        return error_get_last();
    }
    
    /**
     * Wrapper method for `set_error_handler`
     * @codeCoverageIgnore
     * 
     * @param callable $callback
     * @param int      $error_types
     * @return callable|null
     */
    protected function setErrorHandler($callback, $error_types = E_ALL)
    {
        return set_error_handler($callback, $error_types);
    }
    
    /**
     * Wrapper method for `set_exception_handler`
     * @codeCoverageIgnore
     * 
     * @param callable $callback
     * @return callable|null
     */
    protected function setExceptionHandler($callback)
    {
        return set_exception_handler($callback);
    }
    
    /**
     * Wrapper method for `register_shutdown_function`
     * @codeCoverageIgnore
     * 
     * @param callable $callback
     */
    protected function registerShutdownFunction($callback)
    {
        register_shutdown_function($callback);
    }
}