Error reporting: Part II

Last month we looked at PHP's extensive error reporting framework. This month, we'll be looking at customising error reporting, and providing much more information for developers.

Python vs. PHP: Choosing your next project's language

Customised user error reporting

So far, we've focused on programmatic errors detected by the PHP interrupter. Once an application is finished and tested, however, these errors become secondary to producing standardised reports of user generated errors. PHP provides a framework to do this. In the following example, we define our own error handler and use it within our functions:

01 <?
02 error_reporting(0);
03 function errhdlr($errno, $errstr, $errfile, $errline, $vars)
04 {
05 	$ep = "";
06 	switch($errno) {
07 		case E_ERROR: $ep = "Error"; break;
08 		case E_WARNING: $ep = "Warning"; break;
09 		case E_NOTICE: $ep = "Notice"; break;
10 		case E_USER_ERROR: $ep = "Application error"; break;
11 		case E_USER_WARNING: $ep = "Application warning"; break;
12 		case E_USER_NOTICE: $ep = "Application notice"; break;
13 	}
14 	$ue = array(E_USER_ERROR, E_USER_WARNING, E_USER_NOTICE);
15 	$err =  "<p><b>$ep: $errstr ($errfile: $errline)</b></p>";
16 	if(in_array($errno, $ue)) {
17 		$err .= "<p>Function variables: <br />".
18 			"<pre>".var_export($vars, true)."</pre></p>";
19 	}
20 	$err .= "<p>Backtrace: <br /><pre>".var_export(debug_backtrace(), true)."</pre></p>";
21 	echo $err;
22 }
23 function negate($num)
24 {
25 	if(!is_numeric($num)) {
26 		trigger_error("'$num' is not a number", E_USER_ERROR);
27 		return 0;
28 	}
29 	if($num < 0) {
30 		trigger_error("'$num' is already negative", E_USER_WARNING);
31 		return($num);
32 	}
33 	return(- $num);
34 }
35 $olderrhdlr = set_error_handler("errhdlr");
36 $num = negate("foo");
37 $num = negate(-1);
38 $num = negate(1);
39 ?>

On line 02, we turn off PHP error reporting so that we can handle it ourselves. Following this, we define our error handling function, errhdlr(). This function takes five arguments: $errno, the type of error; $errstr, a string describing the error; $errfile, the file in which the error occurred; $errline, the line at which the error occurred; and $vars, an array representing the arguments to the function which generated the error.

Lines 05-13 determine what type of error is taking place and defines a string, $ep, which we'll use in our error report so that the user know s how severe the error is. PHP can generate other errors but, for the sake of simplicity, we'll only look at a few here. A complete list of error types can be found at http://www.php.net/manual/en/ref.errorfunc.php.

On line 14 we construct an array of user level errors to test our error type again. The reason we do this is that only in these cases does $var contain function arguments. On line 15 we finally construct our error report, while on lines 16-19 we append a dump of function arguments, if applicable. On line 20 we generate a backtrace. This describes the path of functions we took to get to the current line, and is very useful for debugging unexpected errors. On line 21 we display the report.

Next, we create a basic function negate() which attempts to negate the argument $num. There are two possible problems we may encounter: $num is not a number, in which case an error has occurred; or $num is already negative, in which case the function has been called incorrectly. In our case, these conditions generate an error and warning respectively.

To do this, we need to validate the argument first. On line 25 we test if $num is actually a number. If it isn't, we generate our error report. This is done by calling the function trigger_error(). The first argument is an error string: $errstr in our error handler errhdlr(). The second argument is the error type. Notice that it corresponds to one of the error types in errhdlr(). When viewed in a Web browser, the error will appear as follows:

Application error: 'foo' is not a number(/script.php: 27)
Function variables:
array (
	'num' => 'foo'
)

Followed by a backtrace. On line 29 we test if $num is already negative. If it is, we generate a warning. Finally, on line 35 we change the default error handler to errhdlr() using set_error_handler(). Following this, we trigger user errors by calling negate() with invalid arguments. That's it for error handling. Next month, I'll be taking an early look at what's new in PHP 5.

Recommended

Keep up with the latest tech news, reviews and previews by subscribing to the Good Gear Guide newsletter.

Gavin Sherry

PC World

Comments

Comments are now closed.

Most Popular Reviews

Follow Us

Best Deals on GoodGearGuide

Shopping.com

Latest News Articles

Resources

GGG Evaluation Team

Kathy Cassidy

STYLISTIC Q702

First impression on unpacking the Q702 test unit was the solid feel and clean, minimalist styling.

Anthony Grifoni

STYLISTIC Q572

For work use, Microsoft Word and Excel programs pre-installed on the device are adequate for preparing short documents.

Steph Mundell

LIFEBOOK UH574

The Fujitsu LifeBook UH574 allowed for great mobility without being obnoxiously heavy or clunky. Its twelve hours of battery life did not disappoint.

Andrew Mitsi

STYLISTIC Q702

The screen was particularly good. It is bright and visible from most angles, however heat is an issue, particularly around the Windows button on the front, and on the back where the battery housing is located.

Simon Harriott

STYLISTIC Q702

My first impression after unboxing the Q702 is that it is a nice looking unit. Styling is somewhat minimalist but very effective. The tablet part, once detached, has a nice weight, and no buttons or switches are located in awkward or intrusive positions.

Latest Jobs

Don’t have an account? Sign up here

Don't have an account? Sign up now

Forgot password?