Code Coverage |
||||||||||
Classes and Traits |
Functions and Methods |
Lines |
||||||||
| Total | |
0.00% |
0 / 1 |
|
63.16% |
12 / 19 |
CRAP | |
86.96% |
80 / 92 |
| LoggerLoggingEvent | |
0.00% |
0 / 1 |
|
63.16% |
12 / 19 |
45.91 | |
86.96% |
80 / 92 |
| __construct($fqcn, $logger, LoggerLevel $level, $message, $timeStamp = null, $throwable = null) | |
100.00% |
1 / 1 |
6 | |
100.00% |
16 / 16 |
|||
| getFullQualifiedClassname() | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getLocationInformation() | |
0.00% |
0 / 1 |
13 | |
96.55% |
28 / 29 |
|||
| getLevel() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getLogger() | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 1 |
|||
| getLoggerName() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getMessage() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getNDC() | |
100.00% |
1 / 1 |
2 | |
100.00% |
5 / 5 |
|||
| getMDC($key) | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getMDCMap () | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getRenderedMessage() | |
0.00% |
0 / 1 |
4.25 | |
75.00% |
6 / 8 |
|||
| getStartTime() | |
0.00% |
0 / 1 |
2.50 | |
50.00% |
2 / 4 |
|||
| getTimeStamp() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getRelativeTime() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| getTime() | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 3 |
|||
| getThreadName() | |
100.00% |
1 / 1 |
2 | |
100.00% |
4 / 4 |
|||
| getThrowableInformation() | |
100.00% |
1 / 1 |
1 | |
100.00% |
1 / 1 |
|||
| toString() | |
0.00% |
0 / 1 |
2 | |
0.00% |
0 / 2 |
|||
| __sleep() | |
100.00% |
1 / 1 |
1 | |
100.00% |
11 / 11 |
|||
| <?php | |
| /** | |
| * Licensed to the Apache Software Foundation (ASF) under one or more | |
| * contributor license agreements. See the NOTICE file distributed with | |
| * this work for additional information regarding copyright ownership. | |
| * The ASF licenses this file to You under the Apache License, Version 2.0 | |
| * (the "License"); you may not use this file except in compliance with | |
| * the License. You may obtain a copy of the License at | |
| * | |
| * http://www.apache.org/licenses/LICENSE-2.0 | |
| * | |
| * Unless required by applicable law or agreed to in writing, software | |
| * distributed under the License is distributed on an "AS IS" BASIS, | |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| * See the License for the specific language governing permissions and | |
| * limitations under the License. | |
| * | |
| * @package log4php | |
| */ | |
| /** | |
| * The internal representation of logging event. | |
| * | |
| * @version $Revision: 1382273 $ | |
| * @package log4php | |
| */ | |
| class LoggerLoggingEvent { | |
| private static $startTime; | |
| /** | |
| * @var string Fully Qualified Class Name of the calling category class. | |
| */ | |
| private $fqcn; | |
| /** | |
| * @var Logger reference | |
| */ | |
| private $logger; | |
| /** | |
| * The category (logger) name. | |
| * This field will be marked as private in future | |
| * releases. Please do not access it directly. | |
| * Use the {@link getLoggerName()} method instead. | |
| * @deprecated | |
| */ | |
| private $categoryName; | |
| /** | |
| * Level of the logging event. | |
| * @var LoggerLevel | |
| */ | |
| protected $level; | |
| /** | |
| * The nested diagnostic context (NDC) of logging event. | |
| * @var string | |
| */ | |
| private $ndc; | |
| /** | |
| * Have we tried to do an NDC lookup? If we did, there is no need | |
| * to do it again. Note that its value is always false when | |
| * serialized. Thus, a receiving SocketNode will never use it's own | |
| * (incorrect) NDC. See also writeObject method. | |
| * @var boolean | |
| */ | |
| private $ndcLookupRequired = true; | |
| /** | |
| * @var mixed The application supplied message of logging event. | |
| */ | |
| private $message; | |
| /** | |
| * The application supplied message rendered through the log4php | |
| * objet rendering mechanism. At present renderedMessage == message. | |
| * @var string | |
| */ | |
| private $renderedMessage; | |
| /** | |
| * The name of thread in which this logging event was generated. | |
| * log4php saves here the process id via {@link PHP_MANUAL#getmypid getmypid()} | |
| * @var mixed | |
| */ | |
| private $threadName; | |
| /** | |
| * The number of seconds elapsed from 1/1/1970 until logging event | |
| * was created plus microseconds if available. | |
| * @var float | |
| */ | |
| public $timeStamp; | |
| /** | |
| * @var LoggerLocationInfo Location information for the caller. | |
| */ | |
| private $locationInfo; | |
| /** | |
| * @var LoggerThrowableInformation log4php internal representation of throwable | |
| */ | |
| private $throwableInfo; | |
| /** | |
| * Instantiate a LoggingEvent from the supplied parameters. | |
| * | |
| * Except {@link $timeStamp} all the other fields of | |
| * LoggerLoggingEvent are filled when actually needed. | |
| * | |
| * @param string $fqcn name of the caller class. | |
| * @param mixed $logger The {@link Logger} category of this event or the logger name. | |
| * @param LoggerLevel $level The level of this event. | |
| * @param mixed $message The message of this event. | |
| * @param integer $timeStamp the timestamp of this logging event. | |
| * @param Exception $throwable The throwable associated with logging event | |
| */ | |
| public function __construct($fqcn, $logger, LoggerLevel $level, $message, $timeStamp = null, $throwable = null) { | |
| $this->fqcn = $fqcn; | |
| if($logger instanceof Logger) { | |
| $this->logger = $logger; | |
| $this->categoryName = $logger->getName(); | |
| } else { | |
| $this->categoryName = strval($logger); | |
| } | |
| $this->level = $level; | |
| $this->message = $message; | |
| if($timeStamp !== null && is_numeric($timeStamp)) { | |
| $this->timeStamp = $timeStamp; | |
| } else { | |
| $this->timeStamp = microtime(true); | |
| } | |
| if ($throwable !== null && $throwable instanceof Exception) { | |
| $this->throwableInfo = new LoggerThrowableInformation($throwable); | |
| } | |
| } | |
| /** | |
| * Returns the full qualified classname. | |
| * TODO: PHP does contain namespaces in 5.3. Those should be returned too, | |
| */ | |
| public function getFullQualifiedClassname() { | |
| return $this->fqcn; | |
| } | |
| /** | |
| * Set the location information for this logging event. The collected | |
| * information is cached for future use. | |
| * | |
| * <p>This method uses {@link PHP_MANUAL#debug_backtrace debug_backtrace()} function (if exists) | |
| * to collect informations about caller.</p> | |
| * <p>It only recognize informations generated by {@link Logger} and its subclasses.</p> | |
| * @return LoggerLocationInfo | |
| */ | |
| public function getLocationInformation() { | |
| if($this->locationInfo === null) { | |
| $locationInfo = array(); | |
| $trace = debug_backtrace(); | |
| $prevHop = null; | |
| // make a downsearch to identify the caller | |
| $hop = array_pop($trace); | |
| while($hop !== null) { | |
| if(isset($hop['class'])) { | |
| // we are sometimes in functions = no class available: avoid php warning here | |
| $className = strtolower($hop['class']); | |
| if(!empty($className) and ($className == 'logger' or | |
| strtolower(get_parent_class($className)) == 'logger')) { | |
| $locationInfo['line'] = $hop['line']; | |
| $locationInfo['file'] = $hop['file']; | |
| break; | |
| } | |
| } | |
| $prevHop = $hop; | |
| $hop = array_pop($trace); | |
| } | |
| $locationInfo['class'] = isset($prevHop['class']) ? $prevHop['class'] : 'main'; | |
| if(isset($prevHop['function']) and | |
| $prevHop['function'] !== 'include' and | |
| $prevHop['function'] !== 'include_once' and | |
| $prevHop['function'] !== 'require' and | |
| $prevHop['function'] !== 'require_once') { | |
| $locationInfo['function'] = $prevHop['function']; | |
| } else { | |
| $locationInfo['function'] = 'main'; | |
| } | |
| $this->locationInfo = new LoggerLocationInfo($locationInfo, $this->fqcn); | |
| } | |
| return $this->locationInfo; | |
| } | |
| /** | |
| * Return the level of this event. Use this form instead of directly | |
| * accessing the {@link $level} field. | |
| * @return LoggerLevel | |
| */ | |
| public function getLevel() { | |
| return $this->level; | |
| } | |
| /** | |
| * Returns the logger which created the event. | |
| * @return Logger | |
| */ | |
| public function getLogger() { | |
| return $this->logger; | |
| } | |
| /** | |
| * Return the name of the logger. Use this form instead of directly | |
| * accessing the {@link $categoryName} field. | |
| * @return string | |
| */ | |
| public function getLoggerName() { | |
| return $this->categoryName; | |
| } | |
| /** | |
| * Return the message for this logging event. | |
| * @return mixed | |
| */ | |
| public function getMessage() { | |
| return $this->message; | |
| } | |
| /** | |
| * This method returns the NDC for this event. It will return the | |
| * correct content even if the event was generated in a different | |
| * thread or even on a different machine. The {@link LoggerNDC::get()} method | |
| * should <b>never</b> be called directly. | |
| * @return string | |
| */ | |
| public function getNDC() { | |
| if($this->ndcLookupRequired) { | |
| $this->ndcLookupRequired = false; | |
| $this->ndc = LoggerNDC::get(); | |
| } | |
| return $this->ndc; | |
| } | |
| /** | |
| * Returns the the context corresponding to the <code>key</code> | |
| * parameter. | |
| * @return string | |
| */ | |
| public function getMDC($key) { | |
| return LoggerMDC::get($key); | |
| } | |
| /** | |
| * Returns the entire MDC context. | |
| * @return array | |
| */ | |
| public function getMDCMap () { | |
| return LoggerMDC::getMap(); | |
| } | |
| /** | |
| * Render message. | |
| * @return string | |
| */ | |
| public function getRenderedMessage() { | |
| if($this->renderedMessage === null and $this->message !== null) { | |
| if(is_string($this->message)) { | |
| $this->renderedMessage = $this->message; | |
| } else { | |
| $rendererMap = Logger::getHierarchy()->getRendererMap(); | |
| $this->renderedMessage= $rendererMap->findAndRender($this->message); | |
| } | |
| } | |
| return $this->renderedMessage; | |
| } | |
| /** | |
| * Returns the time when the application started, as a UNIX timestamp | |
| * with microseconds. | |
| * @return float | |
| */ | |
| public static function getStartTime() { | |
| if(!isset(self::$startTime)) { | |
| self::$startTime = microtime(true); | |
| } | |
| return self::$startTime; | |
| } | |
| /** | |
| * @return float | |
| */ | |
| public function getTimeStamp() { | |
| return $this->timeStamp; | |
| } | |
| /** | |
| * Returns the time in seconds passed from the beginning of execution to | |
| * the time the event was constructed. | |
| * | |
| * @return float Seconds with microseconds in decimals. | |
| */ | |
| public function getRelativeTime() { | |
| return $this->timeStamp - self::$startTime; | |
| } | |
| /** | |
| * Returns the time in milliseconds passed from the beginning of execution | |
| * to the time the event was constructed. | |
| * | |
| * @deprecated This method has been replaced by getRelativeTime which | |
| * does not perform unneccesary multiplication and formatting. | |
| * | |
| * @return integer | |
| */ | |
| public function getTime() { | |
| $eventTime = $this->getTimeStamp(); | |
| $eventStartTime = LoggerLoggingEvent::getStartTime(); | |
| return number_format(($eventTime - $eventStartTime) * 1000, 0, '', ''); | |
| } | |
| /** | |
| * @return mixed | |
| */ | |
| public function getThreadName() { | |
| if ($this->threadName === null) { | |
| $this->threadName = (string)getmypid(); | |
| } | |
| return $this->threadName; | |
| } | |
| /** | |
| * @return mixed LoggerThrowableInformation | |
| */ | |
| public function getThrowableInformation() { | |
| return $this->throwableInfo; | |
| } | |
| /** | |
| * Serialize this object | |
| * @return string | |
| */ | |
| public function toString() { | |
| serialize($this); | |
| } | |
| /** | |
| * Avoid serialization of the {@link $logger} object | |
| */ | |
| public function __sleep() { | |
| return array( | |
| 'fqcn', | |
| 'categoryName', | |
| 'level', | |
| 'ndc', | |
| 'ndcLookupRequired', | |
| 'message', | |
| 'renderedMessage', | |
| 'threadName', | |
| 'timeStamp', | |
| 'locationInfo', | |
| ); | |
| } | |
| } | |
| LoggerLoggingEvent::getStartTime(); |