df4cbf5ac6
get_debug_type() does the same thing but better (spelling type names in the same way as in type declarations, and including names of object classes and resource types). It was added in PHP 8, but the symfony/polyfill-php80 package provides it while we still support 7.4. Also remove uses of get_class() and get_resource_type() where the new method already provides the same information. For reference: https://www.php.net/manual/en/function.get-debug-type.php https://www.php.net/manual/en/function.gettype.php In this commit I'm only changing code where it looks like the result is used only for some king of debug, log, or test output. This probably won't break anything important, but I'm not sure whether anything might depend on the exact values. Change-Id: I7c1f0a8f669228643e86f8e511c0e26a2edb2948
540 lines
15 KiB
PHP
540 lines
15 KiB
PHP
<?php
|
|
/**
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License along
|
|
* with this program; if not, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
|
|
* http://www.gnu.org/copyleft/gpl.html
|
|
*
|
|
* @file
|
|
*/
|
|
|
|
namespace MediaWiki\Logger;
|
|
|
|
use DateTimeZone;
|
|
use Error;
|
|
use LogicException;
|
|
use MediaWiki\Debug\MWDebug;
|
|
use MediaWiki\WikiMap\WikiMap;
|
|
use MWExceptionHandler;
|
|
use Psr\Log\AbstractLogger;
|
|
use Psr\Log\LogLevel;
|
|
use Throwable;
|
|
use UDPTransport;
|
|
use Wikimedia\AtEase\AtEase;
|
|
|
|
/**
|
|
* PSR-3 logger that mimics the historic implementation of MediaWiki's former
|
|
* wfErrorLog logging implementation.
|
|
*
|
|
* This logger is configured by the following global configuration variables:
|
|
* - `$wgDebugLogFile`
|
|
* - `$wgDebugLogGroups`
|
|
* - `$wgDBerrorLog`
|
|
* - `$wgDBerrorLogTZ`
|
|
*
|
|
* See docs/Configuration.md for detailed explanations of these settings.
|
|
*
|
|
* @see \MediaWiki\Logger\LoggerFactory
|
|
* @since 1.25
|
|
* @ingroup Debug
|
|
* @copyright © 2014 Wikimedia Foundation and contributors
|
|
*/
|
|
class LegacyLogger extends AbstractLogger {
|
|
|
|
/**
|
|
* @var string
|
|
*/
|
|
protected $channel;
|
|
|
|
private const LEVEL_DEBUG = 100;
|
|
private const LEVEL_INFO = 200;
|
|
private const LEVEL_NOTICE = 250;
|
|
private const LEVEL_WARNING = 300;
|
|
private const LEVEL_ERROR = 400;
|
|
private const LEVEL_CRITICAL = 500;
|
|
private const LEVEL_ALERT = 550;
|
|
private const LEVEL_EMERGENCY = 600;
|
|
private const LEVEL_INFINITY = 999;
|
|
|
|
/**
|
|
* Convert \Psr\Log\LogLevel constants into int for sensible comparisons
|
|
* These are the same values that Monolog uses
|
|
*
|
|
* @var array
|
|
*/
|
|
protected static $levelMapping = [
|
|
LogLevel::DEBUG => self::LEVEL_DEBUG,
|
|
LogLevel::INFO => self::LEVEL_INFO,
|
|
LogLevel::NOTICE => self::LEVEL_NOTICE,
|
|
LogLevel::WARNING => self::LEVEL_WARNING,
|
|
LogLevel::ERROR => self::LEVEL_ERROR,
|
|
LogLevel::CRITICAL => self::LEVEL_CRITICAL,
|
|
LogLevel::ALERT => self::LEVEL_ALERT,
|
|
LogLevel::EMERGENCY => self::LEVEL_EMERGENCY,
|
|
];
|
|
|
|
/**
|
|
* Minimum level. This is just to allow faster discard of debugging
|
|
* messages. Not all messages meeting the level will be logged.
|
|
*
|
|
* @var int
|
|
*/
|
|
private $minimumLevel;
|
|
|
|
/**
|
|
* Whether the channel is a DB channel
|
|
*
|
|
* @var bool
|
|
*/
|
|
private $isDB;
|
|
|
|
/**
|
|
* @param string $channel
|
|
*/
|
|
public function __construct( $channel ) {
|
|
global $wgDebugLogFile, $wgDBerrorLog, $wgDebugLogGroups, $wgDebugToolbar, $wgDebugRawPage, $wgShowDebug;
|
|
|
|
$this->channel = $channel;
|
|
$this->isDB = ( $channel === 'rdbms' );
|
|
|
|
// Calculate minimum level, duplicating some of the logic from log() and shouldEmit()
|
|
if ( !$wgDebugRawPage && wfIsDebugRawPage() ) {
|
|
$this->minimumLevel = self::LEVEL_WARNING;
|
|
} elseif ( $wgDebugLogFile != '' || $wgShowDebug || $wgDebugToolbar ) {
|
|
// Log all messages if there is a debug log file or debug toolbar
|
|
$this->minimumLevel = self::LEVEL_DEBUG;
|
|
} elseif ( isset( $wgDebugLogGroups[$channel] ) ) {
|
|
$logConfig = $wgDebugLogGroups[$channel];
|
|
// Log messages if the config is set, according to the configured level
|
|
if ( is_array( $logConfig ) && isset( $logConfig['level'] ) ) {
|
|
$this->minimumLevel = self::$levelMapping[$logConfig['level']];
|
|
} else {
|
|
$this->minimumLevel = self::LEVEL_DEBUG;
|
|
}
|
|
} else {
|
|
// No other case hit: discard all messages
|
|
$this->minimumLevel = self::LEVEL_INFINITY;
|
|
}
|
|
|
|
if ( $this->isDB && $wgDBerrorLog && $this->minimumLevel > self::LEVEL_ERROR ) {
|
|
// Log DB errors if there is a DB error log
|
|
$this->minimumLevel = self::LEVEL_ERROR;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Change an existing Logger singleton to act like NullLogger.
|
|
*
|
|
* @internal For use by MediaWikiIntegrationTestCase::setNullLogger
|
|
* @param null|int $level
|
|
* @return int
|
|
*/
|
|
public function setMinimumForTest( ?int $level ) {
|
|
if ( !defined( 'MW_PHPUNIT_TEST' ) ) {
|
|
throw new LogicException( 'Not allowed outside tests' );
|
|
}
|
|
// Set LEVEL_INFINITY if given null, or restore the original level.
|
|
$original = $this->minimumLevel;
|
|
$this->minimumLevel = $level ?? self::LEVEL_INFINITY;
|
|
return $original;
|
|
}
|
|
|
|
/**
|
|
* Logs with an arbitrary level.
|
|
*
|
|
* @param string|int $level
|
|
* @param string $message
|
|
* @param array $context
|
|
*/
|
|
public function log( $level, $message, array $context = [] ) {
|
|
if ( is_string( $level ) ) {
|
|
$level = self::$levelMapping[$level];
|
|
}
|
|
if ( $level < $this->minimumLevel ) {
|
|
return;
|
|
}
|
|
|
|
if ( $this->isDB
|
|
&& $level === self::LEVEL_DEBUG
|
|
&& isset( $context['sql'] )
|
|
) {
|
|
// Also give the query information to the MWDebug tools
|
|
MWDebug::query(
|
|
$context['sql'],
|
|
$context['method'],
|
|
$context['runtime_ms'] / 1000,
|
|
$context['db_server']
|
|
);
|
|
}
|
|
|
|
// If this is a DB-related error, and the site has $wgDBerrorLog
|
|
// configured, rewrite the channel as wfLogDBError instead.
|
|
// Likewise, if the site does not use $wgDBerrorLog, it should
|
|
// configurable like any other channel via $wgDebugLogGroups
|
|
// or $wgMWLoggerDefaultSpi.
|
|
global $wgDBerrorLog;
|
|
if ( $this->isDB && $level >= self::LEVEL_ERROR && $wgDBerrorLog ) {
|
|
// Format and write DB errors to the legacy locations
|
|
$effectiveChannel = 'wfLogDBError';
|
|
} else {
|
|
$effectiveChannel = $this->channel;
|
|
}
|
|
|
|
if ( self::shouldEmit( $effectiveChannel, $message, $level, $context ) ) {
|
|
$text = self::format( $effectiveChannel, $message, $context );
|
|
$destination = self::destination( $effectiveChannel, $message, $context );
|
|
$this->maybeLogToStderr( $text );
|
|
self::emit( $text, $destination );
|
|
}
|
|
if ( !isset( $context['private'] ) || !$context['private'] ) {
|
|
// Add to debug toolbar if not marked as "private"
|
|
MWDebug::debugMsg( $message, [ 'channel' => $this->channel ] + $context );
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Determine if the given message should be emitted or not.
|
|
*
|
|
* @param string $channel
|
|
* @param string $message
|
|
* @param string|int $level \Psr\Log\LogEvent constant or Monolog level int
|
|
* @param array $context
|
|
* @return bool True if message should be sent to disk/network, false
|
|
* otherwise
|
|
*/
|
|
public static function shouldEmit( $channel, $message, $level, $context ) {
|
|
global $wgDebugLogFile, $wgDBerrorLog, $wgDebugLogGroups;
|
|
|
|
if ( is_string( $level ) ) {
|
|
$level = self::$levelMapping[$level];
|
|
}
|
|
|
|
if ( $channel === 'wfLogDBError' ) {
|
|
// wfLogDBError messages are emitted if a database log location is
|
|
// specified.
|
|
$shouldEmit = (bool)$wgDBerrorLog;
|
|
|
|
} elseif ( $channel === 'wfDebug' ) {
|
|
// wfDebug messages are emitted if a catch all logging file has
|
|
// been specified. Checked explicitly so that 'private' flagged
|
|
// messages are not discarded by unset $wgDebugLogGroups channel
|
|
// handling below.
|
|
$shouldEmit = $wgDebugLogFile != '';
|
|
|
|
} elseif ( isset( $wgDebugLogGroups[$channel] ) ) {
|
|
$logConfig = $wgDebugLogGroups[$channel];
|
|
|
|
if ( is_array( $logConfig ) ) {
|
|
$shouldEmit = true;
|
|
if ( isset( $logConfig['sample'] ) ) {
|
|
// Emit randomly with a 1 in 'sample' chance for each message.
|
|
$shouldEmit = mt_rand( 1, $logConfig['sample'] ) === 1;
|
|
}
|
|
|
|
if ( isset( $logConfig['level'] ) ) {
|
|
$shouldEmit = $level >= self::$levelMapping[$logConfig['level']];
|
|
}
|
|
} else {
|
|
// Emit unless the config value is explicitly false.
|
|
$shouldEmit = $logConfig !== false;
|
|
}
|
|
|
|
} elseif ( isset( $context['private'] ) && $context['private'] ) {
|
|
// Don't emit if the message didn't match previous checks based on
|
|
// the channel and the event is marked as private. This check
|
|
// discards messages sent via wfDebugLog() with dest == 'private'
|
|
// and no explicit wgDebugLogGroups configuration.
|
|
$shouldEmit = false;
|
|
} else {
|
|
// Default return value is the same as the historic wfDebug
|
|
// method: emit if $wgDebugLogFile has been set.
|
|
$shouldEmit = $wgDebugLogFile != '';
|
|
}
|
|
|
|
return $shouldEmit;
|
|
}
|
|
|
|
/**
|
|
* Format a message.
|
|
*
|
|
* Messages to the 'wfDebug' and 'wfLogDBError' channels receive special formatting to mimic the
|
|
* historic output of the functions of the same name. All other channel values are formatted
|
|
* based on the historic output of the `wfDebugLog()` global function.
|
|
*
|
|
* @param string $channel
|
|
* @param string $message
|
|
* @param array $context
|
|
* @return string
|
|
*/
|
|
public static function format( $channel, $message, $context ) {
|
|
global $wgDebugLogGroups, $wgLogExceptionBacktrace;
|
|
|
|
if ( $channel === 'wfDebug' ) {
|
|
$text = self::formatAsWfDebug( $channel, $message, $context );
|
|
|
|
} elseif ( $channel === 'wfLogDBError' ) {
|
|
$text = self::formatAsWfLogDBError( $channel, $message, $context );
|
|
|
|
} elseif ( !isset( $wgDebugLogGroups[$channel] ) ) {
|
|
$text = self::formatAsWfDebug(
|
|
$channel, "[{$channel}] {$message}", $context );
|
|
|
|
} else {
|
|
// Default formatting is wfDebugLog's historic style
|
|
$text = self::formatAsWfDebugLog( $channel, $message, $context );
|
|
}
|
|
|
|
// Append stacktrace of throwable if available
|
|
if ( $wgLogExceptionBacktrace && isset( $context['exception'] ) ) {
|
|
$e = $context['exception'];
|
|
$backtrace = false;
|
|
|
|
if ( $e instanceof Throwable ) {
|
|
$backtrace = MWExceptionHandler::getRedactedTrace( $e );
|
|
|
|
} elseif ( is_array( $e ) && isset( $e['trace'] ) ) {
|
|
// Throwable has already been unpacked as structured data
|
|
$backtrace = $e['trace'];
|
|
}
|
|
|
|
if ( $backtrace ) {
|
|
$text .= MWExceptionHandler::prettyPrintTrace( $backtrace ) .
|
|
"\n";
|
|
}
|
|
}
|
|
|
|
return self::interpolate( $text, $context );
|
|
}
|
|
|
|
/**
|
|
* Format a message as `wfDebug()` would have formatted it.
|
|
*
|
|
* @param string $channel
|
|
* @param string $message
|
|
* @param array $context
|
|
* @return string
|
|
*/
|
|
protected static function formatAsWfDebug( $channel, $message, $context ) {
|
|
$text = preg_replace( '![\x00-\x08\x0b\x0c\x0e-\x1f]!', ' ', $message );
|
|
if ( isset( $context['seconds_elapsed'] ) ) {
|
|
// Prepend elapsed request time and real memory usage with two
|
|
// trailing spaces.
|
|
$text = "{$context['seconds_elapsed']} {$context['memory_used']} {$text}";
|
|
}
|
|
if ( isset( $context['prefix'] ) ) {
|
|
$text = "{$context['prefix']}{$text}";
|
|
}
|
|
return "{$text}\n";
|
|
}
|
|
|
|
/**
|
|
* Format a message as `wfLogDBError()` would have formatted it.
|
|
*
|
|
* @param string $channel
|
|
* @param string $message
|
|
* @param array $context
|
|
* @return string
|
|
*/
|
|
protected static function formatAsWfLogDBError( $channel, $message, $context ) {
|
|
global $wgDBerrorLogTZ;
|
|
static $cachedTimezone = null;
|
|
|
|
if ( !$cachedTimezone ) {
|
|
$cachedTimezone = new DateTimeZone( $wgDBerrorLogTZ );
|
|
}
|
|
|
|
$d = date_create( 'now', $cachedTimezone );
|
|
$date = $d->format( 'D M j G:i:s T Y' );
|
|
|
|
$host = wfHostname();
|
|
$wiki = WikiMap::getCurrentWikiId();
|
|
|
|
$text = "{$date}\t{$host}\t{$wiki}\t{$message}\n";
|
|
return $text;
|
|
}
|
|
|
|
/**
|
|
* Format a message as `wfDebugLog() would have formatted it.
|
|
*
|
|
* @param string $channel
|
|
* @param string $message
|
|
* @param array $context
|
|
* @return string
|
|
*/
|
|
protected static function formatAsWfDebugLog( $channel, $message, $context ) {
|
|
$time = wfTimestamp( TS_DB );
|
|
$wiki = WikiMap::getCurrentWikiId();
|
|
$host = wfHostname();
|
|
$text = "{$time} {$host} {$wiki}: {$message}\n";
|
|
return $text;
|
|
}
|
|
|
|
/**
|
|
* Interpolate placeholders in logging message.
|
|
*
|
|
* @param string $message
|
|
* @param array $context
|
|
* @return string Interpolated message
|
|
*/
|
|
public static function interpolate( $message, array $context ) {
|
|
if ( str_contains( $message, '{' ) ) {
|
|
$replace = [];
|
|
foreach ( $context as $key => $val ) {
|
|
$replace['{' . $key . '}'] = self::flatten( $val );
|
|
}
|
|
$message = strtr( $message, $replace );
|
|
}
|
|
return $message;
|
|
}
|
|
|
|
/**
|
|
* Convert a logging context element to a string suitable for
|
|
* interpolation.
|
|
*
|
|
* @param mixed $item
|
|
* @return string
|
|
*/
|
|
protected static function flatten( $item ) {
|
|
if ( $item === null ) {
|
|
return '[Null]';
|
|
}
|
|
|
|
if ( is_bool( $item ) ) {
|
|
return $item ? 'true' : 'false';
|
|
}
|
|
|
|
if ( is_float( $item ) ) {
|
|
if ( is_infinite( $item ) ) {
|
|
return ( $item > 0 ? '' : '-' ) . 'INF';
|
|
}
|
|
if ( is_nan( $item ) ) {
|
|
return 'NaN';
|
|
}
|
|
return (string)$item;
|
|
}
|
|
|
|
if ( is_scalar( $item ) ) {
|
|
return (string)$item;
|
|
}
|
|
|
|
if ( is_array( $item ) ) {
|
|
return '[Array(' . count( $item ) . ')]';
|
|
}
|
|
|
|
if ( $item instanceof \DateTime ) {
|
|
return $item->format( 'c' );
|
|
}
|
|
|
|
if ( $item instanceof Throwable ) {
|
|
$which = $item instanceof Error ? 'Error' : 'Exception';
|
|
return '[' . $which . ' ' . get_class( $item ) . '( ' .
|
|
$item->getFile() . ':' . $item->getLine() . ') ' .
|
|
$item->getMessage() . ']';
|
|
}
|
|
|
|
if ( is_object( $item ) ) {
|
|
if ( method_exists( $item, '__toString' ) ) {
|
|
return (string)$item;
|
|
}
|
|
|
|
return '[Object ' . get_class( $item ) . ']';
|
|
}
|
|
|
|
// phpcs:ignore MediaWiki.Usage.ForbiddenFunctions.is_resource
|
|
if ( is_resource( $item ) ) {
|
|
return '[Resource ' . get_resource_type( $item ) . ']';
|
|
}
|
|
|
|
return '[Unknown ' . get_debug_type( $item ) . ']';
|
|
}
|
|
|
|
/**
|
|
* Select the appropriate log output destination for the given log event.
|
|
*
|
|
* If the event context contains 'destination'
|
|
*
|
|
* @param string $channel
|
|
* @param string $message
|
|
* @param array $context
|
|
* @return string
|
|
*/
|
|
protected static function destination( $channel, $message, $context ) {
|
|
global $wgDebugLogFile, $wgDBerrorLog, $wgDebugLogGroups;
|
|
|
|
// Default destination is the debug log file as historically used by
|
|
// the wfDebug function.
|
|
$destination = $wgDebugLogFile;
|
|
|
|
if ( isset( $context['destination'] ) ) {
|
|
// Use destination explicitly provided in context
|
|
$destination = $context['destination'];
|
|
|
|
} elseif ( $channel === 'wfDebug' ) {
|
|
$destination = $wgDebugLogFile;
|
|
|
|
} elseif ( $channel === 'wfLogDBError' ) {
|
|
$destination = $wgDBerrorLog;
|
|
|
|
} elseif ( isset( $wgDebugLogGroups[$channel] ) ) {
|
|
$logConfig = $wgDebugLogGroups[$channel];
|
|
|
|
if ( is_array( $logConfig ) ) {
|
|
$destination = $logConfig['destination'];
|
|
} else {
|
|
$destination = strval( $logConfig );
|
|
}
|
|
}
|
|
|
|
return $destination;
|
|
}
|
|
|
|
/**
|
|
* Log to a file without getting "file size exceeded" signals.
|
|
*
|
|
* Can also log to UDP with the syntax udp://host:port/prefix. This will send
|
|
* lines to the specified port, prefixed by the specified prefix and a space.
|
|
*
|
|
* @param string $text
|
|
* @param string $file Filename
|
|
*/
|
|
public static function emit( $text, $file ) {
|
|
if ( str_starts_with( $file, 'udp:' ) ) {
|
|
$transport = UDPTransport::newFromString( $file );
|
|
$transport->emit( $text );
|
|
} else {
|
|
AtEase::suppressWarnings();
|
|
$exists = file_exists( $file );
|
|
$size = $exists ? filesize( $file ) : false;
|
|
if ( !$exists ||
|
|
( $size !== false && $size + strlen( $text ) < 0x7fffffff )
|
|
) {
|
|
file_put_contents( $file, $text, FILE_APPEND );
|
|
}
|
|
AtEase::restoreWarnings();
|
|
}
|
|
}
|
|
|
|
/**
|
|
* If MW_LOG_STDERR is set (used currently in `composer serve`) then also
|
|
* emit to stderr using error_log().
|
|
*
|
|
* @param string $text
|
|
* @return void
|
|
*/
|
|
private function maybeLogToStderr( string $text ): void {
|
|
if ( getenv( 'MW_LOG_STDERR' ) ) {
|
|
error_log( trim( $text ) );
|
|
}
|
|
}
|
|
|
|
}
|