Jasny\ErrorHandler\HandleUncaughtException

Complexity

Total Complexity

13

Size/Duplication

Total Lines	120
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

8 Methods

Rating	Name	Duplication	Size	Complexity
	setErrorHandler()	0	1	?
	setExceptionHandler()	0	1	?
	log()	0	1	?
A	getChainedExceptionHandler()	0	4	1
A	getLoggedExceptionClasses()	0	4	1
A	logUncaughtException()	0	8	2
A	initExceptionHandler()	0	6	3
B	handleException()	0	28	6

<?php

namespace Jasny\ErrorHandler;

/**
 * Trait for handling uncaught exceptions using PHP's exception handler
 */
trait HandleUncaughtException
{
    /**
     * @var callable|false
     */
    protected $chainedExceptionHandler;


    /**
     * Log the following exception classes (and subclasses)
     * @var array
     */
    protected $logExceptionClasses = [];


    /**
     * Wrapper method for `set_error_handler`
     * 
     * @param callable $callback
     * @param int      $error_types
     * @return callable|null
     */
    abstract protected function setErrorHandler($callback, $error_types = E_ALL);

    /**
     * Wrapper method for `set_exception_handler`
     * 
     * @param callable $callback
     * @return callable|null
     */
    abstract protected function setExceptionHandler($callback);

    /**
     * Log an error or exception
     * 
     * @param \Exception|\Error $error
     */
    abstract public function log($error);

For interfaces and abstract methods it is generally a good practice to add a @return annotation even if it is just @return void or @return null, so that implementors know what to do in the overridden method.

    /**
     * Get the error handler that has been replaced.
     * 
     * @return callable|false|null
     */
    public function getChainedExceptionHandler()
    {
        return $this->chainedExceptionHandler;
    }
    
    /**
     * Get a list of Exception and other Throwable classes that will be logged
     * @return array
     */
    public function getLoggedExceptionClasses()
    {
        return $this->logExceptionClasses;
    }
    
    
    /**
     * 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();
    }

    
    /**
     * 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;

The property logErrorTypes does not exist. Did you maybe forget to declare it?

        } else {
            $shouldLog = array_sum($isInstanceOf) > 0;
        }
        
        if ($shouldLog) {
            $this->log($exception);
        }
        
        $this->callOnFatalError($exception);

It seems like callOnFatalError() must be provided by classes using this trait. How about adding it as abstract method to this trait?

        
        if ($this->chainedExceptionHandler) {
            call_user_func($this->chainedExceptionHandler, $exception);
        }
        
        throw $exception; // This is now handled by the default exception and error handler
    }
}