Собственный обработчик ошибок php

<?php/**
* Error handler, passes flow over the exception logger with new ErrorException.
*/
function log_error( $num, $str, $file, $line, $context = null )
{
    log_exception( new ErrorException( $str, 0, $num, $file, $line ) );
}/**
* Uncaught exception handler.
*/
function log_exception( Exception $e )
{
    global $config;

        if (

$config["debug"] == true )
    {
        print "<div style='text-align: center;'>";
        print "<h2 style='color: rgb(190, 50, 50);'>Exception Occured:</h2>";
        print "<table style='width: 800px; display: inline-block;'>";
        print "<tr style='background-color:rgb(230,230,230);'><th style='width: 80px;'>Type</th><td>" . get_class( $e ) . "</td></tr>";
        print "<tr style='background-color:rgb(240,240,240);'><th>Message</th><td>{$e->getMessage()}</td></tr>";
        print "<tr style='background-color:rgb(230,230,230);'><th>File</th><td>{$e->getFile()}</td></tr>";
        print "<tr style='background-color:rgb(240,240,240);'><th>Line</th><td>{$e->getLine()}</td></tr>";
        print "</table></div>";
    }
    else
    {
        $message = "Type: " . get_class( $e ) . "; Message: {$e->getMessage()}; File: {$e->getFile()}; Line: {$e->getLine()};";
        file_put_contents( $config["app_dir"] . "/tmp/logs/exceptions.log", $message . PHP_EOL, FILE_APPEND );
        header( "Location: {$config["error_page"]}" );
    }

        exit();
}

/**
* Checks for a fatal error, work around for set_error_handler not working on fatal errors.
*/
function check_for_fatal()
{
    $error = error_get_last();
    if ( $error["type"] == E_ERROR )
        log_error( $error["type"], $error["message"], $error["file"], $error["line"] );
}register_shutdown_function( "check_for_fatal" );
set_error_handler( "log_error" );
set_exception_handler( "log_exception" );
ini_set( "display_errors", "off" );
error_reporting( E_ALL );

class

<?php
function do_something()
    {
    $old = set_error_handler(“my_error_handler”);
    // Do something you want handled by my_error_handler
    set_error_handler($old);
    }
?>

This will work, but it will bite you because each time you do this, it will cause a memory leak as the old error handler is put on a stack for the restore_error_handler() function to use.

So always restore the old error handler using that function instead:

<?php
function do_something()
    {
    set_error_handler(“my_error_handler”);
    // Do something you want handled by my_error_handler
    restore_error_handler();
    }
?>

1) Create a "auto_prepend.php" file in the web root and add this:

<?php

register_shutdown_function('error_alert');

function

error_alert()

{

        if(is_null($e = error_get_last()) === false)

        {

                mail('your.email@example.com', 'Error from auto_prepend', print_r($e, true));

        }

}

?>



2) Then add this "php_value auto_prepend_file /www/auto_prepend.php" to your .htaccess file in the web root.

* make sure you change the email address and the path to the file.

<?php
set_error_handler('\My\Namespace\Bob::errorHandler');
?>

It emails you the errors even if it's a parse error.

set_error_handler() doesn't work for what I wanted.

<?php
ini_set('log_errors',TRUE);
ini_set('error_log','tiny_uploads/errors.txt');

if(

$_SERVER['REMOTE_ADDR'] != "YOUR IP ADDRESS"){
    ini_set('display_errors',false);
}

   function

byebye(){$dir = dirname(__FILE__);
        if(file_exists($dir."/tiny_uploads/errors.txt")){$errors = file_get_contents($dir."/tiny_uploads/errors.txt");

                        if(

trim($errors)){$head = "From: php_errors@".str_replace('www.','',$_SERVER['HTTP_HOST'])."rn";$errors .= "---------------------------------------------nn";$errors .= "nnServer Info:nn".print_r($_SERVER, 1)."nn";
                $errors .= "---------------------------------------------nn";$errors .= "nnCOOKIE:nn".print_r($_COOKIE, 1)."nn";
                $errors .= "---------------------------------------------nn";$errors .= "nnPOST:nn".print_r($_POST, 1)."nn";
                $errors .= "---------------------------------------------nn";$errors .= "nnGET:nn".print_r($_GET, 1)."nn";mail("YOUR@EMAIL.COM","PHP Error ".$_SERVER['HTTP_HOST']."", $errors , $head);$fp = fopen($dir."/tiny_uploads/errors.txt","w+");
                fputs($fp, "");
                fclose($fp);   
            }   
        }
}
register_shutdown_function("byebye");
?>

