[Summary view] [Print] [Text view]

   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 <[email protected]>
  46   * @version $Revision: 1.13 $
  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 <[email protected]>
 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 <[email protected]>
 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 <[email protected]>
 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           
 291          return date($this->df, $event->getTimeStamp());
 292          
 293      }
 294  }
 295  
 296  /**
 297   * @author VxR <[email protected]>
 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 <[email protected]>
 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 <[email protected]>
 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 <[email protected]>
 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 <[email protected]>
 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  ?>