You are here

class Error in Drupal 9

Same name and namespace in other branches
  1. 8 core/lib/Drupal/Core/Utility/Error.php \Drupal\Core\Utility\Error

Drupal error utility class.

Hierarchy

  • class \Drupal\Core\Utility\Error

Expanded class hierarchy of Error

13 files declare their use of Error
bootstrap.inc in core/includes/bootstrap.inc
Functions that need to be loaded on every Drupal request.
BrowserHtmlDebugTrait.php in core/tests/Drupal/Tests/BrowserHtmlDebugTrait.php
BrowserTestBase.php in core/tests/Drupal/Tests/BrowserTestBase.php
DefaultExceptionHtmlSubscriber.php in core/lib/Drupal/Core/EventSubscriber/DefaultExceptionHtmlSubscriber.php
errors.inc in core/includes/errors.inc
Functions for error handling.

... See full list

7 string references to 'Error'
drupal_error_levels in core/includes/errors.inc
Maps PHP error constants to watchdog severity levels.
RfcLogLevel::getLevels in core/lib/Drupal/Core/Logger/RfcLogLevel.php
Returns a list of severity levels, as defined in RFC 5424.
StatusReportPage::preRenderCounters in core/modules/system/src/Element/StatusReportPage.php
#pre_render callback to create counter elements.
system_requirements in core/modules/system/system.install
Implements hook_requirements().
template_preprocess_update_project_status in core/modules/update/update.report.inc
Prepares variables for update project status templates.

... See full list

File

core/lib/Drupal/Core/Utility/Error.php, line 14

Namespace

Drupal\Core\Utility
View source
class Error {

  /**
   * The error severity level.
   *
   * @var int
   */
  const ERROR = 3;

  /**
   * An array of ignored functions.
   *
   * @var array
   */
  protected static $ignoredFunctions = [
    'debug',
    '_drupal_error_handler',
    '_drupal_exception_handler',
  ];

  /**
   * Decodes an exception and retrieves the correct caller.
   *
   * @param \Exception|\Throwable $exception
   *   The exception object that was thrown.
   *
   * @return array
   *   An error in the format expected by _drupal_log_error().
   */
  public static function decodeException($exception) {
    $message = $exception
      ->getMessage();
    $backtrace = $exception
      ->getTrace();

    // Add the line throwing the exception to the backtrace.
    array_unshift($backtrace, [
      'line' => $exception
        ->getLine(),
      'file' => $exception
        ->getFile(),
    ]);

    // For PDOException errors, we try to return the initial caller,
    // skipping internal functions of the database layer.
    if ($exception instanceof \PDOException || $exception instanceof DatabaseExceptionWrapper) {
      $driver_namespace = Database::getConnectionInfo()['default']['namespace'];
      $backtrace = Log::removeDatabaseEntries($backtrace, $driver_namespace);
      if (isset($exception->query_string, $exception->args)) {
        $message .= ": " . $exception->query_string . "; " . print_r($exception->args, TRUE);
      }
    }
    $caller = static::getLastCaller($backtrace);
    return [
      '%type' => get_class($exception),
      // The standard PHP exception handler considers that the exception message
      // is plain-text. We mimic this behavior here.
      '@message' => $message,
      '%function' => $caller['function'],
      '%file' => $caller['file'],
      '%line' => $caller['line'],
      'severity_level' => static::ERROR,
      'backtrace' => $backtrace,
      '@backtrace_string' => $exception
        ->getTraceAsString(),
      'exception' => $exception,
    ];
  }

  /**
   * Renders an exception error message without further exceptions.
   *
   * @param \Exception|\Throwable $exception
   *   The exception object that was thrown.
   *
   * @return string
   *   An error message.
   */
  public static function renderExceptionSafe($exception) {
    $decode = static::decodeException($exception);
    $backtrace = $decode['backtrace'];
    unset($decode['backtrace'], $decode['exception']);

    // Remove 'main()'.
    array_shift($backtrace);

    // Even though it is possible that this method is called on a public-facing
    // site, it is only called when the exception handler itself threw an
    // exception, which normally means that a code change caused the system to
    // no longer function correctly (as opposed to a user-triggered error), so
    // we assume that it is safe to include a verbose backtrace.
    $decode['@backtrace'] = Error::formatBacktrace($backtrace);
    return new FormattableMarkup('%type: @message in %function (line %line of %file). <pre class="backtrace">@backtrace</pre>', $decode);
  }

  /**
   * Gets the last caller from a backtrace.
   *
   * @param array $backtrace
   *   A standard PHP backtrace. Passed by reference.
   *
   * @return array
   *   An associative array with keys 'file', 'line' and 'function'.
   */
  public static function getLastCaller(array &$backtrace) {

    // Errors that occur inside PHP internal functions do not generate
    // information about file and line. Ignore the ignored functions.
    while ($backtrace && !isset($backtrace[0]['line']) || isset($backtrace[1]['function']) && in_array($backtrace[1]['function'], static::$ignoredFunctions)) {
      array_shift($backtrace);
    }

    // The first trace is the call itself.
    // It gives us the line and the file of the last call.
    $call = $backtrace[0];

    // The second call gives us the function where the call originated.
    if (isset($backtrace[1])) {
      if (isset($backtrace[1]['class'])) {
        $call['function'] = $backtrace[1]['class'] . $backtrace[1]['type'] . $backtrace[1]['function'] . '()';
      }
      else {
        $call['function'] = $backtrace[1]['function'] . '()';
      }
    }
    else {
      $call['function'] = 'main()';
    }
    return $call;
  }

  /**
   * Formats a backtrace into a plain-text string.
   *
   * The calls show values for scalar arguments and type names for complex ones.
   *
   * @param array $backtrace
   *   A standard PHP backtrace.
   *
   * @return string
   *   A plain-text line-wrapped string ready to be put inside <pre>.
   */
  public static function formatBacktrace(array $backtrace) {
    $return = '';
    foreach ($backtrace as $trace) {
      $call = [
        'function' => '',
        'args' => [],
      ];
      if (isset($trace['class'])) {
        $call['function'] = $trace['class'] . $trace['type'] . $trace['function'];
      }
      elseif (isset($trace['function'])) {
        $call['function'] = $trace['function'];
      }
      else {
        $call['function'] = 'main';
      }
      if (isset($trace['args'])) {
        foreach ($trace['args'] as $arg) {
          if (is_scalar($arg)) {
            $call['args'][] = is_string($arg) ? '\'' . Xss::filter($arg) . '\'' : $arg;
          }
          else {
            $call['args'][] = ucfirst(gettype($arg));
          }
        }
      }
      $line = '';
      if (isset($trace['line'])) {
        $line = " (Line: {$trace['line']})";
      }
      $return .= $call['function'] . '(' . implode(', ', $call['args']) . "){$line}\n";
    }
    return $return;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
Error::$ignoredFunctions protected static property An array of ignored functions.
Error::decodeException public static function Decodes an exception and retrieves the correct caller.
Error::ERROR constant The error severity level.
Error::formatBacktrace public static function Formats a backtrace into a plain-text string.
Error::getLastCaller public static function Gets the last caller from a backtrace.
Error::renderExceptionSafe public static function Renders an exception error message without further exceptions.