On a server hosting many sites that share common PHP includes, I set in one spot:

<?php

@ini_set ("error_log", "/my/path/php.err-" . $_SERVER ["HTTP_HOST"] . "-" . $_SERVER ["REMOTE_ADDR"] . "-" . $_SERVER ["REQUEST_METHOD"] . "-" . str_replace ("/", "|", $_SERVER ["REQUEST_URI"]));

?>



I actually used some additional information too from my software that I omitted, but that way, you'll find errors sorted more neatly in for example:-

/my/path/php.err-website.com-127.0.0.1-GET-path|index.html?xyz

And that at least helped me tremendously to then further pin-point where the problem is, as opposed to before just seeing the out of memory and not knowing which site/page it was on (as the PHP error only contains the very latest PHP code where it ran out of memory, which usually is just a shared included file, not the actual page).

<?phpfunction myErrorHandler($errno, $errstr, $errfile, $errline){
    switch ($errno) {
    case E_USER_ERROR:
        if ($errstr == "(SQL)"){
            // handling an sql error
            echo "<b>SQL Error</b> [$errno] " . SQLMESSAGE . "<br />n";
            echo "Query : " . SQLQUERY . "<br />n";
            echo "On line " . SQLERRORLINE . " in file " . SQLERRORFILE . " ";
            echo ", PHP " . PHP_VERSION . " (" . PHP_OS . ")<br />n";
            echo "Aborting...<br />n";
        } else {
            echo "<b>My ERROR</b> [$errno] $errstr<br />n";
            echo "  Fatal error on line $errline in file $errfile";
            echo ", PHP " . PHP_VERSION . " (" . PHP_OS . ")<br />n";
            echo "Aborting...<br />n";
        }
        exit(1);
        break;

    case

E_USER_WARNING:
    case E_USER_NOTICE:
    }
    /* Don't execute PHP internal error handler */
    return true;
}// function to test the error handlingfunction sqlerrorhandler($ERROR, $QUERY, $PHPFILE, $LINE){
    define("SQLQUERY", $QUERY);
    define("SQLMESSAGE", $ERROR);
    define("SQLERRORLINE", $LINE);
    define("SQLERRORFILE", $PHPFILE);
    trigger_error("(SQL)", E_USER_ERROR);
}set_error_handler("myErrorHandler");// trigger an sql error
$query = "SELECT * FROM tbl LIMIT 1";
$sql = @mysql_query($query)
    or sqlerrorhandler("(".mysql_errno().") ".mysql_error(), $query, $_SERVER['PHP_SELF'], __LINE__);?>

1. setting the system error handler

If you want to set the standard php error handler again, after having set your own error handler, this works in php 4.2.1 by passing in an empty string:

<?phpfunction my_handler($log_level, $log_text, $error_file, $error_line)
   {
      // if an error occurs here, the standard error
      // would be called (to avoid recursion)

      // do something useful
      // ...

}$last_handler = set_error_handler("my_handler");// after this, $last_handler == ""

   // restore standard error handler

$last_handler = set_error_handler("");// after this, $last_handler == "my_handler"?>

The very same code now raises an error in php 4.3.9:

   set_error_handler() expects argument 1, '', to be a valid callback

(Since the return value of the first call to set_error_handler() is still the empty string "", I don't see how this can be done any more. I don't really need this, because I use my own handlers as shown below, but it might be good to be aware of this.)

2. setting your own 'second level' handler

