class Error in Drupal 10

Drupal error utility class.

Hierarchy

• class \Drupal\Core\Utility\Error

12 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

9 string references to 'Error'

drupal6.php in core/modules/migrate_drupal/tests/fixtures/drupal6.php

A database agnostic dump for testing purposes.

drupal_error_levels in core/includes/errors.inc

Maps PHP error constants to watchdog severity levels.

InstallerException::__construct in core/lib/Drupal/Core/Installer/Exception/InstallerException.php

Constructs a new installer exception.

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.

... See full list

File

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

Namespace

Drupal\Core\Utility

class Error {

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

  /**
   * The default message for logging errors.
   */
  const DEFAULT_ERROR_MESSAGE = '%type: @message in %function (line %line of %file).';

  /**
   * 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(Error::DEFAULT_ERROR_MESSAGE . ' <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;
  }

}