Friendica Communications Platform
(please note that this is a clone of the repository at github, issues are handled there)
https://friendi.ca
You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
347 lines
11 KiB
347 lines
11 KiB
<?php |
|
/** |
|
* @copyright Copyright (C) 2010-2021, the Friendica project |
|
* |
|
* @license GNU AGPL version 3 or any later version |
|
* |
|
* This program is free software: you can redistribute it and/or modify |
|
* it under the terms of the GNU Affero General Public License as |
|
* published by the Free Software Foundation, either version 3 of the |
|
* License, or (at your option) any later version. |
|
* |
|
* This program is distributed in the hope that it will be useful, |
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of |
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
|
* GNU Affero General Public License for more details. |
|
* |
|
* You should have received a copy of the GNU Affero General Public License |
|
* along with this program. If not, see <https://www.gnu.org/licenses/>. |
|
* |
|
*/ |
|
|
|
declare(strict_types=1); |
|
|
|
namespace Friendica\Core\Logger\Handler; |
|
|
|
use Psr\Log\LoggerInterface; |
|
use Psr\Log\LogLevel; |
|
use Throwable; |
|
|
|
/** |
|
* A facility to enable logging of runtime errors, exceptions and fatal errors. |
|
* |
|
* Quick setup: <code>ErrorHandler::register($logger);</code> |
|
*/ |
|
class ErrorHandler |
|
{ |
|
/** @var LoggerInterface */ |
|
private $logger; |
|
|
|
/** @var ?callable */ |
|
private $previousExceptionHandler = null; |
|
/** @var array<class-string, LogLevel::*> an array of class name to LogLevel::* constant mapping */ |
|
private $uncaughtExceptionLevelMap = []; |
|
|
|
/** @var callable|true|null */ |
|
private $previousErrorHandler = null; |
|
/** @var array<int, LogLevel::*> an array of E_* constant to LogLevel::* constant mapping */ |
|
private $errorLevelMap = []; |
|
/** @var bool */ |
|
private $handleOnlyReportedErrors = true; |
|
|
|
/** @var bool */ |
|
private $hasFatalErrorHandler = false; |
|
/** @var LogLevel::* */ |
|
private $fatalLevel = LogLevel::ALERT; |
|
/** @var ?string */ |
|
private $reservedMemory = null; |
|
/** @var ?mixed */ |
|
private $lastFatalTrace; |
|
/** @var int[] */ |
|
private static $fatalErrors = [E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR]; |
|
|
|
public function __construct(LoggerInterface $logger) |
|
{ |
|
$this->logger = $logger; |
|
} |
|
|
|
/** |
|
* Registers a new ErrorHandler for a given Logger |
|
* |
|
* By default it will handle errors, exceptions and fatal errors |
|
* |
|
* @param LoggerInterface $logger |
|
* @param array<int, LogLevel::*>|false $errorLevelMap an array of E_* constant to LogLevel::* constant mapping, or false to disable error handling |
|
* @param array<class-string, LogLevel::*>|false $exceptionLevelMap an array of class name to LogLevel::* constant mapping, or false to disable exception handling |
|
* @param LogLevel::*|null|false $fatalLevel a LogLevel::* constant, null to use the default LogLevel::ALERT or false to disable fatal error handling |
|
* |
|
* @return ErrorHandler |
|
*/ |
|
public static function register(LoggerInterface $logger, $errorLevelMap = [], $exceptionLevelMap = [], $fatalLevel = null): self |
|
{ |
|
/** @phpstan-ignore-next-line */ |
|
$handler = new static($logger); |
|
if ($errorLevelMap !== false) { |
|
$handler->registerErrorHandler($errorLevelMap); |
|
} |
|
if ($exceptionLevelMap !== false) { |
|
$handler->registerExceptionHandler($exceptionLevelMap); |
|
} |
|
if ($fatalLevel !== false) { |
|
$handler->registerFatalHandler($fatalLevel); |
|
} |
|
|
|
return $handler; |
|
} |
|
|
|
/** |
|
* Stringify the class of the given object for logging purpose |
|
* |
|
* @param object $object An object to retrieve the class |
|
* |
|
* @return string the classname of the object |
|
*/ |
|
public static function getClass(object $object): string |
|
{ |
|
$class = \get_class($object); |
|
|
|
if (false === ($pos = \strpos($class, "@anonymous\0"))) { |
|
return $class; |
|
} |
|
|
|
if (false === ($parent = \get_parent_class($class))) { |
|
return \substr($class, 0, $pos + 10); |
|
} |
|
|
|
return $parent . '@anonymous'; |
|
} |
|
|
|
/** |
|
* @param array<class-string, LogLevel::*> $levelMap an array of class name to LogLevel::* constant mapping |
|
* @param bool $callPrevious Set to true, if a previously defined exception handler should be called after handling this exception |
|
* |
|
* @return $this |
|
*/ |
|
public function registerExceptionHandler(array $levelMap = [], bool $callPrevious = true): self |
|
{ |
|
$prev = set_exception_handler(function (Throwable $e): void { |
|
$this->handleException($e); |
|
}); |
|
$this->uncaughtExceptionLevelMap = $levelMap; |
|
foreach ($this->defaultExceptionLevelMap() as $class => $level) { |
|
if (!isset($this->uncaughtExceptionLevelMap[$class])) { |
|
$this->uncaughtExceptionLevelMap[$class] = $level; |
|
} |
|
} |
|
if ($callPrevious && $prev) { |
|
$this->previousExceptionHandler = $prev; |
|
} |
|
|
|
return $this; |
|
} |
|
|
|
/** |
|
* @param array<int, LogLevel::*> $levelMap an array of E_* constant to LogLevel::* constant mapping |
|
* @param bool $callPrevious Set to true, if a previously defined exception handler should be called after handling this exception |
|
* @param int $errorTypes a Mask for masking the errortypes, which should be handled by this error handler |
|
* @param bool $handleOnlyReportedErrors Set to true, only errors set per error_reporting() will be logged |
|
* |
|
* @return $this |
|
*/ |
|
public function registerErrorHandler(array $levelMap = [], bool $callPrevious = true, int $errorTypes = -1, bool $handleOnlyReportedErrors = true): self |
|
{ |
|
$prev = set_error_handler([$this, 'handleError'], $errorTypes); |
|
$this->errorLevelMap = array_replace($this->defaultErrorLevelMap(), $levelMap); |
|
if ($callPrevious) { |
|
$this->previousErrorHandler = $prev ?: true; |
|
} else { |
|
$this->previousErrorHandler = null; |
|
} |
|
|
|
$this->handleOnlyReportedErrors = $handleOnlyReportedErrors; |
|
|
|
return $this; |
|
} |
|
|
|
/** |
|
* @param LogLevel::*|null $level a LogLevel::* constant, null to use the default LogLevel::ALERT |
|
* @param int $reservedMemorySize Amount of KBs to reserve in memory so that it can be freed when handling fatal errors giving Monolog some room in memory to get its job done |
|
* |
|
* @return $this |
|
*/ |
|
public function registerFatalHandler($level = null, int $reservedMemorySize = 20): self |
|
{ |
|
register_shutdown_function([$this, 'handleFatalError']); |
|
|
|
$this->reservedMemory = str_repeat(' ', 1024 * $reservedMemorySize); |
|
$this->fatalLevel = null === $level ? LogLevel::ALERT : $level; |
|
$this->hasFatalErrorHandler = true; |
|
|
|
return $this; |
|
} |
|
|
|
/** |
|
* @return array<class-string, LogLevel::*> |
|
*/ |
|
protected function defaultExceptionLevelMap(): array |
|
{ |
|
return [ |
|
'ParseError' => LogLevel::CRITICAL, |
|
'Throwable' => LogLevel::ERROR, |
|
]; |
|
} |
|
|
|
/** |
|
* @return array<int, LogLevel::*> |
|
*/ |
|
protected function defaultErrorLevelMap(): array |
|
{ |
|
return [ |
|
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, |
|
]; |
|
} |
|
|
|
/** |
|
* The Exception handler |
|
* |
|
* @param Throwable $e The Exception to handle |
|
*/ |
|
private function handleException(Throwable $e): void |
|
{ |
|
$level = LogLevel::ERROR; |
|
foreach ($this->uncaughtExceptionLevelMap as $class => $candidate) { |
|
if ($e instanceof $class) { |
|
$level = $candidate; |
|
break; |
|
} |
|
} |
|
|
|
$this->logger->log( |
|
$level, |
|
sprintf('Uncaught Exception %s: "%s" at %s line %s', self::getClass($e), $e->getMessage(), $e->getFile(), $e->getLine()), |
|
['exception' => $e] |
|
); |
|
|
|
if ($this->previousExceptionHandler) { |
|
($this->previousExceptionHandler)($e); |
|
} |
|
|
|
if (!headers_sent() && !ini_get('display_errors')) { |
|
http_response_code(500); |
|
} |
|
|
|
exit(255); |
|
} |
|
|
|
/** |
|
* The Error handler |
|
* |
|
* @private |
|
* |
|
* @param int $code The PHP error code |
|
* @param string $message The error message |
|
* @param string $file If possible, set the file at which the failure occurred |
|
* @param int $line |
|
* @param array|null $context If possible, add a context to the error for better analysis |
|
* |
|
* @return bool |
|
*/ |
|
public function handleError(int $code, string $message, string $file = '', int $line = 0, ?array $context = []): bool |
|
{ |
|
if ($this->handleOnlyReportedErrors && !(error_reporting() & $code)) { |
|
return false; |
|
} |
|
|
|
// 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 = $this->errorLevelMap[$code] ?? LogLevel::CRITICAL; |
|
$this->logger->log($level, self::codeToString($code).': '.$message, ['code' => $code, 'message' => $message, 'file' => $file, 'line' => $line]); |
|
} else { |
|
$trace = debug_backtrace(DEBUG_BACKTRACE_IGNORE_ARGS); |
|
array_shift($trace); // Exclude handleError from trace |
|
$this->lastFatalTrace = $trace; |
|
} |
|
|
|
if ($this->previousErrorHandler === true) { |
|
return false; |
|
} elseif ($this->previousErrorHandler) { |
|
return (bool) ($this->previousErrorHandler)($code, $message, $file, $line, $context); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
/** |
|
* @private |
|
*/ |
|
public function handleFatalError(): void |
|
{ |
|
$this->reservedMemory = ''; |
|
|
|
$lastError = error_get_last(); |
|
if ($lastError && in_array($lastError['type'], self::$fatalErrors, true)) { |
|
$this->logger->log( |
|
$this->fatalLevel, |
|
'Fatal Error ('.self::codeToString($lastError['type']).'): '.$lastError['message'], |
|
['code' => $lastError['type'], 'message' => $lastError['message'], 'file' => $lastError['file'], 'line' => $lastError['line'], 'trace' => $this->lastFatalTrace] |
|
); |
|
} |
|
} |
|
|
|
/** |
|
* @param mixed $code |
|
* |
|
* @return string |
|
*/ |
|
private static function codeToString($code): string |
|
{ |
|
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'; |
|
} |
|
}
|
|
|