library/log4php/LoggerLoggingEvent.php
changeset 0 4869aea77e21
equal deleted inserted replaced
-1:000000000000 0:4869aea77e21
       
     1 <?php
       
     2 /**
       
     3  * Licensed to the Apache Software Foundation (ASF) under one or more
       
     4  * contributor license agreements. See the NOTICE file distributed with
       
     5  * this work for additional information regarding copyright ownership.
       
     6  * The ASF licenses this file to You under the Apache License, Version 2.0
       
     7  * (the "License"); you may not use this file except in compliance with
       
     8  * the License. You may obtain a copy of the License at
       
     9  *
       
    10  *       http://www.apache.org/licenses/LICENSE-2.0
       
    11  *
       
    12  * Unless required by applicable law or agreed to in writing, software
       
    13  * distributed under the License is distributed on an "AS IS" BASIS,
       
    14  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
       
    15  * See the License for the specific language governing permissions and
       
    16  * limitations under the License.
       
    17  *
       
    18  * @package log4php
       
    19  */
       
    20 
       
    21 /**
       
    22  * The internal representation of logging event.
       
    23  *
       
    24  * @version $Revision: 1382273 $
       
    25  * @package log4php
       
    26  */
       
    27 class LoggerLoggingEvent {
       
    28 
       
    29     private static $startTime;
       
    30 
       
    31     /**
       
    32      * @var string Fully Qualified Class Name of the calling category class.
       
    33      */
       
    34     private $fqcn;
       
    35 
       
    36     /**
       
    37      * @var Logger reference
       
    38      */
       
    39     private $logger;
       
    40 
       
    41     /**
       
    42      * The category (logger) name.
       
    43      * This field will be marked as private in future
       
    44      * releases. Please do not access it directly.
       
    45      * Use the {@link getLoggerName()} method instead.
       
    46      * @deprecated
       
    47      */
       
    48     private $categoryName;
       
    49 
       
    50     /**
       
    51      * Level of the logging event.
       
    52      * @var LoggerLevel
       
    53      */
       
    54     protected $level;
       
    55 
       
    56     /**
       
    57      * The nested diagnostic context (NDC) of logging event.
       
    58      * @var string
       
    59      */
       
    60     private $ndc;
       
    61 
       
    62     /**
       
    63      * Have we tried to do an NDC lookup? If we did, there is no need
       
    64      * to do it again.    Note that its value is always false when
       
    65      * serialized. Thus, a receiving SocketNode will never use it's own
       
    66      * (incorrect) NDC. See also writeObject method.
       
    67      * @var boolean
       
    68      */
       
    69     private $ndcLookupRequired = true;
       
    70 
       
    71     /**
       
    72      * @var mixed The application supplied message of logging event.
       
    73      */
       
    74     private $message;
       
    75 
       
    76     /**
       
    77      * The application supplied message rendered through the log4php
       
    78      * objet rendering mechanism. At present renderedMessage == message.
       
    79      * @var string
       
    80      */
       
    81     private $renderedMessage;
       
    82 
       
    83     /**
       
    84      * The name of thread in which this logging event was generated.
       
    85      * log4php saves here the process id via {@link PHP_MANUAL#getmypid getmypid()}
       
    86      * @var mixed
       
    87      */
       
    88     private $threadName;
       
    89 
       
    90     /**
       
    91      * The number of seconds elapsed from 1/1/1970 until logging event
       
    92      * was created plus microseconds if available.
       
    93      * @var float
       
    94      */
       
    95     public $timeStamp;
       
    96 
       
    97     /**
       
    98      * @var LoggerLocationInfo Location information for the caller.
       
    99      */
       
   100     private $locationInfo;
       
   101 
       
   102     /**
       
   103      * @var LoggerThrowableInformation log4php internal representation of throwable
       
   104      */
       
   105     private $throwableInfo;
       
   106 
       
   107     /**
       
   108      * Instantiate a LoggingEvent from the supplied parameters.
       
   109      *
       
   110      * Except {@link $timeStamp} all the other fields of
       
   111      * LoggerLoggingEvent are filled when actually needed.
       
   112      *
       
   113      * @param string $fqcn name of the caller class.
       
   114      * @param mixed $logger The {@link Logger} category of this event or the logger name.
       
   115      * @param LoggerLevel $level The level of this event.
       
   116      * @param mixed $message The message of this event.
       
   117      * @param integer $timeStamp the timestamp of this logging event.
       
   118      * @param Exception $throwable The throwable associated with logging event
       
   119      */
       
   120     public function __construct($fqcn, $logger, LoggerLevel $level, $message, $timeStamp = null, $throwable = null) {
       
   121         $this->fqcn = $fqcn;
       
   122         if ($logger instanceof Logger) {
       
   123             $this->logger = $logger;
       
   124             $this->categoryName = $logger->getName();
       
   125         } else {
       
   126             $this->categoryName = strval($logger);
       
   127         }
       
   128         $this->level = $level;
       
   129         $this->message = $message;
       
   130         if ($timeStamp !== null && is_numeric($timeStamp)) {
       
   131             $this->timeStamp = $timeStamp;
       
   132         } else {
       
   133             $this->timeStamp = microtime(true);
       
   134         }
       
   135 
       
   136         if ($throwable !== null && $throwable instanceof Exception) {
       
   137             $this->throwableInfo = new LoggerThrowableInformation($throwable);
       
   138         }
       
   139     }
       
   140 
       
   141     /**
       
   142      * Returns the full qualified classname.
       
   143      * TODO: PHP does contain namespaces in 5.3. Those should be returned too,
       
   144      */
       
   145     public function getFullQualifiedClassname() {
       
   146         return $this->fqcn;
       
   147     }
       
   148 
       
   149     /**
       
   150      * Set the location information for this logging event. The collected
       
   151      * information is cached for future use.
       
   152      *
       
   153      * <p>This method uses {@link PHP_MANUAL#debug_backtrace debug_backtrace()} function (if exists)
       
   154      * to collect informations about caller.</p>
       
   155      * <p>It only recognize informations generated by {@link Logger} and its subclasses.</p>
       
   156      * @return LoggerLocationInfo
       
   157      */
       
   158     public function getLocationInformation() {
       
   159         if ($this->locationInfo === null) {
       
   160 
       
   161             $locationInfo = array();
       
   162             $trace = debug_backtrace();
       
   163             $prevHop = null;
       
   164             // make a downsearch to identify the caller
       
   165             $hop = array_pop($trace);
       
   166             while ($hop !== null) {
       
   167                 if (isset($hop['class'])) {
       
   168                     // we are sometimes in functions = no class available: avoid php warning here
       
   169                     $className = strtolower($hop['class']);
       
   170                     if (!empty($className) and ($className == 'logger' or
       
   171                             strtolower(get_parent_class($className)) == 'logger')
       
   172                     ) {
       
   173                         $locationInfo['line'] = $hop['line'];
       
   174                         $locationInfo['file'] = $hop['file'];
       
   175                         break;
       
   176                     }
       
   177                 }
       
   178                 $prevHop = $hop;
       
   179                 $hop = array_pop($trace);
       
   180             }
       
   181             $locationInfo['class'] = isset($prevHop['class']) ? $prevHop['class'] : 'main';
       
   182             if (isset($prevHop['function']) and
       
   183                 $prevHop['function'] !== 'include' and
       
   184                 $prevHop['function'] !== 'include_once' and
       
   185                 $prevHop['function'] !== 'require' and
       
   186                 $prevHop['function'] !== 'require_once'
       
   187             ) {
       
   188 
       
   189                 $locationInfo['function'] = $prevHop['function'];
       
   190             } else {
       
   191                 $locationInfo['function'] = 'main';
       
   192             }
       
   193 
       
   194             $this->locationInfo = new LoggerLocationInfo($locationInfo, $this->fqcn);
       
   195         }
       
   196         return $this->locationInfo;
       
   197     }
       
   198 
       
   199     /**
       
   200      * Return the level of this event. Use this form instead of directly
       
   201      * accessing the {@link $level} field.
       
   202      * @return LoggerLevel
       
   203      */
       
   204     public function getLevel() {
       
   205         return $this->level;
       
   206     }
       
   207 
       
   208     /**
       
   209      * Returns the logger which created the event.
       
   210      * @return Logger
       
   211      */
       
   212     public function getLogger() {
       
   213         return $this->logger;
       
   214     }
       
   215 
       
   216     /**
       
   217      * Return the name of the logger. Use this form instead of directly
       
   218      * accessing the {@link $categoryName} field.
       
   219      * @return string
       
   220      */
       
   221     public function getLoggerName() {
       
   222         return $this->categoryName;
       
   223     }
       
   224 
       
   225     /**
       
   226      * Return the message for this logging event.
       
   227      * @return mixed
       
   228      */
       
   229     public function getMessage() {
       
   230         return $this->message;
       
   231     }
       
   232 
       
   233     /**
       
   234      * This method returns the NDC for this event. It will return the
       
   235      * correct content even if the event was generated in a different
       
   236      * thread or even on a different machine. The {@link LoggerNDC::get()} method
       
   237      * should <b>never</b> be called directly.
       
   238      * @return string
       
   239      */
       
   240     public function getNDC() {
       
   241         if ($this->ndcLookupRequired) {
       
   242             $this->ndcLookupRequired = false;
       
   243             $this->ndc = LoggerNDC::get();
       
   244         }
       
   245         return $this->ndc;
       
   246     }
       
   247 
       
   248     /**
       
   249      * Returns the the context corresponding to the <code>key</code>
       
   250      * parameter.
       
   251      * @return string
       
   252      */
       
   253     public function getMDC($key) {
       
   254         return LoggerMDC::get($key);
       
   255     }
       
   256 
       
   257     /**
       
   258      * Returns the entire MDC context.
       
   259      * @return array
       
   260      */
       
   261     public function getMDCMap() {
       
   262         return LoggerMDC::getMap();
       
   263     }
       
   264 
       
   265     /**
       
   266      * Render message.
       
   267      * @return string
       
   268      */
       
   269     public function getRenderedMessage() {
       
   270         if ($this->renderedMessage === null and $this->message !== null) {
       
   271             if (is_string($this->message)) {
       
   272                 $this->renderedMessage = $this->message;
       
   273             } else {
       
   274                 $rendererMap = Logger::getHierarchy()->getRendererMap();
       
   275                 $this->renderedMessage = $rendererMap->findAndRender($this->message);
       
   276             }
       
   277         }
       
   278         return $this->renderedMessage;
       
   279     }
       
   280 
       
   281     /**
       
   282      * Returns the time when the application started, as a UNIX timestamp
       
   283      * with microseconds.
       
   284      * @return float
       
   285      */
       
   286     public static function getStartTime() {
       
   287         if (!isset(self::$startTime)) {
       
   288             self::$startTime = microtime(true);
       
   289         }
       
   290         return self::$startTime;
       
   291     }
       
   292 
       
   293     /**
       
   294      * @return float
       
   295      */
       
   296     public function getTimeStamp() {
       
   297         return $this->timeStamp;
       
   298     }
       
   299 
       
   300     /**
       
   301      * Returns the time in seconds passed from the beginning of execution to
       
   302      * the time the event was constructed.
       
   303      *
       
   304      * @return float Seconds with microseconds in decimals.
       
   305      */
       
   306     public function getRelativeTime() {
       
   307         return $this->timeStamp - self::$startTime;
       
   308     }
       
   309 
       
   310     /**
       
   311      * Returns the time in milliseconds passed from the beginning of execution
       
   312      * to the time the event was constructed.
       
   313      *
       
   314      * @deprecated This method has been replaced by getRelativeTime which
       
   315      *        does not perform unneccesary multiplication and formatting.
       
   316      *
       
   317      * @return integer
       
   318      */
       
   319     public function getTime() {
       
   320         $eventTime = $this->getTimeStamp();
       
   321         $eventStartTime = LoggerLoggingEvent::getStartTime();
       
   322         return number_format(($eventTime - $eventStartTime) * 1000, 0, '', '');
       
   323     }
       
   324 
       
   325     /**
       
   326      * @return mixed
       
   327      */
       
   328     public function getThreadName() {
       
   329         if ($this->threadName === null) {
       
   330             $this->threadName = (string)getmypid();
       
   331         }
       
   332         return $this->threadName;
       
   333     }
       
   334 
       
   335     /**
       
   336      * @return mixed LoggerThrowableInformation
       
   337      */
       
   338     public function getThrowableInformation() {
       
   339         return $this->throwableInfo;
       
   340     }
       
   341 
       
   342     /**
       
   343      * Serialize this object
       
   344      * @return string
       
   345      */
       
   346     public function toString() {
       
   347         serialize($this);
       
   348     }
       
   349 
       
   350     /**
       
   351      * Avoid serialization of the {@link $logger} object
       
   352      */
       
   353     public function __sleep() {
       
   354         return array(
       
   355             'fqcn',
       
   356             'categoryName',
       
   357             'level',
       
   358             'ndc',
       
   359             'ndcLookupRequired',
       
   360             'message',
       
   361             'renderedMessage',
       
   362             'threadName',
       
   363             'timeStamp',
       
   364             'locationInfo',
       
   365         );
       
   366     }
       
   367 
       
   368 }
       
   369 
       
   370 LoggerLoggingEvent::getStartTime();