Monolog\ErrorHandler Class Reference

Monolog error handler. More...

Collaboration diagram for Monolog\ErrorHandler:

Public Member Functions
	__construct (LoggerInterface $logger)
	registerExceptionHandler ($level=null, $callPrevious=true)
	registerErrorHandler (array $levelMap=array(), $callPrevious=true, $errorTypes=-1, $handleOnlyReportedErrors=true)
	registerFatalHandler ($level=null, $reservedMemorySize=20)
	handleException ($e)
	handleError ($code, $message, $file='', $line=0, $context=array())
	handleFatalError ()

Static Public Member Functions
static	register (LoggerInterface $logger, $errorLevelMap=array(), $exceptionLevel=null, $fatalLevel=null)
	Registers a new ErrorHandler for a given Logger. More...

Protected Member Functions
	defaultErrorLevelMap ()

Static Private Member Functions
static	codeToString ($code)

Private Attributes
	$logger
	$previousExceptionHandler
	$uncaughtExceptionLevel
	$previousErrorHandler
	$errorLevelMap
	$handleOnlyReportedErrors
	$hasFatalErrorHandler
	$fatalLevel
	$reservedMemory

Static Private Attributes
static	$fatalErrors = array(E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR)

Detailed Description

Monolog error handler.

A facility to enable logging of runtime errors, exceptions and fatal errors.

Quick setup: ErrorHandler::register($logger);

Author

Jordi Boggiano j.bog.nosp@m.gian.nosp@m.o@sel.nosp@m.d.be

Definition at line 27 of file ErrorHandler.php.

Constructor & Destructor Documentation

__construct()

Monolog\ErrorHandler::__construct

(

LoggerInterface

$logger

)

Definition at line 43 of file ErrorHandler.php.

    {
        $this->logger = $logger;
    }

Member Function Documentation

codeToString()

static Monolog\ErrorHandler::codeToString (   $code )

staticprivate

Definition at line 190 of file ErrorHandler.php.

    {
        switch ($code) {
            case E_ERROR:
                return 'E_ERROR';
            case E_WARNING:
                return 'E_WARNING';
            case E_PARSE:
                return 'E_PARSE';
            case E_NOTICE:
                return 'E_NOTICE';
            case E_CORE_ERROR:
                return 'E_CORE_ERROR';
            case E_CORE_WARNING:
                return 'E_CORE_WARNING';
            case E_COMPILE_ERROR:
                return 'E_COMPILE_ERROR';
            case E_COMPILE_WARNING:
                return 'E_COMPILE_WARNING';
            case E_USER_ERROR:
                return 'E_USER_ERROR';
            case E_USER_WARNING:
                return 'E_USER_WARNING';
            case E_USER_NOTICE:
                return 'E_USER_NOTICE';
            case E_STRICT:
                return 'E_STRICT';
            case E_RECOVERABLE_ERROR:
                return 'E_RECOVERABLE_ERROR';
            case E_DEPRECATED:
                return 'E_DEPRECATED';
            case E_USER_DEPRECATED:
                return 'E_USER_DEPRECATED';
        }
 
        return 'Unknown PHP error';
    }

References $code.

defaultErrorLevelMap()

Monolog\ErrorHandler::defaultErrorLevelMap ( )

protected

Definition at line 104 of file ErrorHandler.php.

    {
        return array(
            E_ERROR             => LogLevel::CRITICAL,
            E_WARNING           => LogLevel::WARNING,
            E_PARSE             => LogLevel::ALERT,
            E_NOTICE            => LogLevel::NOTICE,
            E_CORE_ERROR        => LogLevel::CRITICAL,
            E_CORE_WARNING      => LogLevel::WARNING,
            E_COMPILE_ERROR     => LogLevel::ALERT,
            E_COMPILE_WARNING   => LogLevel::WARNING,
            E_USER_ERROR        => LogLevel::ERROR,
            E_USER_WARNING      => LogLevel::WARNING,
            E_USER_NOTICE       => LogLevel::NOTICE,
            E_STRICT            => LogLevel::NOTICE,
            E_RECOVERABLE_ERROR => LogLevel::ERROR,
            E_DEPRECATED        => LogLevel::NOTICE,
            E_USER_DEPRECATED   => LogLevel::NOTICE,
        );
    }

handleError()

Monolog\ErrorHandler::handleError	(		$code,
			$message,
			$file = '',
			$line = 0,
			$context = array()
	)

Definition at line 146 of file ErrorHandler.php.

    {
        if ($this->handleOnlyReportedErrors && !(error_reporting() & $code)) {
            return;
        }
 
        // fatal error codes are ignored if a fatal error handler is present as well to avoid duplicate log entries
        if (!$this->hasFatalErrorHandler || !in_array($code, self::$fatalErrors, true)) {
            $level = isset($this->errorLevelMap[$code]) ? $this->errorLevelMap[$code] : LogLevel::CRITICAL;
            $this->logger->log($level, self::codeToString($code).': '.$message, array('code' => $code, 'message' => $message, 'file' => $file, 'line' => $line));
        }
 
        if ($this->previousErrorHandler === true) {
            return false;
        } elseif ($this->previousErrorHandler) {
            return call_user_func($this->previousErrorHandler, $code, $message, $file, $line, $context);
        }
    }

References $code, $file, and $message.

handleException()

Monolog\ErrorHandler::handleException

(

$e

)