If you have set your own error handler, and want to replace it by another one (other than the standard php error handler) while it is being executed, note that the return value of set_error_handler when used INSIDE the error handler is "" instead of the name of the previous handler! This is not too surprising, because during execution of your self defined error handler, php replaces it with the standard php error handler to avoid infinite loops in case of problems inside the handler. This is only interesting if you want nested handlers as I do. Background of my design:

   1st level handler: log into DB
   2nd level handler: log into flat file (if log into DB fails)
   3rd level handler: print to stdout (if log into flat file fails) (this is the sytem handler, finally).

<?phpfunction my_fallback_handler($log_level, $log_text, $error_file, $error_line)
   {
      // if an error occurs here, the standard error
      // would be called (to avoid recursion)

      // do something useful
      // ...

} // my_fallback_handlerfunction my_handler($log_level, $log_text, $error_file, $error_line)
   {
      // if an error occurs here, the standard error
      // would be called (to avoid recursion)

      // but we want to have a fallback handler different
      // to the standard error handler

$last_handler = set_error_handler("my_fallback_handler");// I expected $last_handler == "my_handler"
      // (which it would outside my_handler())
      // but here it is the empty string ""

      // do something useful
      // ...

      // now set the 1st level handler again:
      // (do NOT use $last_handler as argument,
      // because it equals "")

$last_handler = set_error_handler("my_handler");

   }

// my_handler$last_handler = set_error_handler("my_handler");?>

<?phpfunction my_error_handler($errno, $errstr, $errfile, $errline){
    $errno = $errno & error_reporting();
    if($errno == 0) return;
    if(!defined('E_STRICT'))            define('E_STRICT', 2048);
    if(!defined('E_RECOVERABLE_ERROR')) define('E_RECOVERABLE_ERROR', 4096);
    print "<pre>n<b>";
    switch($errno){
        case E_ERROR:               print "Error";                  break;
        case E_WARNING:             print "Warning";                break;
        case E_PARSE:               print "Parse Error";            break;
        case E_NOTICE:              print "Notice";                 break;
        case E_CORE_ERROR:          print "Core Error";             break;
        case E_CORE_WARNING:        print "Core Warning";           break;
        case E_COMPILE_ERROR:       print "Compile Error";          break;
        case E_COMPILE_WARNING:     print "Compile Warning";        break;
        case E_USER_ERROR:          print "User Error";             break;
        case E_USER_WARNING:        print "User Warning";           break;
        case E_USER_NOTICE:         print "User Notice";            break;
        case E_STRICT:              print "Strict Notice";          break;
        case E_RECOVERABLE_ERROR:   print "Recoverable Error";      break;
        default:                    print "Unknown error ($errno)"; break;
    }
    print ":</b> <i>$errstr</i> in <b>$errfile</b> on line <b>$errline</b>n";
    if(function_exists('debug_backtrace')){
        //print "backtrace:n";
        $backtrace = debug_backtrace();
        array_shift($backtrace);
        foreach($backtrace as $i=>$l){
            print "[$i] in function <b>{$l['class']}{$l['type']}{$l['function']}</b>";
            if($l['file']) print " in <b>{$l['file']}</b>";
            if($l['line']) print " on line <b>{$l['line']}</b>";
            print "n";
        }
    }
    print "n</pre>";
    if(isset($GLOBALS['error_fatal'])){
        if($GLOBALS['error_fatal'] & $errno) die('fatal');
    }
}

function

error_fatal($mask = NULL){
    if(!is_null($mask)){
        $GLOBALS['error_fatal'] = $mask;
    }elseif(!isset($GLOBALS['die_on'])){
        $GLOBALS['error_fatal'] = 0;
    }
    return $GLOBALS['error_fatal'];
}?>

Usage :

<?php
error_reporting(E_ALL);      // will report all errors
set_error_handler('my_error_handler');
error_fatal(E_ALL^E_NOTICE); // will die on any error except E_NOTICE
?>

This is not exactly true.  set_error_handler() can't handle them, but ob_start() can handle at least E_ERROR.

<?phpfunction error_handler($output)
{
    $error = error_get_last();
    $output = "";
    foreach ($error as $info => $string)
        $output .= "{$info}: {$string}n";
    return $output;
}ob_start('error_handler');will_this_undefined_function_raise_an_error();?>

