Code Coverage
 
Classes and Traits
Functions and Methods
Lines
Total
0.00%
0 / 1
89.47%
17 / 19
 CRAP
94.34%
50 / 53
LoggerAppender
0.00%
0 / 1
90.00%
18 / 20
 31.17
94.34%
50 / 53
 __construct($name = '')
100.00%
1 / 1
 2
100.00%
5 / 5
 __destruct()
100.00%
1 / 1
 1
100.00%
2 / 2
 getDefaultLayout()
100.00%
1 / 1
 1
100.00%
1 / 1
 addFilter($filter)
100.00%
1 / 1
 2
100.00%
5 / 5
 clearFilters()
100.00%
1 / 1
 1
100.00%
2 / 2
 getFilter()
100.00%
1 / 1
 1
100.00%
1 / 1
 getFirstFilter()
100.00%
1 / 1
 1
100.00%
1 / 1
 doAppend(LoggerLoggingEvent $event)
0.00%
0 / 1
 7.02
92.86%
13 / 14
 setLayout($layout)
100.00%
1 / 1
 2
100.00%
4 / 4
 getLayout()
100.00%
1 / 1
 1
100.00%
1 / 1
 requiresLayout()
100.00%
1 / 1
 1
100.00%
1 / 1
 getName()
100.00%
1 / 1
 1
100.00%
1 / 1
 setName($name)
0.00%
0 / 1
 2
0.00%
0 / 2
 getThreshold()
100.00%
1 / 1
 1
100.00%
1 / 1
 setThreshold($threshold)
100.00%
1 / 1
 1
100.00%
2 / 2
 isAsSevereAsThreshold($level)
100.00%
1 / 1
 2
100.00%
3 / 3
 activateOptions()
100.00%
1 / 1
 1
100.00%
2 / 2
 append(LoggerLoggingEvent $event)
100.00%
1 / 1
 1  
 
 close()
100.00%
1 / 1
 1
100.00%
2 / 2
 warn($message)
100.00%
1 / 1
 2
100.00%
3 / 3
<?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
*/
/**
* Abstract class that defines output logs strategies.
*
* @version $Revision: 1374777 $
* @package log4php
*/
abstract class LoggerAppender extends LoggerConfigurable {
/**
* Set to true when the appender is closed. A closed appender will not
* accept any logging requests.
* @var boolean
*/
protected $closed = false;
/**
* The first filter in the filter chain.
* @var LoggerFilter
*/
protected $filter;
/**
* The appender's layout. Can be null if the appender does not use
* a layout.
* @var LoggerLayout
*/
protected $layout;
/**
* Appender name. Used by other components to identify this appender.
* @var string
*/
protected $name;
/**
* Appender threshold level. Events whose level is below the threshold
* will not be logged.
* @var LoggerLevel
*/
protected $threshold;
/**
* Set to true if the appender requires a layout.
*
* True by default, appenders which do not use a layout should override
* this property to false.
*
* @var boolean
*/
protected $requiresLayout = true;
/**
* Default constructor.
* @param string $name Appender name
*/
public function __construct($name = '') {
$this->name = $name;
if ($this->requiresLayout) {
$this->layout = $this->getDefaultLayout();
}
}
public function __destruct() {
$this->close();
}
/**
* Returns the default layout for this appender. Can be overriden by
* derived appenders.
*
* @return LoggerLayout
*/
public function getDefaultLayout() {
return new LoggerLayoutSimple();
}
/**
* Adds a filter to the end of the filter chain.
* @param LoggerFilter $filter add a new LoggerFilter
*/
public function addFilter($filter) {
if($this->filter === null) {
$this->filter = $filter;
} else {
$this->filter->addNext($filter);
}
}
/**
* Clears the filter chain by removing all the filters in it.
*/
public function clearFilters() {
$this->filter = null;
}
/**
* Returns the first filter in the filter chain.
* The return value may be <i>null</i> if no is filter is set.
* @return LoggerFilter
*/
public function getFilter() {
return $this->filter;
}
/**
* Returns the first filter in the filter chain.
* The return value may be <i>null</i> if no is filter is set.
* @return LoggerFilter
*/
public function getFirstFilter() {
return $this->filter;
}
/**
* Performs threshold checks and invokes filters before delegating logging
* to the subclass' specific <i>append()</i> method.
* @see LoggerAppender::append()
* @param LoggerLoggingEvent $event
*/
public function doAppend(LoggerLoggingEvent $event) {
if($this->closed) {
return;
}
if(!$this->isAsSevereAsThreshold($event->getLevel())) {
return;
}
$filter = $this->getFirstFilter();
while($filter !== null) {
switch ($filter->decide($event)) {
case LoggerFilter::DENY: return;
case LoggerFilter::ACCEPT: return $this->append($event);
case LoggerFilter::NEUTRAL: $filter = $filter->getNext();
}
}
$this->append($event);
}
/**
* Sets the appender layout.
* @param LoggerLayout $layout
*/
public function setLayout($layout) {
if($this->requiresLayout()) {
$this->layout = $layout;
}
}
/**
* Returns the appender layout.
* @return LoggerLayout
*/
public function getLayout() {
return $this->layout;
}
/**
* Configurators call this method to determine if the appender
* requires a layout.
*
* <p>If this method returns <i>true</i>, meaning that layout is required,
* then the configurator will configure a layout using the configuration
* information at its disposal. If this method returns <i>false</i>,
* meaning that a layout is not required, then layout configuration will be
* skipped even if there is available layout configuration
* information at the disposal of the configurator.</p>
*
* <p>In the rather exceptional case, where the appender
* implementation admits a layout but can also work without it, then
* the appender should return <i>true</i>.</p>
*
* @return boolean
*/
public function requiresLayout() {
return $this->requiresLayout;
}
/**
* Retruns the appender name.
* @return string
*/
public function getName() {
return $this->name;
}
/**
* Sets the appender name.
* @param string $name
*/
public function setName($name) {
$this->name = $name;
}
/**
* Returns the appender's threshold level.
* @return LoggerLevel
*/
public function getThreshold() {
return $this->threshold;
}
/**
* Sets the appender threshold.
*
* @param LoggerLevel|string $threshold Either a {@link LoggerLevel}
* object or a string equivalent.
* @see LoggerOptionConverter::toLevel()
*/
public function setThreshold($threshold) {
$this->setLevel('threshold', $threshold);
}
/**
* Checks whether the message level is below the appender's threshold.
*
* If there is no threshold set, then the return value is always <i>true</i>.
*
* @param LoggerLevel $level
* @return boolean Returns true if level is greater or equal than
* threshold, or if the threshold is not set. Otherwise returns false.
*/
public function isAsSevereAsThreshold($level) {
if($this->threshold === null) {
return true;
}
return $level->isGreaterOrEqual($this->getThreshold());
}
/**
* Prepares the appender for logging.
*
* Derived appenders should override this method if option structure
* requires it.
*/
public function activateOptions() {
$this->closed = false;
}
/**
* Forwards the logging event to the destination.
*
* Derived appenders should implement this method to perform actual logging.
*
* @param LoggerLoggingEvent $event
*/
abstract protected function append(LoggerLoggingEvent $event);
/**
* Releases any resources allocated by the appender.
*
* Derived appenders should override this method to perform proper closing
* procedures.
*/
public function close() {
$this->closed = true;
}
/** Triggers a warning for this logger with the given message. */
protected function warn($message) {
$id = get_class($this) . (empty($this->name) ? '' : ":{$this->name}");
trigger_error("log4php: [$id]: $message", E_USER_WARNING);
}
}