Definition at line 128 of file ErrorHandler.php.

    {
        $this->logger->log(
            $this->uncaughtExceptionLevel === null ? LogLevel::ERROR : $this->uncaughtExceptionLevel,
            sprintf('Uncaught Exception %s: "%s" at %s line %s', get_class($e), $e->getMessage(), $e->getFile(), $e->getLine()),
            array('exception' => $e)
        );
 
        if ($this->previousExceptionHandler) {
            call_user_func($this->previousExceptionHandler, $e);
        }
 
        exit(255);
    }

References exit, and sprintf.

handleFatalError()

Monolog\ErrorHandler::handleFatalError

(

)

Definition at line 168 of file ErrorHandler.php.

    {
        $this->reservedMemory = null;
 
        $lastError = error_get_last();
        if ($lastError && in_array($lastError['type'], self::$fatalErrors, true)) {
            $this->logger->log(
                $this->fatalLevel === null ? LogLevel::ALERT : $this->fatalLevel,
                'Fatal Error ('.self::codeToString($lastError['type']).'): '.$lastError['message'],
                array('code' => $lastError['type'], 'message' => $lastError['message'], 'file' => $lastError['file'], 'line' => $lastError['line'])
            );
 
            if ($this->logger instanceof Logger) {
                foreach ($this->logger->getHandlers() as $handler) {
                    if ($handler instanceof AbstractHandler) {
                        $handler->close();
                    }
                }
            }
        }
    }

References $handler.

register()

static Monolog\ErrorHandler::register ( LoggerInterface  $logger,   $errorLevelMap = array(),   $exceptionLevel = null,   $fatalLevel = null  )

static

Registers a new ErrorHandler for a given Logger.

By default it will handle errors, exceptions and fatal errors

Parameters

LoggerInterface	$logger
array | false	$errorLevelMap	an array of E_* constant to LogLevel::* constant mapping, or false to disable error handling
int | false	$exceptionLevel	a LogLevel::* constant, or false to disable exception handling
int | false	$fatalLevel	a LogLevel::* constant, or false to disable fatal error handling

Returns

ErrorHandler

Definition at line 59 of file ErrorHandler.php.

    {
        $handler = new static($logger);
        if ($errorLevelMap !== false) {
            $handler->registerErrorHandler($errorLevelMap);
        }
        if ($exceptionLevel !== false) {
            $handler->registerExceptionHandler($exceptionLevel);
        }
        if ($fatalLevel !== false) {
            $handler->registerFatalHandler($fatalLevel);
        }
 
        return $handler;
    }

References $handler.

Referenced by Monolog\Handler\PHPConsoleHandlerTest\testError().

Here is the caller graph for this function:

registerErrorHandler()

Monolog\ErrorHandler::registerErrorHandler	(	array	$levelMap = array(),
			$callPrevious = true,
			$errorTypes = -1,
			$handleOnlyReportedErrors = true
	)

Definition at line 84 of file ErrorHandler.php.

    {
        $prev = set_error_handler(array($this, 'handleError'), $errorTypes);
        $this->errorLevelMap = array_replace($this->defaultErrorLevelMap(), $levelMap);
        if ($callPrevious) {
            $this->previousErrorHandler = $prev ?: true;
        }
 
        $this->handleOnlyReportedErrors = $handleOnlyReportedErrors;
    }

registerExceptionHandler()

Monolog\ErrorHandler::registerExceptionHandler	(		$level = null,
			$callPrevious = true
	)

Definition at line 75 of file ErrorHandler.php.

    {
        $prev = set_exception_handler(array($this, 'handleException'));
        $this->uncaughtExceptionLevel = $level;
        if ($callPrevious && $prev) {
            $this->previousExceptionHandler = $prev;
        }
    }

registerFatalHandler()

Monolog\ErrorHandler::registerFatalHandler	(		$level = null,
			$reservedMemorySize = 20
	)

Definition at line 95 of file ErrorHandler.php.

    {
        register_shutdown_function(array($this, 'handleFatalError'));
 
        $this->reservedMemory = str_repeat(' ', 1024 * $reservedMemorySize);
        $this->fatalLevel = $level;
        $this->hasFatalErrorHandler = true;
    }

Field Documentation

$errorLevelMap

Monolog\ErrorHandler::$errorLevelMap

private

Definition at line 35 of file ErrorHandler.php.

$fatalErrors

Monolog\ErrorHandler::$fatalErrors = array(E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR)

staticprivate

Definition at line 41 of file ErrorHandler.php.

$fatalLevel

Monolog\ErrorHandler::$fatalLevel

private

Definition at line 39 of file ErrorHandler.php.

$handleOnlyReportedErrors

Monolog\ErrorHandler::$handleOnlyReportedErrors

private

Definition at line 36 of file ErrorHandler.php.

$hasFatalErrorHandler

Monolog\ErrorHandler::$hasFatalErrorHandler

private

Definition at line 38 of file ErrorHandler.php.

$logger

Monolog\ErrorHandler::$logger

private

Definition at line 29 of file ErrorHandler.php.

$previousErrorHandler

Monolog\ErrorHandler::$previousErrorHandler

private

Definition at line 34 of file ErrorHandler.php.

$previousExceptionHandler

Monolog\ErrorHandler::$previousExceptionHandler

private

Definition at line 31 of file ErrorHandler.php.

$reservedMemory

Monolog\ErrorHandler::$reservedMemory

private

Definition at line 40 of file ErrorHandler.php.

$uncaughtExceptionLevel

Monolog\ErrorHandler::$uncaughtExceptionLevel

private

Definition at line 32 of file ErrorHandler.php.

---

The documentation for this class was generated from the following file:

• libs/composer/vendor/monolog/monolog/src/Monolog/ErrorHandler.php