<?php

function shutdown()

{

    $a=error_get_last();

    if($a==null)  

        echo "No errors";

    else

         print_r($a);

   
}

register_shutdown_function('shutdown');

ini_set('max_execution_time',1 );

sleep(3);

?>



it will output

Array ( [type] => 1 [message] => Maximum execution time of 1 second exceeded [file] => /path/to/file_name.php [line] => 136 )

<?php
    error_reporting(E_ALL);
    ini_set('display_errors', 0);

    function

shutdown(){
        $isError = false;
        if ($error = error_get_last()){
            switch($error['type']){
                case E_ERROR:
                case E_CORE_ERROR:
                case E_COMPILE_ERROR:
                case E_USER_ERROR:
                    $isError = true;
                    break;
            }
        }

        if (

$isError){
            echo "Script execution halted ({$error['message']})";
        } else {
            echo "Script completed";
        }
    }register_shutdown_function('shutdown');
?>

Note that this will only catch runtime errors. So calling a method in a non existing class, or declaring a function twice does not trigger the shutdown handler.

('Course, there are ways to create your handler to handle even this situation, but it's probably best left this way for general purposes.)

<?
  if( ($level & error_reporting()) == 0 ) return;
?>

class CallbackClass {
    function CallbackFunction() {
        // refers to $this
    }

    function StaticFunction() {
        // doesn't refer to $this
    }
}

function NonClassFunction() {
}

there appear to be 3 ways to set a callback function in PHP (using set_error_handler() as an example):

1: set_error_handler('NonClassFunction');

2: set_error_handler(array('CallbackClass', 'StaticFunction'));

3: $o =& new CallbackClass();
   set_error_handler(array($o, 'CallbackFunction'));

The following may also prove useful:

class CallbackClass {
    function CallbackClass() {
        set_error_handler(array(&$this, 'CallbackFunction')); // the & is important
    }

        function CallbackFunction() {
        // refers to $this
    }
}

The documentation is not clear in outlining these three examples.

1    E_ERROR (integer)     Fatal run-time errors. These indicate errors that can not be recovered from, such as a memory allocation problem. Execution of the script is halted.    
2    E_WARNING (integer)     Run-time warnings (non-fatal errors). Execution of the script is not halted.    
4    E_PARSE (integer)     Compile-time parse errors. Parse errors should only be generated by the parser.    
8    E_NOTICE (integer)     Run-time notices. Indicate that the script encountered something that could indicate an error, but could also happen in the normal course of running a script.    
16    E_CORE_ERROR (integer)     Fatal errors that occur during PHP's initial startup. This is like an E_ERROR, except it is generated by the core of PHP.    
32    E_CORE_WARNING (integer)     Warnings (non-fatal errors) that occur during PHP's initial startup. This is like an E_WARNING, except it is generated by the core of PHP.    
64    E_COMPILE_ERROR (integer)     Fatal compile-time errors. This is like an E_ERROR, except it is generated by the Zend Scripting Engine.    
128    E_COMPILE_WARNING (integer)     Compile-time warnings (non-fatal errors). This is like an E_WARNING, except it is generated by the Zend Scripting Engine.    
256    E_USER_ERROR (integer)     User-generated error message. This is like an E_ERROR, except it is generated in PHP code by using the PHP function trigger_error().    
512    E_USER_WARNING (integer)     User-generated warning message. This is like an E_WARNING, except it is generated in PHP code by using the PHP function trigger_error().    
1024    E_USER_NOTICE (integer)     User-generated notice message. This is like an E_NOTICE, except it is generated in PHP code by using the PHP function trigger_error().    
2048    E_STRICT (integer)     Enable to have PHP suggest changes to your code which will ensure the best interoperability and forward compatibility of your code.    Since PHP 5 but not included in E_ALL until PHP 5.4.0
4096    E_RECOVERABLE_ERROR (integer)     Catchable fatal error. It indicates that a probably dangerous error occurred, but did not leave the Engine in an unstable state. If the error is not caught by a user defined handle (see also set_error_handler()), the application aborts as it was an E_ERROR.    Since PHP 5.2.0
8192    E_DEPRECATED (integer)     Run-time notices. Enable this to receive warnings about code that will not work in future versions.    Since PHP 5.3.0
16384    E_USER_DEPRECATED (integer)     User-generated warning message. This is like an E_DEPRECATED, except it is generated in PHP code by using the PHP function trigger_error().    Since PHP 5.3.0
32767    E_ALL (integer)     All errors and warnings, as supported, except of level E_STRICT prior to PHP 5.4.0.     32767 in PHP 5.4.x, 30719 in PHP 5.3.x, 6143 in PHP 5.2.x, 2047 previously

