Jasny\ErrorHandler\HandleShutdownError

Complexity

Total Complexity

8

Size/Duplication

Total Lines	88
Duplicated Lines	0 %

Coupling/Cohesion

Components	1
Dependencies	0

Test Coverage

Coverage

100%

Importance

Changes

0

7 Methods

Rating	Name	Duplication	Size	Complexity
	callOnFatalError()	0	1	?
	errorGetLast()	0	1	?
	registerShutdownFunction()	0	1	?
	log()	0	1	?
A	reserveMemory()	0	4	1
A	initShutdownFunction()	0	9	3
A	shutdownFunction()	0	19	4

<?php

namespace Jasny\ErrorHandler;

/**
 * Trait for handling errors on shutdown
 */
trait HandleShutdownError
{
    /**
     * @var boolean
     */
    protected $registeredShutdown = false;
    
    /**
     * 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;
    

    /**
     * Run the fatal error callback
     * 
     * @param \Exception|\Error $error
     */
    abstract protected function callOnFatalError($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.

    /**
     * Wrapper method for `error_get_last`
     * 
     * @return array
     */
    abstract protected function errorGetLast();
    
    /**
     * Wrapper method for `register_shutdown_function`
     * 
     * @param callable $callback
     */
    abstract protected function registerShutdownFunction($callback);

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.

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

    /**
     * Reserve memory for shutdown function in case of out of memory
     */
    protected function reserveMemory()
    {
        $this->reservedMemory = str_repeat(' ', 10 * 1024);
    }
    
    /**
     * Register the 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) {

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

            $this->log($error);
        }
        
        $this->callOnFatalError($error);
    }
}