include/lib/log4php/helpers/LoggerPatternConverter.php

   1 <?php
   2 /**
   3  * log4php is a PHP port of the log4j java logging package.
   4  *
   5  * <p>This framework is based on log4j (see {@link http://jakarta.apache.org/log4j log4j} for details).</p>
   6  * <p>Design, strategies and part of the methods documentation are developed by log4j team
   7  * (Ceki Gülcü as log4j project founder and
   8  * {@link http://jakarta.apache.org/log4j/docs/contributors.html contributors}).</p>
   9  *
  10  * <p>PHP port, extensions and modifications by VxR. All rights reserved.<br>
  11  * For more information, please see {@link http://www.vxr.it/log4php/}.</p>
  12  *
  13  * <p>This software is published under the terms of the LGPL License
  14  * a copy of which has been included with this distribution in the LICENSE file.</p>
  15  *
  16  * @package log4php
  17  * @subpackage helpers
  18  */
  19
  20 /**
  21  * @ignore
  22  */
  23 if (!defined('LOG4PHP_DIR')) define('LOG4PHP_DIR', dirname(__FILE__) . '/..');
  24
  25 /**
  26  */
  27 require_once(LOG4PHP_DIR . '/LoggerLog.php');
  28
  29 /**
  30  * Array for fast space padding
  31  * Used by {@link LoggerPatternConverter::spacePad()}.
  32  */
  33 $GLOBALS['log4php.LoggerPatternConverter.spaces'] = array(" ", "  ", "    ", "        ", //1,2,4,8 spaces
  34                             "                ", // 16 spaces
  35                             "                                " ); // 32 spaces
  36
  37 /**
  38  * LoggerPatternConverter is an abstract class that provides the formatting
  39  * functionality that derived classes need.
  40  *
  41  * <p>Conversion specifiers in a conversion patterns are parsed to
  42  * individual PatternConverters. Each of which is responsible for
  43  * converting a logging event in a converter specific manner.</p>
  44  *
  45  * @author VxR <vxr@vxr.it>
  46  * @version $Revision: 2 $
  47  * @package log4php
  48  * @subpackage helpers
  49  * @abstract
  50  * @since 0.3
  51  */
  52 class LoggerPatternConverter {
  53
  54     /**
  55      * @var LoggerPatternConverter next converter in converter chain
  56      */
  57     var $next = null;
  58
  59     var $min = -1;
  60     var $max = 0x7FFFFFFF;
  61     var $leftAlign = false;
  62
  63     /**
  64      * Constructor
  65      *
  66      * @param LoggerFormattingInfo $fi
  67      */
  68     function LoggerPatternConverter($fi = null)
  69     {
  70         if ($fi !== null) {
  71             $this->min = $fi->min;
  72             $this->max = $fi->max;
  73             $this->leftAlign = $fi->leftAlign;
  74         }
  75     }
  76
  77     /**
  78      * Derived pattern converters must override this method in order to
  79      * convert conversion specifiers in the correct way.
  80      *
  81      * @param LoggerLoggingEvent $event
  82      */
  83     function convert($event) {}
  84
  85     /**
  86      * A template method for formatting in a converter specific way.
  87      *
  88      * @param string &$sbuf string buffer
  89      * @param LoggerLoggingEvent $e
  90      */
  91     function format(&$sbuf, $e)
  92     {
  93         LoggerLog::debug("LoggerPatternConverter::format() sbuf='$sbuf'");
  94
  95         $s = $this->convert($e);
  96
  97         LoggerLog::debug("LoggerPatternConverter::format() converted event is '$s'");
  98
  99
 100         if($s == null or empty($s)) {
 101             if(0 < $this->min)
 102                 $this->spacePad($sbuf, $this->min);
 103             return;
 104         }
 105
 106         $len = strlen($s);
 107
 108         if($len > $this->max) {
 109             $sbuf .= substr($s , 0, ($len - $this->max));
 110         } elseif($len < $this->min) {
 111             if($this->leftAlign) {
 112                 $sbuf .= $s;
 113                 $this->spacePad($sbuf, ($this->min - $len));
 114             } else {
 115                 $this->spacePad($sbuf, ($this->min - $len));
 116                 $sbuf .= $s;
 117             }
 118         } else {
 119             $sbuf .= $s;
 120         }
 121     }
 122
 123
 124     /**
 125      * Fast space padding method.
 126      *
 127      * @param string    &$sbuf     string buffer
 128      * @param integer   $length    pad length
 129      *
 130      * @todo reimplement using PHP string functions
 131      */
 132     function spacePad(&$sbuf, $length)
 133     {
 134         LoggerLog::debug("LoggerPatternConverter::spacePad() sbuf='$sbuf' len='$length'");
 135
 136         while($length >= 32) {
 137           $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][5];
 138           $length -= 32;
 139         }
 140
 141         for($i = 4; $i >= 0; $i--) {
 142             if(($length & (1<<$i)) != 0) {
 143                 $sbuf .= $GLOBALS['log4php.LoggerPatternConverter.spaces'][$i];
 144             }
 145         }
 146
 147         // $sbuf = str_pad($sbuf, $length);
 148     }
 149 }
 150
 151 // ---------------------------------------------------------------------
 152 //                      PatternConverters
 153 // ---------------------------------------------------------------------
 154
 155 /**
 156  * @author VxR <vxr@vxr.it>
 157  * @package log4php
 158  * @subpackage helpers
 159  */
 160 class LoggerBasicPatternConverter extends LoggerPatternConverter {
 161
 162     /**
 163      * @var integer
 164      */
 165     var $type;
 166
 167     /**
 168      * Constructor
 169      *
 170      * @param string $formattingInfo
 171      * @param integer $type
 172      */
 173     function LoggerBasicPatternConverter($formattingInfo, $type)
 174     {
 175       LoggerLog::debug("LoggerBasicPatternConverter::LoggerBasicPatternConverter() type='$type'");
 176
 177       $this->LoggerPatternConverter($formattingInfo);
 178       $this->type = $type;
 179     }
 180
 181     /**
 182      * @param LoggerLoggingEvent $event
 183      * @return string
 184      */
 185     function convert($event)
 186     {
 187         switch($this->type) {
 188             case LOG4PHP_LOGGER_PATTERN_PARSER_RELATIVE_TIME_CONVERTER:
 189                 $timeStamp = $event->getTimeStamp();
 190                 $startTime = LoggerLoggingEvent::getStartTime();
 191                     return (string)(int)($timeStamp * 1000 - $startTime * 1000);
 192
 193             case LOG4PHP_LOGGER_PATTERN_PARSER_THREAD_CONVERTER:
 194                     return $event->getThreadName();
 195
 196             case LOG4PHP_LOGGER_PATTERN_PARSER_LEVEL_CONVERTER:
 197                 $level = $event->getLevel();
 198                     return $level->toString();
 199
 200             case LOG4PHP_LOGGER_PATTERN_PARSER_NDC_CONVERTER:
 201                     return $event->getNDC();
 202
 203             case LOG4PHP_LOGGER_PATTERN_PARSER_MESSAGE_CONVERTER:
 204                     return $event->getRenderedMessage();
 205
 206             default:
 207                 return '';
 208         }
 209     }
 210 }
 211
 212 /**
 213  * @author VxR <vxr@vxr.it>
 214  * @package log4php
 215  * @subpackage helpers
 216  */
 217 class LoggerLiteralPatternConverter extends LoggerPatternConverter {
 218
 219     /**
 220      * @var string
 221      */
 222     var $literal;
 223
 224     /**
 225      * Constructor
 226      *
 227      * @param string $value
 228      */
 229     function LoggerLiteralPatternConverter($value)
 230     {
 231         LoggerLog::debug("LoggerLiteralPatternConverter::LoggerLiteralPatternConverter() value='$value'");
 232
 233         $this->literal = $value;
 234     }
 235
 236     /**
 237      * @param string &$sbuf
 238      * @param LoggerLoggingEvent $event
 239      */
 240     function format(&$sbuf, $event)
 241     {
 242         $sbuf .= $this->literal;
 243     }
 244
 245     /**
 246      * @param LoggerLoggingEvent $event
 247      * @return string
 248      */
 249     function convert($event)
 250     {
 251       return $this->literal;
 252     }
 253 }
 254
 255 /**
 256  * @author VxR <vxr@vxr.it>
 257  * @package log4php
 258  * @subpackage helpers
 259  */
 260 class LoggerDatePatternConverter extends LoggerPatternConverter {
 261
 262     /**
 263      * @var string
 264      */
 265     var $df;
 266
 267     /**
 268      * Constructor
 269      *
 270      * @param string $formattingInfo
 271      * @param string $df
 272      */
 273     function LoggerDatePatternConverter($formattingInfo, $df)
 274     {
 275         LoggerLog::debug("LoggerDatePatternConverter::LoggerDatePatternConverter() dateFormat='$df'");
 276
 277         $this->LoggerPatternConverter($formattingInfo);
 278         $this->df = $df;
 279     }
 280
 281     /**
 282      * @param LoggerLoggingEvent $event
 283      * @return string
 284      */
 285     function convert($event)
 286     {
 287         $timeStamp = $event->getTimeStamp();
 288         $usecs = round(($timeStamp - (int)$timeStamp) * 1000);
 289         $this->df = str_replace("\u", "u", ereg_replace("[^\\]u", sprintf(',%03d', $usecs), $this->df));
 290         //      $this->df = str_replace("\u", "u", ereg_replace(",u", sprintf(',%03d', $usecs), $this->df));            // bug fixed(2006/7/14)
 291         return date($this->df, $event->getTimeStamp());
 292
 293     }
 294 }
 295
 296 /**
 297  * @author VxR <vxr@vxr.it>
 298  * @package log4php
 299  * @subpackage helpers
 300  */
 301 class LoggerMDCPatternConverter extends LoggerPatternConverter {
 302
 303     /**
 304      * @var string
 305      */
 306     var $key;
 307
 308     /**
 309      * Constructor
 310      *
 311      * @param string $formattingInfo
 312      * @param string $key
 313      */
 314     function LoggerMDCPatternConverter($formattingInfo, $key)
 315     {
 316       LoggerLog::debug("LoggerMDCPatternConverter::LoggerMDCPatternConverter() key='$key'");
 317
 318       $this->LoggerPatternConverter($formattingInfo);
 319       $this->key = $key;
 320     }
 321
 322     /**
 323      * @param LoggerLoggingEvent $event
 324      * @return string
 325      */
 326     function convert($event)
 327     {
 328         return $event->getMDC($this->key);
 329     }
 330 }
 331
 332 /**
 333  * @author VxR <vxr@vxr.it>
 334  * @package log4php
 335  * @subpackage helpers
 336  */
 337 class LoggerLocationPatternConverter extends LoggerPatternConverter {
 338
 339     /**
 340      * @var integer
 341      */
 342     var $type;
 343
 344     /**
 345      * Constructor
 346      *
 347      * @param string $formattingInfo
 348      * @param integer $type
 349      */
 350     function LoggerLocationPatternConverter($formattingInfo, $type)
 351     {
 352       LoggerLog::debug("LoggerLocationPatternConverter::LoggerLocationPatternConverter() type='$type'");
 353
 354       $this->LoggerPatternConverter($formattingInfo);
 355       $this->type = $type;
 356     }
 357
 358     /**
 359      * @param LoggerLoggingEvent $event
 360      * @return string
 361      */
 362     function convert($event)
 363     {
 364         $locationInfo = $event->getLocationInformation();
 365         switch($this->type) {
 366             case LOG4PHP_LOGGER_PATTERN_PARSER_FULL_LOCATION_CONVERTER:
 367                     return $locationInfo->fullInfo;
 368             case LOG4PHP_LOGGER_PATTERN_PARSER_METHOD_LOCATION_CONVERTER:
 369                     return $locationInfo->getMethodName();
 370             case LOG4PHP_LOGGER_PATTERN_PARSER_LINE_LOCATION_CONVERTER:
 371                     return $locationInfo->getLineNumber();
 372             case LOG4PHP_LOGGER_PATTERN_PARSER_FILE_LOCATION_CONVERTER:
 373                     return $locationInfo->getFileName();
 374             default:
 375                 return '';
 376         }
 377     }
 378 }
 379
 380 /**
 381  * @author VxR <vxr@vxr.it>
 382  * @package log4php
 383  * @subpackage helpers
 384  * @abstract
 385  */
 386 class LoggerNamedPatternConverter extends LoggerPatternConverter {
 387
 388     /**
 389      * @var integer
 390      */
 391     var $precision;
 392
 393     /**
 394      * Constructor
 395      *
 396      * @param string $formattingInfo
 397      * @param integer $precision
 398      */
 399     function LoggerNamedPatternConverter($formattingInfo, $precision)
 400     {
 401       LoggerLog::debug("LoggerNamedPatternConverter::LoggerNamedPatternConverter() precision='$precision'");
 402
 403       $this->LoggerPatternConverter($formattingInfo);
 404       $this->precision =  $precision;
 405     }
 406
 407     /**
 408      * @param LoggerLoggingEvent $event
 409      * @return string
 410      * @abstract
 411      */
 412     function getFullyQualifiedName($event)
 413     {
 414         // abstract
 415         return;
 416     }
 417
 418     /**
 419      * @param LoggerLoggingEvent $event
 420      * @return string
 421      */
 422     function convert($event)
 423     {
 424         $n = $this->getFullyQualifiedName($event);
 425         if ($this->precision <= 0) {
 426                 return $n;
 427         } else {
 428                 $len = strlen($n);
 429
 430                 // We substract 1 from 'len' when assigning to 'end' to avoid out of
 431                 // bounds exception in return r.substring(end+1, len). This can happen if
 432                 // precision is 1 and the category name ends with a dot.
 433                 $end = $len -1 ;
 434                 for($i = $this->precision; $i > 0; $i--) {
 435                     $end = strrpos(substr($n, 0, ($end - 1)), '.');
 436                     if ($end == false)
 437                         return $n;
 438                 }
 439                 return substr($n, ($end + 1), $len);
 440         }
 441     }
 442 }
 443
 444 /**
 445  * @author VxR <vxr@vxr.it>
 446  * @package log4php
 447  * @subpackage helpers
 448  */
 449 class LoggerClassNamePatternConverter extends LoggerNamedPatternConverter {
 450
 451     /**
 452      * Constructor
 453      *
 454      * @param string $formattingInfo
 455      * @param integer $precision
 456      */
 457     function LoggerClassNamePatternConverter($formattingInfo, $precision)
 458     {
 459         LoggerLog::debug("LoggerClassNamePatternConverter::LoggerClassNamePatternConverter() precision='$precision'");
 460
 461         $this->LoggerNamedPatternConverter($formattingInfo, $precision);
 462     }
 463
 464     /**
 465      * @param LoggerLoggingEvent $event
 466      * @return string
 467      */
 468     function getFullyQualifiedName($event)
 469     {
 470         return $event->fqcn;
 471     }
 472 }
 473
 474 /**
 475  * @author VxR <vxr@vxr.it>
 476  * @package log4php
 477  * @subpackage helpers
 478  */
 479 class LoggerCategoryPatternConverter extends LoggerNamedPatternConverter {
 480
 481     /**
 482      * Constructor
 483      *
 484      * @param string $formattingInfo
 485      * @param integer $precision
 486      */
 487     function LoggerCategoryPatternConverter($formattingInfo, $precision)
 488     {
 489         LoggerLog::debug("LoggerCategoryPatternConverter::LoggerCategoryPatternConverter() precision='$precision'");
 490
 491         $this->LoggerNamedPatternConverter($formattingInfo, $precision);
 492     }
 493
 494     /**
 495      * @param LoggerLoggingEvent $event
 496      * @return string
 497      */
 498     function getFullyQualifiedName($event)
 499     {
 500       return $event->getLoggerName();
 501     }
 502 }
 503
 504 ?>