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

	$lastFatalTrace

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 28 of file ErrorHandler.php.

Constructor & Destructor Documentation

◆ __construct()

Monolog\ErrorHandler::__construct ( LoggerInterface $logger )

Definition at line 45 of file ErrorHandler.php.

     {
         $this->logger = $logger;
     }

Member Function Documentation

◆ codeToString()

static Monolog\ErrorHandler::codeToString ( $code )

staticprivate

Definition at line 202 of file ErrorHandler.php.

References $code.

     {
         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';
     }

◆ defaultErrorLevelMap()

Monolog\ErrorHandler::defaultErrorLevelMap ( )

protected

Definition at line 109 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 151 of file ErrorHandler.php.

References $code, $context, and $message.

     {
         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));
         } else {
             // http://php.net/manual/en/function.debug-backtrace.php
             // As of 5.3.6, DEBUG_BACKTRACE_IGNORE_ARGS option was added.
             // Any version less than 5.3.6 must use the DEBUG_BACKTRACE_IGNORE_ARGS constant value '2'.
             $trace = debug_backtrace((PHP_VERSION_ID < 50306) ? 2 : DEBUG_BACKTRACE_IGNORE_ARGS);
             array_shift($trace); // Exclude handleError from trace
             $this->lastFatalTrace = $trace;
         }
 
         if ($this->previousErrorHandler === true) {
             return false;
         } elseif ($this->previousErrorHandler) {
             return call_user_func($this->previousErrorHandler, $code, $message, $file, $line, $context);
         }
     }

◆ handleException()

Monolog\ErrorHandler::handleException ( $e )

Definition at line 133 of file ErrorHandler.php.

References exit.

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

◆ handleFatalError()

Monolog\ErrorHandler::handleFatalError ( )

Definition at line 180 of file ErrorHandler.php.

References $handler.

     {
         $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'], 'trace' => $this->lastFatalTrace)
             );
 
             if ($this->logger instanceof Logger) {
                 foreach ($this->logger->getHandlers() as $handler) {
                     if ($handler instanceof AbstractHandler) {
                         $handler->close();
                     }
                 }
             }
         }
     }

◆ 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 61 of file ErrorHandler.php.

References $handler.

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

     {
         //Forces the autoloader to run for LogLevel. Fixes an autoload issue at compile-time on PHP5.3. See https://github.com/Seldaek/monolog/pull/929
         class_exists('\\Psr\\Log\\LogLevel', true);
 
         $handler = new static($logger);
         if ($errorLevelMap !== false) {
             $handler->registerErrorHandler($errorLevelMap);
         }
         if ($exceptionLevel !== false) {
             $handler->registerExceptionHandler($exceptionLevel);
         }
         if ($fatalLevel !== false) {
             $handler->registerFatalHandler($fatalLevel);
         }
 
         return $handler;
     }

Here is the caller graph for this function:

◆ registerErrorHandler()

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

Definition at line 89 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 80 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 100 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 36 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 43 of file ErrorHandler.php.

◆ $fatalLevel

Monolog\ErrorHandler::$fatalLevel

private

Definition at line 40 of file ErrorHandler.php.

◆ $handleOnlyReportedErrors

Monolog\ErrorHandler::$handleOnlyReportedErrors

private

Definition at line 37 of file ErrorHandler.php.

◆ $hasFatalErrorHandler

Monolog\ErrorHandler::$hasFatalErrorHandler

private

Definition at line 39 of file ErrorHandler.php.

◆ $lastFatalTrace

Monolog\ErrorHandler::$lastFatalTrace

private

Definition at line 42 of file ErrorHandler.php.

◆ $logger

Monolog\ErrorHandler::$logger

private

Definition at line 30 of file ErrorHandler.php.

◆ $previousErrorHandler

Monolog\ErrorHandler::$previousErrorHandler

private

Definition at line 35 of file ErrorHandler.php.

◆ $previousExceptionHandler

Monolog\ErrorHandler::$previousExceptionHandler

private

Definition at line 32 of file ErrorHandler.php.

◆ $reservedMemory

Monolog\ErrorHandler::$reservedMemory

private

Definition at line 41 of file ErrorHandler.php.

◆ $uncaughtExceptionLevel

Monolog\ErrorHandler::$uncaughtExceptionLevel

private

Definition at line 33 of file ErrorHandler.php.

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

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

Public Member Functions

Static Public Member Functions

Protected Member Functions

Static Private Member Functions

Private Attributes

Static Private Attributes

Detailed Description

Constructor & Destructor Documentation

◆ __construct()

Member Function Documentation

◆ codeToString()

◆ defaultErrorLevelMap()

◆ handleError()

◆ handleException()

◆ handleFatalError()

◆ register()

◆ registerErrorHandler()

◆ registerExceptionHandler()

◆ registerFatalHandler()

Field Documentation

◆ $errorLevelMap

◆ $fatalErrors

◆ $fatalLevel

◆ $handleOnlyReportedErrors

◆ $hasFatalErrorHandler

◆ $lastFatalTrace

◆ $logger

◆ $previousErrorHandler

◆ $previousExceptionHandler

◆ $reservedMemory

◆ $uncaughtExceptionLevel