LineFormatter.php

Go to the documentation of this file.

<?php
namespace MediaWiki\Logger\Monolog;
 
use Error;
use Exception;
use Monolog\Formatter\LineFormatter as MonologLineFormatter;
use MWExceptionHandler;
use Throwable;
 
class LineFormatter extends MonologLineFormatter {
 
    public function __construct(
        $format = null, $dateFormat = null, $allowInlineLineBreaks = false,
        $ignoreEmptyContextAndExtra = false, $includeStacktraces = false
    ) {
        parent::__construct(
            $format, $dateFormat, $allowInlineLineBreaks,
            $ignoreEmptyContextAndExtra
        );
        $this->includeStacktraces( $includeStacktraces );
    }
 
    public function format( array $record ) {
        // Drop the 'private' flag from the context
        unset( $record['context']['private'] );
 
        // Handle exceptions specially: pretty format and remove from context
        // Will be output for a '%exception%' placeholder in format
        $prettyException = '';
        if ( isset( $record['context']['exception'] ) &&
            strpos( $this->format, '%exception%' ) !== false
        ) {
            $e = $record['context']['exception'];
            unset( $record['context']['exception'] );
 
            if ( $e instanceof Throwable || $e instanceof Exception ) {
                $prettyException = $this->normalizeException( $e );
            } elseif ( is_array( $e ) ) {
                $prettyException = $this->normalizeExceptionArray( $e );
            } else {
                $prettyException = $this->stringify( $e );
            }
        }
 
        $output = parent::format( $record );
 
        if ( strpos( $output, '%exception%' ) !== false ) {
            $output = str_replace( '%exception%', $prettyException, $output );
        }
        return $output;
    }
 
    protected function normalizeException( $e ) {
        return $this->normalizeExceptionArray( $this->exceptionAsArray( $e ) );
    }
 
    protected function exceptionAsArray( $e ) {
        $out = [
            'class' => get_class( $e ),
            'message' => $e->getMessage(),
            'code' => $e->getCode(),
            'file' => $e->getFile(),
            'line' => $e->getLine(),
            'trace' => MWExceptionHandler::redactTrace( $e->getTrace() ),
        ];
 
        $prev = $e->getPrevious();
        if ( $prev ) {
            $out['previous'] = $this->exceptionAsArray( $prev );
        }
 
        return $out;
    }
 
    protected function normalizeExceptionArray( array $e ) {
        $defaults = [
            'class' => 'Unknown',
            'file' => 'unknown',
            'line' => null,
            'message' => 'unknown',
            'trace' => [],
        ];
        $e = array_merge( $defaults, $e );
 
        $which = is_a( $e['class'], Error::class, true ) ? 'Error' : 'Exception';
        $str = "\n[$which {$e['class']}] (" .
            "{$e['file']}:{$e['line']}) {$e['message']}";
 
        if ( $this->includeStacktraces && $e['trace'] ) {
            $str .= "\n" .
                MWExceptionHandler::prettyPrintTrace( $e['trace'], '  ' );
        }
 
        if ( isset( $e['previous'] ) ) {
            $prev = $e['previous'];
            while ( $prev ) {
                $prev = array_merge( $defaults, $prev );
                $which = is_a( $prev['class'], Error::class, true ) ? 'Error' : 'Exception';
                $str .= "\nCaused by: [$which {$prev['class']}] (" .
                    "{$prev['file']}:{$prev['line']}) {$prev['message']}";
 
                if ( $this->includeStacktraces && $prev['trace'] ) {
                    $str .= "\n" .
                        MWExceptionHandler::prettyPrintTrace(
                            $prev['trace'], '  '
                        );
                }
 
                $prev = $prev['previous'] ?? null;
            }
        }
        return $str;
    }
}