includes/exception/MWExceptionHandler.php

   1 <?php
   2 /**
   3  * This program is free software; you can redistribute it and/or modify
   4  * it under the terms of the GNU General Public License as published by
   5  * the Free Software Foundation; either version 2 of the License, or
   6  * (at your option) any later version.
   7  *
   8  * This program is distributed in the hope that it will be useful,
   9  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  10  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  11  * GNU General Public License for more details.
  12  *
  13  * You should have received a copy of the GNU General Public License along
  14  * with this program; if not, write to the Free Software Foundation, Inc.,
  15  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  16  * http://www.gnu.org/copyleft/gpl.html
  17  *
  18  * @file
  19  */
  20
  21 use MediaWiki\Logger\LoggerFactory;
  22 use MediaWiki\MediaWikiServices;
  23 use Psr\Log\LogLevel;
  24 use Wikimedia\Rdbms\DBError;
  25
  26 /**
  27  * Handler class for MWExceptions
  28  * @ingroup Exception
  29  */
  30 class MWExceptionHandler {
  31         const CAUGHT_BY_HANDLER = 'mwe_handler'; // error reported by this exception handler
  32         const CAUGHT_BY_OTHER = 'other'; // error reported by direct logException() call
  33
  34         /**
  35          * @var string $reservedMemory
  36          */
  37         protected static $reservedMemory;
  38         /**
  39          * @var array $fatalErrorTypes
  40          */
  41         protected static $fatalErrorTypes = [
  42                 E_ERROR, E_PARSE, E_CORE_ERROR, E_COMPILE_ERROR, E_USER_ERROR,
  43                 /* HHVM's FATAL_ERROR level */ 16777217,
  44         ];
  45         /**
  46          * @var bool $handledFatalCallback
  47          */
  48         protected static $handledFatalCallback = false;
  49
  50         /**
  51          * Install handlers with PHP.
  52          */
  53         public static function installHandler() {
  54                 set_exception_handler( 'MWExceptionHandler::handleException' );
  55                 set_error_handler( 'MWExceptionHandler::handleError' );
  56
  57                 // Reserve 16k of memory so we can report OOM fatals
  58                 self::$reservedMemory = str_repeat( ' ', 16384 );
  59                 register_shutdown_function( 'MWExceptionHandler::handleFatalError' );
  60         }
  61
  62         /**
  63          * Report an exception to the user
  64          * @param Exception|Throwable $e
  65          */
  66         protected static function report( $e ) {
  67                 try {
  68                         // Try and show the exception prettily, with the normal skin infrastructure
  69                         if ( $e instanceof MWException ) {
  70                                 // Delegate to MWException until all subclasses are handled by
  71                                 // MWExceptionRenderer and MWException::report() has been
  72                                 // removed.
  73                                 $e->report();
  74                         } else {
  75                                 MWExceptionRenderer::output( $e, MWExceptionRenderer::AS_PRETTY );
  76                         }
  77                 } catch ( Exception $e2 ) {
  78                         // Exception occurred from within exception handler
  79                         // Show a simpler message for the original exception,
  80                         // don't try to invoke report()
  81                         MWExceptionRenderer::output( $e, MWExceptionRenderer::AS_RAW, $e2 );
  82                 }
  83         }
  84
  85         /**
  86          * Roll back any open database transactions and log the stack trace of the exception
  87          *
  88          * This method is used to attempt to recover from exceptions
  89          *
  90          * @since 1.23
  91          * @param Exception|Throwable $e
  92          */
  93         public static function rollbackMasterChangesAndLog( $e ) {
  94                 $services = MediaWikiServices::getInstance();
  95                 if ( !$services->isServiceDisabled( 'DBLoadBalancerFactory' ) ) {
  96                         // Rollback DBs to avoid transaction notices. This might fail
  97                         // to rollback some databases due to connection issues or exceptions.
  98                         // However, any sane DB driver will rollback implicitly anyway.
  99                         try {
 100                                 $services->getDBLoadBalancerFactory()->rollbackMasterChanges( __METHOD__ );
 101                         } catch ( DBError $e2 ) {
 102                                 // If the DB is unreacheable, rollback() will throw an error
 103                                 // and the error report() method might need messages from the DB,
 104                                 // which would result in an exception loop. PHP may escalate such
 105                                 // errors to "Exception thrown without a stack frame" fatals, but
 106                                 // it's better to be explicit here.
 107                                 self::logException( $e2, self::CAUGHT_BY_HANDLER );
 108                         }
 109                 }
 110
 111                 self::logException( $e, self::CAUGHT_BY_HANDLER );
 112         }
 113
 114         /**
 115          * Exception handler which simulates the appropriate catch() handling:
 116          *
 117          *   try {
 118          *       ...
 119          *   } catch ( Exception $e ) {
 120          *       $e->report();
 121          *   } catch ( Exception $e ) {
 122          *       echo $e->__toString();
 123          *   }
 124          *
 125          * @since 1.25
 126          * @param Exception|Throwable $e
 127          */
 128         public static function handleException( $e ) {
 129                 self::rollbackMasterChangesAndLog( $e );
 130                 self::report( $e );
 131         }
 132
 133         /**
 134          * Handler for set_error_handler() callback notifications.
 135          *
 136          * Receive a callback from the interpreter for a raised error, create an
 137          * ErrorException, and log the exception to the 'error' logging
 138          * channel(s). If the raised error is a fatal error type (only under HHVM)
 139          * delegate to handleFatalError() instead.
 140          *
 141          * @since 1.25
 142          *
 143          * @param int $level Error level raised
 144          * @param string $message
 145          * @param string $file
 146          * @param int $line
 147          * @return bool
 148          *
 149          * @see logError()
 150          */
 151         public static function handleError(
 152                 $level, $message, $file = null, $line = null
 153         ) {
 154                 if ( in_array( $level, self::$fatalErrorTypes ) ) {
 155                         return call_user_func_array(
 156                                 'MWExceptionHandler::handleFatalError', func_get_args()
 157                         );
 158                 }
 159
 160                 // Map error constant to error name (reverse-engineer PHP error
 161                 // reporting)
 162                 switch ( $level ) {
 163                         case E_RECOVERABLE_ERROR:
 164                                 $levelName = 'Error';
 165                                 $severity = LogLevel::ERROR;
 166                                 break;
 167                         case E_WARNING:
 168                         case E_CORE_WARNING:
 169                         case E_COMPILE_WARNING:
 170                         case E_USER_WARNING:
 171                                 $levelName = 'Warning';
 172                                 $severity = LogLevel::WARNING;
 173                                 break;
 174                         case E_NOTICE:
 175                         case E_USER_NOTICE:
 176                                 $levelName = 'Notice';
 177                                 $severity = LogLevel::INFO;
 178                                 break;
 179                         case E_STRICT:
 180                                 $levelName = 'Strict Standards';
 181                                 $severity = LogLevel::DEBUG;
 182                                 break;
 183                         case E_DEPRECATED:
 184                         case E_USER_DEPRECATED:
 185                                 $levelName = 'Deprecated';
 186                                 $severity = LogLevel::INFO;
 187                                 break;
 188                         default:
 189                                 $levelName = 'Unknown error';
 190                                 $severity = LogLevel::ERROR;
 191                                 break;
 192                 }
 193
 194                 $e = new ErrorException( "PHP $levelName: $message", 0, $level, $file, $line );
 195                 self::logError( $e, 'error', $severity );
 196
 197                 // This handler is for logging only. Return false will instruct PHP
 198                 // to continue regular handling.
 199                 return false;
 200         }
 201
 202         /**
 203          * Dual purpose callback used as both a set_error_handler() callback and
 204          * a registered shutdown function. Receive a callback from the interpreter
 205          * for a raised error or system shutdown, check for a fatal error, and log
 206          * to the 'fatal' logging channel.
 207          *
 208          * Special handling is included for missing class errors as they may
 209          * indicate that the user needs to install 3rd-party libraries via
 210          * Composer or other means.
 211          *
 212          * @since 1.25
 213          *
 214          * @param int $level Error level raised
 215          * @param string $message Error message
 216          * @param string $file File that error was raised in
 217          * @param int $line Line number error was raised at
 218          * @param array $context Active symbol table point of error
 219          * @param array $trace Backtrace at point of error (undocumented HHVM
 220          *     feature)
 221          * @return bool Always returns false
 222          */
 223         public static function handleFatalError(
 224                 $level = null, $message = null, $file = null, $line = null,
 225                 $context = null, $trace = null
 226         ) {
 227                 // Free reserved memory so that we have space to process OOM
 228                 // errors
 229                 self::$reservedMemory = null;
 230
 231                 if ( $level === null ) {
 232                         // Called as a shutdown handler, get data from error_get_last()
 233                         if ( static::$handledFatalCallback ) {
 234                                 // Already called once (probably as an error handler callback
 235                                 // under HHVM) so don't log again.
 236                                 return false;
 237                         }
 238
 239                         $lastError = error_get_last();
 240                         if ( $lastError !== null ) {
 241                                 $level = $lastError['type'];
 242                                 $message = $lastError['message'];
 243                                 $file = $lastError['file'];
 244                                 $line = $lastError['line'];
 245                         } else {
 246                                 $level = 0;
 247                                 $message = '';
 248                         }
 249                 }
 250
 251                 if ( !in_array( $level, self::$fatalErrorTypes ) ) {
 252                         // Only interested in fatal errors, others should have been
 253                         // handled by MWExceptionHandler::handleError
 254                         return false;
 255                 }
 256
 257                 $msg = "[{exception_id}] PHP Fatal Error: {$message}";
 258
 259                 // Look at message to see if this is a class not found failure
 260                 // HHVM: Class undefined: foo
 261                 // PHP5: Class 'foo' not found
 262                 if ( preg_match( "/Class (undefined: \w+|'\w+' not found)/", $msg ) ) {
 263                         // @codingStandardsIgnoreStart Generic.Files.LineLength.TooLong
 264                         $msg = <<<TXT
 265 {$msg}
 266
 267 MediaWiki or an installed extension requires this class but it is not embedded directly in MediaWiki's git repository and must be installed separately by the end user.
 268
 269 Please see <a href="https://www.mediawiki.org/wiki/Download_from_Git#Fetch_external_libraries">mediawiki.org</a> for help on installing the required components.
 270 TXT;
 271                         // @codingStandardsIgnoreEnd
 272                 }
 273
 274                 // We can't just create an exception and log it as it is likely that
 275                 // the interpreter has unwound the stack already. If that is true the
 276                 // stacktrace we would get would be functionally empty. If however we
 277                 // have been called as an error handler callback *and* HHVM is in use
 278                 // we will have been provided with a useful stacktrace that we can
 279                 // log.
 280                 $trace = $trace ?: debug_backtrace();
 281                 $logger = LoggerFactory::getInstance( 'fatal' );
 282                 $logger->error( $msg, [
 283                         'fatal_exception' => [
 284                                 'class' => 'ErrorException',
 285                                 'message' => "PHP Fatal Error: {$message}",
 286                                 'code' => $level,
 287                                 'file' => $file,
 288                                 'line' => $line,
 289                                 'trace' => static::redactTrace( $trace ),
 290                         ],
 291                         'exception_id' => wfRandomString( 8 ),
 292                         'caught_by' => self::CAUGHT_BY_HANDLER
 293                 ] );
 294
 295                 // Remember call so we don't double process via HHVM's fatal
 296                 // notifications and the shutdown hook behavior
 297                 static::$handledFatalCallback = true;
 298                 return false;
 299         }
 300
 301         /**
 302          * Generate a string representation of an exception's stack trace
 303          *
 304          * Like Exception::getTraceAsString, but replaces argument values with
 305          * argument type or class name.
 306          *
 307          * @param Exception|Throwable $e
 308          * @return string
 309          * @see prettyPrintTrace()
 310          */
 311         public static function getRedactedTraceAsString( $e ) {
 312                 return self::prettyPrintTrace( self::getRedactedTrace( $e ) );
 313         }
 314
 315         /**
 316          * Generate a string representation of a stacktrace.
 317          *
 318          * @param array $trace
 319          * @param string $pad Constant padding to add to each line of trace
 320          * @return string
 321          * @since 1.26
 322          */
 323         public static function prettyPrintTrace( array $trace, $pad = '' ) {
 324                 $text = '';
 325
 326                 $level = 0;
 327                 foreach ( $trace as $level => $frame ) {
 328                         if ( isset( $frame['file'] ) && isset( $frame['line'] ) ) {
 329                                 $text .= "{$pad}#{$level} {$frame['file']}({$frame['line']}): ";
 330                         } else {
 331                                 // 'file' and 'line' are unset for calls via call_user_func
 332                                 // (T57634) This matches behaviour of
 333                                 // Exception::getTraceAsString to instead display "[internal
 334                                 // function]".
 335                                 $text .= "{$pad}#{$level} [internal function]: ";
 336                         }
 337
 338                         if ( isset( $frame['class'] ) && isset( $frame['type'] ) && isset( $frame['function'] ) ) {
 339                                 $text .= $frame['class'] . $frame['type'] . $frame['function'];
 340                         } elseif ( isset( $frame['function'] ) ) {
 341                                 $text .= $frame['function'];
 342                         } else {
 343                                 $text .= 'NO_FUNCTION_GIVEN';
 344                         }
 345
 346                         if ( isset( $frame['args'] ) ) {
 347                                 $text .= '(' . implode( ', ', $frame['args'] ) . ")\n";
 348                         } else {
 349                                 $text .= "()\n";
 350                         }
 351                 }
 352
 353                 $level = $level + 1;
 354                 $text .= "{$pad}#{$level} {main}";
 355
 356                 return $text;
 357         }
 358
 359         /**
 360          * Return a copy of an exception's backtrace as an array.
 361          *
 362          * Like Exception::getTrace, but replaces each element in each frame's
 363          * argument array with the name of its class (if the element is an object)
 364          * or its type (if the element is a PHP primitive).
 365          *
 366          * @since 1.22
 367          * @param Exception|Throwable $e
 368          * @return array
 369          */
 370         public static function getRedactedTrace( $e ) {
 371                 return static::redactTrace( $e->getTrace() );
 372         }
 373
 374         /**
 375          * Redact a stacktrace generated by Exception::getTrace(),
 376          * debug_backtrace() or similar means. Replaces each element in each
 377          * frame's argument array with the name of its class (if the element is an
 378          * object) or its type (if the element is a PHP primitive).
 379          *
 380          * @since 1.26
 381          * @param array $trace Stacktrace
 382          * @return array Stacktrace with arugment values converted to data types
 383          */
 384         public static function redactTrace( array $trace ) {
 385                 return array_map( function ( $frame ) {
 386                         if ( isset( $frame['args'] ) ) {
 387                                 $frame['args'] = array_map( function ( $arg ) {
 388                                         return is_object( $arg ) ? get_class( $arg ) : gettype( $arg );
 389                                 }, $frame['args'] );
 390                         }
 391                         return $frame;
 392                 }, $trace );
 393         }
 394
 395         /**
 396          * Get the ID for this exception.
 397          *
 398          * The ID is saved so that one can match the one output to the user (when
 399          * $wgShowExceptionDetails is set to false), to the entry in the debug log.
 400          *
 401          * @since 1.22
 402          * @deprecated since 1.27: Exception IDs are synonymous with request IDs.
 403          * @param Exception|Throwable $e
 404          * @return string
 405          */
 406         public static function getLogId( $e ) {
 407                 wfDeprecated( __METHOD__, '1.27' );
 408                 return WebRequest::getRequestId();
 409         }
 410
 411         /**
 412          * If the exception occurred in the course of responding to a request,
 413          * returns the requested URL. Otherwise, returns false.
 414          *
 415          * @since 1.23
 416          * @return string|false
 417          */
 418         public static function getURL() {
 419                 global $wgRequest;
 420                 if ( !isset( $wgRequest ) || $wgRequest instanceof FauxRequest ) {
 421                         return false;
 422                 }
 423                 return $wgRequest->getRequestURL();
 424         }
 425
 426         /**
 427          * Get a message formatting the exception message and its origin.
 428          *
 429          * @since 1.22
 430          * @param Exception|Throwable $e
 431          * @return string
 432          */
 433         public static function getLogMessage( $e ) {
 434                 $id = WebRequest::getRequestId();
 435                 $type = get_class( $e );
 436                 $file = $e->getFile();
 437                 $line = $e->getLine();
 438                 $message = $e->getMessage();
 439                 $url = self::getURL() ?: '[no req]';
 440
 441                 return "[$id] $url   $type from line $line of $file: $message";
 442         }
 443
 444         /**
 445          * Get a normalised message for formatting with PSR-3 log event context.
 446          *
 447          * Must be used together with `getLogContext()` to be useful.
 448          *
 449          * @since 1.30
 450          * @param Exception|Throwable $e
 451          * @return string
 452          */
 453         public static function getLogNormalMessage( $e ) {
 454                 $type = get_class( $e );
 455                 $file = $e->getFile();
 456                 $line = $e->getLine();
 457                 $message = $e->getMessage();
 458
 459                 return "[{exception_id}] {exception_url}   $type from line $line of $file: $message";
 460         }
 461
 462         /**
 463          * @param Exception|Throwable $e
 464          * @return string
 465          */
 466         public static function getPublicLogMessage( $e ) {
 467                 $reqId = WebRequest::getRequestId();
 468                 $type = get_class( $e );
 469                 return '[' . $reqId . '] '
 470                         . gmdate( 'Y-m-d H:i:s' ) . ': '
 471                         . 'Fatal exception of type "' . $type . '"';
 472         }
 473
 474         /**
 475          * Get a PSR-3 log event context from an Exception.
 476          *
 477          * Creates a structured array containing information about the provided
 478          * exception that can be used to augment a log message sent to a PSR-3
 479          * logger.
 480          *
 481          * @param Exception|Throwable $e
 482          * @param string $catcher CAUGHT_BY_* class constant indicating what caught the error
 483          * @return array
 484          */
 485         public static function getLogContext( $e, $catcher = self::CAUGHT_BY_OTHER ) {
 486                 return [
 487                         'exception' => $e,
 488                         'exception_id' => WebRequest::getRequestId(),
 489                         'exception_url' => self::getURL() ?: '[no req]',
 490                         'caught_by' => $catcher
 491                 ];
 492         }
 493
 494         /**
 495          * Get a structured representation of an Exception.
 496          *
 497          * Returns an array of structured data (class, message, code, file,
 498          * backtrace) derived from the given exception. The backtrace information
 499          * will be redacted as per getRedactedTraceAsArray().
 500          *
 501          * @param Exception|Throwable $e
 502          * @param string $catcher CAUGHT_BY_* class constant indicating what caught the error
 503          * @return array
 504          * @since 1.26
 505          */
 506         public static function getStructuredExceptionData( $e, $catcher = self::CAUGHT_BY_OTHER ) {
 507                 global $wgLogExceptionBacktrace;
 508
 509                 $data = [
 510                         'id' => WebRequest::getRequestId(),
 511                         'type' => get_class( $e ),
 512                         'file' => $e->getFile(),
 513                         'line' => $e->getLine(),
 514                         'message' => $e->getMessage(),
 515                         'code' => $e->getCode(),
 516                         'url' => self::getURL() ?: null,
 517                         'caught_by' => $catcher
 518                 ];
 519
 520                 if ( $e instanceof ErrorException &&
 521                         ( error_reporting() & $e->getSeverity() ) === 0
 522                 ) {
 523                         // Flag surpressed errors
 524                         $data['suppressed'] = true;
 525                 }
 526
 527                 if ( $wgLogExceptionBacktrace ) {
 528                         $data['backtrace'] = self::getRedactedTrace( $e );
 529                 }
 530
 531                 $previous = $e->getPrevious();
 532                 if ( $previous !== null ) {
 533                         $data['previous'] = self::getStructuredExceptionData( $previous, $catcher );
 534                 }
 535
 536                 return $data;
 537         }
 538
 539         /**
 540          * Serialize an Exception object to JSON.
 541          *
 542          * The JSON object will have keys 'id', 'file', 'line', 'message', and
 543          * 'url'. These keys map to string values, with the exception of 'line',
 544          * which is a number, and 'url', which may be either a string URL or or
 545          * null if the exception did not occur in the context of serving a web
 546          * request.
 547          *
 548          * If $wgLogExceptionBacktrace is true, it will also have a 'backtrace'
 549          * key, mapped to the array return value of Exception::getTrace, but with
 550          * each element in each frame's "args" array (if set) replaced with the
 551          * argument's class name (if the argument is an object) or type name (if
 552          * the argument is a PHP primitive).
 553          *
 554          * @par Sample JSON record ($wgLogExceptionBacktrace = false):
 555          * @code
 556          *  {
 557          *    "id": "c41fb419",
 558          *    "type": "MWException",
 559          *    "file": "/var/www/mediawiki/includes/cache/MessageCache.php",
 560          *    "line": 704,
 561          *    "message": "Non-string key given",
 562          *    "url": "/wiki/Main_Page"
 563          *  }
 564          * @endcode
 565          *
 566          * @par Sample JSON record ($wgLogExceptionBacktrace = true):
 567          * @code
 568          *  {
 569          *    "id": "dc457938",
 570          *    "type": "MWException",
 571          *    "file": "/vagrant/mediawiki/includes/cache/MessageCache.php",
 572          *    "line": 704,
 573          *    "message": "Non-string key given",
 574          *    "url": "/wiki/Main_Page",
 575          *    "backtrace": [{
 576          *      "file": "/vagrant/mediawiki/extensions/VisualEditor/VisualEditor.hooks.php",
 577          *      "line": 80,
 578          *      "function": "get",
 579          *      "class": "MessageCache",
 580          *      "type": "->",
 581          *      "args": ["array"]
 582          *    }]
 583          *  }
 584          * @endcode
 585          *
 586          * @since 1.23
 587          * @param Exception|Throwable $e
 588          * @param bool $pretty Add non-significant whitespace to improve readability (default: false).
 589          * @param int $escaping Bitfield consisting of FormatJson::.*_OK class constants.
 590          * @param string $catcher CAUGHT_BY_* class constant indicating what caught the error
 591          * @return string|false JSON string if successful; false upon failure
 592          */
 593         public static function jsonSerializeException(
 594                 $e, $pretty = false, $escaping = 0, $catcher = self::CAUGHT_BY_OTHER
 595         ) {
 596                 return FormatJson::encode(
 597                         self::getStructuredExceptionData( $e, $catcher ),
 598                         $pretty,
 599                         $escaping
 600                 );
 601         }
 602
 603         /**
 604          * Log an exception to the exception log (if enabled).
 605          *
 606          * This method must not assume the exception is an MWException,
 607          * it is also used to handle PHP exceptions or exceptions from other libraries.
 608          *
 609          * @since 1.22
 610          * @param Exception|Throwable $e
 611          * @param string $catcher CAUGHT_BY_* class constant indicating what caught the error
 612          */
 613         public static function logException( $e, $catcher = self::CAUGHT_BY_OTHER ) {
 614                 if ( !( $e instanceof MWException ) || $e->isLoggable() ) {
 615                         $logger = LoggerFactory::getInstance( 'exception' );
 616                         $logger->error(
 617                                 self::getLogNormalMessage( $e ),
 618                                 self::getLogContext( $e, $catcher )
 619                         );
 620
 621                         $json = self::jsonSerializeException( $e, false, FormatJson::ALL_OK, $catcher );
 622                         if ( $json !== false ) {
 623                                 $logger = LoggerFactory::getInstance( 'exception-json' );
 624                                 $logger->error( $json, [ 'private' => true ] );
 625                         }
 626
 627                         Hooks::run( 'LogException', [ $e, false ] );
 628                 }
 629         }
 630
 631         /**
 632          * Log an exception that wasn't thrown but made to wrap an error.
 633          *
 634          * @since 1.25
 635          * @param ErrorException $e
 636          * @param string $channel
 637          * @param string $level
 638          */
 639         protected static function logError(
 640                 ErrorException $e, $channel, $level = LogLevel::ERROR
 641         ) {
 642                 $catcher = self::CAUGHT_BY_HANDLER;
 643                 // The set_error_handler callback is independent from error_reporting.
 644                 // Filter out unwanted errors manually (e.g. when
 645                 // MediaWiki\suppressWarnings is active).
 646                 $suppressed = ( error_reporting() & $e->getSeverity() ) === 0;
 647                 if ( !$suppressed ) {
 648                         $logger = LoggerFactory::getInstance( $channel );
 649                         $logger->log(
 650                                 $level,
 651                                 self::getLogNormalMessage( $e ),
 652                                 self::getLogContext( $e, $catcher )
 653                         );
 654                 }
 655
 656                 // Include all errors in the json log (surpressed errors will be flagged)
 657                 $json = self::jsonSerializeException( $e, false, FormatJson::ALL_OK, $catcher );
 658                 if ( $json !== false ) {
 659                         $logger = LoggerFactory::getInstance( "{$channel}-json" );
 660                         $logger->log( $level, $json, [ 'private' => true ] );
 661                 }
 662
 663                 Hooks::run( 'LogException', [ $e, $suppressed ] );
 664         }
 665 }