includes/debug/logger/legacy/Logger.php

   1 <?php
   2 /**
   3  * @section LICENSE
   4  * This program is free software; you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation; either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License along
  15  * with this program; if not, write to the Free Software Foundation, Inc.,
  16  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
  17  * http://www.gnu.org/copyleft/gpl.html
  18  *
  19  * @file
  20  */
  21
  22 /**
  23  * PSR-3 logger that mimics the historic implementation of MediaWiki's
  24  * wfErrorLog logging implementation.
  25  *
  26  * This logger is configured by the following global configuration variables:
  27  * - `$wgDebugLogFile`
  28  * - `$wgDebugLogGroups`
  29  * - `$wgDBerrorLog`
  30  * - `$wgDBerrorLogTZ`
  31  *
  32  * See documentation in DefaultSettings.php for detailed explanations of each
  33  * variable.
  34  *
  35  * @see MWLogger
  36  * @since 1.25
  37  * @author Bryan Davis <bd808@wikimedia.org>
  38  * @copyright © 2014 Bryan Davis and Wikimedia Foundation.
  39  */
  40 class MWLoggerLegacyLogger extends \Psr\Log\AbstractLogger {
  41
  42         /**
  43          * @var string $channel
  44          */
  45         protected $channel;
  46
  47
  48         /**
  49          * @param string $channel
  50          */
  51         public function __construct( $channel ) {
  52                 $this->channel = $channel;
  53         }
  54
  55         /**
  56          * Logs with an arbitrary level.
  57          *
  58          * @param string|int $level
  59          * @param string $message
  60          * @param array $context
  61          */
  62         public function log( $level, $message, array $context = array() ) {
  63                 if ( self::shouldEmit( $this->channel, $message, $context ) ) {
  64                         $text = self::format( $this->channel, $message, $context );
  65                         $destination = self::destination( $this->channel, $message, $context );
  66                         self::emit( $text, $destination );
  67                 }
  68         }
  69
  70
  71         /**
  72          * Determine if the given message should be emitted or not.
  73          *
  74          * @param string $channel
  75          * @param string $message
  76          * @param array $context
  77          * @return bool True if message should be sent to disk/network, false
  78          * otherwise
  79          */
  80         public static function shouldEmit( $channel, $message, $context ) {
  81                 global $wgDebugLogFile, $wgDBerrorLog, $wgDebugLogGroups;
  82
  83                 if ( $channel === 'wfLogDBError' ) {
  84                         // wfLogDBError messages are emitted if a database log location is
  85                         // specfied.
  86                         $shouldEmit = (bool)$wgDBerrorLog;
  87
  88                 } elseif ( $channel === 'wfErrorLog' ) {
  89                         // All messages on the wfErrorLog channel should be emitted.
  90                         $shouldEmit = true;
  91
  92                 } elseif ( isset( $wgDebugLogGroups[$channel] ) ) {
  93                         $logConfig = $wgDebugLogGroups[$channel];
  94
  95                         if ( is_array( $logConfig ) && isset( $logConfig['sample'] ) ) {
  96                                 // Emit randomly with a 1 in 'sample' chance for each message.
  97                                 $shouldEmit = mt_rand( 1, $logConfig['sample'] ) === 1;
  98
  99                         } else {
 100                                 // Emit unless the config value is explictly false.
 101                                 $shouldEmit = $logConfig !== false;
 102                         }
 103
 104                 } elseif ( isset( $context['private'] ) && $context['private'] ) {
 105                         // Don't emit if the message didn't match previous checks based on
 106                         // the channel and the event is marked as private. This check
 107                         // discards messages sent via wfDebugLog() with dest == 'private'
 108                         // and no explicit wgDebugLogGroups configuration.
 109                         $shouldEmit = false;
 110                 } else {
 111                         // Default return value is the the same as the historic wfDebug
 112                         // method: emit if $wgDebugLogFile has been set.
 113                         $shouldEmit = $wgDebugLogFile != '';
 114                 }
 115
 116                 return $shouldEmit;
 117         }
 118
 119
 120         /**
 121          * Format a message.
 122          *
 123          * Messages to the 'wfDebug', 'wfLogDBError' and 'wfErrorLog' channels
 124          * receive special fomatting to mimic the historic output of the functions
 125          * of the same name. All other channel values are formatted based on the
 126          * historic output of the `wfDebugLog()` global function.
 127          *
 128          * @param string $channel
 129          * @param string $message
 130          * @param array $context
 131          * @return string
 132          */
 133         public static function format( $channel, $message, $context ) {
 134                 global $wgDebugLogGroups;
 135
 136                 if ( $channel === 'wfDebug' ) {
 137                         $text = self::formatAsWfDebug( $channel, $message, $context );
 138
 139                 } elseif ( $channel === 'wfLogDBError' ) {
 140                         $text = self::formatAsWfLogDBError( $channel, $message, $context );
 141
 142                 } elseif ( $channel === 'wfErrorLog' ) {
 143                         $text = "{$message}\n";
 144
 145                 } elseif ( $channel === 'profileoutput' ) {
 146                         // Legacy wfLogProfilingData formatitng
 147                         $forward = '';
 148                         if ( isset( $context['forwarded_for'] )) {
 149                                 $forward = " forwarded for {$context['forwarded_for']}";
 150                         }
 151                         if ( isset( $context['client_ip'] ) ) {
 152                                 $forward .= " client IP {$context['client_ip']}";
 153                         }
 154                         if ( isset( $context['from'] ) ) {
 155                                 $forward .= " from {$context['from']}";
 156                         }
 157                         if ( $forward ) {
 158                                 $forward = "\t(proxied via {$context['proxy']}{$forward})";
 159                         }
 160                         if ( $context['anon'] ) {
 161                                 $forward .= ' anon';
 162                         }
 163                         if ( !isset( $context['url'] ) ) {
 164                                 $context['url'] = 'n/a';
 165                         }
 166
 167                         $log = sprintf( "%s\t%04.3f\t%s%s\n",
 168                                 gmdate( 'YmdHis' ), $context['elapsed'], $context['url'], $forward );
 169
 170                         $text = self::formatAsWfDebugLog(
 171                                 $channel, $log . $context['output'], $context );
 172
 173                 } elseif ( !isset( $wgDebugLogGroups[$channel] ) ) {
 174                         $text = self::formatAsWfDebug(
 175                                 $channel, "[{$channel}] {$message}", $context );
 176
 177                 } else {
 178                         // Default formatting is wfDebugLog's historic style
 179                         $text = self::formatAsWfDebugLog( $channel, $message, $context );
 180                 }
 181
 182                 return self::interpolate( $text, $context );
 183         }
 184
 185
 186         /**
 187          * Format a message as `wfDebug()` would have formatted it.
 188          *
 189          * @param string $channel
 190          * @param string $message
 191          * @param array $context
 192          * @return string
 193          */
 194         protected static function formatAsWfDebug( $channel, $message, $context ) {
 195                 $text = preg_replace( '![\x00-\x08\x0b\x0c\x0e-\x1f]!', ' ', $message );
 196                 if ( isset( $context['seconds_elapsed'] ) ) {
 197                         // Prepend elapsed request time and real memory usage with two
 198                         // trailing spaces.
 199                         $text = "{$context['seconds_elapsed']} {$context['memory_used']}  {$text}";
 200                 }
 201                 if ( isset( $context['prefix'] ) ) {
 202                         $text = "{$context['prefix']}{$text}";
 203                 }
 204                 return "{$text}\n";
 205         }
 206
 207
 208         /**
 209          * Format a message as `wfLogDBError()` would have formatted it.
 210          *
 211          * @param string $channel
 212          * @param string $message
 213          * @param array $context
 214          * @return string
 215          */
 216         protected static function formatAsWfLogDBError( $channel, $message, $context ) {
 217                 global $wgDBerrorLogTZ;
 218                 static $cachedTimezone = null;
 219
 220                 if ( $wgDBerrorLogTZ && !$cachedTimezone ) {
 221                         $cachedTimezone = new DateTimeZone( $wgDBerrorLogTZ );
 222                 }
 223
 224                 // Workaround for https://bugs.php.net/bug.php?id=52063
 225                 // Can be removed when min PHP > 5.3.6
 226                 if ( $cachedTimezone === null ) {
 227                         $d = date_create( 'now' );
 228                 } else {
 229                         $d = date_create( 'now', $cachedTimezone );
 230                 }
 231                 $date = $d->format( 'D M j G:i:s T Y' );
 232
 233                 $host = wfHostname();
 234                 $wiki = wfWikiID();
 235
 236                 $text = "{$date}\t{$host}\t{$wiki}\t{$message}\n";
 237                 return $text;
 238         }
 239
 240
 241         /**
 242          * Format a message as `wfDebugLog() would have formatted it.
 243          *
 244          * @param string $channel
 245          * @param string $message
 246          * @param array $context
 247          */
 248         protected static function formatAsWfDebugLog( $channel, $message, $context ) {
 249                 $time = wfTimestamp( TS_DB );
 250                 $wiki = wfWikiID();
 251                 $host = wfHostname();
 252                 $text = "{$time} {$host} {$wiki}: {$message}\n";
 253                 return $text;
 254         }
 255
 256
 257         /**
 258          * Interpolate placeholders in logging message.
 259          *
 260          * @param string $message
 261          * @param array $context
 262          */
 263         public static function interpolate( $message, array $context ) {
 264                 if ( strpos( $message, '{' ) !== false ) {
 265                         $replace = array();
 266                         foreach ( $context as $key => $val ) {
 267                                 $replace['{' . $key . '}'] = $val;
 268                         }
 269                         $message = strtr( $message, $replace );
 270                 }
 271                 return $message;
 272         }
 273
 274
 275         /**
 276          * Select the appropriate log output destination for the given log event.
 277          *
 278          * If the event context contains 'destination'
 279          *
 280          * @param string $channel
 281          * @param string $message
 282          * @param array $context
 283          * @return string
 284          */
 285         protected static function destination( $channel, $message, $context ) {
 286                 global $wgDebugLogFile, $wgDBerrorLog, $wgDebugLogGroups;
 287
 288                 // Default destination is the debug log file as historically used by
 289                 // the wfDebug function.
 290                 $destination = $wgDebugLogFile;
 291
 292                 if ( isset( $context['destination'] ) ) {
 293                         // Use destination explicitly provided in context
 294                         $destination = $context['destination'];
 295
 296                 } elseif ( $channel === 'wfDebug' ) {
 297                         $destination = $wgDebugLogFile;
 298
 299                 } elseif ( $channel === 'wfLogDBError' ) {
 300                         $destination = $wgDBerrorLog;
 301
 302                 } elseif ( isset( $wgDebugLogGroups[$channel] ) ) {
 303                         $logConfig = $wgDebugLogGroups[$channel];
 304
 305                         if ( is_array( $logConfig ) ) {
 306                                 $destination = $logConfig['destination'];
 307                         } else {
 308                                 $destination = strval( $logConfig );
 309                         }
 310                 }
 311
 312                 return $destination;
 313         }
 314
 315
 316         /**
 317         * Log to a file without getting "file size exceeded" signals.
 318         *
 319         * Can also log to UDP with the syntax udp://host:port/prefix. This will send
 320         * lines to the specified port, prefixed by the specified prefix and a space.
 321         *
 322         * @param string $text
 323         * @param string $file Filename
 324         * @throws MWException
 325         */
 326         public static function emit( $text, $file ) {
 327                 if ( substr( $file, 0, 4 ) == 'udp:' ) {
 328                         # Needs the sockets extension
 329                         if ( preg_match( '!^udp:(?://)?\[([0-9a-fA-F:]+)\]:(\d+)(?:/(.*))?$!', $file, $m ) ) {
 330                                 // IPv6 bracketed host
 331                                 $host = $m[1];
 332                                 $port = intval( $m[2] );
 333                                 $prefix = isset( $m[3] ) ? $m[3] : false;
 334                                 $domain = AF_INET6;
 335                         } elseif ( preg_match( '!^udp:(?://)?([a-zA-Z0-9.-]+):(\d+)(?:/(.*))?$!', $file, $m ) ) {
 336                                 $host = $m[1];
 337                                 if ( !IP::isIPv4( $host ) ) {
 338                                         $host = gethostbyname( $host );
 339                                 }
 340                                 $port = intval( $m[2] );
 341                                 $prefix = isset( $m[3] ) ? $m[3] : false;
 342                                 $domain = AF_INET;
 343                         } else {
 344                                 throw new MWException( __METHOD__ . ': Invalid UDP specification' );
 345                         }
 346
 347                         // Clean it up for the multiplexer
 348                         if ( strval( $prefix ) !== '' ) {
 349                                 $text = preg_replace( '/^/m', $prefix . ' ', $text );
 350
 351                                 // Limit to 64KB
 352                                 if ( strlen( $text ) > 65506 ) {
 353                                         $text = substr( $text, 0, 65506 );
 354                                 }
 355
 356                                 if ( substr( $text, -1 ) != "\n" ) {
 357                                         $text .= "\n";
 358                                 }
 359                         } elseif ( strlen( $text ) > 65507 ) {
 360                                 $text = substr( $text, 0, 65507 );
 361                         }
 362
 363                         $sock = socket_create( $domain, SOCK_DGRAM, SOL_UDP );
 364                         if ( !$sock ) {
 365                                 return;
 366                         }
 367
 368                         socket_sendto( $sock, $text, strlen( $text ), 0, $host, $port );
 369                         socket_close( $sock );
 370                 } else {
 371                         wfSuppressWarnings();
 372                         $exists = file_exists( $file );
 373                         $size = $exists ? filesize( $file ) : false;
 374                         if ( !$exists ||
 375                                 ( $size !== false && $size + strlen( $text ) < 0x7fffffff )
 376                         ) {
 377                                 file_put_contents( $file, $text, FILE_APPEND );
 378                         }
 379                         wfRestoreWarnings();
 380                 }
 381         }
 382
 383 }