<?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); }}