MWExceptionHandler.php

Go to the documentation of this file.

<?php
class MWExceptionHandler {
    public static function installHandler() {
        set_exception_handler( array( 'MWExceptionHandler', 'handle' ) );
    }
 
    protected static function report( Exception $e ) {
        global $wgShowExceptionDetails;
 
        $cmdLine = MWException::isCommandLine();
 
        if ( $e instanceof MWException ) {
            try {
                // Try and show the exception prettily, with the normal skin infrastructure
                $e->report();
            } catch ( Exception $e2 ) {
                // Exception occurred from within exception handler
                // Show a simpler error message for the original exception,
                // don't try to invoke report()
                $message = "MediaWiki internal error.\n\n";
 
                if ( $wgShowExceptionDetails ) {
                    $message .= 'Original exception: ' . self::getLogMessage( $e ) .
                        "\nBacktrace:\n" . self::getRedactedTraceAsString( $e ) .
                        "\n\nException caught inside exception handler: " . self::getLogMessage( $e2 ) .
                        "\nBacktrace:\n" . self::getRedactedTraceAsString( $e2 );
                } else {
                    $message .= "Exception caught inside exception handler.\n\n" .
                        "Set \$wgShowExceptionDetails = true; at the bottom of LocalSettings.php " .
                        "to show detailed debugging information.";
                }
 
                $message .= "\n";
 
                if ( $cmdLine ) {
                    self::printError( $message );
                } else {
                    echo nl2br( htmlspecialchars( $message ) ) . "\n";
                }
            }
        } else {
            $message = "Unexpected non-MediaWiki exception encountered, of type \"" .
                get_class( $e ) . "\"";
 
            if ( $wgShowExceptionDetails ) {
                $message .= "\n" . MWExceptionHandler::getLogMessage( $e ) . "\nBacktrace:\n" .
                    self::getRedactedTraceAsString( $e ) . "\n";
            }
 
            if ( $cmdLine ) {
                self::printError( $message );
            } else {
                echo nl2br( htmlspecialchars( $message ) ) . "\n";
            }
        }
    }
 
    public static function printError( $message ) {
        # NOTE: STDERR may not be available, especially if php-cgi is used from the
        # command line (bug #15602). Try to produce meaningful output anyway. Using
        # echo may corrupt output to STDOUT though.
        if ( defined( 'STDERR' ) ) {
            fwrite( STDERR, $message );
        } else {
            echo $message;
        }
    }
 
    public static function rollbackMasterChangesAndLog( Exception $e ) {
        $factory = wfGetLBFactory();
        if ( $factory->hasMasterChanges() ) {
            wfDebugLog( 'Bug56269',
                'Exception thrown with an uncommited database transaction: ' .
                    MWExceptionHandler::getLogMessage( $e ) . "\n" .
                    $e->getTraceAsString()
            );
            $factory->rollbackMasterChanges();
        }
    }
 
    public static function handle( $e ) {
        global $wgFullyInitialised;
 
        self::rollbackMasterChangesAndLog( $e );
 
        self::report( $e );
 
        // Final cleanup
        if ( $wgFullyInitialised ) {
            try {
                // uses $wgRequest, hence the $wgFullyInitialised condition
                wfLogProfilingData();
            } catch ( Exception $e ) {
            }
        }
 
        // Exit value should be nonzero for the benefit of shell jobs
        exit( 1 );
    }
 
    public static function getRedactedTraceAsString( Exception $e ) {
        $text = '';
 
        foreach ( self::getRedactedTrace( $e ) as $level => $frame ) {
            if ( isset( $frame['file'] ) && isset( $frame['line'] ) ) {
                $text .= "#{$level} {$frame['file']}({$frame['line']}): ";
            } else {
                // 'file' and 'line' are unset for calls via call_user_func (bug 55634)
                // This matches behaviour of Exception::getTraceAsString to instead
                // display "[internal function]".
                $text .= "#{$level} [internal function]: ";
            }
 
            if ( isset( $frame['class'] ) ) {
                $text .= $frame['class'] . $frame['type'] . $frame['function'];
            } else {
                $text .= $frame['function'];
            }
 
            if ( isset( $frame['args'] ) ) {
                $text .= '(' . implode( ', ', $frame['args'] ) . ")\n";
            } else {
                $text .= "()\n";
            }
        }
 
        $level = $level + 1;
        $text .= "#{$level} {main}";
 
        return $text;
    }
 
    public static function getRedactedTrace( Exception $e ) {
        return array_map( function ( $frame ) {
            if ( isset( $frame['args'] ) ) {
                $frame['args'] = array_map( function ( $arg ) {
                    return is_object( $arg ) ? get_class( $arg ) : gettype( $arg );
                }, $frame['args'] );
            }
            return $frame;
        }, $e->getTrace() );
    }
 
    public static function getLogId( Exception $e ) {
        if ( !isset( $e->_mwLogId ) ) {
            $e->_mwLogId = wfRandomString( 8 );
        }
        return $e->_mwLogId;
    }
 
    public static function getURL() {
        global $wgRequest;
        if ( !isset( $wgRequest ) || $wgRequest instanceof FauxRequest ) {
            return false;
        }
        return $wgRequest->getRequestURL();
    }
 
    public static function getLogMessage( Exception $e ) {
        $id = self::getLogId( $e );
        $file = $e->getFile();
        $line = $e->getLine();
        $message = $e->getMessage();
        $url = self::getURL() ?: '[no req]';
 
        return "[$id] $url   Exception from line $line of $file: $message";
    }
 
    public static function jsonSerializeException( Exception $e, $pretty = false, $escaping = 0 ) {
        global $wgLogExceptionBacktrace;
 
        $exceptionData = array(
            'id' => self::getLogId( $e ),
            'file' => $e->getFile(),
            'line' => $e->getLine(),
            'message' => $e->getMessage(),
        );
 
        // Because MediaWiki is first and foremost a web application, we set a
        // 'url' key unconditionally, but set it to null if the exception does
        // not occur in the context of a web request, as a way of making that
        // fact visible and explicit.
        $exceptionData['url'] = self::getURL() ?: null;
 
        if ( $wgLogExceptionBacktrace ) {
            // Argument values may not be serializable, so redact them.
            $exceptionData['backtrace'] = self::getRedactedTrace( $e );
        }
 
        return FormatJson::encode( $exceptionData, $pretty, $escaping );
    }
 
    public static function logException( Exception $e ) {
        global $wgLogExceptionBacktrace;
 
        if ( !( $e instanceof MWException ) || $e->isLoggable() ) {
            $log = self::getLogMessage( $e );
            if ( $wgLogExceptionBacktrace ) {
                wfDebugLog( 'exception', $log . "\n" . $e->getTraceAsString() );
            } else {
                wfDebugLog( 'exception', $log );
            }
 
            $json = self::jsonSerializeException( $e, false, FormatJson::ALL_OK );
            if ( $json !== false ) {
                wfDebugLog( 'exception-json', $json, 'private' );
            }
        }
 
    }
 
}