HandleShutdownError::reserveMemory() - Code Metrics - Inspection of "Split up ErrorHandler class into traits" - jasny/error-handler - Measure and Improve Code Quality continuously with Scrutinizer

Failed Conditions

Push — master ( 63ec91...ac34b9 )

by Arnold

created 2017-01-03 21:28 UTC

HandleShutdownError::reserveMemory() A

↳ Parent: HandleShutdownError

Complexity

Conditions	1
Paths	1

Size

Total Lines	4
Code Lines	2

Duplication

Lines	0
Ratio	0 %

Code Coverage

Tests	3
CRAP Score	1

Importance

Changes

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

<?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);


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


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



    /**
     * 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)) {

            return;
        }
        
        $error = new \ErrorException($err['message'], 0, $err['type'], $err['file'], $err['line']);
        
        if ($err['type'] & $this->logErrorTypes) {
class MyClass { }

$x = new MyClass();
$x->foo = true;
            $this->log($error);
        }
        
        $this->callOnFatalError($error);
    }
}



1		<?php
2
3		namespace Jasny\ErrorHandler;
4
5		/**
6		* Trait for handling errors on shutdown
7		*/
8		trait HandleShutdownError
9		{
10		/**
11		* @var boolean
12		*/
13		protected $registeredShutdown = false;
14
15		/**
16		* A string which reserves memory that can be used to log the error in case of an out of memory fatal error
17		* @var string
18		*/
19		protected $reservedMemory;
20
21
22		/**
23		* Run the fatal error callback
24		*
25		* @param \Exception\|\Error $error
26		*/
27		abstract protected function callOnFatalError($error);
		0 ignored issues – show Documentation introduced 2017-01-03 21:31 UTC by Report Bug Copy Issue Report 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. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
28
29		/**
30		* Wrapper method for `error_get_last`
31		*
32		* @return array
33		*/
34		abstract protected function errorGetLast();
35
36		/**
37		* Wrapper method for `register_shutdown_function`
38		*
39		* @param callable $callback
40		*/
41		abstract protected function registerShutdownFunction($callback);
		0 ignored issues – show Documentation introduced 2017-01-03 21:31 UTC by Report Bug Copy Issue Report 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. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
42
43		/**
44		* Log an error or exception
45		*
46		* @param \Exception\|\Error $error
47		*/
48		abstract public function log($error);
		0 ignored issues – show Documentation introduced 2017-01-03 21:31 UTC by Report Bug Copy Issue Report 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. For interface and abstract methods, it is impossible to infer the return type from the immediate code. In these cases, it is generally advisible to explicitly annotate these methods with a `@return` doc comment to communicate to implementors of these methods what they are expected to return. Loading history...
49
50
51		/**
52		* Reserve memory for shutdown function in case of out of memory
53		*/
54	32	protected function reserveMemory()
55		{
56	32	$this->reservedMemory = str_repeat(' ', 10 * 1024);
57	32	}
58
59		/**
60		* Register the shutdown function
61		*/
62	32	protected function initShutdownFunction()
63		{
64	32	if (!$this->registeredShutdown) {
65	32	$this->registerShutdownFunction([$this, 'shutdownFunction']) ?: false;
66	32	$this->registeredShutdown = true;
67
68	32	$this->reserveMemory();
69	16	}
70	32	}
71
72		/**
73		* Called when the script has ends
74		* @ignore
75		*/
76	16	public function shutdownFunction()
77		{
78	16	$this->reservedMemory = null;
79
80	16	$err = $this->errorGetLast();
81	16	$unhandled = E_ERROR \| E_PARSE \| E_CORE_ERROR \| E_COMPILE_ERROR;
82
83	16	if (!$err \|\| !($err['type'] & $unhandled)) {
		0 ignored issues – show Bug Best Practice introduced 2017-01-03 21:31 UTC by Report Bug Copy Issue Report 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. 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...
84	6	return;
85		}
86
87	10	$error = new \ErrorException($err['message'], 0, $err['type'], $err['file'], $err['line']);
88
89	10	if ($err['type'] & $this->logErrorTypes) {
		0 ignored issues – show Bug introduced 2017-01-03 21:31 UTC by Report Bug Copy Issue Report The property `logErrorTypes` does not exist. Did you maybe forget to declare it? In PHP it is possible to write to properties without declaring them. For example, the following is perfectly valid PHP code: class MyClass { } $x = new MyClass(); $x->foo = true; Generally, it is a good practice to explictly declare properties to avoid accidental typos and provide IDE auto-completion: class MyClass { public $foo; } $x = new MyClass(); $x->foo = true; Loading history...
90	4	$this->log($error);
91	2	}
92
93	10	$this->callOnFatalError($error);
94	10	}
95		}
96
97

jasny / error-handler

Push — master ( 63ec91...ac34b9 )

HandleShutdownError::reserveMemory() A

Complexity

Size

Duplication

Code Coverage

Importance

Duplication Side-by-Side

Filter issues like