(Copied from http://php.net/manual/en/errorfunc.constants.php)

<?php// var_dump or anything else, as this will never be called because of the 0
set_error_handler('var_dump', 0);
@$undef_var;
restore_error_handler();// error_get_last() is now in a well known state:
// Undefined variable: undef_var... // Do something$e = error_get_last();

...

?>

In this instance, you should manually load classes required by the error handler.

"errcontext will contain an array of every variable that existed in the scope the error was triggered in. User error handler must not modify error context."

But do you know WHY you must not modify the error context? It appears that errcontext is (in effect if not literally) created by taking $GLOBALS and adding the non-global local variables as additional entries in that array, then passing the whole thing *by reference*.

(You can prove this to be true if you set up a custom error handler and then print_r($errcontext) within it, because $GLOBALS will be printed as a recursive array).

In other words, the language in the manual is misleading, because errcontext is NOT a copy of the variables that existed when the error WAS triggered, but rather is a reference to the *existing LIVE variables* in the calling script.

This includes superglobal variables like $_SERVER, $_POST, $_GET, etc., as well as all user-defined variables in scope.

The significance of that is that if you modify errcontext, you will be modifying those other variables, not just for the life of your error handling function, but for the life of the calling script as well.

That doesn't matter if you plan to halt execution in your error handling function, but it will lead to unexpected behavior if you modify $errcontext and then return to the program's normal flow after handling the error, because the variables will stay modified. For example, if you unset $_SERVER in your custom error handling function, it will remain unset once the function is over and you have returned to the page that generated the error.

This should be made clearer in the manual, starting by marking errhandler with an ampersand (&) for passage by reference in the "Parameters" section above, like so:

handler ( int $errno, string $errstr [, string $errfile [, int $errline [, array &$errcontext]]] )

<?php

class error {

   var $error;

   function

error() {

       $this->setIni();    // this causes PHP to ignore all other changes to the class.

   }

   function

handler() {

       echo $this->error.'!!';

   }

   function

setText($text) {

         $this->error = $text;

   }

   function

setIni() {

       set_error_handler(array($this, 'handler'));

   }

}
$eh = new error;

$eh->setText('Error! <br>');  // this will not be saved
trigger_error('text', E_USER_ERROR);

// prints '!!'

?>



How it should be done:

<?php

class error {

   var $error;

   function

error() {

         // dont let PHP know of our error handler yet

   }

   function

handler() {

       echo $this->error.'!!';

   }

   function

setText($text) {

         $this->error = $text;

   }

   function

setIni() {

       set_error_handler(array($this, 'handler'));

   }

}
$eh = new error;

$eh->setText('Error! <br>');  // this WILL work

$eh->setIni();  // call this method when you're ready with configuring the class. All other methods that will be called will have no effect on the errorHandling by PHP
trigger_error('text', E_USER_ERROR);

// prints 'Error! <br>!!'

?>

<?php

register_shutdown_function('shutdownFunction');

function shutDownFunction() {

    $error = error_get_last();

    if ($error['type'] == 1) {

        //do your stuff    

    }

}

?>

Example:
    <?PHP
        $Handler = new class ()
        {
            public function __construct ()
            {
                set_error_handler([&$this, 'HandleError']);
                set_exception_handler([&$this, 'HandleException']);
            }
            protected function HandleError ( $Code, $Message, $File = null, $Line = 0, $Context = [] )
            {
                // Handle error here.
            }
            private function HandleException ( $Exception )
            {
                // Handle exception here.
            }
        }
    ?>

NOTE: these methods must match the callbacks parameters signatures.

    //
    // Set the error handler to one that prints out more
    // visible errors
    //
    set_error_handler(function ($errno, $errstr)
    {
        $str = '<div style="margin: 20px; background-color: #fdd; border: 3px solid red; padding: 10px; border-radius: 15px; line-height: 25px"><b>Error: </b>%s (error level: %s)</div>';

                printf($str, $errstr, $errno);
    });

<?
$previous = set_error_handler(function ($errno, $errstr, $errfile, $errline, $errcontext) use (&$previous) {
    /* Your custom error handling code here. */

    // If another error handler was defined, call it.
    if ($previous) {
        return $previous($errno, $errstr, $errfile, $errline, $errcontext);
    } else {
        // Use the standard PHP error handler.
        return false;
    }
});
?>

function prettycode($code){
    return $code == 0 ? "FATAL" : array_search($code, get_defined_constants(true)['Core']);
}

With PHP function error_reporting we can add together option with bitwise add operator | . But we can't use those constants in htaccess file and in my case I have no idea how to add bitwise number.

So, solution can be casting selected options to int:

echo (int)(E_ERROR | E_WARNING | E_PARSE | E_USER_ERROR) ;
->263

Then you can use 263 in .htaccess

php_value error_reporting 263

In my case I needed those errors to be displayed for my debugging server. But the combination can be different from mine.

Here is working code:

    // Do nothing if @ operator
    $errLevel=error_reporting(E_ALL);
    if ($errLevel===0)
        return true; // ignore @ prefixed expression errors

This has subtle ramifications for $php_errormsg. If you are relying on your error handler to suppress certain kinds of error message from going into $php_errormsg (via return true; because error_reporting doesn't affect $php_errormsg setting) then this will not work for any code called within that error handler.

here is the solution I found to transform a specific set of errors into exception and afterwards be able to selectively act (with the error code) regarding categories : 

<?php

ini_set('error_reporting',E_ALL^E_NOTICE);
## first 10 bits reserved for the initial error number

define('EMASK',(~0)<<10);

define('ECODEMASK',~EMASK);

## categories

define('IOERROR', 1<<10);

define('EMPTYPARMS', 1<<11);

define('FAILURE', 1<<12);

## string error patterns => code
$catch_me=array(

    "/^(file_get_contents)((.*)).*failed to open stream: (.*)/ " =>

        array ( 'mesg' => "IO::Failed to open stream with",

                'code' => IOERROR | FAILURE

        ),

    "/^fopen(.*): Filename cannot be empty/" =>

        array( 'msg' => "Parameters::empty",

                'code' => EMPTYPARMS

        )

    );

function error_2_exception($errno, $errstr, $errfile, $errline,$context) {

    global $catch_me;

    foreach ($catch_me as $regexp  => $res) {

        if(preg_match($regexp,$errstr,$match)){

            throw new Exception($res['mesg'],$res['code']|( $errno & EMASK ) );

        }

    }

    /* switch back to PHP internal error handler  */

    return false;

}

## => want to catch this one

$f=file_get_contents("mlsdkfm");

## dont want to break existing wrong behaviour yet (so not caught)

$f=file_get_contents('');

## magic

set_error_handler("error_2_exception");

## behaviour remains the same

$f=file_get_contents('');

try {

## web services that dont work now raise an exception o/

$f=file_get_contents("mlsdkfm");

} catch(Exception $e) {

## and I can group my exception by category

    echo ( $e->getCode() & FAILURE )  ? "nEPIC FAILn" : "nbegnine";

}
?>

<?php

$cfg

= array();
$cfg['debug'] = 1;
$cfg['adminEmail'] = 'name@domain.tld';

function

errorHandler($errno, $errstr='', $errfile='', $errline='')
{
    // if error has been supressed with an @
    if (error_reporting() == 0) {
        return;
    }

    global

$cfg;// check if function has been called by an exception
    if(func_num_args() == 5) {
        // called by trigger_error()
        $exception = null;
        list($errno, $errstr, $errfile, $errline) = func_get_args();$backtrace = array_reverse(debug_backtrace());

    }else {

// caught exception
        $exc = func_get_arg(0);
        $errno = $exc->getCode();
        $errstr = $exc->getMessage();
        $errfile = $exc->getFile();
        $errline = $exc->getLine();$backtrace = $exc->getTrace();
    }$errorType = array (
               E_ERROR            => 'ERROR',
               E_WARNING        => 'WARNING',
               E_PARSE          => 'PARSING ERROR',
               E_NOTICE         => 'NOTICE',
               E_CORE_ERROR     => 'CORE ERROR',
               E_CORE_WARNING   => 'CORE WARNING',
               E_COMPILE_ERROR  => 'COMPILE ERROR',
               E_COMPILE_WARNING => 'COMPILE WARNING',
               E_USER_ERROR     => 'USER ERROR',
               E_USER_WARNING   => 'USER WARNING',
               E_USER_NOTICE    => 'USER NOTICE',
               E_STRICT         => 'STRICT NOTICE',
               E_RECOVERABLE_ERROR  => 'RECOVERABLE ERROR'
               );// create error message
    if (array_key_exists($errno, $errorType)) {
        $err = $errorType[$errno];
    } else {
        $err = 'CAUGHT EXCEPTION';
    }$errMsg = "$err: $errstr in $errfile on line $errline";// start backtrace
    foreach ($backtrace as $v) {

        if (isset(

$v['class'])) {$trace = 'in class '.$v['class'].'::'.$v['function'].'(';

            if (isset(

$v['args'])) {
                $separator = '';

                foreach(

$v['args'] as $arg ) {
                    $trace .= "$separator".getArgument($arg);
                    $separator = ', ';
                }
            }
            $trace .= ')';
        }

        elseif (isset(

$v['function']) && empty($trace)) {
            $trace = 'in function '.$v['function'].'(';
            if (!empty($v['args'])) {$separator = '';

                foreach(

$v['args'] as $arg ) {
                    $trace .= "$separator".getArgument($arg);
                    $separator = ', ';
                }
            }
            $trace .= ')';
        }
    }// display error msg, if debug is enabled
    if($cfg['debug'] == 1) {
        echo '<h2>Debug Msg</h2>'.nl2br($errMsg).'<br />
            Trace: '.nl2br($trace).'<br />';
    }// what to do
    switch ($errno) {
        case E_NOTICE:
        case E_USER_NOTICE:
            return;
            break;

        default:
            if(

$cfg['debug'] == 0){
                // send email to admin
                if(!empty($cfg['adminEmail'])) {
                    @mail($cfg['adminEmail'],'critical error on '.$_SERVER['HTTP_HOST'], $errorText,
                            'From: Error Handler');
                }
                // end and display error msg
                exit(displayClientMessage());
            }
            else
                exit('<p>aborting.</p>');
            break;

    }

}

// end of errorHandler()function displayClientMessage()
{
    echo 'some html page with error message';

}

function

getArgument($arg)
{
    switch (strtolower(gettype($arg))) {

        case

'string':
            return( '"'.str_replace( array("n"), array(''), $arg ).'"' );

        case

'boolean':
            return (bool)$arg;

        case

'object':
            return 'object('.get_class($arg).')';

        case

'array':
            $ret = 'array(';
            $separtor = '';

            foreach (

$arg as $k => $v) {
                $ret .= $separtor.getArgument($k).' => '.getArgument($v);
                $separtor = ', ';
            }
            $ret .= ')';

            return

$ret;

        case

'resource':
            return 'resource('.get_resource_type($arg).')';

        default:
            return

var_export($arg, true);
    }
}?>

function userErrorHandler($errno, $errmsg, $filename, $linenum, $vars) {
   if (error_reporting())
echo $errmsg;
    }
set_error_handler("userErrorHandler");

function test(){
trigger_error("Error Message", E_USER_WARNING);
}

@test(); // doesn't output anything