configuration element as
defined in the log4j.dtd.
*/
static
public
void configure (Element element) {
DOMConfigurator configurator = new DOMConfigurator();
configurator.doConfigure(element, LogManager.getLoggerRepository());
}
/**
Like {@link #configureAndWatch(String, long)} except that the
default delay as defined by {@link FileWatchdog#DEFAULT_DELAY} is
used.
@param configFilename A log4j configuration file in XML format.
*/
static
public
void configureAndWatch(String configFilename) {
configureAndWatch(configFilename, FileWatchdog.DEFAULT_DELAY);
}
/**
Read the configuration file configFilename if it
exists. Moreover, a thread will be created that will periodically
check if configFilename has been created or
modified. The period is determined by the delay
argument. If a change or file creation is detected, then
configFilename is read to configure log4j.
@param configFilename A log4j configuration file in XML format.
@param delay The delay in milliseconds to wait between each check.
*/
static
public
void configureAndWatch(String configFilename, long delay) {
XMLWatchdog xdog = new XMLWatchdog(configFilename);
xdog.setDelay(delay);
xdog.start();
}
private interface ParseAction {
Document parse(final DocumentBuilder parser) throws SAXException, IOException;
}
public
void doConfigure(final String filename, LoggerRepository repository) {
ParseAction action = new ParseAction() {
public Document parse(final DocumentBuilder parser) throws SAXException, IOException {
return parser.parse(new File(filename));
}
public String toString() {
return "file [" + filename + "]";
}
};
doConfigure(action, repository);
}
public
void doConfigure(final URL url, LoggerRepository repository) {
ParseAction action = new ParseAction() {
public Document parse(final DocumentBuilder parser) throws SAXException, IOException {
InputStream stream = url.openStream();
try {
InputSource src = new InputSource(stream);
src.setSystemId(url.toString());
return parser.parse(src);
} finally {
stream.close();
}
}
public String toString() {
return "url [" + url.toString() + "]";
}
};
doConfigure(action, repository);
}
/**
Configure log4j by reading in a log4j.dtd compliant XML
configuration file.
*/
public
void doConfigure(final InputStream inputStream, LoggerRepository repository)
throws FactoryConfigurationError {
ParseAction action = new ParseAction() {
public Document parse(final DocumentBuilder parser) throws SAXException, IOException {
InputSource inputSource = new InputSource(inputStream);
inputSource.setSystemId("dummy://log4j.dtd");
return parser.parse(inputSource);
}
public String toString() {
return "input stream [" + inputStream.toString() + "]";
}
};
doConfigure(action, repository);
}
/**
Configure log4j by reading in a log4j.dtd compliant XML
configuration file.
*/
public
void doConfigure(final Reader reader, LoggerRepository repository)
throws FactoryConfigurationError {
ParseAction action = new ParseAction() {
public Document parse(final DocumentBuilder parser) throws SAXException, IOException {
InputSource inputSource = new InputSource(reader);
inputSource.setSystemId("dummy://log4j.dtd");
return parser.parse(inputSource);
}
public String toString() {
return "reader [" + reader.toString() + "]";
}
};
doConfigure(action, repository);
}
/**
Configure log4j by reading in a log4j.dtd compliant XML
configuration file.
*/
protected
void doConfigure(final InputSource inputSource, LoggerRepository repository)
throws FactoryConfigurationError {
if (inputSource.getSystemId() == null) {
inputSource.setSystemId("dummy://log4j.dtd");
}
ParseAction action = new ParseAction() {
public Document parse(final DocumentBuilder parser) throws SAXException, IOException {
return parser.parse(inputSource);
}
public String toString() {
return "input source [" + inputSource.toString() + "]";
}
};
doConfigure(action, repository);
}
private final void doConfigure(final ParseAction action, final LoggerRepository repository)
throws FactoryConfigurationError {
DocumentBuilderFactory dbf = null;
this.repository = repository;
try {
LogLog.debug("System property is :"+
OptionConverter.getSystemProperty(dbfKey,
null));
dbf = DocumentBuilderFactory.newInstance();
LogLog.debug("Standard DocumentBuilderFactory search succeded.");
LogLog.debug("DocumentBuilderFactory is: "+dbf.getClass().getName());
} catch(FactoryConfigurationError fce) {
Exception e = fce.getException();
LogLog.debug("Could not instantiate a DocumentBuilderFactory.", e);
throw fce;
}
try {
dbf.setValidating(true);
DocumentBuilder docBuilder = dbf.newDocumentBuilder();
docBuilder.setErrorHandler(new SAXErrorHandler());
docBuilder.setEntityResolver(new Log4jEntityResolver());
Document doc = action.parse(docBuilder);
parse(doc.getDocumentElement());
} catch (Exception e) {
// I know this is miserable...
LogLog.error("Could not parse "+ action.toString() + ".", e);
}
}
/**
Configure by taking in an DOM element.
*/
public void doConfigure(Element element, LoggerRepository repository) {
this.repository = repository;
parse(element);
}
/**
A static version of {@link #doConfigure(String, LoggerRepository)}. */
static
public
void configure(String filename) throws FactoryConfigurationError {
new DOMConfigurator().doConfigure(filename,
LogManager.getLoggerRepository());
}
/**
A static version of {@link #doConfigure(URL, LoggerRepository)}.
*/
static
public
void configure(URL url) throws FactoryConfigurationError {
new DOMConfigurator().doConfigure(url, LogManager.getLoggerRepository());
}
/**
Used internally to configure the log4j framework by parsing a DOM
tree of XML elements based on log4j.dtd.
*/
protected
void parse(Element element) {
String rootElementName = element.getTagName();
if (!rootElementName.equals(CONFIGURATION_TAG)) {
if(rootElementName.equals(OLD_CONFIGURATION_TAG)) {
LogLog.warn("The <"+OLD_CONFIGURATION_TAG+
"> element has been deprecated.");
LogLog.warn("Use the <"+CONFIGURATION_TAG+"> element instead.");
} else {
LogLog.error("DOM element is - not a <"+CONFIGURATION_TAG+"> element.");
return;
}
}
String debugAttrib = subst(element.getAttribute(INTERNAL_DEBUG_ATTR));
LogLog.debug("debug attribute= \"" + debugAttrib +"\".");
// if the log4j.dtd is not specified in the XML file, then the
// "debug" attribute is returned as the empty string.
if(!debugAttrib.equals("") && !debugAttrib.equals("null")) {
LogLog.setInternalDebugging(OptionConverter.toBoolean(debugAttrib, true));
} else {
LogLog.debug("Ignoring " + INTERNAL_DEBUG_ATTR + " attribute.");
}
//
// reset repository before configuration if reset="true"
// on configuration element.
//
String resetAttrib = subst(element.getAttribute(RESET_ATTR));
LogLog.debug("reset attribute= \"" + resetAttrib +"\".");
if(!("".equals(resetAttrib)) &&
OptionConverter.toBoolean(resetAttrib, false)) {
repository.resetConfiguration();
}
String confDebug = subst(element.getAttribute(CONFIG_DEBUG_ATTR));
if(!confDebug.equals("") && !confDebug.equals("null")) {
LogLog.warn("The \""+CONFIG_DEBUG_ATTR+"\" attribute is deprecated.");
LogLog.warn("Use the \""+INTERNAL_DEBUG_ATTR+"\" attribute instead.");
LogLog.setInternalDebugging(OptionConverter.toBoolean(confDebug, true));
}
String thresholdStr = subst(element.getAttribute(THRESHOLD_ATTR));
LogLog.debug("Threshold =\"" + thresholdStr +"\".");
if(!"".equals(thresholdStr) && !"null".equals(thresholdStr)) {
repository.setThreshold(thresholdStr);
}
//Hashtable appenderBag = new Hashtable(11);
/* Building Appender objects, placing them in a local namespace
for future reference */
// First configure each category factory under the root element.
// Category factories need to be configured before any of
// categories they support.
//
String tagName = null;
Element currentElement = null;
Node currentNode = null;
NodeList children = element.getChildNodes();
final int length = children.getLength();
for (int loop = 0; loop < length; loop++) {
currentNode = children.item(loop);
if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
currentElement = (Element) currentNode;
tagName = currentElement.getTagName();
if (tagName.equals(CATEGORY_FACTORY_TAG) || tagName.equals(LOGGER_FACTORY_TAG)) {
parseCategoryFactory(currentElement);
}
}
}
for (int loop = 0; loop < length; loop++) {
currentNode = children.item(loop);
if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
currentElement = (Element) currentNode;
tagName = currentElement.getTagName();
if (tagName.equals(CATEGORY) || tagName.equals(LOGGER)) {
parseCategory(currentElement);
} else if (tagName.equals(ROOT_TAG)) {
parseRoot(currentElement);
} else if(tagName.equals(RENDERER_TAG)) {
parseRenderer(currentElement);
} else if (!(tagName.equals(APPENDER_TAG)
|| tagName.equals(CATEGORY_FACTORY_TAG)
|| tagName.equals(LOGGER_FACTORY_TAG))) {
quietParseUnrecognizedElement(repository, currentElement, props);
}
}
}
}
protected
String subst(final String value) {
return subst(value, props);
}
/**
* Substitutes property value for any references in expression.
*
* @param value value from configuration file, may contain
* literal text, property references or both
* @param props properties.
* @return evaluated expression, may still contain expressions
* if unable to expand.
* @since 1.2.15
*/
public static String subst(final String value, final Properties props) {
try {
return OptionConverter.substVars(value, props);
} catch (IllegalArgumentException e) {
LogLog.warn("Could not perform variable substitution.", e);
return value;
}
}
/**
* Sets a parameter based from configuration file content.
*
* @param elem param element, may not be null.
* @param propSetter property setter, may not be null.
* @param props properties
* @since 1.2.15
*/
public static void setParameter(final Element elem,
final PropertySetter propSetter,
final Properties props) {
String name = subst(elem.getAttribute("name"), props);
String value = (elem.getAttribute("value"));
value = subst(OptionConverter.convertSpecialChars(value), props);
propSetter.setProperty(name, value);
}
/**
* Creates an OptionHandler and processes any nested param elements
* but does not call activateOptions. If the class also supports
* UnrecognizedElementParser, the parseUnrecognizedElement method
* will be call for any child elements other than param.
*
* @param element element, may not be null.
* @param props properties
* @param expectedClass interface or class expected to be implemented
* by created class
* @return created class or null.
* @throws Exception thrown if the contain object should be abandoned.
* @since 1.2.15
*/
public static OptionHandler parseElement(final Element element,
final Properties props,
final Class expectedClass) throws Exception {
String clazz = subst(element.getAttribute("class"), props);
Object instance = OptionConverter.instantiateByClassName(clazz,
expectedClass, null);
if (instance instanceof OptionHandler) {
OptionHandler optionHandler = (OptionHandler) instance;
PropertySetter propSetter = new PropertySetter(optionHandler);
NodeList children = element.getChildNodes();
final int length = children.getLength();
for (int loop = 0; loop < length; loop++) {
Node currentNode = children.item(loop);
if (currentNode.getNodeType() == Node.ELEMENT_NODE) {
Element currentElement = (Element) currentNode;
String tagName = currentElement.getTagName();
if (tagName.equals("param")) {
setParameter(currentElement, propSetter, props);
} else {
parseUnrecognizedElement(instance, currentElement, props);
}
}
}
return optionHandler;
}
return null;
}
private static class XMLWatchdog extends FileWatchdog {
XMLWatchdog(String filename) {
super(filename);
}
/**
Call {@link DOMConfigurator#configure(String)} with the
filename to reconfigure log4j. */
public
void doOnChange() {
new DOMConfigurator().doConfigure(filename,
LogManager.getLoggerRepository());
}
}
/**
* An {@link EntityResolver} specifically designed to return
* log4j.dtd which is embedded within the log4j jar
* file.
*
* @author Paul Austin
* */
private static final class Log4jEntityResolver implements EntityResolver {
public InputSource resolveEntity (String publicId, String systemId) {
if (systemId.endsWith("log4j.dtd")) {
InputStream in = Log4jEntityResolver.class.getResourceAsStream("log4j.dtd");
if (in == null) {
LogLog.warn("Could not find [log4j.dtd] using [" +
Log4jEntityResolver.class.getClassLoader()
+ "] class loader, parsed without DTD.");
in = new ByteArrayInputStream(new byte[0]);
}
return new InputSource(in);
} else {
return null;
}
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/extras/SoundAppender.java 0000664 0000000 0000000 00000006011 12527427642 0030201 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.extras;
import java.applet.Applet;
import java.applet.AudioClip;
import java.net.MalformedURLException;
import java.net.URL;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.helpers.LogLog;
/**
* This class is equivalent to org.apache.log4j.varia.SoundAppender
* except for a package change to aid in use with OSGi.
*
* Plays a sound clip created using Applet.newAudioClip when an event is received.
*
* If the audio format is not supported, a message stating the SoundAppender could
* not be initialized is logged.
*
* Use a filter in combination with this appender to control when the appender is
* triggered.
*
* For example, in the appender definition, include a LevelMatchFilter configured
* to accept WARN or greater, followed by a DenyAllFilter.
*
* @author Scott Deboy
*
*/
public final class SoundAppender extends AppenderSkeleton {
private AudioClip clip;
private String audioURL;
public SoundAppender() {
}
/**
* Attempt to initialize the appender by creating a reference to an AudioClip.
*
* Will log a message if format is not supported, file not found, etc.
*
*/
public void activateOptions() {
/*
* AudioSystem.getAudioInputStream requires jdk 1.3,
* so we use applet.newaudioclip instead
*
*/
try {
clip = Applet.newAudioClip(new URL(audioURL));
} catch (MalformedURLException mue) {
LogLog.error("unable to initialize SoundAppender", mue);}
if (clip == null) {
LogLog.error("Unable to initialize SoundAppender");
}
}
/**
* Accessor
*
* @return audio file
*/
public String getAudioURL() {
return audioURL;
}
/**
* Mutator - common format for a file-based url:
* file:///c:/path/someaudioclip.wav
*
* @param audioURL
*/
public void setAudioURL(String audioURL) {
this.audioURL = audioURL;
}
/**
* Play the sound if an event is being processed
*/
protected void append(LoggingEvent event) {
if (clip != null) {
clip.play();
}
}
public void close() {
//nothing to do
}
/**
* Gets whether appender requires a layout.
* @return false
*/
public boolean requiresLayout() {
return false;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/extras/UtilLoggingLevel.java 0000664 0000000 0000000 00000014417 12527427642 0030657 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.extras;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.Level;
/**
* This class is identical to org.apache.log4j.helpers.UtilLoggingLevel
* except for a package change to aid in use with OSGi.
*
* An extension of the Level class that provides support for java.util.logging
* Levels.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class UtilLoggingLevel extends Level {
/**
* Serialization version id.
*/
private static final long serialVersionUID = 909301162611820211L;
/**
* Numerical value for SEVERE.
*/
public static final int SEVERE_INT = 17000;
/**
* Numerical value for WARNING.
*/
public static final int WARNING_INT = 16000;
/**
* Numerical value for INFO.
*/
public static final int INFO_INT = 15000;
/**
* Numerical value for CONFIG.
*/
public static final int CONFIG_INT = 14000;
/**
* Numerical value for FINE.
*/
public static final int FINE_INT = 13000;
/**
* Numerical value for FINER.
*/
public static final int FINER_INT = 12000;
/**
* Numerical value for FINEST.
*/
public static final int FINEST_INT = 11000;
/**
* Numerical value for UNKNOWN.
*/
public static final int UNKNOWN_INT = 10000;
/**
* SEVERE.
*/
public static final UtilLoggingLevel SEVERE =
new UtilLoggingLevel(SEVERE_INT, "SEVERE", 0);
/**
* WARNING.
*/
public static final UtilLoggingLevel WARNING =
new UtilLoggingLevel(WARNING_INT, "WARNING", 4);
/**
* INFO.
*/
public static final UtilLoggingLevel INFO =
new UtilLoggingLevel(INFO_INT, "INFO", 5);
/**
* CONFIG.
*/
public static final UtilLoggingLevel CONFIG =
new UtilLoggingLevel(CONFIG_INT, "CONFIG", 6);
/**
* FINE.
*/
public static final UtilLoggingLevel FINE =
new UtilLoggingLevel(FINE_INT, "FINE", 7);
/**
* FINER.
*/
public static final UtilLoggingLevel FINER =
new UtilLoggingLevel(FINER_INT, "FINER", 8);
/**
* FINEST.
*/
public static final UtilLoggingLevel FINEST =
new UtilLoggingLevel(FINEST_INT, "FINEST", 9);
/**
* Create new instance.
* @param level numeric value for level.
* @param levelStr symbolic name for level.
* @param syslogEquivalent Equivalent syslog severity.
*/
protected UtilLoggingLevel(final int level,
final String levelStr,
final int syslogEquivalent) {
super(level, levelStr, syslogEquivalent);
}
/**
* Convert an integer passed as argument to a level. If the
* conversion fails, then this method returns the specified default.
* @param val numeric value.
* @param defaultLevel level to be returned if no level matches
* numeric value.
* @return matching level or default level.
*/
public static UtilLoggingLevel toLevel(final int val,
final UtilLoggingLevel defaultLevel) {
switch (val) {
case SEVERE_INT:
return SEVERE;
case WARNING_INT:
return WARNING;
case INFO_INT:
return INFO;
case CONFIG_INT:
return CONFIG;
case FINE_INT:
return FINE;
case FINER_INT:
return FINER;
case FINEST_INT:
return FINEST;
default:
return defaultLevel;
}
}
/**
* Gets level matching numeric value.
* @param val numeric value.
* @return matching level or UtilLoggerLevel.FINEST if no match.
*/
public static Level toLevel(final int val) {
return toLevel(val, FINEST);
}
/**
* Gets list of supported levels.
* @return list of supported levels.
*/
public static List getAllPossibleLevels() {
ArrayList list = new ArrayList();
list.add(FINE);
list.add(FINER);
list.add(FINEST);
list.add(INFO);
list.add(CONFIG);
list.add(WARNING);
list.add(SEVERE);
return list;
}
/**
* Get level with specified symbolic name.
* @param s symbolic name.
* @return matching level or Level.DEBUG if no match.
*/
public static Level toLevel(final String s) {
return toLevel(s, Level.DEBUG);
}
/**
* Get level with specified symbolic name.
* @param sArg symbolic name.
* @param defaultLevel level to return if no match.
* @return matching level or defaultLevel if no match.
*/
public static Level toLevel(final String sArg,
final Level defaultLevel) {
if (sArg == null) {
return defaultLevel;
}
String s = sArg.toUpperCase();
if (s.equals("SEVERE")) {
return SEVERE;
}
//if(s.equals("FINE")) return Level.FINE;
if (s.equals("WARNING")) {
return WARNING;
}
if (s.equals("INFO")) {
return INFO;
}
if (s.equals("CONFI")) {
return CONFIG;
}
if (s.equals("FINE")) {
return FINE;
}
if (s.equals("FINER")) {
return FINER;
}
if (s.equals("FINEST")) {
return FINEST;
}
return defaultLevel;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/extras/XSLTLayout.java 0000664 0000000 0000000 00000043333 12527427642 0027432 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.extras;
import org.apache.log4j.Layout;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.helpers.MDCKeySetExtractor;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LocationInfo;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.util.Set;
import java.util.Properties;
import java.util.Arrays;
import java.util.TimeZone;
import java.nio.charset.Charset;
import java.nio.ByteBuffer;
import org.apache.log4j.pattern.CachedDateFormat;
import java.text.SimpleDateFormat;
import org.w3c.dom.Document;
import org.xml.sax.helpers.AttributesImpl;
/**
* This class is identical to org.apache.log4j.xml.XSLTLayout
* except for a change in package to aid in use with OSGi.
*
*
* XSLTLayout transforms each event as a document using
* a specified or default XSLT transform. The default
* XSLT transform produces a result similar to XMLLayout.
*
* When used with a FileAppender or similar, the transformation of
* an event will be appended to the results for previous
* transforms. If each transform results in an XML element, then
* resulting file will only be an XML entity
* since an XML document requires one and only one top-level element.
* To process the entity, reference it in a XML document like so:
*
* * <!DOCTYPE log4j:eventSet [<!ENTITY data SYSTEM "data.xml">]> * * <log4j:eventSet xmlns:log4j="http://jakarta.apache.org/log4j/"> * &data * </log4j:eventSet> * ** * The layout will detect the encoding and media-type specified in * the transform. If no encoding is specified in the transform, * an xsl:output element specifying the US-ASCII encoding will be inserted * before processing the transform. If an encoding is specified in the transform, * the same encoding should be explicitly specified for the appender. * * Extracting MDC values can be expensive when used with log4j releases * prior to 1.2.15. Output of MDC values is enabled by default * but be suppressed by setting properties to false. * * Extracting location info can be expensive regardless of log4j version. * Output of location info is disabled by default but can be enabled * by setting locationInfo to true. * * Embedded transforms in XML configuration should not * depend on namespace prefixes defined earlier in the document * as namespace aware parsing in not generally performed when * using DOMConfigurator. The transform will serialize * and reparse to get the namespace aware document needed. * */ public final class XSLTLayout extends Layout implements org.apache.log4j.xml.UnrecognizedElementHandler { /** * Namespace for XSLT. */ private static final String XSLT_NS = "http://www.w3.org/1999/XSL/Transform"; /** * Namespace for log4j events. */ private static final String LOG4J_NS = "http://jakarta.apache.org/log4j/"; /** * Whether location information should be written. */ private boolean locationInfo = false; /** * media-type (mime type) extracted from XSLT transform. */ private String mediaType = "text/plain"; /** * Encoding extracted from XSLT transform. */ private Charset encoding; /** * Transformer factory. */ private SAXTransformerFactory transformerFactory; /** * XSLT templates. */ private Templates templates; /** * Output stream. */ private final ByteArrayOutputStream outputStream; /** * Whether throwable information should be ignored. */ private boolean ignoresThrowable = false; /** * Whether properties should be extracted. */ private boolean properties = true; /** * Whether activateOptions has been called. */ private boolean activated = false; /** * DateFormat for UTC time. */ private final CachedDateFormat utcDateFormat; /** * Default constructor. * */ public XSLTLayout() { outputStream = new ByteArrayOutputStream(); transformerFactory = (SAXTransformerFactory) TransformerFactory.newInstance(); SimpleDateFormat zdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'"); zdf.setTimeZone(TimeZone.getTimeZone("UTC")); utcDateFormat = new CachedDateFormat(zdf, 1000); } /** * {@inheritDoc} */ public synchronized String getContentType() { return mediaType; } /** * The LocationInfo option takes a boolean value. By default, it is * set to false which means there will be no location information output by * this layout. If the the option is set to true, then the file name and line * number of the statement at the origin of the log statement will be output. * *
* If you are embedding this layout within an {@link
* org.apache.log4j.net.SMTPAppender} then make sure to set the
* LocationInfo option of that appender as well.
*
* @param flag new value.
*/
public synchronized void setLocationInfo(final boolean flag) {
locationInfo = flag;
}
/**
* Gets whether location info should be output.
* @return if location is output.
*/
public synchronized boolean getLocationInfo() {
return locationInfo;
}
/**
* Sets whether MDC key-value pairs should be output, default false.
* @param flag new value.
*/
public synchronized void setProperties(final boolean flag) {
properties = flag;
}
/**
* Gets whether MDC key-value pairs should be output.
* @return true if MDC key-value pairs are output.
*/
public synchronized boolean getProperties() {
return properties;
}
/** {@inheritDoc} */
public synchronized void activateOptions() {
if (templates == null) {
try {
InputStream is = XSLTLayout.class.getResourceAsStream("default.xslt");
StreamSource ss = new StreamSource(is);
templates = transformerFactory.newTemplates(ss);
encoding = Charset.forName("US-ASCII");
mediaType = "text/plain";
} catch (Exception ex) {
LogLog.error("Error loading default.xslt", ex);
}
}
activated = true;
}
/**
* Gets whether throwables should not be output.
* @return true if throwables should not be output.
*/
public synchronized boolean ignoresThrowable() {
return ignoresThrowable;
}
/**
* Sets whether throwables should not be output.
* @param ignoresThrowable if true, throwables should not be output.
*/
public synchronized void setIgnoresThrowable(boolean ignoresThrowable) {
this.ignoresThrowable = ignoresThrowable;
}
/**
* {@inheritDoc}
*/
public synchronized String format(final LoggingEvent event) {
if (!activated) {
activateOptions();
}
if (templates != null && encoding != null) {
outputStream.reset();
try {
TransformerHandler transformer =
transformerFactory.newTransformerHandler(templates);
transformer.setResult(new StreamResult(outputStream));
transformer.startDocument();
//
// event element
//
AttributesImpl attrs = new AttributesImpl();
attrs.addAttribute(null, "logger", "logger",
"CDATA", event.getLoggerName());
attrs.addAttribute(null, "timestamp", "timestamp",
"CDATA", Long.toString(event.timeStamp));
attrs.addAttribute(null, "level", "level",
"CDATA", event.getLevel().toString());
attrs.addAttribute(null, "thread", "thread",
"CDATA", event.getThreadName());
StringBuffer buf = new StringBuffer();
utcDateFormat.format(event.timeStamp, buf);
attrs.addAttribute(null, "time", "time", "CDATA", buf.toString());
transformer.startElement(LOG4J_NS, "event", "event", attrs);
attrs.clear();
//
// message element
//
transformer.startElement(LOG4J_NS, "message", "message", attrs);
String msg = event.getRenderedMessage();
if (msg != null && msg.length() > 0) {
transformer.characters(msg.toCharArray(), 0, msg.length());
}
transformer.endElement(LOG4J_NS, "message", "message");
//
// NDC element
//
String ndc = event.getNDC();
if (ndc != null) {
transformer.startElement(LOG4J_NS, "NDC", "NDC", attrs);
char[] ndcChars = ndc.toCharArray();
transformer.characters(ndcChars, 0, ndcChars.length);
transformer.endElement(LOG4J_NS, "NDC", "NDC");
}
//
// throwable element unless suppressed
//
if (!ignoresThrowable) {
String[] s = event.getThrowableStrRep();
if (s != null) {
transformer.startElement(LOG4J_NS, "throwable",
"throwable", attrs);
char[] nl = new char[] { '\n' };
for (int i = 0; i < s.length; i++) {
char[] line = s[i].toCharArray();
transformer.characters(line, 0, line.length);
transformer.characters(nl, 0, nl.length);
}
transformer.endElement(LOG4J_NS, "throwable", "throwable");
}
}
//
// location info unless suppressed
//
//
if (locationInfo) {
LocationInfo locationInfo = event.getLocationInformation();
attrs.addAttribute(null, "class", "class", "CDATA",
locationInfo.getClassName());
attrs.addAttribute(null, "method", "method", "CDATA",
locationInfo.getMethodName());
attrs.addAttribute(null, "file", "file", "CDATA",
locationInfo.getFileName());
attrs.addAttribute(null, "line", "line", "CDATA",
locationInfo.getLineNumber());
transformer.startElement(LOG4J_NS, "locationInfo",
"locationInfo", attrs);
transformer.endElement(LOG4J_NS, "locationInfo",
"locationInfo");
}
if (properties) {
//
// write MDC contents out as properties element
//
Set mdcKeySet = MDCKeySetExtractor.INSTANCE.getPropertyKeySet(event);
if ((mdcKeySet != null) && (mdcKeySet.size() > 0)) {
attrs.clear();
transformer.startElement(LOG4J_NS,
"properties", "properties", attrs);
Object[] keys = mdcKeySet.toArray();
Arrays.sort(keys);
for (int i = 0; i < keys.length; i++) {
String key = keys[i].toString();
Object val = event.getMDC(key);
attrs.clear();
attrs.addAttribute(null, "name", "name", "CDATA", key);
attrs.addAttribute(null, "value", "value",
"CDATA", val.toString());
transformer.startElement(LOG4J_NS,
"data", "data", attrs);
transformer.endElement(LOG4J_NS, "data", "data");
}
}
}
transformer.endElement(LOG4J_NS, "event", "event");
transformer.endDocument();
String body = encoding.decode(
ByteBuffer.wrap(outputStream.toByteArray())).toString();
outputStream.reset();
//
// must remove XML declaration since it may
// result in erroneous encoding info
// if written by FileAppender in a different encoding
if (body.startsWith("");
if (endDecl != -1) {
for(endDecl += 2;
endDecl < body.length() &&
(body.charAt(endDecl) == '\n' || body.charAt(endDecl) == '\r');
endDecl++);
return body.substring(endDecl);
}
}
return body;
} catch (Exception ex) {
LogLog.error("Error during transformation", ex);
return ex.toString();
}
}
return "No valid transform or encoding specified.";
}
/**
* Sets XSLT transform.
* @param xsltdoc DOM document containing XSLT transform source,
* may be modified.
* @throws TransformerConfigurationException if transformer can not be
* created.
*/
public void setTransform(final Document xsltdoc)
throws TransformerConfigurationException {
//
// scan transform source for xsl:output elements
// and extract encoding, media (mime) type and output method
//
String encodingName = null;
mediaType = null;
String method = null;
NodeList nodes = xsltdoc.getElementsByTagNameNS(
XSLT_NS,
"output");
for(int i = 0; i < nodes.getLength(); i++) {
Element outputElement = (Element) nodes.item(i);
if (method == null || method.length() == 0) {
method = outputElement.getAttributeNS(null, "method");
}
if (encodingName == null || encodingName.length() == 0) {
encodingName = outputElement.getAttributeNS(null, "encoding");
}
if (mediaType == null || mediaType.length() == 0) {
mediaType = outputElement.getAttributeNS(null, "media-type");
}
}
if (mediaType == null || mediaType.length() == 0) {
if ("html".equals(method)) {
mediaType = "text/html";
} else if ("xml".equals(method)) {
mediaType = "text/xml";
} else {
mediaType = "text/plain";
}
}
//
// if encoding was not specified,
// add xsl:output encoding=US-ASCII to XSLT source
//
if (encodingName == null || encodingName.length() == 0) {
Element transformElement = xsltdoc.getDocumentElement();
Element outputElement = xsltdoc.
createElementNS(XSLT_NS, "output");
outputElement.setAttributeNS(null, "encoding", "US-ASCII");
transformElement.insertBefore(outputElement, transformElement.getFirstChild());
encoding = Charset.forName("US-ASCII");
} else {
encoding = Charset.forName(encodingName);
}
DOMSource transformSource = new DOMSource(xsltdoc);
templates = transformerFactory.newTemplates(transformSource);
}
/**
* {@inheritDoc}
*/
public boolean parseUnrecognizedElement(final Element element,
final Properties props)
throws Exception {
if (XSLT_NS.equals(element.getNamespaceURI()) ||
element.getNodeName().indexOf("transform") != -1 ||
element.getNodeName().indexOf("stylesheet") != -1) {
//
// DOMConfigurator typically not namespace aware
// serialize tree and reparse.
ByteArrayOutputStream os = new ByteArrayOutputStream();
DOMSource source = new DOMSource(element);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(source, new StreamResult(os));
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
domFactory.setNamespaceAware(true);
Document xsltdoc = domFactory.newDocumentBuilder().parse(is);
setTransform(xsltdoc);
return true;
}
return false;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/ 0000775 0000000 0000000 00000000000 12527427642 0024550 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/AndFilter.java 0000664 0000000 0000000 00000011256 12527427642 0027270 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.filter;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.OptionHandler;
import org.apache.log4j.xml.UnrecognizedElementHandler;
import org.w3c.dom.Element;
import java.util.Properties;
/**
* A filter that 'and's the results of any number of contained filters together.
*
* For the filter to process events, all contained filters must return Filter.ACCEPT.
*
* If the contained filters do not return Filter.ACCEPT, Filter.NEUTRAL is returned.
*
* If acceptOnMatch is set to true, Filter.ACCEPT is returned.
* If acceptOnMatch is set to false, Filter.DENY is returned.
*
* Here is an example config that will accept only events that contain BOTH
* a DEBUG level AND 'test' in the message:
*
*
You can add this filter to the end of a filter chain to
switch from the default "accept all unless instructed otherwise"
filtering behaviour to a "deny all unless instructed otherwise"
behaviour.
@author Ceki Gülcü
@since 0.9.0 */
public class DenyAllFilter extends Filter {
/**
Returns null as there are no options.
@deprecated We now use JavaBeans introspection to configure
components. Options strings are no longer needed.
*/
public
String[] getOptionStrings() {
return null;
}
/**
No options to set.
@deprecated Use the setter method for the option directly instead
of the generic setOption method.
*/
public
void setOption(String key, String value) {
}
/**
Always returns the integer constant {@link Filter#DENY}
regardless of the {@link LoggingEvent} parameter.
@param event The LoggingEvent to filter.
@return Always returns {@link Filter#DENY}.
*/
public
int decide(LoggingEvent event) {
return Filter.DENY;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/ExpressionFilter.java 0000664 0000000 0000000 00000011700 12527427642 0030717 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.filter;
import org.apache.log4j.rule.ExpressionRule;
import org.apache.log4j.rule.Rule;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
/**
* A filter supporting complex expressions - supports both infix and postfix
* expressions (infix expressions must first be converted to postfix prior
* to processing).
*
See org.apache.log4j.chainsaw.LoggingEventFieldResolver.java
* for the correct names for logging event fields
* used when building expressions.
*
See org.apache.log4j.chainsaw.rule package
* for a list of available
* rules which can be applied using the expression syntax.
*
See org.apache.log4j.chainsaw.RuleFactory for the symbols
* used to activate the corresponding rules.
*
The filter admits two options LevelToMatch and
AcceptOnMatch. If there is an exact match between the value
of the LevelToMatch option and the level of the {@link
org.apache.log4j.spi.LoggingEvent}, then the {@link #decide} method returns {@link
org.apache.log4j.spi.Filter#ACCEPT} in case the AcceptOnMatch option value is set
to true, if it is false then {@link
org.apache.log4j.spi.Filter#DENY} is returned. If there is no match, {@link
org.apache.log4j.spi.Filter#NEUTRAL} is returned.
@author Ceki Gülcü
@since 1.2 */
public class LevelMatchFilter extends Filter {
/**
Do we return ACCEPT when a match occurs. Default is
true. */
boolean acceptOnMatch = true;
/**
*/
Level levelToMatch;
public void setLevelToMatch(String level) {
levelToMatch = OptionConverter.toLevel(level, null);
}
public String getLevelToMatch() {
return (levelToMatch == null) ? null : levelToMatch.toString();
}
public void setAcceptOnMatch(boolean acceptOnMatch) {
this.acceptOnMatch = acceptOnMatch;
}
public boolean getAcceptOnMatch() {
return acceptOnMatch;
}
/**
Return the decision of this filter.
Returns {@link Filter#NEUTRAL} if the LevelToMatch option
is not set or if there is not match. Otherwise, if there is a
match, then the returned decision is {@link Filter#ACCEPT} if the
AcceptOnMatch property is set to true. The
returned decision is {@link Filter#DENY} if the
AcceptOnMatch property is set to false.
*/
public int decide(LoggingEvent event) {
if (this.levelToMatch == null) {
return Filter.NEUTRAL;
}
boolean matchOccured = false;
if (this.levelToMatch.equals(event.getLevel())) {
matchOccured = true;
}
if (matchOccured) {
if (this.acceptOnMatch) {
return Filter.ACCEPT;
} else {
return Filter.DENY;
}
} else {
return Filter.NEUTRAL;
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/LevelRangeFilter.java 0000664 0000000 0000000 00000010305 12527427642 0030604 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.filter;
import org.apache.log4j.Level;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
/**
This is a very simple filter based on level matching, which can be
used to reject messages with priorities outside a certain range.
The filter admits three options LevelMin, LevelMax and AcceptOnMatch.
If the level of the {@link org.apache.log4j.spi.LoggingEvent} is not between Min and Max (inclusive), then {@link org.apache.log4j.spi.Filter#DENY} is returned.
If the Logging event level is within the specified range, then if AcceptOnMatch is true, {@link org.apache.log4j.spi.Filter#ACCEPT} is returned, and if AcceptOnMatch is false, {@link org.apache.log4j.spi.Filter#NEUTRAL} is returned.
If LevelMin is not defined, then there is no
minimum acceptable level (ie a level is never rejected for
being too "low"/unimportant). If LevelMax is not
defined, then there is no maximum acceptable level (ie a
level is never rejected for beeing too "high"/important).
Refer to the {@link
org.apache.log4j.AppenderSkeleton#setThreshold setThreshold} method
available to all appenders extending {@link
org.apache.log4j.AppenderSkeleton} for a more convenient way to
filter out events by level.
@author Simon Kitching
@author based on code by Ceki Gülcü
*/
public class LevelRangeFilter extends Filter {
/**
Do we return ACCEPT when a match occurs. Default is
false, so that later filters get run by default */
boolean acceptOnMatch = false;
Level levelMin;
Level levelMax;
/**
Return the decision of this filter.
*/
public
int decide(LoggingEvent event) {
if(this.levelMin != null
&& event.getLevel().isGreaterOrEqual(levelMin) == false) {
// level of event is less than minimum
return Filter.DENY;
}
if(this.levelMax != null
&& event.getLevel().toInt() > levelMax.toInt()) {
// level of event is greater than maximum
// Alas, there is no Level.isGreater method. and using
// a combo of isGreaterOrEqual && !Equal seems worse than
// checking the int values of the level objects..
return Filter.DENY;
}
if (acceptOnMatch) {
// this filter set up to bypass later filters and always return
// accept if level in range
return Filter.ACCEPT;
}
else {
// event is ok for this filter; allow later filters to have a look..
return Filter.NEUTRAL;
}
}
/**
Get the value of the LevelMax option. */
public
Level getLevelMax() {
return levelMax;
}
/**
Get the value of the LevelMin option. */
public
Level getLevelMin() {
return levelMin;
}
/**
Get the value of the AcceptOnMatch option.
*/
public
boolean getAcceptOnMatch() {
return acceptOnMatch;
}
/**
Set the LevelMax option.
*/
public
void setLevelMax(Level levelMax) {
this.levelMax = levelMax;
}
/**
Set the LevelMin option.
*/
public
void setLevelMin(Level levelMin) {
this.levelMin = levelMin;
}
/**
Set the AcceptOnMatch option.
*/
public
void setAcceptOnMatch(boolean acceptOnMatch) {
this.acceptOnMatch = acceptOnMatch;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/LocationInfoFilter.java 0000664 0000000 0000000 00000006162 12527427642 0031152 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.filter;
import org.apache.log4j.rule.ExpressionRule;
import org.apache.log4j.rule.Rule;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
/**
* Location information is usually specified at the appender level -
* all events associated
* with an appender either create and parse stack traces or they do not.
* This is an expensive operation and in some cases not needed
* for all events associated with an appender.
*
* This filter creates event-level location information only
* if the provided expression evaluates to true.
*
* For information on expression syntax,
* see org.apache.log4j.rule.ExpressionRule
*
* @author Scott Deboy sdeboy@apache.org
*/
public class LocationInfoFilter extends Filter {
/**
* Convert to in-fix to post-fix.
*/
boolean convertInFixToPostFix = true;
/**
* Expression.
*/
String expression;
/**
* Compiled expression.
*/
Rule expressionRule;
/**
* {@inheritDoc}
*/
public void activateOptions() {
expressionRule =
ExpressionRule.getRule(expression, !convertInFixToPostFix);
}
/**
* Set expression.
* @param exp expression.
*/
public void setExpression(final String exp) {
this.expression = exp;
}
/**
* Get expression.
* @return expression.
*/
public String getExpression() {
return expression;
}
/**
* Set whether in-fix expressions should be converted to post-fix.
* @param newValue if true, convert/
*/
public void setConvertInFixToPostFix(final boolean newValue) {
this.convertInFixToPostFix = newValue;
}
/**
* Set whether in-fix expressions should be converted to post-fix.
* @return if true, expressions are converted.
*/
public boolean getConvertInFixToPostFix() {
return convertInFixToPostFix;
}
/**
* If this event does not already contain location information,
* evaluate the event against the expression.
*
* If the expression evaluates to true,
* force generation of location information by
* calling getLocationInfo.
*
* @param event event
* @return Filter.NEUTRAL.
*/
public int decide(final LoggingEvent event) {
if (expressionRule.evaluate(event, null)) {
event.getLocationInformation();
}
return Filter.NEUTRAL;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/LoggerMatchFilter.java 0000664 0000000 0000000 00000006117 12527427642 0030762 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.filter;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
/**
This is a very simple filter based on logger name matching.
The filter admits two options LoggerToMatch and
AcceptOnMatch. If there is an exact match between the value
of the LoggerToMatch option and the logger of the {@link
org.apache.log4j.spi.LoggingEvent}, then the {@link #decide} method returns {@link
org.apache.log4j.spi.Filter#ACCEPT} in case the AcceptOnMatch option value is set
to true, if it is false then {@link
org.apache.log4j.spi.Filter#DENY} is returned. If there is no match, {@link
org.apache.log4j.spi.Filter#NEUTRAL} is returned. A loggerToMatch of "root"
matches both the root logger and a logger named "root".
*/
public class LoggerMatchFilter extends Filter {
/**
Do we return ACCEPT when a match occurs. Default is
true. */
private boolean acceptOnMatch = true;
/**
* Logger name, may be null or empty in which case it matches root.
*/
private String loggerToMatch = "root";
/**
* Sets logger name.
* @param logger logger name.
*/
public void setLoggerToMatch(final String logger) {
if (logger == null) {
loggerToMatch = "root";
} else {
loggerToMatch = logger;
}
}
/**
* Gets logger name.
* @return logger name.
*/
public String getLoggerToMatch() {
return loggerToMatch;
}
/**
* Sets whether a match should result in acceptance.
* @param acceptOnMatch if true, accept if logger name matches, otherwise reject.
*/
public void setAcceptOnMatch(final boolean acceptOnMatch) {
this.acceptOnMatch = acceptOnMatch;
}
/**
* Gets whether a match should result in acceptance.
* @return true if event is accepted if logger name matches.
*/
public boolean getAcceptOnMatch() {
return acceptOnMatch;
}
/**
* {@inheritDoc}
*/
public int decide(final LoggingEvent event) {
boolean matchOccured = loggerToMatch.equals(event.getLoggerName());
if (matchOccured) {
if (this.acceptOnMatch) {
return Filter.ACCEPT;
} else {
return Filter.DENY;
}
} else {
return Filter.NEUTRAL;
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/StringMatchFilter.java 0000664 0000000 0000000 00000004616 12527427642 0031013 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.filter;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
/**
This is a very simple filter based on string matching.
The filter admits two options StringToMatch and
AcceptOnMatch. If there is a match between the value of the
StringToMatch option and the message of the {@link LoggingEvent},
then the {@link #decide(LoggingEvent)} method returns
{@link org.apache.log4j.spi.Filter#ACCEPT} if
the AcceptOnMatch option value is true, if it is false then
{@link org.apache.log4j.spi.Filter#DENY} is returned. If there is no match, {@link
org.apache.log4j.spi.Filter#NEUTRAL} is returned.
@author Ceki Gülcü
@since 0.9.0
*/
public class StringMatchFilter extends Filter {
boolean acceptOnMatch = true;
String stringToMatch;
public
void setStringToMatch(String s) {
stringToMatch = s;
}
public
String getStringToMatch() {
return stringToMatch;
}
public
void setAcceptOnMatch(boolean acceptOnMatch) {
this.acceptOnMatch = acceptOnMatch;
}
public
boolean getAcceptOnMatch() {
return acceptOnMatch;
}
/**
Returns {@link Filter#NEUTRAL} is there is no string match.
*/
public
int decide(LoggingEvent event) {
String msg = event.getRenderedMessage();
if(msg == null || stringToMatch == null)
return Filter.NEUTRAL;
if( msg.indexOf(stringToMatch) == -1 ) {
return Filter.NEUTRAL;
} else { // we've got a match
if(acceptOnMatch) {
return Filter.ACCEPT;
} else {
return Filter.DENY;
}
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/filter/TimeFilter.java 0000664 0000000 0000000 00000010411 12527427642 0027454 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.filter;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.spi.Filter;
import org.apache.log4j.spi.LoggingEvent;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Calendar;
import java.util.TimeZone;
/**
* Filters events that fall within a specified time period
* in each day.
*
*/
public final class TimeFilter extends Filter {
private boolean acceptOnMatch;
/**
* Starting offset from midnight in milliseconds.
*/
private long start;
/**
* Ending offset from midnight in milliseconds.
*/
private long end;
/**
* Timezone.
*/
private Calendar calendar;
/**
* Length of hour in milliseconds.
*/
private static final long HOUR_MS = 3600000;
/**
* Length of minute in milliseconds.
*/
private static final long MINUTE_MS = 60000;
/**
* Length of second in milliseconds.
*/
private static final long SECOND_MS = 1000;
/**
* Constructor.
*/
public TimeFilter() {
acceptOnMatch = true;
start = 0;
end = Long.MAX_VALUE;
calendar = Calendar.getInstance();
}
/**
* Set start (inclusive) of time span.
* @param s string representation of start time as HH:mm:ss.
*/
public void setStart(final String s) {
SimpleDateFormat stf = new SimpleDateFormat("HH:mm:ss");
stf.setTimeZone(TimeZone.getTimeZone("UTC"));
try {
start = stf.parse(s).getTime();
} catch(ParseException ex) {
LogLog.warn("Error parsing start value " + s, ex);
}
}
/**
* Set end (exclusive) of time span.
* @param s string representation of end time as HH:mm:ss.
*/
public void setEnd(final String s) {
SimpleDateFormat stf = new SimpleDateFormat("HH:mm:ss");
stf.setTimeZone(TimeZone.getTimeZone("UTC"));
try {
end = stf.parse(s).getTime();
} catch(ParseException ex) {
LogLog.warn("Error parsing end value " + s, ex);
}
}
/**
* Set timezone.
* @param s time zone.
*/
public void setTimeZone(final String s) {
if (s == null) {
calendar = Calendar.getInstance();
} else {
calendar = Calendar.getInstance(TimeZone.getTimeZone(s));
}
}
/**
* Sets whether an event within the timespan should be accepted or denied.
* @param acceptOnMatch true if matching event should be accepted.
*/
public synchronized void setAcceptOnMatch(boolean acceptOnMatch) {
this.acceptOnMatch = acceptOnMatch;
}
/**
* Gets whether an event within the timespan should be accepted or denied.
* @return true if matching event should be accepted.
*/
public synchronized boolean getAcceptOnMatch() {
return acceptOnMatch;
}
/** {@inheritDoc} */
public int decide(final LoggingEvent event) {
calendar.setTimeInMillis(event.timeStamp);
//
// get apparent number of milliseconds since midnight
// (ignores extra or missing hour on daylight time changes).
//
long apparentOffset = calendar.get(Calendar.HOUR_OF_DAY) * HOUR_MS +
calendar.get(Calendar.MINUTE) * MINUTE_MS +
calendar.get(Calendar.SECOND) * SECOND_MS +
calendar.get(Calendar.MILLISECOND);
if (apparentOffset >= start && apparentOffset < end) {
if (acceptOnMatch) {
return Filter.ACCEPT;
} else {
return Filter.DENY;
}
}
return Filter.NEUTRAL;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/pattern/ 0000775 0000000 0000000 00000000000 12527427642 0024740 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/pattern/ExtrasFormattingInfo.java 0000664 0000000 0000000 00000010514 12527427642 0031721 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.pattern;
/**
* Modifies the output of a pattern converter for a specified minimum
* and maximum width and alignment.
*
*
* @author Jim Cakalic
* @author Ceki Gülcü
* @author Curt Arnold
*
*/
public final class ExtrasFormattingInfo {
/**
* Array of spaces.
*/
private static final char[] SPACES =
new char[] { ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ' };
/**
* Default instance.
*/
private static final ExtrasFormattingInfo DEFAULT =
new ExtrasFormattingInfo(false, 0, Integer.MAX_VALUE);
/**
* Minimum length.
*/
private final int minLength;
/**
* Maximum length.
*/
private final int maxLength;
/**
* Alignment.
*/
private final boolean leftAlign;
/**
* Right truncation.
* @since 1.2.17
*/
private final boolean rightTruncate;
/**
* Creates new instance.
* @param leftAlign left align if true.
* @param minLength minimum length.
* @param maxLength maximum length.
* @deprecated since 1.2.17
*/
public ExtrasFormattingInfo(
final boolean leftAlign,
final int minLength,
final int maxLength) {
this.leftAlign = leftAlign;
this.minLength = minLength;
this.maxLength = maxLength;
this.rightTruncate = false;
}
/**
* Creates new instance.
* @param leftAlign left align if true.
* @param rightTruncate right truncate if true.
* @param minLength minimum length.
* @param maxLength maximum length.
* @since 1.2.17
*/
public ExtrasFormattingInfo(
final boolean leftAlign,
final boolean rightTruncate,
final int minLength,
final int maxLength) {
this.leftAlign = leftAlign;
this.minLength = minLength;
this.maxLength = maxLength;
this.rightTruncate = rightTruncate;
}
/**
* Gets default instance.
* @return default instance.
*/
public static ExtrasFormattingInfo getDefault() {
return DEFAULT;
}
/**
* Determine if left aligned.
* @return true if left aligned.
*/
public boolean isLeftAligned() {
return leftAlign;
}
/**
* Determine if right truncated.
* @return true if right truncated.
* @since 1.2.17
*/
public boolean isRightTruncated() {
return rightTruncate;
}
/**
* Get minimum length.
* @return minimum length.
*/
public int getMinLength() {
return minLength;
}
/**
* Get maximum length.
* @return maximum length.
*/
public int getMaxLength() {
return maxLength;
}
/**
* Adjust the content of the buffer based on the specified lengths and alignment.
*
* @param fieldStart start of field in buffer.
* @param buffer buffer to be modified.
*/
public void format(final int fieldStart, final StringBuffer buffer) {
final int rawLength = buffer.length() - fieldStart;
if (rawLength > maxLength) {
if(rightTruncate) {
buffer.setLength(fieldStart + maxLength);
} else {
buffer.delete(fieldStart, buffer.length() - maxLength);
}
} else if (rawLength < minLength) {
if (leftAlign) {
final int fieldEnd = buffer.length();
buffer.setLength(fieldStart + minLength);
for (int i = fieldEnd; i < buffer.length(); i++) {
buffer.setCharAt(i, ' ');
}
} else {
int padLength = minLength - rawLength;
for (; padLength > 8; padLength -= 8) {
buffer.insert(fieldStart, SPACES);
}
buffer.insert(fieldStart, SPACES, 0, padLength);
}
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/pattern/ExtrasPatternParser.java 0000664 0000000 0000000 00000047436 12527427642 0031602 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.pattern;
import org.apache.log4j.helpers.Loader;
import org.apache.log4j.helpers.LogLog;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
// Contributors: Nelson Minar <(nelson@monkey.org>
// Igor E. Poteryaev It is this class that parses conversion patterns and creates
* a chained list of {@link PatternConverter PatternConverters}.
*
* @author James P. Cakalic
* @author Ceki Gülcü
* @author Anders Kristensen
* @author Paul Smith
* @author Curt Arnold
*
*/
public final class ExtrasPatternParser {
/**
* Escape character for format specifier.
*/
private static final char ESCAPE_CHAR = '%';
/**
* Literal state.
*/
private static final int LITERAL_STATE = 0;
/**
* In converter name state.
*/
private static final int CONVERTER_STATE = 1;
/**
* Dot state.
*/
private static final int DOT_STATE = 3;
/**
* Min state.
*/
private static final int MIN_STATE = 4;
/**
* Max state.
*/
private static final int MAX_STATE = 5;
/**
* Standard format specifiers for EnhancedPatternLayout.
*/
private static final Map PATTERN_LAYOUT_RULES;
/**
* Standard format specifiers for rolling file appenders.
*/
private static final Map FILENAME_PATTERN_RULES;
static {
// We set the global rules in the static initializer of ExtrasPatternParser class
Map rules = new HashMap(17);
rules.put("c", LoggerPatternConverter.class);
rules.put("logger", LoggerPatternConverter.class);
rules.put("C", ClassNamePatternConverter.class);
rules.put("class", ClassNamePatternConverter.class);
rules.put("d", DatePatternConverter.class);
rules.put("date", DatePatternConverter.class);
rules.put("F", FileLocationPatternConverter.class);
rules.put("file", FileLocationPatternConverter.class);
rules.put("l", FullLocationPatternConverter.class);
rules.put("L", LineLocationPatternConverter.class);
rules.put("line", LineLocationPatternConverter.class);
rules.put("m", MessagePatternConverter.class);
rules.put("message", MessagePatternConverter.class);
rules.put("n", LineSeparatorPatternConverter.class);
rules.put("M", MethodLocationPatternConverter.class);
rules.put("method", MethodLocationPatternConverter.class);
rules.put("p", LevelPatternConverter.class);
rules.put("level", LevelPatternConverter.class);
rules.put("r", RelativeTimePatternConverter.class);
rules.put("relative", RelativeTimePatternConverter.class);
rules.put("t", ThreadPatternConverter.class);
rules.put("thread", ThreadPatternConverter.class);
rules.put("x", NDCPatternConverter.class);
rules.put("ndc", NDCPatternConverter.class);
rules.put("X", PropertiesPatternConverter.class);
rules.put("properties", PropertiesPatternConverter.class);
rules.put("sn", SequenceNumberPatternConverter.class);
rules.put("sequenceNumber", SequenceNumberPatternConverter.class);
rules.put("throwable", ThrowableInformationPatternConverter.class);
PATTERN_LAYOUT_RULES = new ReadOnlyMap(rules);
Map fnameRules = new HashMap(4);
fnameRules.put("d", FileDatePatternConverter.class);
fnameRules.put("date", FileDatePatternConverter.class);
fnameRules.put("i", IntegerPatternConverter.class);
fnameRules.put("index", IntegerPatternConverter.class);
FILENAME_PATTERN_RULES = new ReadOnlyMap(fnameRules);
}
/**
* Private constructor.
*/
private ExtrasPatternParser() {
}
/**
* Get standard format specifiers for EnhancedPatternLayout.
* @return read-only map of format converter classes keyed by format specifier strings.
*/
public static Map getPatternLayoutRules() {
return PATTERN_LAYOUT_RULES;
}
/**
* Get standard format specifiers for rolling file appender file specification.
* @return read-only map of format converter classes keyed by format specifier strings.
*/
public static Map getFileNamePatternRules() {
return FILENAME_PATTERN_RULES;
}
/** Extract the converter identifier found at position i.
*
* After this function returns, the variable i will point to the
* first char after the end of the converter identifier.
*
* If i points to a char which is not a character acceptable at the
* start of a unicode identifier, the value null is returned.
*
* @param lastChar last processed character.
* @param pattern format string.
* @param i current index into pattern format.
* @param convBuf buffer to receive conversion specifier.
* @param currentLiteral literal to be output in case format specifier in unrecognized.
* @return position in pattern after converter.
*/
private static int extractConverter(
char lastChar, final String pattern, int i, final StringBuffer convBuf,
final StringBuffer currentLiteral) {
convBuf.setLength(0);
// When this method is called, lastChar points to the first character of the
// conversion word. For example:
// For "%hello" lastChar = 'h'
// For "%-5hello" lastChar = 'h'
//System.out.println("lastchar is "+lastChar);
if (!Character.isUnicodeIdentifierStart(lastChar)) {
return i;
}
convBuf.append(lastChar);
while (
(i < pattern.length())
&& Character.isUnicodeIdentifierPart(pattern.charAt(i))) {
convBuf.append(pattern.charAt(i));
currentLiteral.append(pattern.charAt(i));
//System.out.println("conv buffer is now ["+convBuf+"].");
i++;
}
return i;
}
/**
* Extract options.
* @param pattern conversion pattern.
* @param i start of options.
* @param options array to receive extracted options
* @return position in pattern after options.
*/
private static int extractOptions(String pattern, int i, List options) {
while ((i < pattern.length()) && (pattern.charAt(i) == '{')) {
int end = pattern.indexOf('}', i);
if (end == -1) {
break;
}
String r = pattern.substring(i + 1, end);
options.add(r);
i = end + 1;
}
return i;
}
/**
* Parse a format specifier.
* @param pattern pattern to parse.
* @param patternConverters list to receive pattern converters.
* @param formattingInfos list to receive field specifiers corresponding to pattern converters.
* @param converterRegistry map of user-supported pattern converters keyed by format specifier, may be null.
* @param rules map of stock pattern converters keyed by format specifier.
*/
public static void parse(
final String pattern, final List patternConverters,
final List formattingInfos, final Map converterRegistry, final Map rules) {
if (pattern == null) {
throw new NullPointerException("pattern");
}
StringBuffer currentLiteral = new StringBuffer(32);
int patternLength = pattern.length();
int state = LITERAL_STATE;
char c;
int i = 0;
ExtrasFormattingInfo formattingInfo = ExtrasFormattingInfo.getDefault();
while (i < patternLength) {
c = pattern.charAt(i++);
switch (state) {
case LITERAL_STATE:
// In literal state, the last char is always a literal.
if (i == patternLength) {
currentLiteral.append(c);
continue;
}
if (c == ESCAPE_CHAR) {
// peek at the next char.
switch (pattern.charAt(i)) {
case ESCAPE_CHAR:
currentLiteral.append(c);
i++; // move pointer
break;
default:
if (currentLiteral.length() != 0) {
patternConverters.add(
new LiteralPatternConverter(currentLiteral.toString()));
formattingInfos.add(ExtrasFormattingInfo.getDefault());
}
currentLiteral.setLength(0);
currentLiteral.append(c); // append %
state = CONVERTER_STATE;
formattingInfo = ExtrasFormattingInfo.getDefault();
}
} else {
currentLiteral.append(c);
}
break;
case CONVERTER_STATE:
currentLiteral.append(c);
switch (c) {
case '-':
formattingInfo =
new ExtrasFormattingInfo(
true,
formattingInfo.isRightTruncated(),
formattingInfo.getMinLength(),
formattingInfo.getMaxLength());
break;
case '!':
formattingInfo =
new ExtrasFormattingInfo(
formattingInfo.isLeftAligned(),
true,
formattingInfo.getMinLength(),
formattingInfo.getMaxLength());
break;
case '.':
state = DOT_STATE;
break;
default:
if ((c >= '0') && (c <= '9')) {
formattingInfo =
new ExtrasFormattingInfo(
formattingInfo.isLeftAligned(),
formattingInfo.isRightTruncated(),
c - '0',
formattingInfo.getMaxLength());
state = MIN_STATE;
} else {
i = finalizeConverter(
c, pattern, i, currentLiteral, formattingInfo,
converterRegistry, rules, patternConverters, formattingInfos);
// Next pattern is assumed to be a literal.
state = LITERAL_STATE;
formattingInfo = ExtrasFormattingInfo.getDefault();
currentLiteral.setLength(0);
}
} // switch
break;
case MIN_STATE:
currentLiteral.append(c);
if ((c >= '0') && (c <= '9')) {
formattingInfo =
new ExtrasFormattingInfo(
formattingInfo.isLeftAligned(),
formattingInfo.isRightTruncated(),
(formattingInfo.getMinLength() * 10) + (c - '0'),
formattingInfo.getMaxLength());
} else if (c == '.') {
state = DOT_STATE;
} else {
i = finalizeConverter(
c, pattern, i, currentLiteral, formattingInfo,
converterRegistry, rules, patternConverters, formattingInfos);
state = LITERAL_STATE;
formattingInfo = ExtrasFormattingInfo.getDefault();
currentLiteral.setLength(0);
}
break;
case DOT_STATE:
currentLiteral.append(c);
if ((c >= '0') && (c <= '9')) {
formattingInfo =
new ExtrasFormattingInfo(
formattingInfo.isLeftAligned(),
formattingInfo.isRightTruncated(),
formattingInfo.getMinLength(),
c - '0');
state = MAX_STATE;
} else {
LogLog.error(
"Error occured in position " + i
+ ".\n Was expecting digit, instead got char \"" + c + "\".");
state = LITERAL_STATE;
}
break;
case MAX_STATE:
currentLiteral.append(c);
if ((c >= '0') && (c <= '9')) {
formattingInfo =
new ExtrasFormattingInfo(
formattingInfo.isLeftAligned(),
formattingInfo.isRightTruncated(),
formattingInfo.getMinLength(),
(formattingInfo.getMaxLength() * 10) + (c - '0'));
} else {
i = finalizeConverter(
c, pattern, i, currentLiteral, formattingInfo,
converterRegistry, rules, patternConverters, formattingInfos);
state = LITERAL_STATE;
formattingInfo = ExtrasFormattingInfo.getDefault();
currentLiteral.setLength(0);
}
break;
} // switch
}
// while
if (currentLiteral.length() != 0) {
patternConverters.add(
new LiteralPatternConverter(currentLiteral.toString()));
formattingInfos.add(ExtrasFormattingInfo.getDefault());
}
}
/**
* Creates a new PatternConverter.
*
*
* @param converterId converterId.
* @param currentLiteral literal to be used if converter is unrecognized or following converter
* if converterId contains extra characters.
* @param converterRegistry map of user-supported pattern converters keyed by format specifier, may be null.
* @param rules map of stock pattern converters keyed by format specifier.
* @param options converter options.
* @return converter or null.
*/
private static PatternConverter createConverter(
final String converterId, final StringBuffer currentLiteral,
final Map converterRegistry, final Map rules, final List options) {
String converterName = converterId;
Object converterObj = null;
for (int i = converterId.length(); (i > 0) && (converterObj == null);
i--) {
converterName = converterName.substring(0, i);
if (converterRegistry != null) {
converterObj = converterRegistry.get(converterName);
}
if ((converterObj == null) && (rules != null)) {
converterObj = rules.get(converterName);
}
}
if (converterObj == null) {
LogLog.error("Unrecognized format specifier [" + converterId + "]");
return null;
}
Class converterClass;
if (converterObj instanceof Class) {
converterClass = (Class) converterObj;
} else {
if (converterObj instanceof String) {
try {
converterClass = Loader.loadClass((String) converterObj);
} catch (ClassNotFoundException ex) {
LogLog.warn(
"Class for conversion pattern %" + converterName + " not found",
ex);
return null;
}
} else {
LogLog.warn(
"Bad map entry for conversion pattern %" + converterName + ".");
return null;
}
}
try {
Method factory =
converterClass.getMethod(
"newInstance",
new Class[] {
Class.forName("[Ljava.lang.String;")
});
String[] optionsArray = new String[options.size()];
optionsArray = (String[]) options.toArray(optionsArray);
Object newObj =
factory.invoke(null, new Object[] { optionsArray });
if (newObj instanceof PatternConverter) {
currentLiteral.delete(
0,
currentLiteral.length()
- (converterId.length() - converterName.length()));
return (PatternConverter) newObj;
} else {
LogLog.warn(
"Class " + converterClass.getName()
+ " does not extend PatternConverter.");
}
} catch (Exception ex) {
LogLog.error("Error creating converter for " + converterId, ex);
try {
//
// try default constructor
PatternConverter pc = (PatternConverter) converterClass.newInstance();
currentLiteral.delete(
0,
currentLiteral.length()
- (converterId.length() - converterName.length()));
return pc;
} catch (Exception ex2) {
LogLog.error("Error creating converter for " + converterId, ex2);
}
}
return null;
}
/**
* Processes a format specifier sequence.
*
* @param c initial character of format specifier.
* @param pattern conversion pattern
* @param i current position in conversion pattern.
* @param currentLiteral current literal.
* @param formattingInfo current field specifier.
* @param converterRegistry map of user-provided pattern converters keyed by format specifier, may be null.
* @param rules map of stock pattern converters keyed by format specifier.
* @param patternConverters list to receive parsed pattern converter.
* @param formattingInfos list to receive corresponding field specifier.
* @return position after format specifier sequence.
*/
private static int finalizeConverter(
char c, String pattern, int i,
final StringBuffer currentLiteral, final ExtrasFormattingInfo formattingInfo,
final Map converterRegistry, final Map rules, final List patternConverters,
final List formattingInfos) {
StringBuffer convBuf = new StringBuffer();
i = extractConverter(c, pattern, i, convBuf, currentLiteral);
String converterId = convBuf.toString();
List options = new ArrayList();
i = extractOptions(pattern, i, options);
PatternConverter pc =
createConverter(
converterId, currentLiteral, converterRegistry, rules, options);
if (pc == null) {
StringBuffer msg;
if (converterId.length() == 0) {
msg =
new StringBuffer("Empty conversion specifier starting at position ");
} else {
msg = new StringBuffer("Unrecognized conversion specifier [");
msg.append(converterId);
msg.append("] starting at position ");
}
msg.append(Integer.toString(i));
msg.append(" in conversion pattern.");
LogLog.error(msg.toString());
patternConverters.add(
new LiteralPatternConverter(currentLiteral.toString()));
formattingInfos.add(ExtrasFormattingInfo.getDefault());
} else {
patternConverters.add(pc);
formattingInfos.add(formattingInfo);
if (currentLiteral.length() > 0) {
patternConverters.add(
new LiteralPatternConverter(currentLiteral.toString()));
formattingInfos.add(ExtrasFormattingInfo.getDefault());
}
}
currentLiteral.setLength(0);
return i;
}
/**
* The class wraps another Map but throws exceptions on any attempt to modify the map.
*/
private static class ReadOnlyMap implements Map {
/**
* Wrapped map.
*/
private final Map map;
/**
* Constructor
* @param src source map.
*/
public ReadOnlyMap(Map src) {
map = src;
}
/**
* {@inheritDoc}
*/
public void clear() {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
public boolean containsKey(Object key) {
return map.containsKey(key);
}
/**
* {@inheritDoc}
*/
public boolean containsValue(Object value) {
return map.containsValue(value);
}
/**
* {@inheritDoc}
*/
public Set entrySet() {
return map.entrySet();
}
/**
* {@inheritDoc}
*/
public Object get(Object key) {
return map.get(key);
}
/**
* {@inheritDoc}
*/
public boolean isEmpty() {
return map.isEmpty();
}
/**
* {@inheritDoc}
*/
public Set keySet() {
return map.keySet();
}
/**
* {@inheritDoc}
*/
public Object put(Object key, Object value) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
public void putAll(Map t) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
public Object remove(Object key) {
throw new UnsupportedOperationException();
}
/**
* {@inheritDoc}
*/
public int size() {
return map.size();
}
/**
* {@inheritDoc}
*/
public Collection values() {
return map.values();
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/pattern/package.html 0000664 0000000 0000000 00000001715 12527427642 0027225 0 ustar 00root root 0000000 0000000
Provides classes implementing format specifiers in conversion patterns.
* NOTE: This receiver cannot yet be created through Chainsaw's receiver panel.
* It must be created through an XML configuration file.
*
* This receiver supports database configuration via ConnectionSource, in the
* org.apache.log4j.db package: DriverManagerConnectionSource,
* DataSourceConnectionSource, JNDIConnectionSource
*
* This database receiver differs from DBReceiver in that this receiver relies
* on custom SQL to retrieve logging event data, where DBReceiver requires the
* use of a log4j-defined schema.
*
* A 'refreshMillis' int parameter controls SQL execution. If 'refreshMillis' is
* zero (the default), the receiver will run only one time. If it is set to any
* other numeric value, the SQL will be executed on a recurring basis every
* 'refreshMillis' milliseconds.
*
* The receiver closes the connection and acquires a new connection on each
* execution of the SQL (use pooled connections if possible).
*
* If the SQL will be executing on a recurring basis, specify the IDField param -
* the column name holding the unique identifier (int) representing the logging
* event.
*
* As events are retrieved, the column represented by IDField is examined and
* the largest value is held and used by the next execution of the SQL statement
* to avoid retrieving previously processed events.
*
* As an example, the IDField references a 'COUNTER' (int, auto-increment,
* unique) column. The first execution of the SQL statement returns 500 rows,
* with a final value in the COUNTER field of 500.
*
* The SQL statement is manipulated prior to the next execution, adding ' WHERE
* COUNTER > 500' to the statement to avoid retrieval of previously processed
* events.
*
* The select statement must provide ALL fields which define a LoggingEvent.
*
* The SQL statement MUST include the columns: LOGGER, TIMESTAMP, LEVEL, THREAD,
* MESSAGE, NDC, MDC, CLASS, METHOD, FILE, LINE, PROPERTIES, THROWABLE
*
* Use ' AS ' in the SQL statement to alias the SQL's column names to match your
* database schema. (see example below).
*
* Include all fields in the SQL statement, even if you don't have data for the
* field (specify an empty string as the value for columns which you don't have
* data).
*
* The TIMESTAMP column must be a datetime.
*
* Both a PROPERTIES column and an MDC column are supported. These fields
* represent Maps on the logging event, but require the use of string
* concatenation database functions to hold the (possibly multiple) name/value
* pairs in the column.
*
* For example, to include both 'userid' and 'lastname' properties in the
* logging event (from either the PROPERTIES or MDC columns), the name/value
* pairs must be concatenated together by your database.
*
* The resulting PROPERTIES or MDC column must have data in this format: {{name,
* value, name2, value2}}
*
* The resulting PROPERTIES column would contain this text: {{userid, someone,
* lastname, mylastname}}
*
* Here is an example of concatenating a PROPERTIES or MDC column using MySQL's
* concat function, where the 'application' and 'hostname' parameters were fixed
* text, but the 'log4jid' key's value is the value of the COUNTER column:
*
* concat("{{application,databaselogs,hostname,mymachine,log4jid,", COUNTER,
* "}}") as PROPERTIES
*
* log4jid is a special property that is used by Chainsaw to represent an 'ID'
* field. Specify this property to ensure you can map events in Chainsaw to
* events in the database if you need to go back and view events at a later time
* or save the events to XML for later analysis.
*
* Here is a complete MySQL SQL statement which can be used to provide events to
* Chainsaw (note how in the example below, there is no column in logtable representing the throwable, so an
* empty string is passed in and an ALIAS is still defined):
*
* select myloggercolumn as LOGGER, mytimestampcolumn as TIMESTAMP, mylevelcolumn as LEVEL, mythreadcolumn as
* THREAD, mymessagecolumn as MESSAGE, myndccolumn as NDC, mymdccolumn as MDC, myclasscolumn as CLASS, mymethodcolumn as
* METHOD, myfilecolumn as FILE, mylinecolumn as LINE,
* concat("{{application,databaselogs,hostname,mymachine, log4jid,",
* COUNTER,"}}") as PROPERTIES, "" as THROWABLE from logtable
*
* @author Scott Deboy
*/
public class CustomSQLDBReceiver extends Receiver implements Pauseable, UnrecognizedElementHandler {
protected volatile Connection connection = null;
protected String sqlStatement = "";
/**
* By default we refresh data every 1000 milliseconds.
*
* @see #setRefreshMillis
*/
static int DEFAULT_REFRESH_MILLIS = 1000;
int refreshMillis = DEFAULT_REFRESH_MILLIS;
protected String idField = null;
int lastID = -1;
private static final String WHERE_CLAUSE = " WHERE ";
private static final String AND_CLAUSE = " AND ";
private boolean whereExists = false;
private boolean paused = false;
private ConnectionSource connectionSource;
public static final String LOG4J_ID_KEY = "log4jid";
private CustomReceiverJob customReceiverJob;
public void activateOptions() {
if(connectionSource == null) {
throw new IllegalStateException(
"CustomSQLDBReceiver cannot function without a connection source");
}
whereExists = (sqlStatement.toUpperCase().indexOf(WHERE_CLAUSE) > -1);
customReceiverJob = new CustomReceiverJob();
if(this.repository == null) {
throw new IllegalStateException(
"CustomSQLDBReceiver cannot function without a reference to its owning repository");
}
if (repository instanceof LoggerRepositoryEx) {
Scheduler scheduler = ((LoggerRepositoryEx) repository).getScheduler();
scheduler.schedule(
customReceiverJob, System.currentTimeMillis() + 500, refreshMillis);
}
}
void closeConnection() {
if (connection != null) {
try {
// LogLog.warn("closing the connection. ", new Exception("x"));
connection.close();
} catch (SQLException sqle) {
// nothing we can do here
}
}
}
public void setRefreshMillis(int refreshMillis) {
this.refreshMillis = refreshMillis;
}
public int getRefreshMillis() {
return refreshMillis;
}
/**
* @return Returns the connectionSource.
*/
public ConnectionSource getConnectionSource() {
return connectionSource;
}
/**
* @param connectionSource
* The connectionSource to set.
*/
public void setConnectionSource(ConnectionSource connectionSource) {
this.connectionSource = connectionSource;
}
public void close() {
try {
if ((connection != null) && !connection.isClosed()) {
connection.close();
}
} catch (SQLException e) {
e.printStackTrace();
} finally {
connection = null;
}
}
public void finalize() throws Throwable {
super.finalize();
close();
}
/*
* (non-Javadoc)
*
* @see org.apache.log4j.plugins.Plugin#shutdown()
*/
public void shutdown() {
getLogger().info("removing receiverJob from the Scheduler.");
if(this.repository instanceof LoggerRepositoryEx) {
Scheduler scheduler = ((LoggerRepositoryEx) repository).getScheduler();
scheduler.delete(customReceiverJob);
}
lastID = -1;
}
public void setSql(String s) {
sqlStatement = s;
}
public String getSql() {
return sqlStatement;
}
public void setIDField(String id) {
idField = id;
}
public String getIDField() {
return idField;
}
public synchronized void setPaused(boolean p) {
paused = p;
}
public synchronized boolean isPaused() {
return paused;
}
class CustomReceiverJob implements Job {
public void execute() {
int oldLastID = lastID;
try {
connection = connectionSource.getConnection();
Statement statement = connection.createStatement();
Logger eventLogger = null;
long timeStamp = 0L;
String level = null;
String threadName = null;
Object message = null;
String ndc = null;
Hashtable mdc = null;
String[] throwable = null;
String className = null;
String methodName = null;
String fileName = null;
String lineNumber = null;
Hashtable properties = null;
String currentSQLStatement = sqlStatement;
if (whereExists) {
currentSQLStatement = sqlStatement + AND_CLAUSE + idField
+ " > " + lastID;
} else {
currentSQLStatement = sqlStatement + WHERE_CLAUSE + idField
+ " > " + lastID;
}
ResultSet rs = statement.executeQuery(currentSQLStatement);
int i = 0;
while (rs.next()) {
// add a small break every 1000 received events
if (++i == 1000) {
synchronized (this) {
try {
// add a delay
wait(300);
} catch (InterruptedException ie) {
}
i = 0;
}
}
eventLogger = Logger.getLogger(rs.getString("LOGGER"));
timeStamp = rs.getTimestamp("TIMESTAMP").getTime();
level = rs.getString("LEVEL");
threadName = rs.getString("THREAD");
message = rs.getString("MESSAGE");
ndc = rs.getString("NDC");
String mdcString = rs.getString("MDC");
mdc = new Hashtable();
if (mdcString != null) {
// support MDC being wrapped in {{name, value}}
// or
// just name, value
if ((mdcString.indexOf("{{") > -1)
&& (mdcString.indexOf("}}") > -1)) {
mdcString = mdcString
.substring(mdcString.indexOf("{{") + 2,
mdcString.indexOf("}}"));
}
StringTokenizer tok = new StringTokenizer(mdcString,
",");
while (tok.countTokens() > 1) {
mdc.put(tok.nextToken(), tok.nextToken());
}
}
throwable = new String[] { rs.getString("THROWABLE") };
className = rs.getString("CLASS");
methodName = rs.getString("METHOD");
fileName = rs.getString("FILE");
lineNumber = rs.getString("LINE");
// if properties are provided in the
// SQL they can be used here (for example, to route
// events to a unique tab in
// Chainsaw if the machinename and/or appname
// property
// are set)
String propertiesString = rs.getString("PROPERTIES");
properties = new Hashtable();
if (propertiesString != null) {
// support properties being wrapped in {{name,
// value}} or just name, value
if ((propertiesString.indexOf("{{") > -1)
&& (propertiesString.indexOf("}}") > -1)) {
propertiesString = propertiesString.substring(
propertiesString.indexOf("{{") + 2,
propertiesString.indexOf("}}"));
}
StringTokenizer tok2 = new StringTokenizer(
propertiesString, ",");
while (tok2.countTokens() > 1) {
String tokenName = tok2.nextToken();
String value = tok2.nextToken();
if (tokenName.equals(LOG4J_ID_KEY)) {
try {
int thisInt = Integer.parseInt(value);
value = String.valueOf(thisInt);
if (thisInt > lastID) {
lastID = thisInt;
}
} catch (Exception e) {
}
}
properties.put(tokenName, value);
}
}
Level levelImpl = Level.toLevel(level);
LocationInfo locationInfo = new LocationInfo(fileName,
className, methodName, lineNumber);
ThrowableInformation throwableInfo = new ThrowableInformation(
throwable);
properties.putAll(mdc);
LoggingEvent event = new LoggingEvent(eventLogger.getName(),
eventLogger, timeStamp, levelImpl, message,
threadName,
throwableInfo,
ndc,
locationInfo,
properties);
doPost(event);
}
//log when rows are retrieved
if (lastID != oldLastID) {
getLogger().debug("lastID: " + lastID);
oldLastID = lastID;
}
statement.close();
statement = null;
} catch (SQLException sqle) {
getLogger()
.error("*************Problem receiving events", sqle);
} finally {
closeConnection();
}
// if paused, loop prior to executing sql query
synchronized (this) {
while (isPaused()) {
try {
wait(1000);
} catch (InterruptedException ie) {
}
}
}
}
}
/**
* {@inheritDoc}
*/
public boolean parseUnrecognizedElement(Element element, Properties props) throws Exception {
if ("connectionSource".equals(element.getNodeName())) {
Object instance =
DOMConfigurator.parseElement(element, props, ConnectionSource.class);
if (instance instanceof ConnectionSource) {
ConnectionSource source = (ConnectionSource) instance;
source.activateOptions();
setConnectionSource(source);
}
return true;
}
return false;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/DBHelper.java 0000664 0000000 0000000 00000003712 12527427642 0030132 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db;
import org.apache.log4j.spi.LoggingEvent;
import java.sql.Connection;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Set;
/**
* @author Ceki Gülcü
*
*/
public class DBHelper {
public final static short PROPERTIES_EXIST = 0x01;
public final static short EXCEPTION_EXISTS = 0x02;
public static short computeReferenceMask(LoggingEvent event) {
short mask = 0;
Set propertiesKeys = event.getPropertyKeySet();
if(propertiesKeys.size() > 0) {
mask = PROPERTIES_EXIST;
}
String[] strRep = event.getThrowableStrRep();
if(strRep != null) {
mask |= EXCEPTION_EXISTS;
}
return mask;
}
static public void closeConnection(Connection connection) {
if(connection != null) {
try {
connection.close();
} catch(SQLException sqle) {
// static utility classes should not log without an explicit repository
// reference
}
}
}
public static void closeStatement(Statement statement) {
if(statement != null) {
try {
statement.close();
} catch(SQLException sqle) {
}
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/DBReceiver.java 0000664 0000000 0000000 00000010062 12527427642 0030453 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db;
import org.apache.log4j.component.plugins.Pauseable;
import org.apache.log4j.component.plugins.Receiver;
import org.apache.log4j.component.scheduler.Scheduler;
import org.apache.log4j.component.spi.LoggerRepositoryEx;
import org.apache.log4j.xml.DOMConfigurator;
import org.apache.log4j.xml.UnrecognizedElementHandler;
import org.w3c.dom.Element;
import java.util.Properties;
/**
*
* @author Scott Deboy
*
* @author Ray DeCampo
* @author Ceki Gülcü
*/
public class DataSourceConnectionSource extends ConnectionSourceSkeleton
implements UnrecognizedElementHandler {
private DataSource dataSource;
public void activateOptions() {
//LogLog.debug("**********DataSourceConnectionSource.activateOptions called");
if (dataSource == null) {
getLogger().warn("WARNING: No data source specified");
} else {
Connection connection = null;
try {
connection = getConnection();
} catch(SQLException se) {
getLogger().warn("Could not get a connection to discover the dialect to use.", se);
}
if(connection != null) {
discoverConnnectionProperties();
}
if(!supportsGetGeneratedKeys() && getSQLDialectCode() == ConnectionSource.UNKNOWN_DIALECT) {
getLogger().warn("Connection does not support GetGeneratedKey method and could not discover the dialect.");
}
}
}
/**
* @see org.apache.log4j.receivers.db.ConnectionSource#getConnection()
*/
public Connection getConnection() throws SQLException {
if (dataSource == null) {
getLogger().error("WARNING: No data source specified");
return null;
}
if (getUser() == null) {
return dataSource.getConnection();
} else {
return dataSource.getConnection(getUser(), getPassword());
}
}
public DataSource getDataSource() {
return dataSource;
}
public void setDataSource(DataSource dataSource) {
this.dataSource = dataSource;
}
/**
* {@inheritDoc}
*/
public boolean parseUnrecognizedElement(Element element, Properties props) throws Exception {
if ("dataSource".equals(element.getNodeName())) {
Object instance =
DOMConfigurator.parseElement(element, props, DataSource.class);
if (instance instanceof DataSource) {
setDataSource((DataSource) instance);
}
return true;
}
return false;
}
}
DriverManagerConnectionSource.java 0000664 0000000 0000000 00000011033 12527427642 0034350 0 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db /*
* 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 org.apache.log4j.receivers.db;
import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.SQLException;
/**
* The DriverManagerConnectionSource is an implementation of {@link ConnectionSource}
* that obtains the Connection in the traditional JDBC manner based on the
* connection URL.
*
* Note that this class will establish a new Connection for each call to
* {@link #getConnection()}. It is recommended that you either use a JDBC
* driver that natively supported Connection pooling or that you create
* your own implementation of {@link ConnectionSource} that taps into whatever
* pooling mechanism you are already using. (If you have access to a JNDI
* implementation that supports {@link javax.sql.DataSource}s, e.g. within
* a J2EE application server, see {@link JNDIConnectionSource}). See
* below for a configuration example that uses the
* commons-dbcp
* package from Apache.
*
* Sample configuration:
* If you do not have another connection pooling mechanism
* built into your application, you can use the
* commons-dbcp
* package from Apache:
* Sample configuration:
* Sample configuration (with username and password):
* Note that this class will obtain an {@link javax.naming.InitialContext}
* using the no-argument constructor. This will usually work when executing
* within a J2EE environment. When outside the J2EE environment, make sure
* that you provide a jndi.properties file as described by your JNDI
* provider's documentation.
*
* @author Ray DeCampo
*/
public class JNDIConnectionSource
extends ConnectionSourceSkeleton {
private String jndiLocation = null;
private DataSource dataSource = null;
/**
* @see org.apache.log4j.spi.OptionHandler#activateOptions()
*/
public void activateOptions() {
if (jndiLocation == null) {
getLogger().error("No JNDI location specified for JNDIConnectionSource.");
}
discoverConnnectionProperties();
}
/**
* @see org.apache.log4j.receivers.db.ConnectionSource#getConnection()
*/
public Connection getConnection()
throws SQLException {
Connection conn = null;
try {
if(dataSource == null) {
dataSource = lookupDataSource();
}
if (getUser() == null) {
conn = dataSource.getConnection();
} else {
conn = dataSource.getConnection(getUser(), getPassword());
}
} catch (final NamingException ne) {
getLogger().error("Error while getting data source", ne);
throw new SQLException("NamingException while looking up DataSource: " + ne.getMessage());
} catch (final ClassCastException cce) {
getLogger().error("ClassCastException while looking up DataSource.", cce);
throw new SQLException("ClassCastException while looking up DataSource: " + cce.getMessage());
}
return conn;
}
/**
* Returns the jndiLocation.
* @return String
*/
public String getJndiLocation() {
return jndiLocation;
}
/**
* Sets the jndiLocation.
* @param jndiLocation The jndiLocation to set
*/
public void setJndiLocation(String jndiLocation) {
this.jndiLocation = jndiLocation;
}
private DataSource lookupDataSource()
throws NamingException, SQLException {
DataSource ds;
Context ctx = new InitialContext();
Object obj = ctx.lookup(jndiLocation);
// PortableRemoteObject was introduced in JDK 1.3. We won't use it.
//ds = (DataSource)PortableRemoteObject.narrow(obj, DataSource.class);
ds = (DataSource) obj;
if (ds == null) {
throw new SQLException("Failed to obtain data source from JNDI location " + jndiLocation);
} else {
return ds;
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/ 0000775 0000000 0000000 00000000000 12527427642 0027244 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/HSQLDBDialect.java0000664 0000000 0000000 00000002177 12527427642 0032361 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db.dialect;
/**
* The HSQLDB dialect.
*
* @author Ceki Gülcü
*/
public class HSQLDBDialect implements SQLDialect {
public static final String SELECT_CURRVAL = "CALL IDENTITY()";
public String getSelectInsertId() {
return SELECT_CURRVAL;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/MsSQLDialect.java 0000664 0000000 0000000 00000002362 12527427642 0032337 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db.dialect;
/**
* The MS SQL Server dialect is untested.
*
* Note that the dialect is not needed if your JDBC driver supports
* the getGeneratedKeys method introduced in JDBC 3.0 specification.
*
* @author James Stauffer
*/
public class MsSQLDialect implements SQLDialect {
public static final String SELECT_CURRVAL = "SELECT @@identity id";
public String getSelectInsertId() {
return SELECT_CURRVAL;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/MySQLDialect.java 0000664 0000000 0000000 00000002114 12527427642 0032340 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db.dialect;
/**
*
*
* @author Ceki
*
*/
public class MySQLDialect implements SQLDialect {
public static final String SELECT_LAST_INSERT_ID = "SELECT LAST_INSERT_ID()";
public String getSelectInsertId() {
return SELECT_LAST_INSERT_ID;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/OracleDialect.java0000664 0000000 0000000 00000002275 12527427642 0032610 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db.dialect;
/**
* The Oracle dialect. Tested successfully on Oracle9i Release 9.2.0.3.0 by
* James Stauffer.
*
* @author Ceki Gülcü
*/
public class OracleDialect implements SQLDialect {
public static final String SELECT_CURRVAL = "SELECT logging_event_id_seq.currval from dual";
public String getSelectInsertId() {
return SELECT_CURRVAL;
}
}
PostgreSQLDialect.java 0000664 0000000 0000000 00000002321 12527427642 0033317 0 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect /*
* 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 org.apache.log4j.receivers.db.dialect;
/**
*
* @author ceki
*
* To change the template for this generated type comment go to
* Window>Preferences>Java>Code Generation>Code and Comments
*/
public class PostgreSQLDialect
implements SQLDialect {
public static final String SELECT_CURRVAL = "SELECT currval('logging_event_id_seq')";
public String getSelectInsertId() {
return SELECT_CURRVAL;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/SQLDialect.java 0000664 0000000 0000000 00000001673 12527427642 0032043 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db.dialect;
/**
* @author ceki
*
*/
public interface SQLDialect {
public String getSelectInsertId();
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/SybaseDialect.java0000664 0000000 0000000 00000002075 12527427642 0032627 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db.dialect;
/**
* The Sybase dialect.
*
*/
public class SybaseDialect implements SQLDialect {
public static final String SELECT_CURRVAL = "select @@identity";
public String getSelectInsertId() {
return SELECT_CURRVAL;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/Util.java 0000664 0000000 0000000 00000007542 12527427642 0031034 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db.dialect;
import org.apache.log4j.component.spi.ComponentBase;
import org.apache.log4j.receivers.db.ConnectionSource;
import java.sql.DatabaseMetaData;
import java.sql.SQLException;
/**
*
* @author Ceki Gulcu
*
*/
public class Util extends ComponentBase {
private static final String POSTGRES_PART = "postgresql";
private static final String MYSQL_PART = "mysql";
private static final String ORACLE_PART = "oracle";
//private static final String MSSQL_PART = "mssqlserver4";
private static final String MSSQL_PART = "microsoft";
private static final String HSQL_PART = "hsql";
public static int discoverSQLDialect(DatabaseMetaData meta) {
int dialectCode = 0;
try {
String dbName = meta.getDatabaseProductName().toLowerCase();
if (dbName.indexOf(POSTGRES_PART) != -1) {
return ConnectionSource.POSTGRES_DIALECT;
} else if (dbName.indexOf(MYSQL_PART) != -1) {
return ConnectionSource.MYSQL_DIALECT;
} else if (dbName.indexOf(ORACLE_PART) != -1) {
return ConnectionSource.ORACLE_DIALECT;
} else if (dbName.indexOf(MSSQL_PART) != -1) {
return ConnectionSource.MSSQL_DIALECT;
} else if (dbName.indexOf(HSQL_PART) != -1) {
return ConnectionSource.HSQL_DIALECT;
} else {
return ConnectionSource.UNKNOWN_DIALECT;
}
} catch (SQLException sqle) {
// we can't do much here
}
return dialectCode;
}
public static SQLDialect getDialectFromCode(int dialectCode) {
SQLDialect sqlDialect = null;
switch (dialectCode) {
case ConnectionSource.POSTGRES_DIALECT:
sqlDialect = new PostgreSQLDialect();
break;
case ConnectionSource.MYSQL_DIALECT:
sqlDialect = new MySQLDialect();
break;
case ConnectionSource.ORACLE_DIALECT:
sqlDialect = new OracleDialect();
break;
case ConnectionSource.MSSQL_DIALECT:
sqlDialect = new MsSQLDialect();
break;
case ConnectionSource.HSQL_DIALECT:
sqlDialect = new HSQLDBDialect();
break;
}
return sqlDialect;
}
/**
* This method handles cases where the
* {@link DatabaseMetaData#supportsGetGeneratedKeys} method is missing in the
* JDBC driver implementation.
*/
public boolean supportsGetGeneratedKeys(DatabaseMetaData meta) {
try {
//
// invoking JDK 1.4 method by reflection
//
return ((Boolean) DatabaseMetaData.class.getMethod("supportsGetGeneratedKeys", null).invoke(meta, null)).booleanValue();
} catch(Throwable e) {
getLogger().info("Could not call supportsGetGeneratedKeys method. This may be recoverable");
return false;
}
}
/**
* This method handles cases where the
* {@link DatabaseMetaData#supportsBatchUpdates} method is missing in the
* JDBC driver implementation.
*/
public boolean supportsBatchUpdates(DatabaseMetaData meta) {
try {
return meta.supportsBatchUpdates();
} catch(Throwable e) {
getLogger().info("Missing DatabaseMetaData.supportsBatchUpdates method.");
return false;
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/db2.sql 0000664 0000000 0000000 00000004527 12527427642 0030444 0 ustar 00root root 0000000 0000000 # 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.
#
# This SQL script creates the required tables by org.apache.log4j.db.DBAppender and
# org.apache.log4j.db.DBReceiver.
#
# It is intended for IBM DB2 databases.
#
# WARNING WARNING WARNING WARNING
# =================================
# This SQL script has not been tested on an actual DB2
# instance. It may contain errors or even invalid SQL
# statements.
DROP TABLE logging_event_property;
DROP TABLE logging_event_exception;
DROP TABLE logging_event;
CREATE TABLE logging_event
(
sequence_number BIGINT NOT NULL,
timestamp BIGINT NOT NULL,
rendered_message VARCHAR(4000) NOT NULL,
logger_name VARCHAR(254) NOT NULL,
level_string VARCHAR(254) NOT NULL,
ndc VARCHAR(4000),
thread_name VARCHAR(254),
reference_flag SMALLINT,
caller_filename VARCHAR(254) NOT NULL,
caller_class VARCHAR(254) NOT NULL,
caller_method VARCHAR(254) NOT NULL,
caller_line CHAR(4) NOT NULL,
event_id INTEGER GENERATED ALWAYS AS IDENTITY (START WITH 1)
);
CREATE TABLE logging_event_property
(
event_id INTEGER NOT NULL,
mapped_key VARCHAR(254) NOT NULL,
mapped_value VARCHAR(1024),
PRIMARY KEY(event_id, mapped_key),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
CREATE TABLE logging_event_exception
(
event_id INTEGER NOT NULL,
i SMALLINT NOT NULL,
trace_line VARCHAR(254) NOT NULL,
PRIMARY KEY(event_id, i),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/db2l.sql 0000664 0000000 0000000 00000004260 12527427642 0030612 0 ustar 00root root 0000000 0000000 # 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.
# This SQL script creates the required tables by org.apache.log4j.db.DBAppender and
# org.apache.log4j.db.DBReceiver.
#
# It is intended for PostgreSQL databases.
DROP TABLE logging_event_property;
DROP TABLE logging_event_exception;
DROP TABLE logging_event;
CREATE SEQUENCE logging_event_id_seq MINVALUE 1 START 1;
CREATE TABLE logging_event
(
sequence_number BIGINT NOT NULL,
timestamp BIGINT NOT NULL,
rendered_message TEXT NOT NULL,
logger_name VARCHAR(254) NOT NULL,
level_string VARCHAR(254) NOT NULL,
ndc TEXT,
thread_name VARCHAR(254),
reference_flag SMALLINT,
caller_filename VARCHAR(254) NOT NULL,
caller_class VARCHAR(254) NOT NULL,
caller_method VARCHAR(254) NOT NULL,
caller_line CHAR(4) NOT NULL,
event_id INT IDENTITY GENERATED ALWAYS PRIMARY KEY
);
CREATE TABLE logging_event_property
(
event_id INT NOT NULL,
mapped_key VARCHAR(254) NOT NULL,
mapped_value VARCHAR(1024),
PRIMARY KEY(event_id, mapped_key),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
CREATE TABLE logging_event_exception
(
event_id INT NOT NULL,
i SMALLINT NOT NULL,
trace_line VARCHAR(254) NOT NULL,
PRIMARY KEY(event_id, i),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/hsqldb.sql 0000664 0000000 0000000 00000004107 12527427642 0031244 0 ustar 00root root 0000000 0000000 // 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.
// This SQL script creates the required tables by
// org.apache.log4j.db.DBAppender and org.apache.log4j.db.DBReceiver.
//
// It is intended for HSQLDB.
//
DROP TABLE logging_event_exception IF EXISTS;
DROP TABLE logging_event_property IF EXISTS;
DROP TABLE logging_event IF EXISTS;
CREATE TABLE logging_event
(
sequence_number BIGINT NOT NULL,
timestamp BIGINT NOT NULL,
rendered_message LONGVARCHAR NOT NULL,
logger_name VARCHAR NOT NULL,
level_string VARCHAR NOT NULL,
ndc LONGVARCHAR,
thread_name VARCHAR,
reference_flag SMALLINT,
caller_filename VARCHAR,
caller_class VARCHAR,
caller_method VARCHAR,
caller_line CHAR(4),
event_id INT NOT NULL IDENTITY
);
CREATE TABLE logging_event_property
(
event_id INT NOT NULL,
mapped_key VARCHAR(254) NOT NULL,
mapped_value LONGVARCHAR,
PRIMARY KEY(event_id, mapped_key),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
CREATE TABLE logging_event_exception
(
event_id INT NOT NULL,
i SMALLINT NOT NULL,
trace_line VARCHAR NOT NULL,
PRIMARY KEY(event_id, i),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/mssql.sql 0000664 0000000 0000000 00000004361 12527427642 0031130 0 ustar 00root root 0000000 0000000 -- 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.
--
--
-- This SQL script creates the required tables by org.apache.log4j.db.DBAppender and
-- org.apache.log4j.db.DBReceiver.
--
-- It is intended for MS SQL Server databases. This has been tested with version 7.0.
DROP TABLE logging_event_property
DROP TABLE logging_event_exception
DROP TABLE logging_event
CREATE TABLE logging_event
(
sequence_number DECIMAL(20) NOT NULL,
timestamp DECIMAL(20) NOT NULL,
rendered_message VARCHAR(4000) NOT NULL,
logger_name VARCHAR(254) NOT NULL,
level_string VARCHAR(254) NOT NULL,
ndc VARCHAR(4000),
thread_name VARCHAR(254),
reference_flag SMALLINT,
caller_filename VARCHAR(254) NOT NULL,
caller_class VARCHAR(254) NOT NULL,
caller_method VARCHAR(254) NOT NULL,
caller_line CHAR(4) NOT NULL,
event_id INT NOT NULL identity,
PRIMARY KEY(event_id)
)
CREATE TABLE logging_event_property
(
event_id INT NOT NULL,
mapped_key VARCHAR(254) NOT NULL,
mapped_value VARCHAR(1024),
PRIMARY KEY(event_id, mapped_key),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
)
CREATE TABLE logging_event_exception
(
event_id INT NOT NULL,
i SMALLINT NOT NULL,
trace_line VARCHAR(254) NOT NULL,
PRIMARY KEY(event_id, i),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
)
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/mysql.sql 0000664 0000000 0000000 00000004364 12527427642 0031141 0 ustar 00root root 0000000 0000000 # 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.
#
#
#
# This SQL script creates the required tables by org.apache.log4j.db.DBAppender and
# org.apache.log4j.db.DBReceiver.
#
# It is intended for MySQL databases. It has been tested on MySQL 4.1.1 with
# INNODB tables.
BEGIN;
DROP TABLE IF EXISTS logging_event_property;
DROP TABLE IF EXISTS logging_event_exception;
DROP TABLE IF EXISTS logging_event;
COMMIT;
BEGIN;
CREATE TABLE logging_event
(
sequence_number BIGINT NOT NULL,
timestamp BIGINT NOT NULL,
rendered_message TEXT NOT NULL,
logger_name VARCHAR(254) NOT NULL,
level_string VARCHAR(254) NOT NULL,
ndc TEXT,
thread_name VARCHAR(254),
reference_flag SMALLINT,
caller_filename VARCHAR(254) NOT NULL,
caller_class VARCHAR(254) NOT NULL,
caller_method VARCHAR(254) NOT NULL,
caller_line CHAR(4) NOT NULL,
event_id INT NOT NULL AUTO_INCREMENT PRIMARY KEY
);
COMMIT;
BEGIN;
CREATE TABLE logging_event_property
(
event_id INT NOT NULL,
mapped_key VARCHAR(254) NOT NULL,
mapped_value TEXT,
PRIMARY KEY(event_id, mapped_key),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
COMMIT;
BEGIN;
CREATE TABLE logging_event_exception
(
event_id INT NOT NULL,
i SMALLINT NOT NULL,
trace_line VARCHAR(254) NOT NULL,
PRIMARY KEY(event_id, i),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
COMMIT;
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/oracle.sql 0000664 0000000 0000000 00000005301 12527427642 0031231 0 ustar 00root root 0000000 0000000 -- 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.
--
--
-- This SQL script creates the required tables by org.apache.log4j.db.DBAppender and
-- org.apache.log4j.db.DBReceiver.
--
-- It is intended for Oracle databases.
-- Tested successfully on Oracle9i Release 9.2.0.3.0 by James Stauffer
-- Tested successfully on Oracle9i Release by Elias Ross
-- The following lines are useful in cleaning any previous tables
--drop TRIGGER logging_event_id_seq_trig;
--drop SEQUENCE logging_event_id_seq;
--drop table logging_event_property;
--drop table logging_event_exception;
--drop table logging_event;
CREATE SEQUENCE logging_event_id_seq MINVALUE 1 START WITH 1;
CREATE TABLE logging_event
(
sequence_number NUMBER(20) NOT NULL,
timestamp NUMBER(20) NOT NULL,
rendered_message VARCHAR2(4000) NOT NULL,
logger_name VARCHAR2(254) NOT NULL,
level_string VARCHAR2(254) NOT NULL,
ndc VARCHAR2(4000),
thread_name VARCHAR2(254),
reference_flag NUMBER(5),
caller_filename VARCHAR2(254) NOT NULL,
caller_class VARCHAR2(254) NOT NULL,
caller_method VARCHAR2(254) NOT NULL,
caller_line CHAR(4) NOT NULL,
event_id NUMBER(10) PRIMARY KEY
);
CREATE OR REPLACE TRIGGER logging_event_id_seq_trig
BEFORE INSERT ON logging_event
FOR EACH ROW
BEGIN
SELECT logging_event_id_seq.nextval
INTO :new.sequence_number FROM dual;
END;
CREATE TABLE logging_event_property
(
event_id NUMBER(10) NOT NULL,
mapped_key VARCHAR2(254) NOT NULL,
mapped_value VARCHAR2(1024),
PRIMARY KEY(event_id, mapped_key),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
CREATE TABLE logging_event_exception
(
event_id NUMBER(10) NOT NULL,
i NUMBER(5) NOT NULL,
trace_line VARCHAR2(254) NOT NULL,
PRIMARY KEY(event_id, i),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/dialect/postgresql.sql 0000664 0000000 0000000 00000004345 12527427642 0032176 0 ustar 00root root 0000000 0000000 # 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.
#
## This SQL script creates the required tables by org.apache.log4j.db.DBAppender and
# org.apache.log4j.db.DBReceiver.
#
# It is intended for PostgreSQL databases.
DROP TABLE logging_event_property;
DROP TABLE logging_event_exception;
DROP SEQUENCE logging_event_id_seq;
DROP TABLE logging_event;
CREATE SEQUENCE logging_event_id_seq MINVALUE 1 START 1;
CREATE TABLE logging_event
(
sequence_number BIGINT NOT NULL,
timestamp BIGINT NOT NULL,
rendered_message TEXT NOT NULL,
logger_name VARCHAR(254) NOT NULL,
level_string VARCHAR(254) NOT NULL,
ndc TEXT,
thread_name VARCHAR(254),
reference_flag SMALLINT,
caller_filename VARCHAR(254) NOT NULL,
caller_class VARCHAR(254) NOT NULL,
caller_method VARCHAR(254) NOT NULL,
caller_line CHAR(4) NOT NULL,
event_id INT DEFAULT nextval('logging_event_id_seq') PRIMARY KEY
);
CREATE TABLE logging_event_property
(
event_id INT NOT NULL,
mapped_key VARCHAR(254) NOT NULL,
mapped_value VARCHAR(1024),
PRIMARY KEY(event_id, mapped_key),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
CREATE TABLE logging_event_exception
(
event_id INT NOT NULL,
i SMALLINT NOT NULL,
trace_line VARCHAR(254) NOT NULL,
PRIMARY KEY(event_id, i),
FOREIGN KEY (event_id) REFERENCES logging_event(event_id)
);
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/package.html 0000664 0000000 0000000 00000002565 12527427642 0030130 0 ustar 00root root 0000000 0000000
The org.apache.log4j.db package provides means to append logging events
into various databases. The persisted data can be later read back using
{@link org.apache.log4j.receivers.db.DBReceiver}.
Most popular database systems, such as PostgreSQL, MySQL, Oracle, DB2 and MsSQL
are supported.
Just as importantly, the way for obtaining JDBC connections is pluggable. Connections can
be obtained through the traditional way of DriverManager, or alternatively as a DataSource.
A DataSource can be instantiated directly or it can obtained through JNDI.
Once the event has been "posted", it will be handled by the
appenders currently configured in the LoggerRespository.
This implementation borrows heavily from the JMSSink
implementation.
@author Mark Womack
@author Paul Smith
@author Stephen Pain
*/
public class JMSReceiver extends Receiver implements MessageListener {
private boolean active = false;
protected String topicFactoryName;
protected String topicName;
protected String userId;
protected String password;
protected TopicConnection topicConnection;
protected String jndiPath;
private String remoteInfo;
private String providerUrl;
public JMSReceiver() { }
public JMSReceiver(String _topicFactoryName, String _topicName,
String _userId, String _password, String _jndiPath) {
topicFactoryName = _topicFactoryName;
topicName = _topicName;
userId = _userId;
password = _password;
jndiPath = _jndiPath;
}
/**
* Sets the path to a properties file containing
* the initial context and jndi provider url
*/
public void setJndiPath(String _jndiPath) {
jndiPath = _jndiPath;
}
/**
* Gets the path to a properties file containing
* the initial context and jndi provider url
*/
public String getJndiPath() {
return jndiPath;
}
/**
Sets the JMS topic factory name to use when creating the
JMS connection. */
public void setTopicFactoryName(String _topicFactoryName) {
topicFactoryName = _topicFactoryName;
}
/**
Gets the curernt JMS topic factory name property. */
public String getTopicFactoryName() {
return topicFactoryName;
}
/**
* Sets the JMS topic name to use when creating the
* JMS connection.
*/
public void setTopicName(String _topicName) {
topicName = _topicName;
}
/**
* Gets the curernt JMS topic name property.
*/
public String getTopicName() {
return topicName;
}
/**
Sets the user id to use when creating the
JMS connection. */
public void setUserId(String _userId) {
userId = _userId;
}
/**
* Gets the current user id property.
*/
public String getUserId() {
return userId;
}
/**
* Sets the password to use when creating the
* JMS connection.
*/
public void setPassword(String _password) {
password = _password;
}
/**
* Gets the curernt password property.
*/
public String getPassword() {
return password;
}
/**
* Returns true if the receiver is the same class and they are
* configured for the same properties, and super class also considers
* them to be equivalent. This is used by PluginRegistry when determining
* if the a similarly configured receiver is being started.
*
* @param testPlugin The plugin to test equivalency against.
* @return boolean True if the testPlugin is equivalent to this plugin.
*/
public boolean isEquivalent(Plugin testPlugin) {
// only do full check if an instance of this class
if (testPlugin instanceof JMSReceiver) {
JMSReceiver receiver = (JMSReceiver)testPlugin;
// check for same topic name and super class equivalency
return (
topicFactoryName.equals(receiver.getTopicFactoryName()) &&
(jndiPath == null || jndiPath.equals(receiver.getJndiPath())) &&
super.isEquivalent(testPlugin)
);
}
return false;
}
/**
Returns true if this receiver is active. */
public synchronized boolean isActive() {
return active;
}
/**
Sets the flag to indicate if receiver is active or not. */
protected synchronized void setActive(boolean _active) {
active = _active;
}
/**
Starts the JMSReceiver with the current options. */
public void activateOptions() {
if (!isActive()) {
try {
remoteInfo = topicFactoryName + ":" + topicName;
Context ctx = null;
if (jndiPath == null || jndiPath.equals("")) {
ctx = new InitialContext();
} else {
FileInputStream is = new FileInputStream(jndiPath);
Properties p = new Properties();
p.load(is);
is.close();
ctx = new InitialContext(p);
}
// give some more flexibility about the choice of a tab name
providerUrl = (String)ctx.getEnvironment().get(Context.PROVIDER_URL);
TopicConnectionFactory topicConnectionFactory;
topicConnectionFactory =
(TopicConnectionFactory) lookup(ctx, topicFactoryName);
if (userId != null && password != null) {
topicConnection =
topicConnectionFactory.createTopicConnection(userId, password);
} else {
topicConnection =
topicConnectionFactory.createTopicConnection();
}
TopicSession topicSession =
topicConnection.createTopicSession(false, Session.AUTO_ACKNOWLEDGE);
Topic topic = (Topic)ctx.lookup(topicName);
TopicSubscriber topicSubscriber = topicSession.createSubscriber(topic);
topicSubscriber.setMessageListener(this);
topicConnection.start();
setActive(true);
} catch(Exception e) {
setActive(false);
if (topicConnection != null) {
try {
topicConnection.close();
} catch (Exception e2) {
// do nothing
}
topicConnection = null;
}
getLogger().error("Could not start JMSReceiver.", e);
}
}
}
/**
Called when the receiver should be stopped. */
public synchronized void shutdown() {
if (isActive()) {
// mark this as no longer running
setActive(false);
if (topicConnection != null) {
try {
topicConnection.close();
} catch (Exception e) {
// do nothing
}
topicConnection = null;
}
}
}
public void onMessage(Message message) {
try {
if(message instanceof ObjectMessage) {
// get the logging event and post it to the repository
ObjectMessage objectMessage = (ObjectMessage) message;
LoggingEvent event = (LoggingEvent) objectMessage.getObject();
// store the known remote info in an event property
event.setProperty("log4j.remoteSourceInfo", remoteInfo);
event.setProperty("log4j.jmsProviderUrl", providerUrl);
doPost(event);
} else {
getLogger().warn("Received message is of type "+message.getJMSType()
+", was expecting ObjectMessage.");
}
} catch(Exception e) {
getLogger().error("Exception thrown while processing incoming message.", e);
}
}
protected Object lookup(Context ctx, String name) throws NamingException {
try {
return ctx.lookup(name);
} catch(NameNotFoundException e) {
getLogger().error("Could not find name ["+name+"].");
throw e;
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/net/JMSReceiverBeanInfo.java 0000664 0000000 0000000 00000003436 12527427642 0032431 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.net;
import java.beans.PropertyDescriptor;
import java.beans.SimpleBeanInfo;
/**
* BeanInfo class for the JMSReceiver.
*
* @author Paul Smith Messages are not sent as LoggingEvent objects but as text after
* applying XMLLayout.
*
* The port and remoteHost properties can be set in configuration properties.
* By setting the remoteHost to a broadcast address any number of clients can
* listen for log messages.
*
* This was inspired and really extended/copied from {@link org.apache.log4j.net.SocketAppender}. Please
* see the docs for the proper credit to the authors of that class.
*
* @author Kevin Brown
* @author Scott Deboy This will mark the appender as closed and
call then {@link #cleanUp} method.
*/
public synchronized void close() {
if (closed) {
return;
}
this.closed = true;
if (advertiseViaMulticastDNS) {
zeroConf.unadvertise();
}
cleanUp();
}
/**
Close the Socket and release the underlying
connector thread if it has been created
*/
public void cleanUp() {
if (outSocket != null) {
try {
outSocket.close();
} catch (Exception e) {
LogLog.error("Could not close outSocket.", e);
}
outSocket = null;
}
}
void connect() {
if (this.address == null) {
return;
}
try {
// First, close the previous connection if any.
cleanUp();
outSocket = new MulticastSocket();
outSocket.setTimeToLive(timeToLive);
} catch (IOException e) {
LogLog.error("Error in connect method of MulticastAppender named "+name, e);
}
}
public void append(LoggingEvent event) {
if (event == null) {
return;
}
if(locationInfo) {
event.getLocationInformation();
}
if (outSocket != null) {
event.setProperty(Constants.HOSTNAME_KEY, hostname);
if (application != null) {
event.setProperty(Constants.APPLICATION_KEY, application);
}
if(locationInfo) {
event.getLocationInformation();
}
try {
StringBuffer buf = new StringBuffer(layout.format(event));
byte[] payload;
if(encoding == null) {
payload = buf.toString().getBytes();
} else {
payload = buf.toString().getBytes(encoding);
}
DatagramPacket dp =
new DatagramPacket(payload, payload.length, address, port);
outSocket.send(dp);
} catch (IOException e) {
outSocket = null;
LogLog.warn("Detected problem with Multicast connection: " + e);
}
}
}
InetAddress getAddressByName(String host) {
try {
return InetAddress.getByName(host);
} catch (Exception e) {
LogLog.error("Could not find address of [" + host + "].", e);
return null;
}
}
/**
The RemoteHost option takes a string value which should be
the host name or ipaddress to send the multicast packets.
*/
public void setRemoteHost(String host) {
remoteHost = host;
}
/**
Returns value of the RemoteHost option.
*/
public String getRemoteHost() {
return remoteHost;
}
/**
The LocationInfo option takes a boolean value. If true,
the information sent to the remote host will include location
information. By default no location information is sent to the server.
*/
public void setLocationInfo(boolean locationInfo) {
this.locationInfo = locationInfo;
}
/**
* Returns value of the LocationInfo option.
*/
public boolean getLocationInfo() {
return locationInfo;
}
/**
The Encoding option specifies how the bytes are encoded. If this option is not specified,
the System encoding is used.
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
Returns value of the Encoding option.
*/
public String getEncoding() {
return encoding;
}
/**
The App option takes a string value which should be the name of the application getting logged.
If property was already set (via system property), don't set here.
*/
public void setApplication(String app) {
this.application = app;
}
/**
Returns value of the App option.
*/
public String getApplication() {
return application;
}
/**
The Time to live option takes a positive integer representing
the time to live value.
*/
public void setTimeToLive(int timeToLive) {
this.timeToLive = timeToLive;
}
/**
Returns value of the Time to Live option.
*/
public int getTimeToLive() {
return timeToLive;
}
/**
The Port option takes a positive integer representing
the port where multicast packets will be sent.
*/
public void setPort(int port) {
this.port = port;
}
/**
Returns value of the Port option.
*/
public int getPort() {
return port;
}
/* (non-Javadoc)
* @see org.apache.log4j.net.NetworkBased#isActive()
*/
public boolean isActive() {
// TODO handle active/inactive
return true;
}
/**
* Gets whether appender requires a layout.
* @return false
*/
public boolean requiresLayout() {
return true;
}
public boolean isAdvertiseViaMulticastDNS() {
return advertiseViaMulticastDNS;
}
public void setAdvertiseViaMulticastDNS(boolean advertiseViaMulticastDNS) {
this.advertiseViaMulticastDNS = advertiseViaMulticastDNS;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/net/MulticastReceiver.java 0000664 0000000 0000000 00000015736 12527427642 0032351 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.net;
import org.apache.log4j.component.plugins.Pauseable;
import org.apache.log4j.component.plugins.Receiver;
import org.apache.log4j.net.ZeroConfSupport;
import org.apache.log4j.receivers.spi.Decoder;
import org.apache.log4j.spi.LoggingEvent;
import java.io.IOException;
import java.net.*;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Multicast-based receiver. Accepts LoggingEvents encoded using
* MulticastAppender and XMLLayout. The the XML data is converted
* back to a LoggingEvent and is posted.
*
* @author Scott Deboy Once the event has been "posted", it will be handled by the
appenders currently configured in the LoggerRespository.
@author Mark Womack
@author Ceki Gülcü
@author Paul Smith (psmith@apache.org)
*/
public class SocketHubReceiver
extends Receiver implements SocketNodeEventListener, PortBased {
/**
* Default reconnection delay.
*/
static final int DEFAULT_RECONNECTION_DELAY = 30000;
/**
* Host.
*/
protected String host;
/**
* Port.
*/
protected int port;
/**
* Reconnection delay.
*/
protected int reconnectionDelay = DEFAULT_RECONNECTION_DELAY;
/**
* The MulticastDNS zone advertised by a SocketHubReceiver
*/
public static final String ZONE = "_log4j_obj_tcpconnect_receiver.local.";
/**
* Active.
*/
protected boolean active = false;
/**
* Connector.
*/
protected Connector connector;
/**
* Socket.
*/
protected SocketNode13 socketNode;
/**
* Listener list.
*/
private List listenerList = Collections.synchronizedList(new ArrayList());
private boolean advertiseViaMulticastDNS;
private ZeroConfSupport zeroConf;
/**
* Create new instance.
*/
public SocketHubReceiver() {
super();
}
/**
* Create new instance.
* @param h host
* @param p port
*/
public SocketHubReceiver(final String h,
final int p) {
super();
host = h;
port = p;
}
/**
* Create new instance.
* @param h host
* @param p port
* @param repo logger repository
*/
public SocketHubReceiver(final String h,
final int p,
final LoggerRepository repo) {
super();
host = h;
port = p;
repository = repo;
}
/**
* Adds a SocketNodeEventListener to this receiver to be notified
* of SocketNode events.
* @param l listener
*/
public void addSocketNodeEventListener(final SocketNodeEventListener l) {
listenerList.add(l);
}
/**
* Removes a specific SocketNodeEventListener from this instance
* so that it will no longer be notified of SocketNode events.
* @param l listener
*/
public void removeSocketNodeEventListener(
final SocketNodeEventListener l) {
listenerList.remove(l);
}
/**
Get the remote host to connect to for logging events.
@return host
*/
public String getHost() {
return host;
}
/**
* Configures the Host property, this will require activateOptions
* to be called for this to take effect.
* @param remoteHost address of remote host.
*/
public void setHost(final String remoteHost) {
this.host = remoteHost;
}
/**
Set the remote host to connect to for logging events.
Equivalent to setHost.
@param remoteHost address of remote host.
*/
public void setPort(final String remoteHost) {
host = remoteHost;
}
/**
Get the remote port to connect to for logging events.
@return port
*/
public int getPort() {
return port;
}
/**
Set the remote port to connect to for logging events.
@param p port
*/
public void setPort(final int p) {
this.port = p;
}
/**
The ReconnectionDelay option takes a positive integer
representing the number of milliseconds to wait between each
failed connection attempt to the server. The default value of
this option is 30000 which corresponds to 30 seconds.
Setting this option to zero turns off reconnection
capability.
@param delay milliseconds to wait or zero to not reconnect.
*/
public void setReconnectionDelay(final int delay) {
int oldValue = this.reconnectionDelay;
this.reconnectionDelay = delay;
firePropertyChange("reconnectionDelay", oldValue, this.reconnectionDelay);
}
/**
Returns value of the ReconnectionDelay option.
@return value of reconnection delay option.
*/
public int getReconnectionDelay() {
return reconnectionDelay;
}
/**
* Returns true if the receiver is the same class and they are
* configured for the same properties, and super class also considers
* them to be equivalent. This is used by PluginRegistry when determining
* if the a similarly configured receiver is being started.
*
* @param testPlugin The plugin to test equivalency against.
* @return boolean True if the testPlugin is equivalent to this plugin.
*/
public boolean isEquivalent(final Plugin testPlugin) {
if (testPlugin != null && testPlugin instanceof SocketHubReceiver) {
SocketHubReceiver sReceiver = (SocketHubReceiver) testPlugin;
return (port == sReceiver.getPort()
&& host.equals(sReceiver.getHost())
&& reconnectionDelay == sReceiver.getReconnectionDelay()
&& super.isEquivalent(testPlugin));
}
return false;
}
/**
Sets the flag to indicate if receiver is active or not.
@param b new value
*/
protected synchronized void setActive(final boolean b) {
active = b;
}
/**
Starts the SocketReceiver with the current options. */
public void activateOptions() {
if (!isActive()) {
setActive(true);
if (advertiseViaMulticastDNS) {
zeroConf = new ZeroConfSupport(ZONE, port, getName());
zeroConf.advertise();
}
fireConnector(false);
}
}
/**
Called when the receiver should be stopped. Closes the socket */
public synchronized void shutdown() {
// mark this as no longer running
active = false;
// close the socket
try {
if (socketNode != null) {
socketNode.close();
socketNode = null;
}
} catch (Exception e) {
getLogger().info("Excpetion closing socket", e);
// ignore for now
}
// stop the connector
if (connector != null) {
connector.interrupted = true;
connector = null; // allow gc
}
if (advertiseViaMulticastDNS) {
zeroConf.unadvertise();
}
}
/**
Listen for a socketClosedEvent from the SocketNode. Reopen the
socket if this receiver is still active.
@param e exception not used.
*/
public void socketClosedEvent(final Exception e) {
// if it is a non-normal closed event
// we clear the connector object here
// so that it actually does reconnect if the
// remote socket dies.
if (e != null) {
connector = null;
fireConnector(true);
}
}
/**
* Fire connectors.
* @param isReconnect true if reconnect.
*/
private synchronized void fireConnector(final boolean isReconnect) {
if (active && connector == null) {
getLogger().debug("Starting a new connector thread.");
connector = new Connector(isReconnect);
connector.setDaemon(true);
connector.setPriority(Thread.MIN_PRIORITY);
connector.start();
}
}
/**
* Set socket.
* @param newSocket new value for socket.
*/
private synchronized void setSocket(final Socket newSocket) {
connector = null;
socketNode = new SocketNode13(newSocket, this);
socketNode.addSocketNodeEventListener(this);
synchronized (listenerList) {
for (Iterator iter = listenerList.iterator(); iter.hasNext();) {
SocketNodeEventListener listener =
(SocketNodeEventListener) iter.next();
socketNode.addSocketNodeEventListener(listener);
}
}
new Thread(socketNode).start();
}
public void setAdvertiseViaMulticastDNS(boolean advertiseViaMulticastDNS) {
this.advertiseViaMulticastDNS = advertiseViaMulticastDNS;
}
public boolean isAdvertiseViaMulticastDNS() {
return advertiseViaMulticastDNS;
}
/**
The Connector will reconnect when the server becomes available
again. It does this by attempting to open a new connection every
It stops trying whenever a connection is established. It will
restart to try reconnect to the server when previpously open
connection is droppped.
@author Ceki Gülcü
*/
private final class Connector extends Thread {
/**
* Interruption status.
*/
boolean interrupted = false;
/**
* If true, then delay on next iteration.
*/
boolean doDelay;
/**
* Create new instance.
* @param isReconnect true if reconnecting.
*/
public Connector(final boolean isReconnect) {
super();
doDelay = isReconnect;
}
/**
* Attempt to connect until interrupted.
*/
public void run() {
while (!interrupted) {
try {
if (doDelay) {
getLogger().debug("waiting for " + reconnectionDelay
+ " milliseconds before reconnecting.");
sleep(reconnectionDelay);
}
doDelay = true;
getLogger().debug("Attempting connection to " + host);
Socket s = new Socket(host, port);
setSocket(s);
getLogger().debug(
"Connection established. Exiting connector thread.");
break;
} catch (InterruptedException e) {
getLogger().debug("Connector interrupted. Leaving loop.");
return;
} catch (java.net.ConnectException e) {
getLogger().debug("Remote host {} refused connection.", host);
} catch (IOException e) {
getLogger().debug("Could not connect to {}. Exception is {}.",
host, e);
}
}
}
}
/**
* This method does nothing.
* @param remoteInfo remote info.
*/
public void socketOpened(final String remoteInfo) {
// This method does nothing.
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/net/SocketNode13.java 0000664 0000000 0000000 00000021055 12527427642 0031110 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.net;
import org.apache.log4j.Logger;
import org.apache.log4j.component.helpers.Constants;
import org.apache.log4j.component.plugins.Pauseable;
import org.apache.log4j.component.plugins.Receiver;
import org.apache.log4j.component.spi.ComponentBase;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.log4j.spi.LoggingEvent;
import java.io.BufferedInputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.net.Socket;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
// Contributors: Moses Hohman For example, the socket node might decide to log events to a
local file and also resent them to a second socket node.
Implementation lifted from org.apache.log4j.net.SocketNode
in log4j 1.3 and renamed to prevent collision with
log4j 1.2 implementation.
@author Ceki Gülcü
@author Paul Smith (psmith@apache.org)
*/
public class SocketNode13 extends ComponentBase implements Runnable, Pauseable {
/**
* Paused state.
*/
private boolean paused;
/**
* Closed state.
*/
private boolean closed;
/**
* Socket.
*/
private Socket socket;
/**
* Receiver.
*/
private Receiver receiver;
/**
* List of listeners.
*/
private List listenerList = Collections.synchronizedList(new ArrayList());
/**
Constructor for socket and logger repository.
@param s socket
@param hierarchy logger repository
*/
public SocketNode13(final Socket s,
final LoggerRepository hierarchy) {
super();
this.socket = s;
this.repository = hierarchy;
}
/**
Constructor for socket and receiver.
@param s socket
@param r receiver
*/
public SocketNode13(final Socket s, final Receiver r) {
super();
this.socket = s;
this.receiver = r;
}
/**
* Set the event listener on this node.
*
* @deprecated Now supports mutliple listeners, this method
* simply invokes the removeSocketNodeEventListener() to remove
* the listener, and then readds it.
* @param l listener
*/
public void setListener(final SocketNodeEventListener l) {
removeSocketNodeEventListener(l);
addSocketNodeEventListener(l);
}
/**
* Adds the listener to the list of listeners to be notified of the
* respective event.
* @param listener the listener to add to the list
*/
public void addSocketNodeEventListener(
final SocketNodeEventListener listener) {
listenerList.add(listener);
}
/**
* Removes the registered Listener from this instances list of
* listeners. If the listener has not been registered, then invoking
* this method has no effect.
*
* @param listener the SocketNodeEventListener to remove
*/
public void removeSocketNodeEventListener(
final SocketNodeEventListener listener) {
listenerList.remove(listener);
}
/**
* Deserialize events from socket until interrupted.
*/
public void run() {
LoggingEvent event;
Logger remoteLogger;
Exception listenerException = null;
ObjectInputStream ois = null;
try {
ois =
new ObjectInputStream(
new BufferedInputStream(socket.getInputStream()));
} catch (Exception e) {
ois = null;
listenerException = e;
getLogger().error("Exception opening ObjectInputStream to " + socket, e);
}
if (ois != null) {
String hostName = socket.getInetAddress().getHostName();
String remoteInfo = hostName + ":" + socket.getPort();
/**
* notify the listener that the socket has been
* opened and this SocketNode is ready and waiting
*/
fireSocketOpened(remoteInfo);
try {
while (!isClosed()) {
// read an event from the wire
event = (LoggingEvent) ois.readObject();
event.setProperty(Constants.HOSTNAME_KEY, hostName);
// store the known remote info in an event property
event.setProperty("log4j.remoteSourceInfo", remoteInfo);
// if configured with a receiver, tell it to post the event
if (!isPaused() && !isClosed()) {
if ((receiver != null)) {
receiver.doPost(event);
// else post it via the hierarchy
} else {
// get a logger from the hierarchy. The name of the logger
// is taken to be the name contained in the event.
remoteLogger = repository.getLogger(event.getLoggerName());
//event.logger = remoteLogger;
// apply the logger-level filter
if (event
.getLevel()
.isGreaterOrEqual(remoteLogger.getEffectiveLevel())) {
// finally log the event as if was generated locally
remoteLogger.callAppenders(event);
}
}
} else {
//we simply discard this event.
}
}
} catch (java.io.EOFException e) {
getLogger().info("Caught java.io.EOFException closing connection.");
listenerException = e;
} catch (java.net.SocketException e) {
getLogger().info("Caught java.net.SocketException closing connection.");
listenerException = e;
} catch (IOException e) {
getLogger().info("Caught java.io.IOException: " + e);
getLogger().info("Closing connection.");
listenerException = e;
} catch (Exception e) {
getLogger().error("Unexpected exception. Closing connection.", e);
listenerException = e;
}
}
// close the socket
try {
if (ois != null) {
ois.close();
}
} catch (Exception e) {
//getLogger().info("Could not close connection.", e);
}
// send event to listener, if configured
if (listenerList.size() > 0 && !isClosed()) {
fireSocketClosedEvent(listenerException);
}
}
/**
* Notifies all registered listeners regarding the closing of the Socket.
* @param listenerException listener exception
*/
private void fireSocketClosedEvent(final Exception listenerException) {
synchronized (listenerList) {
for (Iterator iter = listenerList.iterator(); iter.hasNext();) {
SocketNodeEventListener snel =
(SocketNodeEventListener) iter.next();
if (snel != null) {
snel.socketClosedEvent(listenerException);
}
}
}
}
/**
* Notifies all registered listeners regarding the opening of a Socket.
* @param remoteInfo remote info
*/
private void fireSocketOpened(final String remoteInfo) {
synchronized (listenerList) {
for (Iterator iter = listenerList.iterator(); iter.hasNext();) {
SocketNodeEventListener snel =
(SocketNodeEventListener) iter.next();
if (snel != null) {
snel.socketOpened(remoteInfo);
}
}
}
}
/**
* Sets if node is paused.
* @param b new value
*/
public void setPaused(final boolean b) {
this.paused = b;
}
/**
* Get if node is paused.
* @return true if pause.
*/
public boolean isPaused() {
return this.paused;
}
/**
* Close the node and underlying socket
*/
public void close() throws IOException {
getLogger().debug("closing socket");
this.closed = true;
socket.close();
fireSocketClosedEvent(null);
}
/**
* Get if node is closed.
* @return true if closed.
*/
public boolean isClosed() {
return this.closed;
}
}
SocketNodeEventListener.java 0000664 0000000 0000000 00000002750 12527427642 0033376 0 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/net /*
* 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 org.apache.log4j.receivers.net;
import java.util.EventListener;
/**
Interface used to listen for {@link org.apache.log4j.net.SocketNode} related
events. Clients register an instance of the interface and the
instance is called back when the various events occur.
@author Mark Womack
@author Paul Smith (psmith@apache.org)
*/
public interface SocketNodeEventListener extends EventListener {
/**
* Called when the SocketNode is created and begins awaiting data.
* @param remoteInfo remote info
*/
void socketOpened(String remoteInfo);
/**
Called when the socket the node was given has been closed.
@param e exception
*/
void socketClosedEvent(Exception e);
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/net/SocketReceiver.java 0000664 0000000 0000000 00000027701 12527427642 0031627 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.net;
import org.apache.log4j.component.plugins.Pauseable;
import org.apache.log4j.component.plugins.Plugin;
import org.apache.log4j.component.plugins.Receiver;
import org.apache.log4j.net.ZeroConfSupport;
import org.apache.log4j.spi.LoggerRepository;
import org.apache.log4j.spi.LoggingEvent;
import java.io.IOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.*;
/**
SocketReceiver receives a remote logging event on a configured
socket and "posts" it to a LoggerRepository as if the event was
generated locally. This class is designed to receive events from
the SocketAppender class (or classes that send compatible events).
Once the event has been "posted", it will be handled by the
appenders currently configured in the LoggerRespository.
@author Mark Womack
@author Scott Deboy (sdeboy@apache.org)
@author Paul Smith (psmith@apache.org)
*/
public class SocketReceiver extends Receiver implements Runnable, PortBased,
Pauseable {
/**
* socket map.
*/
private Map socketMap = new HashMap();
/**
* Paused.
*/
private boolean paused;
/**
* Thread.
*/
private Thread rThread;
/**
* Port.
*/
protected int port;
/**
* Server socket.
*/
private ServerSocket serverSocket;
/**
* Socket list.
*/
private Vector socketList = new Vector();
/**
* The MulticastDNS zone advertised by a SocketReceiver
*/
public static final String ZONE = "_log4j_obj_tcpaccept_receiver.local.";
/**
* Listener.
*/
private SocketNodeEventListener listener = null;
/**
* Listeners.
*/
private List listenerList = Collections.synchronizedList(new ArrayList());
private boolean advertiseViaMulticastDNS;
private ZeroConfSupport zeroConf;
/**
* Create new instance.
*/
public SocketReceiver() {
super();
}
/**
* Create new instance.
* @param p port
*/
public SocketReceiver(final int p) {
super();
port = p;
}
/**
* Create new instance.
* @param p port
* @param repo logger repository
*/
public SocketReceiver(final int p, final LoggerRepository repo) {
super();
this.port = p;
repository = repo;
}
public int getPort() {
return port;
}
public void setPort(final int p) {
port = p;
}
/**
* Returns true if the receiver is the same class and they are
* configured for the same properties, and super class also considers
* them to be equivalent. This is used by PluginRegistry when determining
* if the a similarly configured receiver is being started.
*
* @param testPlugin The plugin to test equivalency against.
* @return boolean True if the testPlugin is equivalent to this plugin.
*/
public boolean isEquivalent(final Plugin testPlugin) {
if ((testPlugin != null) && testPlugin instanceof SocketReceiver) {
SocketReceiver sReceiver = (SocketReceiver) testPlugin;
return (port == sReceiver.getPort() && super.isEquivalent(testPlugin));
}
return false;
}
/**
Starts the SocketReceiver with the current options. */
public void activateOptions() {
if (!isActive()) {
// shutdown();
rThread = new Thread(this);
rThread.setDaemon(true);
rThread.start();
if (advertiseViaMulticastDNS) {
zeroConf = new ZeroConfSupport(ZONE, port, getName());
zeroConf.advertise();
}
active = true;
}
}
/**
* Called when the receiver should be stopped. Closes the
* server socket and all of the open sockets.
*/
public synchronized void shutdown() {
getLogger().debug(getName() + " received shutdown request");
// mark this as no longer running
active = false;
if (rThread != null) {
rThread.interrupt();
rThread = null;
}
if (advertiseViaMulticastDNS) {
zeroConf.unadvertise();
}
doShutdown();
}
/**
* Does the actual shutting down by closing the server socket
* and any connected sockets that have been created.
*/
private synchronized void doShutdown() {
active = false;
getLogger().debug(getName() + " doShutdown called");
// close the server socket
closeServerSocket();
// close all of the accepted sockets
closeAllAcceptedSockets();
}
/**
* Closes the server socket, if created.
*/
private void closeServerSocket() {
getLogger().debug("{} closing server socket", getName());
try {
if (serverSocket != null) {
serverSocket.close();
}
} catch (Exception e) {
// ignore for now
}
serverSocket = null;
}
/**
* Closes all the connected sockets in the List.
*/
private synchronized void closeAllAcceptedSockets() {
for (int x = 0; x < socketList.size(); x++) {
try {
((Socket) socketList.get(x)).close();
} catch (Exception e) {
// ignore for now
}
}
// clear member variables
socketMap.clear();
socketList.clear();
}
/**
Sets the flag to indicate if receiver is active or not.
@param b new value
*/
protected synchronized void setActive(final boolean b) {
active = b;
}
public void setAdvertiseViaMulticastDNS(boolean advertiseViaMulticastDNS) {
this.advertiseViaMulticastDNS = advertiseViaMulticastDNS;
}
public boolean isAdvertiseViaMulticastDNS() {
return advertiseViaMulticastDNS;
}
/**
Loop, accepting new socket connections. */
public void run() {
/**
* Ensure we start fresh.
*/
closeServerSocket();
closeAllAcceptedSockets();
// start the server socket
try {
serverSocket = new ServerSocket(port);
} catch (Exception e) {
getLogger().error(
"error starting SocketReceiver (" + this.getName()
+ "), receiver did not start", e);
active = false;
return;
}
Socket socket = null;
try {
getLogger().debug("in run-about to enter while not interrupted loop");
active = true;
while (!rThread.isInterrupted()) {
// if we have a socket, start watching it
if (socket != null) {
getLogger().debug(
"socket not null - creating and starting socketnode");
socketList.add(socket);
SocketNode13 node = new SocketNode13(socket, this);
synchronized (listenerList) {
for (Iterator iter = listenerList.iterator();
iter.hasNext();) {
SocketNodeEventListener l =
(SocketNodeEventListener) iter.next();
node.addSocketNodeEventListener(l);
}
}
socketMap.put(socket, node);
new Thread(node).start();
socket = null;
}
getLogger().debug("waiting to accept socket");
// wait for a socket to open, then loop to start it
socket = serverSocket.accept();
getLogger().debug("accepted socket");
}
} catch (Exception e) {
getLogger().warn(
"exception while watching socket server in SocketReceiver ("
+ this.getName() + "), stopping");
}
getLogger().debug("{} has exited the not interrupted loop", getName());
// socket not watched because we a no longer running
// so close it now.
if (socket != null) {
try {
socket.close();
} catch (IOException e1) {
getLogger().warn("socket exception caught - socket closed");
}
}
getLogger().debug("{} is exiting main run loop", getName());
}
/**
* Returns a Vector of SocketDetail representing the IP/Domain name
* of the currently connected sockets that this receiver has
* been responsible for creating.
* @return Vector of SocketDetails
*/
public Vector getConnectedSocketDetails() {
Vector details = new Vector(socketList.size());
for (Enumeration enumeration = socketList.elements();
enumeration.hasMoreElements();
) {
Socket socket = (Socket) enumeration.nextElement();
details.add(
new SocketDetail(socket, (SocketNode13) socketMap.get(socket)));
}
return details;
}
/**
* Returns the currently configured SocketNodeEventListener that
* will be automatically set for each SocketNode created.
* @return SocketNodeEventListener currently configured
*
* @deprecated This receiver now supports multiple listeners
*/
public SocketNodeEventListener getListener() {
return listener;
}
/**
* Adds the listener to the list of listeners to be notified of the
* respective event.
* @param l the listener to add to the list
*/
public void addSocketNodeEventListener(
final SocketNodeEventListener l) {
listenerList.add(l);
}
/**
* Removes the registered Listener from this instances list of
* listeners. If the listener has not been registered, then invoking
* this method has no effect.
*
* @param l the SocketNodeEventListener to remove
*/
public void removeSocketNodeEventListener(
final SocketNodeEventListener l) {
listenerList.remove(l);
}
/**
* Sets the SocketNodeEventListener that will be used for each
* created SocketNode.
* @param l the listener to set on each creation of a SocketNode
* @deprecated This receiver now supports multiple listeners and
* so this method simply removes the listener (if there already)
* and readds it to the list.
*
* The passed listener will also be returned via the getListener()
* method still, but this is also deprecated
*/
public void setListener(final SocketNodeEventListener l) {
removeSocketNodeEventListener(l);
addSocketNodeEventListener(l);
this.listener = l;
}
/** {@inheritDoc} */
public boolean isPaused() {
return paused;
}
/** {@inheritDoc} */
public void setPaused(final boolean b) {
paused = b;
}
/**
* Socket detail.
*/
private static final class SocketDetail implements AddressBased, PortBased,
Pauseable {
/**
* Address.
*/
private String address;
/**
* Port.
*/
private int port;
/**
* Socket node.
*/
private SocketNode13 socketNode;
/**
* Create new instance.
* @param socket socket
* @param node socket node
*/
private SocketDetail(final Socket socket,
final SocketNode13 node) {
super();
this.address = socket.getInetAddress().getHostName();
this.port = socket.getPort();
this.socketNode = node;
}
/** {@inheritDoc} */
public String getAddress() {
return address;
}
/** {@inheritDoc} */
public int getPort() {
return port;
}
/** {@inheritDoc} */
public String getName() {
return "Socket";
}
/** {@inheritDoc} */
public boolean isActive() {
return true;
}
/** {@inheritDoc} */
public boolean isPaused() {
return socketNode.isPaused();
}
/** {@inheritDoc} */
public void setPaused(final boolean b) {
socketNode.setPaused(b);
}
}
/** {@inheritDoc} */
public void doPost(final LoggingEvent event) {
if (!isPaused()) {
super.doPost(event);
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/net/UDPAppender.java 0000664 0000000 0000000 00000021134 12527427642 0031013 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.net;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.component.helpers.Constants;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.net.ZeroConfSupport;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.xml.XMLLayout;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.UnknownHostException;
/**
* Sends log information as a UDP datagrams.
*
* The UDPAppender is meant to be used as a diagnostic logging tool
* so that logging can be monitored by a simple UDP client.
*
* Messages are not sent as LoggingEvent objects but as text after
* applying the designated Layout.
*
* The port and remoteHost properties can be set in configuration properties.
* By setting the remoteHost to a broadcast address any number of clients can
* listen for log messages.
*
* This was inspired and really extended/copied from {@link org.apache.log4j.net.SocketAppender}.
* Please see the docs for the proper credit to the authors of that class.
*
* @author Kevin Brown
* @author Scott Deboy This will mark the appender as closed and
call then {@link #cleanUp} method.
*/
public synchronized void close() {
if (closed) {
return;
}
if (advertiseViaMulticastDNS) {
zeroConf.unadvertise();
}
this.closed = true;
cleanUp();
}
/**
Close the UDP Socket and release the underlying
connector thread if it has been created
*/
public void cleanUp() {
if (outSocket != null) {
try {
outSocket.close();
} catch (Exception e) {
LogLog.error("Could not close outSocket.", e);
}
outSocket = null;
}
}
void connect(InetAddress address, int port) {
if (this.address == null) {
return;
}
try {
// First, close the previous connection if any.
cleanUp();
outSocket = new DatagramSocket();
outSocket.connect(address, port);
} catch (IOException e) {
LogLog.error(
"Could not open UDP Socket for sending.", e);
inError = true;
}
}
public void append(LoggingEvent event) {
if(inError) {
return;
}
if (event == null) {
return;
}
if (address == null) {
return;
}
if (outSocket != null) {
event.setProperty(Constants.HOSTNAME_KEY, hostname);
if (application != null) {
event.setProperty(Constants.APPLICATION_KEY, application);
}
try {
StringBuffer buf = new StringBuffer(layout.format(event));
byte[] payload;
if(encoding == null) {
payload = buf.toString().getBytes();
} else {
payload = buf.toString().getBytes(encoding);
}
DatagramPacket dp =
new DatagramPacket(payload, payload.length, address, port);
outSocket.send(dp);
} catch (IOException e) {
outSocket = null;
LogLog.warn("Detected problem with UDP connection: " + e);
}
}
}
public boolean isActive() {
return !inError;
}
InetAddress getAddressByName(String host) {
try {
return InetAddress.getByName(host);
} catch (Exception e) {
LogLog.error("Could not find address of [" + host + "].", e);
return null;
}
}
/**
The UDPAppender uses layouts. Hence, this method returns
For example, the socket node might decide to log events to a
local file and also resent them to a second socket node.
@author Scott Deboy
This receiver supports log files created using log4j's XMLLayout, as well as java.util.logging
XMLFormatter (via the org.apache.log4j.spi.Decoder interface).
By default, log4j's XMLLayout is supported (no need to specify a decoder in that case).
To configure this receiver to support java.util.logging's XMLFormatter, specify a 'decoder' param
of org.apache.log4j.xml.UtilLoggingXMLDecoder.
Once the event has been "posted", it will be handled by the
appenders currently configured in the LoggerRespository.
@author Mark Womack
@author Scott Deboy
* This receiver relies on java.util.regex features to perform the parsing of text in the
* log file, however the only regular expression field explicitly supported is
* a glob-style wildcard used to ignore fields in the log file if needed. All other
* fields are parsed by using the supplied keywords.
*
* Features:
* Keywords:
* Use a * to ignore portions of the log format that should be ignored
*
* Example:
* specify this as the log format:
* To define a PROPERTY field, use PROP(key)
*
* Example:
* If your file's patternlayout is this:
* specify this as the log format:
* Note the * - it can be used to ignore a single word or sequence of words in the log file
* (in order for the wildcard to ignore a sequence of words, the text being ignored must be
* followed by some delimiter, like '-' or '[') - ndc is being ignored in the following example.
*
* Assign a filterExpression in order to only process events which match a filter.
* If a filterExpression is not assigned, all events are processed.
*
* Limitations:
* Example receiver configuration settings (add these as params, specifying a LogFilePatternReceiver 'plugin'):
* This configuration will be able to process these sample events:
* Return the index of the first matched line
* (the match may be the 1st line of an exception)
*
* Assumptions:
* the event will already have a message - combine this message
* with the message lines in the additionalLines list
* (all entries prior to the exceptionLine index)
*
* @param firstMessageLine primary message line
* @param exceptionLine index of first exception line
* @return message
*/
private String buildMessage(String firstMessageLine, int exceptionLine) {
if (additionalLines.size() == 0) {
return firstMessageLine;
}
StringBuffer message = new StringBuffer();
if (firstMessageLine != null) {
message.append(firstMessageLine);
}
int linesToProcess = (exceptionLine == -1?additionalLines.size(): exceptionLine);
for (int i = 0; i < linesToProcess; i++) {
message.append(newLine);
message.append(additionalLines.get(i));
}
return message.toString();
}
/**
* Combine all exception lines occuring in the additionalLines list into a
* String array
*
* (all entries equal to or greater than the exceptionLine index)
*
* @param exceptionLine index of first exception line
* @return exception
*/
private String[] buildException(int exceptionLine) {
if (exceptionLine == -1) {
return emptyException;
}
String[] exception = new String[additionalLines.size() - exceptionLine - 1];
for (int i = 0; i < exception.length; i++) {
exception[i] = (String) additionalLines.get(i + exceptionLine);
}
return exception;
}
/**
* Construct a logging event from currentMap and additionalLines
* (additionalLines contains multiple message lines and any exception lines)
*
* CurrentMap and additionalLines are cleared in the process
*
* @return event
*/
private LoggingEvent buildEvent() {
if (currentMap.size() == 0) {
if (additionalLines.size() > 0) {
for (Iterator iter = additionalLines.iterator();iter.hasNext();) {
getLogger().info("found non-matching line: " + iter.next());
}
}
additionalLines.clear();
return null;
}
//the current map contains fields - build an event
int exceptionLine = getExceptionLine();
String[] exception = buildException(exceptionLine);
//messages are listed before exceptions in additionallines
if (additionalLines.size() > 0 && exception.length > 0) {
currentMap.put(MESSAGE, buildMessage((String) currentMap.get(MESSAGE),
exceptionLine));
}
LoggingEvent event = convertToEvent(currentMap, exception);
currentMap.clear();
additionalLines.clear();
return event;
}
/**
* Read, parse and optionally tail the log file, converting entries into logging events.
*
* A runtimeException is thrown if the logFormat pattern is malformed.
*
* @param bufferedReader
* @throws IOException
*/
protected void process(BufferedReader bufferedReader) throws IOException {
Matcher eventMatcher;
Matcher exceptionMatcher;
String line;
while ((line = bufferedReader.readLine()) != null) {
//skip empty line entries
eventMatcher = regexpPattern.matcher(line);
if (line.trim().equals("")) {continue;}
exceptionMatcher = exceptionPattern.matcher(line);
if (eventMatcher.matches()) {
//build an event from the previous match (held in current map)
LoggingEvent event = buildEvent();
if (event != null) {
if (passesExpression(event)) {
doPost(event);
}
}
currentMap.putAll(processEvent(eventMatcher.toMatchResult()));
} else if (exceptionMatcher.matches()) {
//an exception line
additionalLines.add(line);
} else {
//neither...either post an event with the line or append as additional lines
//if this was a logging event with multiple lines, each line will show up as its own event instead of being
//appended as multiple lines on the same event..
//choice is to have each non-matching line show up as its own line, or append them all to a previous event
if (appendNonMatches) {
//hold on to the previous time, so we can do our best to preserve time-based ordering if the event is a non-match
String lastTime = (String)currentMap.get(TIMESTAMP);
//build an event from the previous match (held in current map)
if (currentMap.size() > 0) {
LoggingEvent event = buildEvent();
if (event != null) {
if (passesExpression(event)) {
doPost(event);
}
}
}
if (lastTime != null) {
currentMap.put(TIMESTAMP, lastTime);
}
currentMap.put(MESSAGE, line);
} else {
additionalLines.add(line);
}
}
}
//process last event if one exists
LoggingEvent event = buildEvent();
if (event != null) {
if (passesExpression(event)) {
doPost(event);
}
}
}
protected void createPattern() {
regexpPattern = Pattern.compile(regexp);
}
/**
* Helper method that supports the evaluation of the expression
*
* @param event
* @return true if expression isn't set, or the result of the evaluation otherwise
*/
private boolean passesExpression(LoggingEvent event) {
if (event != null) {
if (expressionRule != null) {
return (expressionRule.evaluate(event, null));
}
}
return true;
}
/**
* Convert the match into a map.
*
* Relies on the fact that the matchingKeywords list is in the same
* order as the groups in the regular expression
*
* @param result
* @return map
*/
private Map processEvent(MatchResult result) {
Map map = new HashMap();
//group zero is the entire match - process all other groups
for (int i = 1; i < result.groupCount() + 1; i++) {
Object key = matchingKeywords.get(i - 1);
Object value = result.group(i);
map.put(key, value);
}
return map;
}
/**
* Helper method that will convert timestamp format to a pattern
*
*
* @return string
*/
private String convertTimestamp() {
//some locales (for example, French) generate timestamp text with characters not included in \w -
// now using \S (all non-whitespace characters) instead of /w
String result = timestampFormat.replaceAll(VALID_DATEFORMAT_CHAR_PATTERN + "+", "\\\\S+");
//make sure dots in timestamp are escaped
result = result.replaceAll(Pattern.quote("."), "\\\\.");
return result;
}
protected void setHost(String host) {
this.host = host;
}
protected void setPath(String path) {
this.path = path;
}
public String getPath() {
return path;
}
/**
* Build the regular expression needed to parse log entries
*
*/
protected void initialize() {
if (host == null && path == null) {
try {
URL url = new URL(fileURL);
host = url.getHost();
path = url.getPath();
} catch (MalformedURLException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}
}
if (host == null || host.trim().equals("")) {
host = DEFAULT_HOST;
}
if (path == null || path.trim().equals("")) {
path = fileURL;
}
currentMap = new HashMap();
additionalLines = new ArrayList();
matchingKeywords = new ArrayList();
if (timestampFormat != null) {
dateFormat = new SimpleDateFormat(quoteTimeStampChars(timestampFormat));
timestampPatternText = convertTimestamp();
}
//if custom level definitions exist, parse them
updateCustomLevelDefinitionMap();
try {
if (filterExpression != null) {
expressionRule = ExpressionRule.getRule(filterExpression);
}
} catch (Exception e) {
getLogger().warn("Invalid filter expression: " + filterExpression, e);
}
List buildingKeywords = new ArrayList();
String newPattern = logFormat;
int index = 0;
String current = newPattern;
//build a list of property names and temporarily replace the property with an empty string,
//we'll rebuild the pattern later
List propertyNames = new ArrayList();
while (index > -1) {
if (current.indexOf(PROP_START) > -1 && current.indexOf(PROP_END) > -1) {
index = current.indexOf(PROP_START);
String longPropertyName = current.substring(current.indexOf(PROP_START), current.indexOf(PROP_END) + 1);
String shortProp = getShortPropertyName(longPropertyName);
buildingKeywords.add(shortProp);
propertyNames.add(longPropertyName);
current = current.substring(longPropertyName.length() + 1 + index);
newPattern = singleReplace(newPattern, longPropertyName, new Integer(buildingKeywords.size() -1).toString());
} else {
//no properties
index = -1;
}
}
/*
* we're using a treemap, so the index will be used as the key to ensure
* keywords are ordered correctly
*
* examine pattern, adding keywords to an index-based map patterns can
* contain only one of these per entry...properties are the only 'keyword'
* that can occur multiple times in an entry
*/
Iterator iter = keywords.iterator();
while (iter.hasNext()) {
String keyword = (String) iter.next();
int index2 = newPattern.indexOf(keyword);
if (index2 > -1) {
buildingKeywords.add(keyword);
newPattern = singleReplace(newPattern, keyword, new Integer(buildingKeywords.size() -1).toString());
}
}
String buildingInt = "";
for (int i=0;i
* This receiver supports log files created using log4j's XMLLayout, as well as java.util.logging
* XMLFormatter (via the org.apache.log4j.spi.Decoder interface).
*
* By default, log4j's XMLLayout is supported (no need to specify a decoder in that case).
*
* To configure this receiver to support java.util.logging's XMLFormatter, specify a 'decoder' param
* of org.apache.log4j.xml.UtilLoggingXMLDecoder.
*
* Tailing -may- work, but not in all cases (try using a file:// URL). If a process has a log file
* open, the receiver may be able to read and tail the file. If the process closes the file and
* reopens the file, the receiver may not be able to continue tailing the file.
*
* An expressionFilter may be specified. Only events passing the expression will be forwarded to the
* log4j framework.
*
* Once the event has been "posted", it will be handled by the appenders currently configured in the
* LoggerRespository.
*
* @author Scott Deboy The ActiveFileName property, which is required, represents the name
* of the file where current logging output will be written.
* The FileNamePattern option represents the file name pattern for the
* archived (rolled over) log files. If present, the FileNamePattern
* option must include an integer token, that is the string "%i" somewhere
* within the pattern.
*
* Let max and min represent the values of respectively
* the MaxIndex and MinIndex options. Let "foo.log" be the value
* of the ActiveFile option and "foo.%i.log" the value of
* FileNamePattern. Then, when rolling over, the file
* Given that this rollover algorithm requires as many file renaming
* operations as the window size, large window sizes are discouraged. The
* current implementation will automatically reduce the window size to 12 when
* larger values are specified by the user.
*
*
* @author Ceki Gülcü
* */
public final class FixedWindowRollingPolicy extends RollingPolicyBase {
/**
* It's almost always a bad idea to have a large window size, say over 12.
*/
private static final int MAX_WINDOW_SIZE = 12;
/**
* Index for oldest retained log file.
*/
private int maxIndex;
/**
* Index for most recent log file.
*/
private int minIndex;
/**
* if true, then an explicit name for the active file was
* specified using RollingFileAppender.file or the
* redundent RollingPolicyBase.setActiveFile
*/
private boolean explicitActiveFile;
/**
* Constructs a new instance.
*/
public FixedWindowRollingPolicy() {
minIndex = 1;
maxIndex = 7;
}
/**
* {@inheritDoc}
*/
public void activateOptions() {
super.activateOptions();
if (maxIndex < minIndex) {
LogLog.warn(
"MaxIndex (" + maxIndex + ") cannot be smaller than MinIndex ("
+ minIndex + ").");
LogLog.warn("Setting maxIndex to equal minIndex.");
maxIndex = minIndex;
}
if ((maxIndex - minIndex) > MAX_WINDOW_SIZE) {
LogLog.warn("Large window sizes are not allowed.");
maxIndex = minIndex + MAX_WINDOW_SIZE;
LogLog.warn("MaxIndex reduced to " + String.valueOf(maxIndex) + ".");
}
PatternConverter itc = getIntegerPatternConverter();
if (itc == null) {
throw new IllegalStateException(
"FileNamePattern [" + getFileNamePattern()
+ "] does not contain a valid integer format specifier");
}
}
/**
* {@inheritDoc}
*/
public RolloverDescription initialize(
final String file, final boolean append) {
String newActiveFile = file;
explicitActiveFile = false;
if (activeFileName != null) {
explicitActiveFile = true;
newActiveFile = activeFileName;
}
if (file != null) {
explicitActiveFile = true;
newActiveFile = file;
}
if (!explicitActiveFile) {
StringBuffer buf = new StringBuffer();
formatFileName(new Integer(minIndex), buf);
newActiveFile = buf.toString();
}
return new RolloverDescriptionImpl(newActiveFile, append, null, null);
}
/**
* {@inheritDoc}
*/
public RolloverDescription rollover(final String currentFileName) {
if (maxIndex >= 0) {
int purgeStart = minIndex;
if (!explicitActiveFile) {
purgeStart++;
}
if (!purge(purgeStart, maxIndex)) {
return null;
}
StringBuffer buf = new StringBuffer();
formatFileName(new Integer(purgeStart), buf);
String renameTo = buf.toString();
String compressedName = renameTo;
Action compressAction = null;
if (renameTo.endsWith(".gz")) {
renameTo = renameTo.substring(0, renameTo.length() - 3);
compressAction =
new GZCompressAction(
new File(renameTo), new File(compressedName), true);
} else if (renameTo.endsWith(".zip")) {
renameTo = renameTo.substring(0, renameTo.length() - 4);
compressAction =
new ZipCompressAction(
new File(renameTo), new File(compressedName), true);
}
FileRenameAction renameAction =
new FileRenameAction(
new File(currentFileName), new File(renameTo), false);
return new RolloverDescriptionImpl(
currentFileName, false, renameAction, compressAction);
}
return null;
}
/**
* Get index of oldest log file to be retained.
* @return index of oldest log file.
*/
public int getMaxIndex() {
return maxIndex;
}
/**
* Get index of most recent log file.
* @return index of oldest log file.
*/
public int getMinIndex() {
return minIndex;
}
/**
* Set index of oldest log file to be retained.
* @param maxIndex index of oldest log file to be retained.
*/
public void setMaxIndex(int maxIndex) {
this.maxIndex = maxIndex;
}
/**
* Set index of most recent log file.
* @param minIndex Index of most recent log file.
*/
public void setMinIndex(int minIndex) {
this.minIndex = minIndex;
}
/**
* Purge and rename old log files in preparation for rollover
* @param lowIndex low index
* @param highIndex high index. Log file associated with high
* index will be deleted if needed.
* @return true if purge was successful and rollover should be attempted.
*/
private boolean purge(final int lowIndex, final int highIndex) {
int suffixLength = 0;
List renames = new ArrayList();
StringBuffer buf = new StringBuffer();
formatFileName(new Integer(lowIndex), buf);
String lowFilename = buf.toString();
if (lowFilename.endsWith(".gz")) {
suffixLength = 3;
} else if (lowFilename.endsWith(".zip")) {
suffixLength = 4;
}
for (int i = lowIndex; i <= highIndex; i++) {
File toRename = new File(lowFilename);
boolean isBase = false;
if (suffixLength > 0) {
File toRenameBase =
new File(
lowFilename.substring(0, lowFilename.length() - suffixLength));
if (toRename.exists()) {
if (toRenameBase.exists()) {
toRenameBase.delete();
}
} else {
toRename = toRenameBase;
isBase = true;
}
}
if (toRename.exists()) {
//
// if at upper index then
// attempt to delete last file
// if that fails then abandon purge
if (i == highIndex) {
if (!toRename.delete()) {
return false;
}
break;
}
//
// if intermediate index
// add a rename action to the list
buf.setLength(0);
formatFileName(new Integer(i + 1), buf);
String highFilename = buf.toString();
String renameTo = highFilename;
if (isBase) {
renameTo =
highFilename.substring(0, highFilename.length() - suffixLength);
}
renames.add(new FileRenameAction(toRename, new File(renameTo), true));
lowFilename = highFilename;
} else {
break;
}
}
//
// work renames backwards
//
for (int i = renames.size() - 1; i >= 0; i--) {
Action action = (Action) renames.get(i);
try {
if (!action.execute()) {
return false;
}
} catch (Exception ex) {
LogLog.warn("Exception during purge in RollingFileAppender", ex);
return false;
}
}
return true;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/RollingFileAppender.java 0000664 0000000 0000000 00000042107 12527427642 0031465 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import org.apache.log4j.Appender;
import org.apache.log4j.FileAppender;
import org.apache.log4j.Logger;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.helpers.QuietWriter;
import org.apache.log4j.rolling.helper.Action;
import org.apache.log4j.spi.ErrorHandler;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.OptionHandler;
import org.apache.log4j.xml.UnrecognizedElementHandler;
import org.w3c.dom.Element;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.Properties;
/**
*
* To be of any use, a This configuration file specifies a monthly rollover schedule including
* automatic compression of the archived files. See
* {@link TimeBasedRollingPolicy} for more details.
*
* @author Heinz Richter
* @author Ceki Gülcü
* @since 1.3
* */
public final class RollingFileAppender extends FileAppender
implements UnrecognizedElementHandler {
/**
* Triggering policy.
*/
private TriggeringPolicy triggeringPolicy;
/**
* Rolling policy.
*/
private RollingPolicy rollingPolicy;
/**
* Length of current active log file.
*/
private long fileLength = 0;
/**
* Asynchronous action (like compression) from previous rollover.
*/
private Action lastRolloverAsyncAction = null;
/**
* Construct a new instance.
*/
public RollingFileAppender() {
}
/**
* Prepare instance of use.
*/
public void activateOptions() {
if (rollingPolicy == null) {
LogLog.warn(
"Please set a rolling policy for the RollingFileAppender named '"
+ getName() + "'");
return;
}
//
// if no explicit triggering policy and rolling policy is both.
//
if (
(triggeringPolicy == null) && rollingPolicy instanceof TriggeringPolicy) {
triggeringPolicy = (TriggeringPolicy) rollingPolicy;
}
if (triggeringPolicy == null) {
LogLog.warn(
"Please set a TriggeringPolicy for the RollingFileAppender named '"
+ getName() + "'");
return;
}
Exception exception = null;
synchronized (this) {
triggeringPolicy.activateOptions();
rollingPolicy.activateOptions();
try {
RolloverDescription rollover =
rollingPolicy.initialize(getFile(), getAppend());
if (rollover != null) {
Action syncAction = rollover.getSynchronous();
if (syncAction != null) {
syncAction.execute();
}
setFile(rollover.getActiveFileName());
setAppend(rollover.getAppend());
lastRolloverAsyncAction = rollover.getAsynchronous();
if (lastRolloverAsyncAction != null) {
Thread runner = new Thread(lastRolloverAsyncAction);
runner.start();
}
}
File activeFile = new File(getFile());
if (getAppend()) {
fileLength = activeFile.length();
} else {
fileLength = 0;
}
super.activateOptions();
} catch (Exception ex) {
exception = ex;
}
}
if (exception != null) {
LogLog.warn(
"Exception while initializing RollingFileAppender named '" + getName()
+ "'", exception);
}
}
private QuietWriter createQuietWriter(final Writer writer) {
ErrorHandler handler = errorHandler;
if (handler == null) {
handler = new DefaultErrorHandler(this);
}
return new QuietWriter(writer, handler);
}
/**
Implements the usual roll over behaviour.
If If In order to use
*
* The active file is defined as the log file for the current period
* whereas archived files are those files which have been rolled over
* in previous periods.
*
* By setting the ActiveFileName option you can decouple the location
* of the active log file and the location of the archived log files.
*
*
* If configuring programatically, do not forget to call {@link #activateOptions}
* method before using this policy. Moreover, {@link #activateOptions} of
* Internal helper classes used by {@link org.apache.log4j.rolling} package. Implements various file rolling policies. The {@link org.apache.log4j.rolling.RollingFileAppender} class
serves as the linchpin of this package. Its behaviour is
controlled by two subcomponents of type {@link
org.apache.log4j.rolling.RollingPolicy} and {@link
org.apache.log4j.rolling.TriggeringPolicy}.
What True/False means can be client-specific.
*
* @param e LoggingEvent this instance will evaluate
* @param matches a Map of event field keys to Sets of matching strings (may be null) which will be
* updated during execution of this method to include field and string matches based on the rule
* evaluation results
* @return true if this Rule instance accepts the event, otherwise false.
*/
boolean evaluate(LoggingEvent e, Map matches);
/**
* Adds a PropertyChangeListener to this instance, which is notified when
* underlying Rule information has changed.
* (there are no specific property name events).
* @param listener listener
*/
void addPropertyChangeListener(PropertyChangeListener listener);
/**
* Removes a known PropertyChangeListener from this Rule.
* @param listener listener
*/
void removePropertyChangeListener(PropertyChangeListener listener);
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/RuleFactory.java 0000664 0000000 0000000 00000012020 12527427642 0027327 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.util.Collection;
import java.util.LinkedList;
import java.util.Locale;
import java.util.Stack;
/**
* A Factory class which, given a string representation of the rule,
* and a context stack, will
* return a Rule ready for evaluation against events.
* If an operator is requested that isn't supported,
* an IllegalArgumentException is thrown.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public final class RuleFactory {
/**
* Singleton instance.
*/
private static final RuleFactory FACTORY = new RuleFactory();
/**
* Rules.
*/
private static final Collection RULES = new LinkedList();
/**
* AND operator literal.
*/
private static final String AND_RULE = "&&";
/**
* OR operator literal.
*/
private static final String OR_RULE = "||";
/**
* NOT operator literal.
*/
private static final String NOT_RULE = "!";
/**
* Inequality operator literal.
*/
private static final String NOT_EQUALS_RULE = "!=";
/**
* Equality operator literal.
*/
private static final String EQUALS_RULE = "==";
/**
* Partial match operator literal.
*/
private static final String PARTIAL_TEXT_MATCH_RULE = "~=";
/**
* Like operator literal.
*/
private static final String LIKE_RULE = "like";
/**
* Exists operator literal.
*/
private static final String EXISTS_RULE = "exists";
/**
* Less than operator literal.
*/
private static final String LESS_THAN_RULE = "<";
/**
* Greater than operator literal.
*/
private static final String GREATER_THAN_RULE = ">";
/**
* Less than or equal operator literal.
*/
private static final String LESS_THAN_EQUALS_RULE = "<=";
/**
* Greater than or equal operator literal.
*/
private static final String GREATER_THAN_EQUALS_RULE = ">=";
static {
RULES.add(AND_RULE);
RULES.add(OR_RULE);
RULES.add(NOT_RULE);
RULES.add(NOT_EQUALS_RULE);
RULES.add(EQUALS_RULE);
RULES.add(PARTIAL_TEXT_MATCH_RULE);
RULES.add(LIKE_RULE);
RULES.add(EXISTS_RULE);
RULES.add(LESS_THAN_RULE);
RULES.add(GREATER_THAN_RULE);
RULES.add(LESS_THAN_EQUALS_RULE);
RULES.add(GREATER_THAN_EQUALS_RULE);
}
/**
* Create instance.
*/
private RuleFactory() {
super();
}
/**
* Get instance.
* @return rule factory instance.
*/
public static RuleFactory getInstance() {
return FACTORY;
}
/**
* Determine if specified string is a known operator.
* @param symbol string
* @return true if string is a known operator
*/
public boolean isRule(final String symbol) {
return ((symbol != null) && (RULES.contains(symbol.toLowerCase(Locale.ENGLISH))));
}
/**
* Create rule from applying operator to stack.
* @param symbol symbol
* @param stack stack
* @return new instance
*/
public Rule getRule(final String symbol, final Stack stack) {
if (AND_RULE.equals(symbol)) {
return AndRule.getRule(stack);
}
if (OR_RULE.equals(symbol)) {
return OrRule.getRule(stack);
}
if (NOT_RULE.equals(symbol)) {
return NotRule.getRule(stack);
}
if (NOT_EQUALS_RULE.equals(symbol)) {
return NotEqualsRule.getRule(stack);
}
if (EQUALS_RULE.equals(symbol)) {
return EqualsRule.getRule(stack);
}
if (PARTIAL_TEXT_MATCH_RULE.equals(symbol)) {
return PartialTextMatchRule.getRule(stack);
}
if (RULES.contains(LIKE_RULE) && LIKE_RULE.equalsIgnoreCase(symbol)) {
return LikeRule.getRule(stack);
}
if (EXISTS_RULE.equalsIgnoreCase(symbol)) {
return ExistsRule.getRule(stack);
}
if (LESS_THAN_RULE.equals(symbol)) {
return InequalityRule.getRule(LESS_THAN_RULE, stack);
}
if (GREATER_THAN_RULE.equals(symbol)) {
return InequalityRule.getRule(GREATER_THAN_RULE, stack);
}
if (LESS_THAN_EQUALS_RULE.equals(symbol)) {
return InequalityRule.getRule(LESS_THAN_EQUALS_RULE, stack);
}
if (GREATER_THAN_EQUALS_RULE.equals(symbol)) {
return InequalityRule.getRule(GREATER_THAN_EQUALS_RULE, stack);
}
throw new IllegalArgumentException("Invalid rule: " + symbol);
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/TimestampEqualsRule.java 0000664 0000000 0000000 00000007275 12527427642 0031056 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.io.IOException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
/**
* A Rule class implementing equality evaluation for timestamps.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class TimestampEqualsRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = 1639079557187790321L;
/**
* Resolver.
*/
private static final LoggingEventFieldResolver RESOLVER =
LoggingEventFieldResolver.getInstance();
/**
* Date format.
*/
private static final DateFormat DATE_FORMAT =
new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
/**
* time stamp.
*/
private long timeStamp;
/**
* Create new instance.
* @param value string representation of date.
*/
private TimestampEqualsRule(final String value) {
super();
//expects value to be a timestamp value represented as a long
try {
timeStamp = DATE_FORMAT.parse(value).getTime();
} catch (ParseException pe) {
throw new IllegalArgumentException("Could not parse date: " + value);
}
}
/**
* Create new instance.
* @param value string representation of date.
* @return new instance
*/
public static Rule getRule(final String value) {
return new TimestampEqualsRule(value);
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
String eventTimeStampString = RESOLVER.getValue(LoggingEventFieldResolver.TIMESTAMP_FIELD, event).toString();
long eventTimeStamp = Long.parseLong(eventTimeStampString) / 1000 * 1000;
boolean result = (eventTimeStamp == timeStamp);
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.TIMESTAMP_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.TIMESTAMP_FIELD, entries);
}
entries.add(eventTimeStampString);
}
return result;
}
/**
* Deserialize the state of the object.
*
* @param in object input stream
*
* @throws IOException if IO error during deserialization
* @throws ClassNotFoundException if class not found during
* deserialization
*/
private void readObject(final java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException {
timeStamp = in.readLong();
}
/**
* Serialize the state of the object.
*
* @param out object output stream
*
* @throws IOException if IO error during serialization
*/
private void writeObject(final java.io.ObjectOutputStream out)
throws IOException {
out.writeLong(timeStamp);
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/TimestampInequalityRule.java 0000664 0000000 0000000 00000010622 12527427642 0031736 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.io.IOException;
import java.text.DateFormat;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
/**
* A Rule class implementing inequality evaluation for timestamps.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class TimestampInequalityRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = -4642641663914789241L;
/**
* Resolver.
*/
private static final LoggingEventFieldResolver RESOLVER =
LoggingEventFieldResolver.getInstance();
/**
* Date format.
*/
private static final DateFormat DATE_FORMAT =
new SimpleDateFormat("yyyy/MM/dd HH:mm:ss");
/**
* Inequality symbol.
*/
private transient String inequalitySymbol;
/**
* Timestamp.
*/
private long timeStamp;
/**
* Create new instance.
* @param inequalitySymbol inequality symbol.
* @param value string representation of date.
*/
private TimestampInequalityRule(
final String inequalitySymbol, final String value) {
super();
this.inequalitySymbol = inequalitySymbol;
try {
timeStamp = DATE_FORMAT.parse(value).getTime();
} catch (ParseException pe) {
throw new IllegalArgumentException("Could not parse date: " + value);
}
}
/**
* Create new instance.
* @param inequalitySymbol inequality symbol
* @param value string representation of date
* @return new instance
*/
public static Rule getRule(final String inequalitySymbol,
final String value) {
return new TimestampInequalityRule(inequalitySymbol, value);
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
String eventTimeStampString = RESOLVER.getValue(LoggingEventFieldResolver.TIMESTAMP_FIELD, event).toString();
long eventTimeStamp = Long.parseLong(
eventTimeStampString) / 1000 * 1000;
boolean result = false;
long first = eventTimeStamp;
long second = timeStamp;
if ("<".equals(inequalitySymbol)) {
result = first < second;
} else if (">".equals(inequalitySymbol)) {
result = first > second;
} else if ("<=".equals(inequalitySymbol)) {
result = first <= second;
} else if (">=".equals(inequalitySymbol)) {
result = first >= second;
}
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.TIMESTAMP_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.TIMESTAMP_FIELD, entries);
}
entries.add(eventTimeStampString);
}
return result;
}
/**
* Deserialize the state of the object.
*
* @param in object input stream
*
* @throws IOException if IO error during deserialization
* @throws ClassNotFoundException if class not found
*/
private void readObject(final java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException {
inequalitySymbol = (String) in.readObject();
timeStamp = in.readLong();
}
/**
* Serialize the state of the object.
*
* @param out object output stream
*
* @throws IOException if IO error during serialization
*/
private void writeObject(final java.io.ObjectOutputStream out)
throws IOException {
out.writeObject(inequalitySymbol);
out.writeLong(timeStamp);
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/spi/ 0000775 0000000 0000000 00000000000 12527427642 0024056 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/spi/LoggingEventFieldResolver.java 0000664 0000000 0000000 00000022347 12527427642 0032007 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.spi;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Locale;
import org.apache.log4j.rule.InFixToPostFix;
/**
* A singleton helper utility which accepts a field name
* and a LoggingEvent and returns the value of that field.
*
* This class defines a grammar used in creation of an expression-based Rule.
*
* The only available method is
* Object getField(String fieldName, LoggingEvent event).
*
* Here is a description of the mapping of field names in the grammar
* to fields on the logging event. While the getField method returns an Object,
* the individual types returned per field are described here:
*
* Field Name Field value (String representation Return type
* LOGGER category name (logger) String
* LEVEL level Level
* CLASS locationInformation's class name String
* FILE locationInformation's file name String
* LINE locationInformation's line number String
* METHOD locationInformation's method name String
* MSG message Object
* NDC NDC String
* EXCEPTION throwable string representation ThrowableInformation
* TIMESTAMP timestamp Long
* THREAD thread String
* PROP.keyName entry in the Property hashtable String
* mapped to the key [keyName]
* NOTE: the values for the 'keyName' portion of the MDC and PROP mappings must
* be an exact match to the key in the hashTable (case sensitive).
*
* If the passed-in field is null or doesn't match an entry
* in the above-described mapping, an exception is thrown.
*
* @author Scott Deboy (sdeboy@apache.org)
* @author Paul Smith (psmith@apache.org)
*
*/
public final class LoggingEventFieldResolver {
/**
* Keyword list.
*/
public static final List KEYWORD_LIST = new ArrayList();
/**
* LOGGER string literal.
*/
public static final String LOGGER_FIELD = "LOGGER";
/**
* LEVEL string literal.
*/
public static final String LEVEL_FIELD = "LEVEL";
/**
* CLASS string literal.
*/
public static final String CLASS_FIELD = "CLASS";
/**
* FILE string literal.
*/
public static final String FILE_FIELD = "FILE";
/**
* LINE string literal.
*/
public static final String LINE_FIELD = "LINE";
/**
* METHOD string literal.
*/
public static final String METHOD_FIELD = "METHOD";
/**
* MSG string literal.
*/
public static final String MSG_FIELD = "MSG";
/**
* NDC string literal.
*/
public static final String NDC_FIELD = "NDC";
/**
* EXCEPTION string literal.
*/
public static final String EXCEPTION_FIELD = "EXCEPTION";
/**
* TIMESTAMP string literal.
*/
public static final String TIMESTAMP_FIELD = "TIMESTAMP";
/**
* THREAD string literal.
*/
public static final String THREAD_FIELD = "THREAD";
/**
* PROP. string literal.
*/
public static final String PROP_FIELD = "PROP.";
/**
* empty string literal.
*/
public static final String EMPTY_STRING = "";
/**
* LOGGER string literal.
*/
private static final LoggingEventFieldResolver RESOLVER =
new LoggingEventFieldResolver();
/**
* Create new instance.
*/
private LoggingEventFieldResolver() {
super();
KEYWORD_LIST.add(LOGGER_FIELD);
KEYWORD_LIST.add(LEVEL_FIELD);
KEYWORD_LIST.add(CLASS_FIELD);
KEYWORD_LIST.add(FILE_FIELD);
KEYWORD_LIST.add(LINE_FIELD);
KEYWORD_LIST.add(METHOD_FIELD);
KEYWORD_LIST.add(MSG_FIELD);
KEYWORD_LIST.add(NDC_FIELD);
KEYWORD_LIST.add(EXCEPTION_FIELD);
KEYWORD_LIST.add(TIMESTAMP_FIELD);
KEYWORD_LIST.add(THREAD_FIELD);
KEYWORD_LIST.add(PROP_FIELD);
}
/**
* Apply fields.
* @param replaceText replacement text.
* @param event logging event.
* @return evaluted expression
*/
public String applyFields(final String replaceText,
final LoggingEvent event) {
if (replaceText == null) {
return null;
}
InFixToPostFix.CustomTokenizer tokenizer = new InFixToPostFix.CustomTokenizer(replaceText);
StringBuffer result = new StringBuffer();
boolean found = false;
while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
if (isField(token) || token.toUpperCase(Locale.US).startsWith(PROP_FIELD)) {
result.append(getValue(token, event).toString());
found = true;
} else {
result.append(token);
}
}
if (found) {
return result.toString();
}
return null;
}
/**
* Get singleton instance.
* @return singleton instance
*/
public static LoggingEventFieldResolver getInstance() {
return RESOLVER;
}
/**
* Determines if specified string is a recognized field.
* @param fieldName field name
* @return true if recognized field.
*/
public boolean isField(final String fieldName) {
if (fieldName != null) {
return (KEYWORD_LIST.contains(
fieldName.toUpperCase(Locale.US))
|| fieldName.toUpperCase().startsWith(PROP_FIELD));
}
return false;
}
/**
* Get value of field.
* @param fieldName field
* @param event event
* @return value of field
*/
public Object getValue(final String fieldName,
final LoggingEvent event) {
String upperField = fieldName.toUpperCase(Locale.US);
if (LOGGER_FIELD.equals(upperField)) {
return event.getLoggerName();
} else if (LEVEL_FIELD.equals(upperField)) {
return event.getLevel();
} else if (MSG_FIELD.equals(upperField)) {
return event.getMessage();
} else if (NDC_FIELD.equals(upperField)) {
String ndcValue = event.getNDC();
return ((ndcValue == null) ? EMPTY_STRING : ndcValue);
} else if (EXCEPTION_FIELD.equals(upperField)) {
String[] throwableRep = event.getThrowableStrRep();
if (throwableRep == null) {
return EMPTY_STRING;
} else {
return getExceptionMessage(throwableRep);
}
} else if (TIMESTAMP_FIELD.equals(upperField)) {
return new Long(event.timeStamp);
} else if (THREAD_FIELD.equals(upperField)) {
return event.getThreadName();
} else if (upperField.startsWith(PROP_FIELD)) {
//note: need to use actual fieldname since case matters
Object propValue = event.getMDC(fieldName.substring(5));
if (propValue == null) {
//case-specific match didn't work, try case insensitive match
String lowerPropKey = fieldName.substring(5).toLowerCase();
Set entrySet = event.getProperties().entrySet();
for (Iterator iter = entrySet.iterator();iter.hasNext();) {
Map.Entry thisEntry = (Map.Entry) iter.next();
if (thisEntry.getKey().toString().equalsIgnoreCase(lowerPropKey)) {
propValue = thisEntry.getValue();
}
}
}
return ((propValue == null) ? EMPTY_STRING : propValue.toString());
} else {
LocationInfo info = event.getLocationInformation();
if (CLASS_FIELD.equals(upperField)) {
return ((info == null) ? EMPTY_STRING : info.getClassName());
} else if (FILE_FIELD.equals(upperField)) {
return ((info == null) ? EMPTY_STRING : info.getFileName());
} else if (LINE_FIELD.equals(upperField)) {
return ((info == null) ? EMPTY_STRING : info.getLineNumber());
} else if (METHOD_FIELD.equals(upperField)) {
return ((info == null) ? EMPTY_STRING : info.getMethodName());
}
}
//there wasn't a match, so throw a runtime exception
throw new IllegalArgumentException("Unsupported field name: " + fieldName);
}
/**
* Get message from throwable representation.
* @param exception exception
* @return message
*/
private static String getExceptionMessage(final String[] exception) {
StringBuffer buff = new StringBuffer();
for (int i = 0; i < exception.length; i++) {
buff.append(exception[i]);
}
return buff.toString();
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/varia/ 0000775 0000000 0000000 00000000000 12527427642 0024365 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/varia/SoundAppender.java 0000664 0000000 0000000 00000005607 12527427642 0030007 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.varia;
import java.applet.Applet;
import java.applet.AudioClip;
import java.net.MalformedURLException;
import java.net.URL;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.helpers.LogLog;
/**
* Plays a sound clip created using Applet.newAudioClip when an event is received.
*
* If the audio format is not supported, a message stating the SoundAppender could
* not be initialized is logged.
*
* Use a filter in combination with this appender to control when the appender is
* triggered.
*
* For example, in the appender definition, include a LevelMatchFilter configured
* to accept WARN or greater, followed by a DenyAllFilter.
*
* @author Scott Deboy
*
*/
public final class SoundAppender extends AppenderSkeleton {
private AudioClip clip;
private String audioURL;
public SoundAppender() {
}
/**
* Attempt to initialize the appender by creating a reference to an AudioClip.
*
* Will log a message if format is not supported, file not found, etc.
*
*/
public void activateOptions() {
/*
* AudioSystem.getAudioInputStream requires jdk 1.3,
* so we use applet.newaudioclip instead
*
*/
try {
clip = Applet.newAudioClip(new URL(audioURL));
} catch (MalformedURLException mue) {
LogLog.error("unable to initialize SoundAppender", mue);}
if (clip == null) {
LogLog.error("Unable to initialize SoundAppender");
}
}
/**
* Accessor
*
* @return audio file
*/
public String getAudioURL() {
return audioURL;
}
/**
* Mutator - common format for a file-based url:
* file:///c:/path/someaudioclip.wav
*
* @param audioURL
*/
public void setAudioURL(String audioURL) {
this.audioURL = audioURL;
}
/**
* Play the sound if an event is being processed
*/
protected void append(LoggingEvent event) {
if (clip != null) {
clip.play();
}
}
public void close() {
//nothing to do
}
/**
* Gets whether appender requires a layout.
* @return false
*/
public boolean requiresLayout() {
return false;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/xml/ 0000775 0000000 0000000 00000000000 12527427642 0024063 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/xml/XSLTLayout.java 0000664 0000000 0000000 00000043107 12527427642 0026723 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.xml;
import org.apache.log4j.Layout;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.helpers.MDCKeySetExtractor;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LocationInfo;
import org.w3c.dom.Element;
import org.w3c.dom.NodeList;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.stream.StreamSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.parsers.DocumentBuilderFactory;
import java.io.InputStream;
import java.io.ByteArrayOutputStream;
import java.io.ByteArrayInputStream;
import java.util.Set;
import java.util.Properties;
import java.util.Arrays;
import java.util.TimeZone;
import java.nio.charset.Charset;
import java.nio.ByteBuffer;
import org.apache.log4j.pattern.CachedDateFormat;
import java.text.SimpleDateFormat;
import org.w3c.dom.Document;
import org.xml.sax.helpers.AttributesImpl;
/**
* XSLTLayout transforms each event as a document using
* a specified or default XSLT transform. The default
* XSLT transform produces a result similar to XMLLayout.
*
* When used with a FileAppender or similar, the transformation of
* an event will be appended to the results for previous
* transforms. If each transform results in an XML element, then
* resulting file will only be an XML entity
* since an XML document requires one and only one top-level element.
* To process the entity, reference it in a XML document like so:
*
*
* If you are embedding this layout within an {@link
* org.apache.log4j.net.SMTPAppender} then make sure to set the
* LocationInfo option of that appender as well.
*
* @param flag new value.
*/
public synchronized void setLocationInfo(final boolean flag) {
locationInfo = flag;
}
/**
* Gets whether location info should be output.
* @return if location is output.
*/
public synchronized boolean getLocationInfo() {
return locationInfo;
}
/**
* Sets whether MDC key-value pairs should be output, default false.
* @param flag new value.
*/
public synchronized void setProperties(final boolean flag) {
properties = flag;
}
/**
* Gets whether MDC key-value pairs should be output.
* @return true if MDC key-value pairs are output.
*/
public synchronized boolean getProperties() {
return properties;
}
/** {@inheritDoc} */
public synchronized void activateOptions() {
if (templates == null) {
try {
InputStream is = XSLTLayout.class.getResourceAsStream("default.xslt");
StreamSource ss = new StreamSource(is);
templates = transformerFactory.newTemplates(ss);
encoding = Charset.forName("US-ASCII");
mediaType = "text/plain";
} catch (Exception ex) {
LogLog.error("Error loading default.xslt", ex);
}
}
activated = true;
}
/**
* Gets whether throwables should not be output.
* @return true if throwables should not be output.
*/
public synchronized boolean ignoresThrowable() {
return ignoresThrowable;
}
/**
* Sets whether throwables should not be output.
* @param ignoresThrowable if true, throwables should not be output.
*/
public synchronized void setIgnoresThrowable(boolean ignoresThrowable) {
this.ignoresThrowable = ignoresThrowable;
}
/**
* {@inheritDoc}
*/
public synchronized String format(final LoggingEvent event) {
if (!activated) {
activateOptions();
}
if (templates != null && encoding != null) {
outputStream.reset();
try {
TransformerHandler transformer =
transformerFactory.newTransformerHandler(templates);
transformer.setResult(new StreamResult(outputStream));
transformer.startDocument();
//
// event element
//
AttributesImpl attrs = new AttributesImpl();
attrs.addAttribute(null, "logger", "logger",
"CDATA", event.getLoggerName());
attrs.addAttribute(null, "timestamp", "timestamp",
"CDATA", Long.toString(event.timeStamp));
attrs.addAttribute(null, "level", "level",
"CDATA", event.getLevel().toString());
attrs.addAttribute(null, "thread", "thread",
"CDATA", event.getThreadName());
StringBuffer buf = new StringBuffer();
utcDateFormat.format(event.timeStamp, buf);
attrs.addAttribute(null, "time", "time", "CDATA", buf.toString());
transformer.startElement(LOG4J_NS, "event", "event", attrs);
attrs.clear();
//
// message element
//
transformer.startElement(LOG4J_NS, "message", "message", attrs);
String msg = event.getRenderedMessage();
if (msg != null && msg.length() > 0) {
transformer.characters(msg.toCharArray(), 0, msg.length());
}
transformer.endElement(LOG4J_NS, "message", "message");
//
// NDC element
//
String ndc = event.getNDC();
if (ndc != null) {
transformer.startElement(LOG4J_NS, "NDC", "NDC", attrs);
char[] ndcChars = ndc.toCharArray();
transformer.characters(ndcChars, 0, ndcChars.length);
transformer.endElement(LOG4J_NS, "NDC", "NDC");
}
//
// throwable element unless suppressed
//
if (!ignoresThrowable) {
String[] s = event.getThrowableStrRep();
if (s != null) {
transformer.startElement(LOG4J_NS, "throwable",
"throwable", attrs);
char[] nl = new char[] { '\n' };
for (int i = 0; i < s.length; i++) {
char[] line = s[i].toCharArray();
transformer.characters(line, 0, line.length);
transformer.characters(nl, 0, nl.length);
}
transformer.endElement(LOG4J_NS, "throwable", "throwable");
}
}
//
// location info unless suppressed
//
//
if (locationInfo) {
LocationInfo locationInfo = event.getLocationInformation();
attrs.addAttribute(null, "class", "class", "CDATA",
locationInfo.getClassName());
attrs.addAttribute(null, "method", "method", "CDATA",
locationInfo.getMethodName());
attrs.addAttribute(null, "file", "file", "CDATA",
locationInfo.getFileName());
attrs.addAttribute(null, "line", "line", "CDATA",
locationInfo.getLineNumber());
transformer.startElement(LOG4J_NS, "locationInfo",
"locationInfo", attrs);
transformer.endElement(LOG4J_NS, "locationInfo",
"locationInfo");
}
if (properties) {
//
// write MDC contents out as properties element
//
Set mdcKeySet = MDCKeySetExtractor.INSTANCE.getPropertyKeySet(event);
if ((mdcKeySet != null) && (mdcKeySet.size() > 0)) {
attrs.clear();
transformer.startElement(LOG4J_NS,
"properties", "properties", attrs);
Object[] keys = mdcKeySet.toArray();
Arrays.sort(keys);
for (int i = 0; i < keys.length; i++) {
String key = keys[i].toString();
Object val = event.getMDC(key);
attrs.clear();
attrs.addAttribute(null, "name", "name", "CDATA", key);
attrs.addAttribute(null, "value", "value",
"CDATA", val.toString());
transformer.startElement(LOG4J_NS,
"data", "data", attrs);
transformer.endElement(LOG4J_NS, "data", "data");
}
}
}
transformer.endElement(LOG4J_NS, "event", "event");
transformer.endDocument();
String body = encoding.decode(
ByteBuffer.wrap(outputStream.toByteArray())).toString();
outputStream.reset();
//
// must remove XML declaration since it may
// result in erroneous encoding info
// if written by FileAppender in a different encoding
if (body.startsWith("");
if (endDecl != -1) {
for(endDecl += 2;
endDecl < body.length() &&
(body.charAt(endDecl) == '\n' || body.charAt(endDecl) == '\r');
endDecl++);
return body.substring(endDecl);
}
}
return body;
} catch (Exception ex) {
LogLog.error("Error during transformation", ex);
return ex.toString();
}
}
return "No valid transform or encoding specified.";
}
/**
* Sets XSLT transform.
* @param xsltdoc DOM document containing XSLT transform source,
* may be modified.
* @throws TransformerConfigurationException if transformer can not be
* created.
*/
public void setTransform(final Document xsltdoc)
throws TransformerConfigurationException {
//
// scan transform source for xsl:output elements
// and extract encoding, media (mime) type and output method
//
String encodingName = null;
mediaType = null;
String method = null;
NodeList nodes = xsltdoc.getElementsByTagNameNS(
XSLT_NS,
"output");
for(int i = 0; i < nodes.getLength(); i++) {
Element outputElement = (Element) nodes.item(i);
if (method == null || method.length() == 0) {
method = outputElement.getAttributeNS(null, "method");
}
if (encodingName == null || encodingName.length() == 0) {
encodingName = outputElement.getAttributeNS(null, "encoding");
}
if (mediaType == null || mediaType.length() == 0) {
mediaType = outputElement.getAttributeNS(null, "media-type");
}
}
if (mediaType == null || mediaType.length() == 0) {
if ("html".equals(method)) {
mediaType = "text/html";
} else if ("xml".equals(method)) {
mediaType = "text/xml";
} else {
mediaType = "text/plain";
}
}
//
// if encoding was not specified,
// add xsl:output encoding=US-ASCII to XSLT source
//
if (encodingName == null || encodingName.length() == 0) {
Element transformElement = xsltdoc.getDocumentElement();
Element outputElement = xsltdoc.
createElementNS(XSLT_NS, "output");
outputElement.setAttributeNS(null, "encoding", "US-ASCII");
transformElement.insertBefore(outputElement, transformElement.getFirstChild());
encoding = Charset.forName("US-ASCII");
} else {
encoding = Charset.forName(encodingName);
}
DOMSource transformSource = new DOMSource(xsltdoc);
templates = transformerFactory.newTemplates(transformSource);
}
/**
* {@inheritDoc}
*/
public boolean parseUnrecognizedElement(final Element element,
final Properties props)
throws Exception {
if (XSLT_NS.equals(element.getNamespaceURI()) ||
element.getNodeName().indexOf("transform") != -1 ||
element.getNodeName().indexOf("stylesheet") != -1) {
//
// DOMConfigurator typically not namespace aware
// serialize tree and reparse.
ByteArrayOutputStream os = new ByteArrayOutputStream();
DOMSource source = new DOMSource(element);
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.transform(source, new StreamResult(os));
ByteArrayInputStream is = new ByteArrayInputStream(os.toByteArray());
DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance();
domFactory.setNamespaceAware(true);
Document xsltdoc = domFactory.newDocumentBuilder().parse(is);
setTransform(xsltdoc);
return true;
}
return false;
}
}
apache-log4j-extras1.2-1.2.17/src/main/resources/ 0000775 0000000 0000000 00000000000 12527427642 0021325 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/resources/META-INF/ 0000775 0000000 0000000 00000000000 12527427642 0022465 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/resources/META-INF/LICENSE 0000664 0000000 0000000 00000026146 12527427642 0023503 0 ustar 00root root 0000000 0000000
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright 1999-2005 The Apache Software Foundation
Licensed 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.
apache-log4j-extras1.2-1.2.17/src/main/resources/META-INF/NOTICE 0000664 0000000 0000000 00000000272 12527427642 0023372 0 ustar 00root root 0000000 0000000 Apache Extras Companion for log4j 1.2.
Copyright 2007 The Apache Software Foundation
This product includes software developed at
The Apache Software Foundation (http://www.apache.org/). apache-log4j-extras1.2-1.2.17/src/main/resources/org/ 0000775 0000000 0000000 00000000000 12527427642 0022114 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/resources/org/apache/ 0000775 0000000 0000000 00000000000 12527427642 0023335 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/resources/org/apache/log4j/ 0000775 0000000 0000000 00000000000 12527427642 0024354 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/resources/org/apache/log4j/extras/ 0000775 0000000 0000000 00000000000 12527427642 0025662 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/resources/org/apache/log4j/extras/log4j.dtd 0000664 0000000 0000000 00000015076 12527427642 0027407 0 ustar 00root root 0000000 0000000
apache-log4j-extras1.2-1.2.17/src/main/resources/org/apache/log4j/xml/ 0000775 0000000 0000000 00000000000 12527427642 0025154 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/resources/org/apache/log4j/xml/default.xslt 0000664 0000000 0000000 00000005363 12527427642 0027523 0 ustar 00root root 0000000 0000000
+[e3 ~.1
~f#xvÄgY*@@b)tn`6{,c]_J*[V狰l#EpԷDiBm yb$c%o.mOKC&RYL(W cj긙/ uկ CO} j|s`n`(6:^>G FD®Y$nDQ66x1 y ,/n^o0j܁1nw2HF_ q<k:TchJ9K2.U>nkI 5$EUJ]q;3m}Ԭ vr-ޭwGPMm{ˁ V>-fMCN^ ^
]RFJE 7c$SV,l}wq(b>GT0}l_`] &Z1,-|QI9#%&SP A[bQ 6_{b9R. ZMv*0d ^re 1ՙE+ӽqY3A>0rL)\{ kRJz1Է
CА~6Ļ&NFDq=KA K{A,n+_짏qG$ZqU_xs4k bXw*{6 [22(Tč $v쒞A &Ѓ{
k> < ٸok,cn;K%BBĐzǐ[WѵYË=rbar% r/tP*+9HM`V ۳sia*GoW+H HU W2wnE)}s i,=pu !VqdF1RwSj;qX{"kLQ_KKE)T[\+ ud(|7\WsAHbrA:F-ڃӥb+)¹GڳR0M2/FuT (`@S S1^b9}Ͷ+h;o^J@+U F$uU N sl}/n{>hO)>X#NJ" }cm+[Va8:"ytM6 eBB1*S* #~BXN==·"qnwT7 :6|_cٿ[~#7#"3|c Yz [s`ue⺜( ʊ MQZ3n.4k VW/ ̫Џ\7"u9Jbtje\;'p4UĽI7P}mq2 ȅ1p ?ZA 62䰇cI$$&NLP[>Uԙ)8b'#FM˕VIH v$iYLT.1u^ ػ 3*ģD}oه+'A
gXZqOY¤5[ԳD4a}Up& It relies heavily on the proper configuration of its environment
* in joran config files as well system properties.
* See also the Ant build file in the tests/ directory.
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/ 0000775 0000000 0000000 00000000000 12527427642 0025252 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/ 0000775 0000000 0000000 00000000000 12527427642 0025637 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/ConnectionSource.java 0000664 0000000 0000000 00000004573 12527427642 0031773 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db;
import org.apache.log4j.component.spi.Component;
import org.apache.log4j.spi.OptionHandler;
import java.sql.Connection;
import java.sql.SQLException;
/**
* The null if not overridden.
*/
public String getOverriddenSupportsGetGeneratedKeys() {
return overriddenSupportsGetGeneratedKeys != null ? overriddenSupportsGetGeneratedKeys
.toString()
: null;
}
/**
* Sets the "overridden" value of "supportsGetGeneratedKeys" property of the
* JDBC driver. In certain cases, getting (e.g. Oracle 10g) generated keys
* does not work because it returns the ROWID, not the value of the sequence.
*
* @param overriddenSupportsGetGeneratedKeys
* A non null string, with "true" or "false" value, if overridden,
* null if not overridden.
*/
public void setOverriddenSupportsGetGeneratedKeys(
String overriddenSupportsGetGeneratedKeys) {
this.overriddenSupportsGetGeneratedKeys = Boolean
.valueOf(overriddenSupportsGetGeneratedKeys);
}
/**
* Does this connection support batch updates?
*/
public final boolean supportsBatchUpdates() {
return supportsBatchUpdates;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/CustomSQLDBReceiver.java 0000664 0000000 0000000 00000041546 12527427642 0032241 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.component.plugins.Pauseable;
import org.apache.log4j.component.plugins.Receiver;
import org.apache.log4j.component.scheduler.Job;
import org.apache.log4j.component.scheduler.Scheduler;
import org.apache.log4j.component.spi.LoggerRepositoryEx;
import org.apache.log4j.spi.LocationInfo;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.ThrowableInformation;
import org.apache.log4j.xml.DOMConfigurator;
import org.apache.log4j.xml.UnrecognizedElementHandler;
import org.w3c.dom.Element;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.Hashtable;
import java.util.Properties;
import java.util.StringTokenizer;
/**
* Converts log data stored in a database into LoggingEvents.
*
*
* <connectionSource class="org.apache.log4j.jdbc.DriverManagerConnectionSource">
* <param name="driver" value="com.mysql.jdbc.Driver" />
* <param name="url" value="jdbc:mysql://localhost:3306/mydb" />
* <param name="username" value="myUser" />
* <param name="password" value="myPassword" />
* </connectionSource>
*
*
*
* <connectionSource class="org.apache.log4j.jdbc.DriverManagerConnectionSource">
* <param name="driver" value="org.apache.commons.dbcp.PoolingDriver" />
* <param name="url" value="jdbc:apache:commons:dbcp:/myPoolingDriver" />
* </connectionSource>
*
* Then the configuration information for the commons-dbcp package goes into
* the file myPoolingDriver.jocl and is placed in the classpath. See the
* commons-dbcp
* documentation for details.
*
* @author Ray DeCampo
*/
public class DriverManagerConnectionSource extends ConnectionSourceSkeleton {
private String driverClass = null;
private String url = null;
public void activateOptions() {
try {
if (driverClass != null) {
Class.forName(driverClass);
discoverConnnectionProperties();
} else {
getLogger().error(
"WARNING: No JDBC driver specified for log4j DriverManagerConnectionSource.");
}
} catch (final ClassNotFoundException cnfe) {
getLogger().error("Could not load JDBC driver class: " + driverClass, cnfe);
}
}
/**
* @see org.apache.log4j.receivers.db.ConnectionSource#getConnection()
*/
public Connection getConnection() throws SQLException {
if (getUser() == null) {
return DriverManager.getConnection(url);
} else {
return DriverManager.getConnection(url, getUser(), getPassword());
}
}
/**
* Returns the url.
* @return String
*/
public String getUrl() {
return url;
}
/**
* Sets the url.
* @param url The url to set
*/
public void setUrl(String url) {
this.url = url;
}
/**
* Returns the name of the driver class.
* @return String
*/
public String getDriverClass() {
return driverClass;
}
/**
* Sets the driver class.
* @param driverClass The driver class to set
*/
public void setDriverClass(String driverClass) {
this.driverClass = driverClass;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/db/JNDIConnectionSource.java 0000664 0000000 0000000 00000011451 12527427642 0032431 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.db;
import javax.naming.Context;
import javax.naming.InitialContext;
import javax.naming.NamingException;
import javax.sql.DataSource;
import java.sql.Connection;
import java.sql.SQLException;
// PortableRemoteObject was introduced in JDK 1.3. We won't use it.
// import javax.rmi.PortableRemoteObject;
/**
* The
*
* <connectionSource class="org.apache.log4j.jdbc.JNDIConnectionSource">
* <param name="jndiLocation" value="jdbc/MySQLDS" />
* </connectionSource>
*
*
*
* <connectionSource class="org.apache.log4j.jdbc.JNDIConnectionSource">
* <param name="jndiLocation" value="jdbc/MySQLDS" />
* <param name="username" value="myUser" />
* <param name="password" value="myPassword" />
* </connectionSource>
*
* reconnectionDelay milliseconds.
address and port.
*/
public UDPAppender(final InetAddress address, final int port) {
super(false);
this.address = address;
this.remoteHost = address.getHostName();
this.port = port;
activateOptions();
}
/**
Sends UDP packets to the address and port.
*/
public UDPAppender(final String host, final int port) {
super(false);
this.port = port;
this.address = getAddressByName(host);
this.remoteHost = host;
activateOptions();
}
/**
Open the UDP sender for the RemoteHost and Port.
*/
public void activateOptions() {
try {
hostname = InetAddress.getLocalHost().getHostName();
} catch (UnknownHostException uhe) {
try {
hostname = InetAddress.getLocalHost().getHostAddress();
} catch (UnknownHostException uhe2) {
hostname = "unknown";
}
}
//allow system property of application to be primary
if (application == null) {
application = System.getProperty(Constants.APPLICATION_KEY);
} else {
if (System.getProperty(Constants.APPLICATION_KEY) != null) {
application = application + "-" + System.getProperty(Constants.APPLICATION_KEY);
}
}
if(remoteHost != null) {
address = getAddressByName(remoteHost);
connect(address, port);
} else {
String err = "The RemoteHost property is required for SocketAppender named "+ name;
LogLog.error(err);
throw new IllegalStateException(err);
}
if (layout == null) {
layout = new XMLLayout();
}
if (advertiseViaMulticastDNS) {
zeroConf = new ZeroConfSupport(ZONE, port, getName());
zeroConf.advertise();
}
super.activateOptions();
}
/**
Close this appender.
true.
*/
public boolean requiresLayout() {
return true;
}
/**
The RemoteHost option takes a string value which should be
the host name or ipaddress to send the UDP packets.
*/
public void setRemoteHost(String host) {
remoteHost = host;
}
/**
Returns value of the RemoteHost option.
*/
public String getRemoteHost() {
return remoteHost;
}
/**
The App option takes a string value which should be the name of the application getting logged.
If property was already set (via system property), don't set here.
*/
public void setApplication(String app) {
this.application = app;
}
/**
Returns value of the App option.
*/
public String getApplication() {
return application;
}
/**
The Encoding option specifies how the bytes are encoded. If this option is not specified,
the System encoding is used.
*/
public void setEncoding(String encoding) {
this.encoding = encoding;
}
/**
Returns value of the Encoding option.
*/
public String getEncoding() {
return encoding;
}
/**
The Port option takes a positive integer representing
the port where UDP packets will be sent.
*/
public void setPort(int port) {
this.port = port;
}
/**
Returns value of the Port option.
*/
public int getPort() {
return port;
}
public void setAdvertiseViaMulticastDNS(boolean advertiseViaMulticastDNS) {
this.advertiseViaMulticastDNS = advertiseViaMulticastDNS;
}
public boolean isAdvertiseViaMulticastDNS() {
return advertiseViaMulticastDNS;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/receivers/net/UDPReceiver.java 0000664 0000000 0000000 00000016457 12527427642 0031035 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.receivers.net;
import org.apache.log4j.component.plugins.Pauseable;
import org.apache.log4j.component.plugins.Receiver;
import org.apache.log4j.net.ZeroConfSupport;
import org.apache.log4j.receivers.spi.Decoder;
import org.apache.log4j.spi.LoggingEvent;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.SocketException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
/**
* Receive LoggingEvents encoded with an XMLLayout, convert the XML data to a
* LoggingEvent and post the LoggingEvent.
*
* @author Scott Deboy
* - specify the URL of the log file to be processed
* - specify the timestamp format in the file (if one exists, using patterns from {@link java.text.SimpleDateFormat})
* - specify the pattern (logFormat) used in the log file using keywords, a wildcard character (*) and fixed text
* - 'tail' the file (allows the contents of the file to be continually read and new events processed)
* - supports the parsing of multi-line messages and exceptions
* - 'hostname' property set to URL host (or 'file' if not available)
* - 'application' property set to URL path (or value of fileURL if not available)
*
* TIMESTAMP
* LOGGER
* LEVEL
* THREAD
* CLASS
* FILE
* LINE
* METHOD
* RELATIVETIME
* MESSAGE
* NDC
* PROP(key)
*
* If your file's patternlayout is this:
* %d %-5p [%t] %C{2} (%F:%L) - %m%n
*
* TIMESTAMP LEVEL [THREAD] CLASS (FILE:LINE) - MESSAGE
*
* If you used the RELATIVETIME pattern layout character in the file,
* you can use PROP(RELATIVETIME) in the logFormat definition to assign
* the RELATIVETIME field as a property on the event.
*
* %r [%t] %-5p %c %x - %m%n
*
* PROP(RELATIVETIME) [THREAD] LEVEL LOGGER * - MESSAGE
*
* - no support for the single-line version of throwable supported by patternlayout
* (this version of throwable will be included as the last line of the message)
* - the relativetime patternLayout character must be set as a property: PROP(RELATIVETIME)
* - messages should appear as the last field of the logFormat because the variability in message content
* - exceptions are converted if the exception stack trace (other than the first line of the exception)
* is stored in the log file with a tab followed by the word 'at' as the first characters in the line
* - tailing may fail if the file rolls over.
*
* param: "timestampFormat" value="yyyy-MM-d HH:mm:ss,SSS"
* param: "logFormat" value="PROP(RELATIVETIME) [THREAD] LEVEL LOGGER * - MESSAGE"
* param: "fileURL" value="file:///c:/events.log"
* param: "tailing" value="true"
*
* 710 [ Thread-0] DEBUG first.logger first -
* 880 [ Thread-2] DEBUG first.logger third -
* 880 [ Thread-0] INFO first.logger first - infomsg-0
* java.lang.Exception: someexception-first
* at Generator2.run(Generator2.java:102)
*
*@author Scott Deboy
*/
public class LogFilePatternReceiver extends Receiver {
private final List keywords = new ArrayList();
private static final String PROP_START = "PROP(";
private static final String PROP_END = ")";
private static final String LOGGER = "LOGGER";
private static final String MESSAGE = "MESSAGE";
private static final String TIMESTAMP = "TIMESTAMP";
private static final String NDC = "NDC";
private static final String LEVEL = "LEVEL";
private static final String THREAD = "THREAD";
private static final String CLASS = "CLASS";
private static final String FILE = "FILE";
private static final String LINE = "LINE";
private static final String METHOD = "METHOD";
private static final String DEFAULT_HOST = "file";
//all lines other than first line of exception begin with tab followed by 'at' followed by text
private static final String EXCEPTION_PATTERN = "^\\s+at.*";
private static final String REGEXP_DEFAULT_WILDCARD = ".*?";
private static final String REGEXP_GREEDY_WILDCARD = ".*";
private static final String PATTERN_WILDCARD = "*";
private static final String NOSPACE_GROUP = "(\\S*\\s*?)";
private static final String DEFAULT_GROUP = "(" + REGEXP_DEFAULT_WILDCARD + ")";
private static final String GREEDY_GROUP = "(" + REGEXP_GREEDY_WILDCARD + ")";
private static final String MULTIPLE_SPACES_REGEXP = "[ ]+";
private final String newLine = System.getProperty("line.separator");
private final String[] emptyException = new String[] { "" };
private SimpleDateFormat dateFormat;
private String timestampFormat = "yyyy-MM-d HH:mm:ss,SSS";
private String logFormat;
private String customLevelDefinitions;
private String fileURL;
private String host;
private String path;
private boolean tailing;
private String filterExpression;
private long waitMillis = 2000; //default 2 seconds
private static final String VALID_DATEFORMAT_CHARS = "GyMwWDdFEaHkKhmsSzZ";
private static final String VALID_DATEFORMAT_CHAR_PATTERN = "[" + VALID_DATEFORMAT_CHARS + "]";
private Rule expressionRule;
private Map currentMap;
private List additionalLines;
private List matchingKeywords;
private String regexp;
private Reader reader;
private Pattern regexpPattern;
private Pattern exceptionPattern;
private String timestampPatternText;
private boolean useCurrentThread;
public static final int MISSING_FILE_RETRY_MILLIS = 10000;
private boolean appendNonMatches;
private final Map customLevelDefinitionMap = new HashMap();
public LogFilePatternReceiver() {
keywords.add(TIMESTAMP);
keywords.add(LOGGER);
keywords.add(LEVEL);
keywords.add(THREAD);
keywords.add(CLASS);
keywords.add(FILE);
keywords.add(LINE);
keywords.add(METHOD);
keywords.add(MESSAGE);
keywords.add(NDC);
try {
exceptionPattern = Pattern.compile(EXCEPTION_PATTERN);
} catch (PatternSyntaxException pse) {
//shouldn't happen
}
}
/**
* Accessor
*
* @return file URL
*/
public String getFileURL() {
return fileURL;
}
/**
* Mutator
*
* @param fileURL
*/
public void setFileURL(String fileURL) {
this.fileURL = fileURL;
}
/**
* If the log file contains non-log4j level strings, they can be mapped to log4j levels using the format (android example):
* V=TRACE,D=DEBUG,I=INFO,W=WARN,E=ERROR,F=FATAL,S=OFF
*
* @param customLevelDefinitions the level definition string
*/
public void setCustomLevelDefinitions(String customLevelDefinitions) {
this.customLevelDefinitions = customLevelDefinitions;
}
public String getCustomLevelDefinitions() {
return customLevelDefinitions;
}
/**
* Accessor
* @return append non matches
*/
public boolean isAppendNonMatches() {
return appendNonMatches;
}
/**
* Mutator
* @param appendNonMatches
*/
public void setAppendNonMatches(boolean appendNonMatches) {
this.appendNonMatches = appendNonMatches;
}
/**
* Accessor
*
* @return filter expression
*/
public String getFilterExpression() {
return filterExpression;
}
/**
* Mutator
*
* @param filterExpression
*/
public void setFilterExpression(String filterExpression) {
this.filterExpression = filterExpression;
}
/**
* Accessor
*
* @return tailing
*/
public boolean isTailing() {
return tailing;
}
/**
* Mutator
*
* @param tailing
*/
public void setTailing(boolean tailing) {
this.tailing = tailing;
}
/**
* When true, this property uses the current Thread to perform the import,
* otherwise when false (the default), a new Thread is created and started to manage
* the import.
* @return true, if the current thread is used
*/
public final boolean isUseCurrentThread() {
return useCurrentThread;
}
/**
* Sets whether the current Thread or a new Thread is created to perform the import,
* the default being false (new Thread created).
*
* @param useCurrentThread
*/
public final void setUseCurrentThread(boolean useCurrentThread) {
this.useCurrentThread = useCurrentThread;
}
/**
* Accessor
*
* @return log format
*/
public String getLogFormat() {
return logFormat;
}
/**
* Mutator
*
* @param logFormat
* the format
*/
public void setLogFormat(String logFormat) {
this.logFormat = logFormat;
}
/**
* Mutator. Specify a pattern from {@link java.text.SimpleDateFormat}
*
* @param timestampFormat
*/
public void setTimestampFormat(String timestampFormat) {
this.timestampFormat = timestampFormat;
}
/**
* Accessor
*
* @return timestamp format
*/
public String getTimestampFormat() {
return timestampFormat;
}
/**
* Accessor
* @return millis between retrieves of content
*/
public long getWaitMillis() {
return waitMillis;
}
/**
* Mutator
* @param waitMillis
*/
public void setWaitMillis(long waitMillis) {
this.waitMillis = waitMillis;
}
/**
* Walk the additionalLines list, looking for the EXCEPTION_PATTERN.
*
* - the additionalLines list may contain both message and exception lines
* - message lines are added to the additionalLines list and then
* exception lines (all message lines occur in the list prior to all
* exception lines)
*
* @return -1 if no exception line exists, line number otherwise
*/
private int getExceptionLine() {
for (int i = 0; i < additionalLines.size(); i++) {
Matcher exceptionMatcher = exceptionPattern.matcher((String)additionalLines.get(i));
if (exceptionMatcher.matches()) {
return i;
}
}
return -1;
}
/**
* Combine all message lines occuring in the additionalLines list, adding
* a newline character between each line
* null initially.
*/
private Filter headFilter;
/**
* The last filter in the filter chain.
*/
private Filter tailFilter;
/**
* Creates a new FilterBasedTriggeringPolicy.
*/
public FilterBasedTriggeringPolicy() {
}
/**
* {@inheritDoc}
*/
public boolean isTriggeringEvent(LoggingEvent event) {
//
// in the abnormal case of no contained filters
// always return true to avoid each logging event
// from having its own file.
if (headFilter == null) {
return false;
}
//
// otherwise loop through the filters
//
for (Filter f = headFilter; f != null; f = f.next) {
switch (f.decide(event)) {
case Filter.DENY:
return false;
case Filter.ACCEPT:
return true;
}
}
return true;
}
/**
* {@inheritDoc}
*
*/
public boolean isTriggeringEvent(
final Appender appender, final LoggingEvent event, final String file,
final long fileLength) {
return isTriggeringEvent(event);
}
/**
* Add a filter to end of the filter list.
* @param newFilter filter to add to end of list.
*/
public void addFilter(final Filter newFilter) {
if (headFilter == null) {
headFilter = newFilter;
tailFilter = newFilter;
} else {
tailFilter.next = newFilter;
tailFilter = newFilter;
}
}
/**
* Clear the filters chain.
*
*/
public void clearFilters() {
headFilter = null;
tailFilter = null;
}
/**
* Returns the head Filter.
* @return head of filter chain, may be null.
*
*/
public Filter getFilter() {
return headFilter;
}
/**
* {@inheritDoc}
*/
public void activateOptions() {
for (Filter f = headFilter; f != null; f = f.next) {
f.activateOptions();
}
}
/**
* {@inheritDoc}
*/
public boolean parseUnrecognizedElement(final Element element,
final Properties props) throws Exception {
final String nodeName = element.getNodeName();
if ("filter".equals(nodeName)) {
OptionHandler filter =
org.apache.log4j.extras.DOMConfigurator.parseElement(
element, props, Filter.class);
if (filter instanceof Filter) {
filter.activateOptions();
this.addFilter((Filter) filter);
}
return true;
}
return false;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/FixedWindowRollingPolicy.java 0000664 0000000 0000000 00000022317 12527427642 0032537 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import java.io.File;
import java.util.ArrayList;
import java.util.List;
import org.apache.log4j.pattern.PatternConverter;
import org.apache.log4j.rolling.helper.Action;
import org.apache.log4j.rolling.helper.FileRenameAction;
import org.apache.log4j.rolling.helper.GZCompressAction;
import org.apache.log4j.rolling.helper.ZipCompressAction;
import org.apache.log4j.helpers.LogLog;
/**
* When rolling over, FixedWindowRollingPolicy renames files
* according to a fixed window algorithm as described below.
*
* foo.max.log will be deleted, the file
* foo.max-1.log will be renamed as
* foo.max.log, the file foo.max-2.log
* renamed as foo.max-1.log, and so on,
* the file foo.min+1.log renamed as
* foo.min+2.log. Lastly, the active file foo.log
* will be renamed as foo.min.log and a new active file name
* foo.log will be created.
*
* RollingFileAppender extends {@link FileAppender} to backup the log files
* depending on {@link RollingPolicy} and {@link TriggeringPolicy}.
* RollingFileAppender instance must have both
* a RollingPolicy and a TriggeringPolicy set up.
* However, if its RollingPolicy also implements the
* TriggeringPolicy interface, then only the former needs to be
* set up. For example, {@link TimeBasedRollingPolicy} acts both as a
* RollingPolicy and a TriggeringPolicy.
*
* RollingFileAppender can be configured programattically or
* using {@link org.apache.log4j.extras.DOMConfigurator} or
* {@link org.apache.log4j.xml.DOMConfigurator} in log4j 1.2.15 or later. Here is a sample
* configration file:
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration>
<log4j:configuration debug="true">
<appender name="ROLL" class="org.apache.log4j.rolling.RollingFileAppender">
<rollingPolicy class="org.apache.log4j.rolling.TimeBasedRollingPolicy">
<param name="FileNamePattern" value="/wombat/foo.%d{yyyy-MM}.gz"/>
</rollingPolicy>
<layout class="org.apache.log4j.PatternLayout">
<param name="ConversionPattern" value="%c{1} - %m%n"/>
</layout>
</appender>
<root">
<appender-ref ref="ROLL"/>
</root>
</log4j:configuration>
*MaxBackupIndex is positive, then files
{File.1, ..., File.MaxBackupIndex -1}
are renamed to {File.2, ...,
File.MaxBackupIndex}. Moreover, File is
renamed File.1 and closed. A new File is
created to receive further log output.
MaxBackupIndex is equal to zero, then the
File is truncated with no backup files created.
* @return true if rollover performed.
*/
public boolean rollover() {
//
// can't roll without a policy
//
if (rollingPolicy != null) {
Exception exception = null;
synchronized (this) {
//
// if a previous async task is still running
//}
if (lastRolloverAsyncAction != null) {
//
// block until complete
//
lastRolloverAsyncAction.close();
//
// or don't block and return to rollover later
//
//if (!lastRolloverAsyncAction.isComplete()) return false;
}
try {
RolloverDescription rollover = rollingPolicy.rollover(getFile());
if (rollover != null) {
if (rollover.getActiveFileName().equals(getFile())) {
closeWriter();
boolean success = true;
if (rollover.getSynchronous() != null) {
success = false;
try {
success = rollover.getSynchronous().execute();
} catch (Exception ex) {
exception = ex;
}
}
if (success) {
if (rollover.getAppend()) {
fileLength = new File(rollover.getActiveFileName()).length();
} else {
fileLength = 0;
}
if (rollover.getAsynchronous() != null) {
lastRolloverAsyncAction = rollover.getAsynchronous();
new Thread(lastRolloverAsyncAction).start();
}
setFile(
rollover.getActiveFileName(), rollover.getAppend(),
bufferedIO, bufferSize);
} else {
setFile(
rollover.getActiveFileName(), true, bufferedIO, bufferSize);
if (exception == null) {
LogLog.warn("Failure in post-close rollover action");
} else {
LogLog.warn(
"Exception in post-close rollover action", exception);
}
}
} else {
Writer newWriter =
createWriter(
createFileOutputStream(
rollover.getActiveFileName(), rollover.getAppend()));
closeWriter();
setFile(rollover.getActiveFileName());
this.qw = createQuietWriter(newWriter);
boolean success = true;
if (rollover.getSynchronous() != null) {
success = false;
try {
success = rollover.getSynchronous().execute();
} catch (Exception ex) {
exception = ex;
}
}
if (success) {
if (rollover.getAppend()) {
fileLength = new File(rollover.getActiveFileName()).length();
} else {
fileLength = 0;
}
if (rollover.getAsynchronous() != null) {
lastRolloverAsyncAction = rollover.getAsynchronous();
new Thread(lastRolloverAsyncAction).start();
}
}
writeHeader();
}
return true;
}
} catch (Exception ex) {
exception = ex;
}
}
if (exception != null) {
LogLog.warn(
"Exception during rollover, rollover deferred.", exception);
}
}
return false;
}
/**
* Creates a new FileOutputStream of a new log file, possibly creating first all the needed parent directories
*
* @param newFileName Filename of new log file to be created
* @param append If file should be appended
* @return newly created FileOutputStream
* @throws FileNotFoundException if creating log file or parent directories was unsuccessful
*/
private FileOutputStream createFileOutputStream(String newFileName, boolean append)
throws FileNotFoundException {
try {
//
// attempt to create file
//
return new FileOutputStream(newFileName, append);
} catch(FileNotFoundException ex) {
//
// if parent directory does not exist then
// attempt to create it and try to create file
// see bug 9150
//
String parentName = new File(newFileName).getParent();
if (parentName != null) {
File parentDir = new File(parentName);
if (!parentDir.exists() && parentDir.mkdirs()) {
return new FileOutputStream(newFileName, append);
} else {
throw ex;
}
} else {
throw ex;
}
}
}
/**
* {@inheritDoc}
*/
protected void subAppend(final LoggingEvent event) {
// The rollover check must precede actual writing. This is the
// only correct behavior for time driven triggers.
if (
triggeringPolicy.isTriggeringEvent(
this, event, getFile(), getFileLength())) {
//
// wrap rollover request in try block since
// rollover may fail in case read access to directory
// is not provided. However appender should still be in good
// condition and the append should still happen.
try {
rollover();
} catch (Exception ex) {
LogLog.warn("Exception during rollover attempt.", ex);
}
}
super.subAppend(event);
}
/**
* Get rolling policy.
* @return rolling policy.
*/
public RollingPolicy getRollingPolicy() {
return rollingPolicy;
}
/**
* Get triggering policy.
* @return triggering policy.
*/
public TriggeringPolicy getTriggeringPolicy() {
return triggeringPolicy;
}
/**
* Sets the rolling policy.
* @param policy rolling policy.
*/
public void setRollingPolicy(final RollingPolicy policy) {
rollingPolicy = policy;
}
/**
* Set triggering policy.
* @param policy triggering policy.
*/
public void setTriggeringPolicy(final TriggeringPolicy policy) {
triggeringPolicy = policy;
}
/**
* Close appender. Waits for any asynchronous file compression actions to be completed.
*/
public void close() {
synchronized (this) {
if (lastRolloverAsyncAction != null) {
lastRolloverAsyncAction.close();
}
}
super.close();
}
/**
Returns an OutputStreamWriter when passed an OutputStream. The
encoding used will depend on the value of the
encoding property. If the encoding value is
specified incorrectly the writer will be opened using the default
system encoding (an error message will be printed to the loglog.
@param os output stream, may not be null.
@return new writer.
*/
protected OutputStreamWriter createWriter(final OutputStream os) {
return super.createWriter(new CountingOutputStream(os, this));
}
/**
* Get byte length of current active log file.
* @return byte length of current active log file.
*/
public long getFileLength() {
return fileLength;
}
/**
* Increments estimated byte length of current active log file.
* @param increment additional bytes written to log file.
*/
public synchronized void incrementFileLength(int increment) {
fileLength += increment;
}
/**
* {@inheritDoc}
*/
public boolean parseUnrecognizedElement(final Element element,
final Properties props) throws Exception {
final String nodeName = element.getNodeName();
if ("rollingPolicy".equals(nodeName)) {
OptionHandler rollingPolicy =
org.apache.log4j.extras.DOMConfigurator.parseElement(
element, props, RollingPolicy.class);
if (rollingPolicy != null) {
rollingPolicy.activateOptions();
this.setRollingPolicy((RollingPolicy) rollingPolicy);
}
return true;
}
if ("triggeringPolicy".equals(nodeName)) {
OptionHandler triggerPolicy =
org.apache.log4j.extras.DOMConfigurator.parseElement(
element, props, TriggeringPolicy.class);
if (triggerPolicy != null) {
triggerPolicy.activateOptions();
this.setTriggeringPolicy((TriggeringPolicy) triggerPolicy);
}
return true;
}
return false;
}
/**
* Wrapper for OutputStream that will report all write
* operations back to this class for file length calculations.
*/
private static class CountingOutputStream extends OutputStream {
/**
* Wrapped output stream.
*/
private final OutputStream os;
/**
* Rolling file appender to inform of stream writes.
*/
private final RollingFileAppender rfa;
/**
* Constructor.
* @param os output stream to wrap.
* @param rfa rolling file appender to inform.
*/
public CountingOutputStream(
final OutputStream os, final RollingFileAppender rfa) {
this.os = os;
this.rfa = rfa;
}
/**
* {@inheritDoc}
*/
public void close() throws IOException {
os.close();
}
/**
* {@inheritDoc}
*/
public void flush() throws IOException {
os.flush();
}
/**
* {@inheritDoc}
*/
public void write(final byte[] b) throws IOException {
os.write(b);
rfa.incrementFileLength(b.length);
}
/**
* {@inheritDoc}
*/
public void write(final byte[] b, final int off, final int len)
throws IOException {
os.write(b, off, len);
rfa.incrementFileLength(len);
}
/**
* {@inheritDoc}
*/
public void write(final int b) throws IOException {
os.write(b);
rfa.incrementFileLength(1);
}
}
private static final class DefaultErrorHandler implements ErrorHandler {
private final RollingFileAppender appender;
public DefaultErrorHandler(final RollingFileAppender appender) {
this.appender = appender;
}
/**@since 1.2*/
public void setLogger(Logger logger) {
}
public void error(String message, Exception ioe, int errorCode) {
appender.close();
LogLog.error("IO failure for appender named "+ appender.getName(), ioe);
}
public void error(String message) {
}
/**@since 1.2*/
public void error(String message, Exception e, int errorCode, LoggingEvent event) {
}
/**@since 1.2*/
public void setAppender(Appender appender) {
}
/**@since 1.2*/
public void setBackupAppender(Appender appender) {
}
public void activateOptions() {
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/RollingPolicy.java 0000664 0000000 0000000 00000004156 12527427642 0030370 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import org.apache.log4j.spi.OptionHandler;
/**
* A RollingPolicy specifies the actions taken
* on a logging file rollover.
*
* @author Ceki Gülcü
* @author Curt Arnold
* */
public interface RollingPolicy extends OptionHandler {
/**
* Initialize the policy and return any initial actions for rolling file appender..
*
* @param file current value of RollingFileAppender.getFile().
* @param append current value of RollingFileAppender.getAppend().
* @return Description of the initialization, may be null to indicate
* no initialization needed.
* @throws SecurityException if denied access to log files.
*/
public RolloverDescription initialize(
final String file, final boolean append) throws SecurityException;
/**
* Prepare for a rollover. This method is called prior to
* closing the active log file, performs any necessary
* preliminary actions and describes actions needed
* after close of current log file.
*
* @param activeFile file name for current active log file.
* @return Description of pending rollover, may be null to indicate no rollover
* at this time.
* @throws SecurityException if denied access to log files.
*/
public RolloverDescription rollover(final String activeFile) throws SecurityException;
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/RollingPolicyBase.java 0000664 0000000 0000000 00000012017 12527427642 0031156 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import org.apache.log4j.pattern.ExtrasFormattingInfo;
import org.apache.log4j.pattern.ExtrasPatternParser;
import org.apache.log4j.pattern.PatternConverter;
import org.apache.log4j.pattern.IntegerPatternConverter;
import org.apache.log4j.pattern.DatePatternConverter;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.spi.OptionHandler;
import java.util.ArrayList;
import java.util.List;
/**
* Implements methods common to most, it not all, rolling
* policies. Currently such methods are limited to a compression mode
* getter/setter.
*
* @author Ceki Gülcü
* @author Curt Arnold
*/
public abstract class RollingPolicyBase
implements RollingPolicy, OptionHandler {
/**
* Error message.
*/
private static final String FNP_NOT_SET =
"The FileNamePattern option must be set before using RollingPolicy. ";
/**
* Reference for error message.
*/
private static final String SEE_FNP_NOT_SET =
"See also http://logging.apache.org/log4j/codes.html#tbr_fnp_not_set";
/**
* File name pattern converters.
*/
private PatternConverter[] patternConverters;
/**
* File name field specifiers.
*/
private ExtrasFormattingInfo[] patternFields;
/**
* File name pattern.
*/
private String fileNamePatternStr;
/**
* Active file name may be null.
* Duplicates FileAppender.file and should be removed.
*/
protected String activeFileName;
/**
* {@inheritDoc}
*/
public void activateOptions() {
// find out period from the filename pattern
if (fileNamePatternStr != null) {
parseFileNamePattern();
} else {
LogLog.warn(FNP_NOT_SET);
LogLog.warn(SEE_FNP_NOT_SET);
throw new IllegalStateException(FNP_NOT_SET + SEE_FNP_NOT_SET);
}
}
/**
* Set file name pattern.
* @param fnp file name pattern.
*/
public void setFileNamePattern(String fnp) {
fileNamePatternStr = fnp;
}
/**
* Get file name pattern.
* @return file name pattern.
*/
public String getFileNamePattern() {
return fileNamePatternStr;
}
/**
* ActiveFileName can be left unset, i.e. as null.
* @param afn active file name.
* @deprecated Duplicates FileAppender.file and should be removed
*/
public void setActiveFileName(String afn) {
activeFileName = afn;
}
/**
* Return the value of the ActiveFile option.
* @deprecated Duplicates FileAppender.file and should be removed
* @return active file name.
*/
public String getActiveFileName() {
return activeFileName;
}
/**
* Parse file name pattern.
*/
protected final void parseFileNamePattern() {
List converters = new ArrayList();
List fields = new ArrayList();
ExtrasPatternParser.parse(
fileNamePatternStr, converters, fields, null,
ExtrasPatternParser.getFileNamePatternRules());
patternConverters = new PatternConverter[converters.size()];
patternConverters =
(PatternConverter[]) converters.toArray(patternConverters);
patternFields = new ExtrasFormattingInfo[converters.size()];
patternFields = (ExtrasFormattingInfo[]) fields.toArray(patternFields);
}
/**
* Format file name.
*
* @param obj object to be evaluted in formatting, may not be null.
* @param buf string buffer to which formatted file name is appended, may not be null.
*/
protected final void formatFileName(
final Object obj, final StringBuffer buf) {
for (int i = 0; i < patternConverters.length; i++) {
int fieldStart = buf.length();
patternConverters[i].format(obj, buf);
if (patternFields[i] != null) {
patternFields[i].format(fieldStart, buf);
}
}
}
protected final PatternConverter getDatePatternConverter() {
for (int i = 0; i < patternConverters.length; i++) {
if (patternConverters[i] instanceof DatePatternConverter) {
return patternConverters[i];
}
}
return null;
}
protected final PatternConverter getIntegerPatternConverter() {
for (int i = 0; i < patternConverters.length; i++) {
if (patternConverters[i] instanceof IntegerPatternConverter) {
return patternConverters[i];
}
}
return null;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/RolloverDescription.java 0000664 0000000 0000000 00000003276 12527427642 0031614 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import org.apache.log4j.rolling.helper.Action;
/**
* Description of actions needed to complete rollover.
*
* @author Curt Arnold
*
*/
public interface RolloverDescription {
/**
* Active log file name after rollover.
* @return active log file name after rollover.
*/
String getActiveFileName();
/**
* Specifies if active file should be opened for appending.
* @return if true, active file should be opened for appending.
*/
boolean getAppend();
/**
* Action to be completed after close of current active log file
* before returning control to caller.
*
* @return action, may be null.
*/
Action getSynchronous();
/**
* Action to be completed after close of current active log file
* and before next rollover attempt, may be executed asynchronously.
*
* @return action, may be null.
*/
Action getAsynchronous();
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/RolloverDescriptionImpl.java 0000664 0000000 0000000 00000006125 12527427642 0032432 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import org.apache.log4j.rolling.helper.Action;
/**
* Description of actions needed to complete rollover.
*
* @author Curt Arnold
*
*/
public final class RolloverDescriptionImpl implements RolloverDescription {
/**
* Active log file name after rollover.
*/
private final String activeFileName;
/**
* Should active file be opened for appending.
*/
private final boolean append;
/**
* Action to be completed after close of current active log file
* before returning control to caller.
*/
private final Action synchronous;
/**
* Action to be completed after close of current active log file
* and before next rollover attempt, may be executed asynchronously.
*/
private final Action asynchronous;
/**
* Create new instance.
* @param activeFileName active log file name after rollover, may not be null.
* @param append true if active log file after rollover should be opened for appending.
* @param synchronous action to be completed after close of current active log file, may be null.
* @param asynchronous action to be completed after close of current active log file and
* before next rollover attempt.
*/
public RolloverDescriptionImpl(
final String activeFileName, final boolean append, final Action synchronous,
final Action asynchronous) {
if (activeFileName == null) {
throw new NullPointerException("activeFileName");
}
this.append = append;
this.activeFileName = activeFileName;
this.synchronous = synchronous;
this.asynchronous = asynchronous;
}
/**
* Active log file name after rollover.
* @return active log file name after rollover.
*/
public String getActiveFileName() {
return activeFileName;
}
/**
* {@inheritDoc}
*/
public boolean getAppend() {
return append;
}
/**
* Action to be completed after close of current active log file
* before returning control to caller.
*
* @return action, may be null.
*/
public Action getSynchronous() {
return synchronous;
}
/**
* Action to be completed after close of current active log file
* and before next rollover attempt, may be executed asynchronously.
*
* @return action, may be null.
*/
public Action getAsynchronous() {
return asynchronous;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/SizeBasedTriggeringPolicy.java 0000664 0000000 0000000 00000004417 12527427642 0032655 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import org.apache.log4j.Appender;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.OptionHandler;
/**
* SizeBasedTriggeringPolicy looks at size of the file being
* currently written to.
*
* @author Ceki Gülcü
* @author Curt Arnold
*
*/
public final class SizeBasedTriggeringPolicy implements TriggeringPolicy,
OptionHandler {
/**
* Rollover threshold size in bytes.
*/
private long maxFileSize = 10 * 1024 * 1024; // let 10 MB the default max size
/**
* Constructs a new instance.
*/
public SizeBasedTriggeringPolicy() {
}
/**
* Constructs an new instance.
* @param maxFileSize rollover threshold size in bytes.
*/
public SizeBasedTriggeringPolicy(final long maxFileSize) {
this.maxFileSize = maxFileSize;
}
/**
* {@inheritDoc}
*/
public boolean isTriggeringEvent(
final Appender appender, final LoggingEvent event, final String file,
final long fileLength) {
//System.out.println("Size"+file.length());
return (fileLength >= maxFileSize);
}
/**
* Gets rollover threshold size in bytes.
* @return rollover threshold size in bytes.
*/
public long getMaxFileSize() {
return maxFileSize;
}
/**
* Sets rollover threshold size in bytes.
* @param l new value for rollover threshold size.
*/
public void setMaxFileSize(long l) {
maxFileSize = l;
}
/**
* Prepares policy for use.
*/
public void activateOptions() {
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/TimeBasedRollingPolicy.java 0000664 0000000 0000000 00000022717 12527427642 0032151 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import java.io.File;
import java.util.Date;
import org.apache.log4j.Appender;
import org.apache.log4j.pattern.PatternConverter;
import org.apache.log4j.rolling.helper.Action;
import org.apache.log4j.rolling.helper.FileRenameAction;
import org.apache.log4j.rolling.helper.GZCompressAction;
import org.apache.log4j.rolling.helper.ZipCompressAction;
import org.apache.log4j.spi.LoggingEvent;
/**
* TimeBasedRollingPolicy is both easy to configure and quite
* powerful.
*
* TimeBasedRollingPolicy, the
* FileNamePattern option must be set. It basically specifies the name of the
* rolled log files. The value FileNamePattern should consist of
* the name of the file, plus a suitably placed %d conversion
* specifier. The %d conversion specifier may contain a date and
* time pattern as specified by the {@link java.text.SimpleDateFormat} class. If
* the date and time pattern is ommitted, then the default pattern of
* "yyyy-MM-dd" is assumed. The following examples should clarify the point.
*
*
*
*
*
* FileNamePattern valueRollover schedule
* Example
*
*
* /wombat/folder/foo.%dDaily rollover (at midnight). Due to the omission of the optional
* time and date pattern for the %d token specifier, the default pattern
* of "yyyy-MM-dd" is assumed, which corresponds to daily rollover.
*
* During November 23rd, 2004, logging output will go to
* the file
* /wombat/foo.2004-11-23. At midnight and for
* the rest of the 24th, logging output will be directed to
* /wombat/foo.2004-11-24.
*
*
* /wombat/foo.%d{yyyy-MM}.logRollover at the beginning of each month.
* During the month of October 2004, logging output will go to
*
* /wombat/foo.2004-10.log. After midnight of October 31st
* and for the rest of November, logging output will be directed to
* /wombat/foo.2004-11.log.
* Automatic file compression
* TimeBasedRollingPolicy supports automatic file compression.
* This feature is enabled if the value of the FileNamePattern option
* ends with .gz or .zip.
*
*
*
*
*
* FileNamePattern valueRollover schedule
* Example
*
*
* /wombat/foo.%d.gzDaily rollover (at midnight) with automatic GZIP compression of the
* archived files.
* During November 23rd, 2004, logging output will go to
* the file
* /wombat/foo.2004-11-23. However, at midnight that
* file will be compressed to become /wombat/foo.2004-11-23.gz.
* For the 24th of November, logging output will be directed to
* /wombat/folder/foo.2004-11-24 until its rolled over at the
* beginning of the next day.
* Decoupling the location of the active log file and the archived log files
*
*
*
*
* FileNamePattern valueActiveFileName
* Rollover schedule
* Example
*
*
* /wombat/foo.log.%d/wombat/foo.logDaily rollover.
*
* During November 23rd, 2004, logging output will go to
* the file
* /wombat/foo.log. However, at midnight that file
* will archived as /wombat/foo.log.2004-11-23. For the 24th
* of November, logging output will be directed to
* /wombat/folder/foo.log until its archived as
* /wombat/foo.log.2004-11-24 at the beginning of the next
* day.
* TimeBasedRollingPolicy must be called before calling
* the {@link #activateOptions} method of the owning
* RollingFileAppender.
*
* @author Ceki Gülcü
* @author Curt Arnold
*/
public final class TimeBasedRollingPolicy extends RollingPolicyBase
implements TriggeringPolicy {
/**
* Time for next determination if time for rollover.
*/
private long nextCheck = 0;
/**
* File name at last rollover.
*/
private String lastFileName = null;
/**
* Length of any file type suffix (.gz, .zip).
*/
private int suffixLength = 0;
/**
* Constructs a new instance.
*/
public TimeBasedRollingPolicy() {
}
/**
* Prepares instance of use.
*/
public void activateOptions() {
super.activateOptions();
PatternConverter dtc = getDatePatternConverter();
if (dtc == null) {
throw new IllegalStateException(
"FileNamePattern [" + getFileNamePattern()
+ "] does not contain a valid date format specifier");
}
long n = System.currentTimeMillis();
StringBuffer buf = new StringBuffer();
formatFileName(new Date(n), buf);
lastFileName = buf.toString();
suffixLength = 0;
if (lastFileName.endsWith(".gz")) {
suffixLength = 3;
} else if (lastFileName.endsWith(".zip")) {
suffixLength = 4;
}
}
/**
* {@inheritDoc}
*/
public RolloverDescription initialize(
final String currentActiveFile, final boolean append) {
long n = System.currentTimeMillis();
nextCheck = ((n / 1000) + 1) * 1000;
StringBuffer buf = new StringBuffer();
formatFileName(new Date(n), buf);
lastFileName = buf.toString();
//
// RollingPolicyBase.activeFileName duplicates RollingFileAppender.file
// and should be removed.
//
if (activeFileName != null) {
return new RolloverDescriptionImpl(activeFileName, append, null, null);
} else if (currentActiveFile != null) {
return new RolloverDescriptionImpl(
currentActiveFile, append, null, null);
} else {
return new RolloverDescriptionImpl(
lastFileName.substring(0, lastFileName.length() - suffixLength), append,
null, null);
}
}
/**
* {@inheritDoc}
*/
public RolloverDescription rollover(final String currentActiveFile) {
long n = System.currentTimeMillis();
nextCheck = ((n / 1000) + 1) * 1000;
StringBuffer buf = new StringBuffer();
formatFileName(new Date(n), buf);
String newFileName = buf.toString();
//
// if file names haven't changed, no rollover
//
if (newFileName.equals(lastFileName)) {
return null;
}
Action renameAction = null;
Action compressAction = null;
String lastBaseName =
lastFileName.substring(0, lastFileName.length() - suffixLength);
String nextActiveFile =
newFileName.substring(0, newFileName.length() - suffixLength);
//
// if currentActiveFile is not lastBaseName then
// active file name is not following file pattern
// and requires a rename plus maintaining the same name
if (!currentActiveFile.equals(lastBaseName)) {
renameAction =
new FileRenameAction(
new File(currentActiveFile), new File(lastBaseName), true);
nextActiveFile = currentActiveFile;
}
if (suffixLength == 3) {
compressAction =
new GZCompressAction(
new File(lastBaseName), new File(lastFileName), true);
}
if (suffixLength == 4) {
compressAction =
new ZipCompressAction(
new File(lastBaseName), new File(lastFileName), true);
}
lastFileName = newFileName;
return new RolloverDescriptionImpl(
nextActiveFile, false, renameAction, compressAction);
}
/**
* {@inheritDoc}
*/
public boolean isTriggeringEvent(
final Appender appender, final LoggingEvent event, final String filename,
final long fileLength) {
return System.currentTimeMillis() >= nextCheck;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/TriggeringPolicy.java 0000664 0000000 0000000 00000003572 12527427642 0031064 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling;
import org.apache.log4j.Appender;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.OptionHandler;
/**
* A TriggeringPolicy controls the conditions under which rollover
* occurs. Such conditions include time of day, file size, an
* external event, the log request or a combination thereof.
*
* @author Ceki Gülcü
* @author Curt Arnold
*
*/
public interface TriggeringPolicy extends OptionHandler {
/**
* Determines if a rollover may be appropriate at this time. If
* true is returned, RolloverPolicy.rollover will be called but it
* can determine that a rollover is not warranted.
*
* @param appender A reference to the appender.
* @param event A reference to the currently event.
* @param filename The filename for the currently active log file.
* @param fileLength Length of the file in bytes.
* @return true if a rollover should occur.
*/
public boolean isTriggeringEvent(
final Appender appender, final LoggingEvent event, final String filename,
final long fileLength);
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/ 0000775 0000000 0000000 00000000000 12527427642 0026210 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/Action.java 0000664 0000000 0000000 00000003211 12527427642 0030265 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling.helper;
import java.io.IOException;
/**
* The Action interface should be implemented by any class that performs
* file system actions for RollingFileAppenders after the close of
* the active log file.
*
* @author Curt Arnold
*/
public interface Action extends Runnable {
/**
* Perform an action.
* @return true if action was successful. A return value of false will cause
* the rollover to be aborted if possible.
* @throws IOException if IO error, a thrown exception will cause the rollover
* to be aborted if possible.
*/
boolean execute() throws IOException;
/**
* Cancels the action if not already initialized or waits till completion.
*/
void close();
/**
* Determines if action has been completed.
* @return true if action is complete.
*/
boolean isComplete();
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/ActionBase.java 0000664 0000000 0000000 00000003753 12527427642 0031073 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling.helper;
import java.io.IOException;
/**
* Abstract base class for implementations of Action.
*
* @author Curt Arnold
*/
public abstract class ActionBase implements Action {
/**
* Is action complete.
*/
private boolean complete = false;
/**
* Is action interrupted.
*/
private boolean interrupted = false;
/**
* Constructor.
*/
protected ActionBase() {
}
/**
* Perform action.
*
* @throws IOException if IO error.
* @return true if successful.
*/
public abstract boolean execute() throws IOException;
/**
* {@inheritDoc}
*/
public synchronized void run() {
if (!interrupted) {
try {
execute();
} catch (IOException ex) {
reportException(ex);
}
complete = true;
interrupted = true;
}
}
/**
* {@inheritDoc}
*/
public synchronized void close() {
interrupted = true;
}
/**
* Tests if the action is complete.
* @return true if action is complete.
*/
public boolean isComplete() {
return complete;
}
/**
* Capture exception.
*
* @param ex exception.
*/
protected void reportException(final Exception ex) {
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/CompositeAction.java 0000664 0000000 0000000 00000005057 12527427642 0032162 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling.helper;
import java.io.IOException;
import java.util.List;
import org.apache.log4j.helpers.LogLog;
/**
* A group of Actions to be executed in sequence.
*
* @author Curt Arnold
*
*/
public class CompositeAction extends ActionBase {
/**
* Actions to perform.
*/
private final Action[] actions;
/**
* Stop on error.
*/
private final boolean stopOnError;
/**
* Construct a new composite action.
* @param actions list of actions, may not be null.
* @param stopOnError if true, stop on the first false return value or exception.
*/
public CompositeAction(final List actions,
final boolean stopOnError) {
this.actions = new Action[actions.size()];
actions.toArray(this.actions);
this.stopOnError = stopOnError;
}
/**
* {@inheritDoc}
*/
public void run() {
try {
execute();
} catch (IOException ex) {
LogLog.warn("Exception during file rollover.", ex);
}
}
/**
* Execute sequence of actions.
* @return true if all actions were successful.
* @throws IOException on IO error.
*/
public boolean execute() throws IOException {
if (stopOnError) {
for (int i = 0; i < actions.length; i++) {
if (!actions[i].execute()) {
return false;
}
}
return true;
} else {
boolean status = true;
IOException exception = null;
for (int i = 0; i < actions.length; i++) {
try {
status &= actions[i].execute();
} catch (IOException ex) {
status = false;
if (exception == null) {
exception = ex;
}
}
}
if (exception != null) {
throw exception;
}
return status;
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/FileRenameAction.java 0000664 0000000 0000000 00000004350 12527427642 0032222 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling.helper;
import java.io.File;
/**
* File rename action.
*
* @author Curt Arnold
*/
public final class FileRenameAction extends ActionBase {
/**
* Source.
*/
private final File source;
/**
* Destination.
*/
private final File destination;
/**
* If true, rename empty files, otherwise delete empty files.
*/
private final boolean renameEmptyFiles;
/**
* Creates an FileRenameAction.
*
* @param src current file name.
* @param dst new file name.
* @param renameEmptyFiles if true, rename file even if empty, otherwise delete empty files.
*/
public FileRenameAction(
final File src, final File dst, boolean renameEmptyFiles) {
source = src;
destination = dst;
this.renameEmptyFiles = renameEmptyFiles;
}
/**
* Rename file.
*
* @return true if successfully renamed.
*/
public boolean execute() {
return execute(source, destination, renameEmptyFiles);
}
/**
* Rename file.
* @param source current file name.
* @param destination new file name.
* @param renameEmptyFiles if true, rename file even if empty, otherwise delete empty files.
* @return true if successfully renamed.
*/
public static boolean execute(
final File source, final File destination, boolean renameEmptyFiles) {
if (renameEmptyFiles || (source.length() > 0)) {
return source.renameTo(destination);
}
return source.delete();
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/GZCompressAction.java 0000664 0000000 0000000 00000007141 12527427642 0032250 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling.helper;
import org.apache.log4j.helpers.LogLog;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.GZIPOutputStream;
/**
* Compresses a file using GZ compression.
*
* @author Curt Arnold
*/
public final class GZCompressAction extends ActionBase {
/**
* Source file.
*/
private final File source;
/**
* Destination file.
*/
private final File destination;
/**
* If true, attempt to delete file on completion.
*/
private final boolean deleteSource;
/**
* Create new instance of GZCompressAction.
*
* @param source file to compress, may not be null.
* @param destination compressed file, may not be null.
* @param deleteSource if true, attempt to delete file on completion. Failure to delete
* does not cause an exception to be thrown or affect return value.
*/
public GZCompressAction(
final File source, final File destination, final boolean deleteSource) {
if (source == null) {
throw new NullPointerException("source");
}
if (destination == null) {
throw new NullPointerException("destination");
}
this.source = source;
this.destination = destination;
this.deleteSource = deleteSource;
}
/**
* Compress.
* @return true if successfully compressed.
* @throws IOException on IO exception.
*/
public boolean execute() throws IOException {
return execute(source, destination, deleteSource);
}
/**
* Compress a file.
*
* @param source file to compress, may not be null.
* @param destination compressed file, may not be null.
* @param deleteSource if true, attempt to delete file on completion. Failure to delete
* does not cause an exception to be thrown or affect return value.
* @return true if source file compressed.
* @throws IOException on IO exception.
*/
public static boolean execute(
final File source, final File destination, final boolean deleteSource)
throws IOException {
if (source.exists()) {
FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(destination);
GZIPOutputStream gzos = new GZIPOutputStream(fos);
byte[] inbuf = new byte[8102];
int n;
while ((n = fis.read(inbuf)) != -1) {
gzos.write(inbuf, 0, n);
}
gzos.close();
fis.close();
if (deleteSource && !source.delete()) {
LogLog.warn("Unable to delete " + source.toString() + ".");
}
return true;
}
return false;
}
/**
* Capture exception.
*
* @param ex exception.
*/
protected void reportException(final Exception ex) {
LogLog.warn("Exception during compression of '" + source.toString() + "'.", ex);
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/ZipCompressAction.java 0000664 0000000 0000000 00000007334 12527427642 0032476 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rolling.helper;
import org.apache.log4j.helpers.LogLog;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
/**
* Compresses a file using Zip compression.
*
* @author Curt Arnold
*/
public final class ZipCompressAction extends ActionBase {
/**
* Source file.
*/
private final File source;
/**
* Destination file.
*/
private final File destination;
/**
* If true, attempt to delete file on completion.
*/
private final boolean deleteSource;
/**
* Create new instance of GZCompressAction.
*
* @param source file to compress, may not be null.
* @param destination compressed file, may not be null.
* @param deleteSource if true, attempt to delete file on completion. Failure to delete
* does not cause an exception to be thrown or affect return value.
*/
public ZipCompressAction(
final File source, final File destination, final boolean deleteSource) {
if (source == null) {
throw new NullPointerException("source");
}
if (destination == null) {
throw new NullPointerException("destination");
}
this.source = source;
this.destination = destination;
this.deleteSource = deleteSource;
}
/**
* Compress.
* @return true if successfully compressed.
* @throws IOException on IO exception.
*/
public boolean execute() throws IOException {
return execute(source, destination, deleteSource);
}
/**
* Compress a file.
*
* @param source file to compress, may not be null.
* @param destination compressed file, may not be null.
* @param deleteSource if true, attempt to delete file on completion. Failure to delete
* does not cause an exception to be thrown or affect return value.
* @return true if source file compressed.
* @throws IOException on IO exception.
*/
public static boolean execute(
final File source, final File destination, final boolean deleteSource)
throws IOException {
if (source.exists()) {
FileInputStream fis = new FileInputStream(source);
FileOutputStream fos = new FileOutputStream(destination);
ZipOutputStream zos = new ZipOutputStream(fos);
ZipEntry zipEntry = new ZipEntry(source.getName());
zos.putNextEntry(zipEntry);
byte[] inbuf = new byte[8102];
int n;
while ((n = fis.read(inbuf)) != -1) {
zos.write(inbuf, 0, n);
}
zos.close();
fis.close();
if (deleteSource && !source.delete()) {
LogLog.warn("Unable to delete " + source.toString() + ".");
}
return true;
}
return false;
}
/**
* Capture exception.
*
* @param ex exception.
*/
protected void reportException(final Exception ex) {
LogLog.warn("Exception during compression of '" + source.toString() + "'.", ex);
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/helper/package.html 0000664 0000000 0000000 00000001717 12527427642 0030477 0 ustar 00root root 0000000 0000000
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rolling/package.html 0000664 0000000 0000000 00000002350 12527427642 0027212 0 ustar 00root root 0000000 0000000
RuleFactory.
*
* NOTE: parsing is supported through the use of
* StringTokenizer, which
* implies two limitations:
* 1: all tokens in the expression must be separated by spaces,
* including parenthesis
* 2: operands which contain spaces MUST be wrapped in single quotes.
* For example, the expression:
* msg == 'some msg'
* is a valid expression.
* 3: To group expressions, use parentheses.
* For example, the expression:
* level >= INFO || ( msg == 'some msg' || logger == 'test' )
* is a valid expression.
* See org.apache.log4j.rule.InFixToPostFix for a
* description of supported operators.
* See org.apache.log4j.spi.LoggingEventFieldResolver for field keywords.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class ExpressionRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = 5809121703146893729L;
/**
* Converter.
*/
private static final InFixToPostFix CONVERTER = new InFixToPostFix();
/**
* Compiler.
*/
private static final PostFixExpressionCompiler COMPILER =
new PostFixExpressionCompiler();
/**
* Rule.
*/
private final Rule rule;
/**
* Create new instance.
* @param r rule
*/
private ExpressionRule(final Rule r) {
super();
this.rule = r;
}
/**
* Get rule.
* @param expression expression.
* @return rule.
*/
public static Rule getRule(final String expression) {
return getRule(expression, false);
}
/**
* Get rule.
* @param expression expression.
* @param isPostFix If post-fix.
* @return rule
*/
public static Rule getRule(final String expression,
final boolean isPostFix) {
String postFix = expression;
if (!isPostFix) {
postFix = CONVERTER.convert(expression);
}
return new ExpressionRule(COMPILER.compileExpression(postFix));
}
/**
* {@inheritDoc}
*/
public boolean evaluate(final LoggingEvent event, Map matches) {
return rule.evaluate(event, matches);
}
/**
* {@inheritDoc}
*/
public String toString() {
return rule.toString();
}
/**
* Evaluate a boolean postfix expression.
*
*/
static final class PostFixExpressionCompiler {
/**
* Compile expression.
* @param expression expression.
* @return rule.
*/
public Rule compileExpression(final String expression) {
RuleFactory factory = RuleFactory.getInstance();
Stack stack = new Stack();
InFixToPostFix.CustomTokenizer tokenizer = new InFixToPostFix.CustomTokenizer(expression);
while (tokenizer.hasMoreTokens()) {
//examine each token
String token = tokenizer.nextToken();
if (token.startsWith("'") || token.startsWith("\"")) {
String quoteChar = token.substring(0, 1);
token = token.substring(1);
while (!token.endsWith(quoteChar) && tokenizer.hasMoreTokens()) {
token = token + " " + tokenizer.nextToken();
}
if (token.length() > 0) {
token = token.substring(0, token.length() - 1);
}
} else {
//if a symbol is found, pop 2 off the stack,
// evaluate and push the result
if (factory.isRule(token)) {
Rule r = factory.getRule(token, stack);
stack.push(r);
//null out the token so we don't try to push it below
token = null;
}
}
//variables or constants are pushed onto the stack
if (token != null && token.length() > 0) {
stack.push(token);
}
}
if ((stack.size() == 1) && (!(stack.peek() instanceof Rule))) {
//while this may be an attempt at creating an expression,
//for ease of use, convert this single entry to a partial-text
//match on the MSG field
Object o = stack.pop();
stack.push("MSG");
stack.push(o);
return factory.getRule("~=", stack);
}
//stack should contain a single rule if the expression is valid
if ((stack.size() != 1) || (!(stack.peek() instanceof Rule))) {
throw new IllegalArgumentException("invalid expression: " + expression);
} else {
return (Rule) stack.pop();
}
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/InFixToPostFix.java 0000664 0000000 0000000 00000027040 12527427642 0027735 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Stack;
import java.util.Vector;
import org.apache.log4j.spi.LoggingEventFieldResolver;
/**
* A helper class which converts infix expressions to postfix expressions
* Currently grouping is supported, as well as all of the
* Rules supported by RuleFactory
*
* Supports grouping via parens, mult-word operands using single or double quotes,
* and these operators:
*
* ! NOT operator
* != NOT EQUALS operator
* == EQUALS operator
* ~= CASE-INSENSITIVE equals operator
* || OR operator
* && AND operator
* like REGEXP operator
* exists NOT NULL operator
* < LESS THAN operator
* > GREATER THAN operator
* <= LESS THAN EQUALS operator
* >= GREATER THAN EQUALS operator
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class InFixToPostFix {
/**
* Precedence map.
*/
private static final Map precedenceMap = new HashMap();
/**
* Operators.
*/
private static final List operators = new Vector();
static {
//order multi-char operators before single-char operators (will use this order during parsing)
operators.add("<=");
operators.add(">=");
operators.add("!=");
operators.add("==");
operators.add("~=");
operators.add("||");
operators.add("&&");
operators.add("like");
operators.add("exists");
operators.add("!");
operators.add("<");
operators.add(">");
//boolean precedence
precedenceMap.put("<", new Integer(3));
precedenceMap.put(">", new Integer(3));
precedenceMap.put("<=", new Integer(3));
precedenceMap.put(">=", new Integer(3));
precedenceMap.put("!", new Integer(3));
precedenceMap.put("!=", new Integer(3));
precedenceMap.put("==", new Integer(3));
precedenceMap.put("~=", new Integer(3));
precedenceMap.put("like", new Integer(3));
precedenceMap.put("exists", new Integer(3));
precedenceMap.put("||", new Integer(2));
precedenceMap.put("&&", new Integer(2));
}
/**
* Convert in-fix expression to post-fix.
* @param expression in-fix expression.
* @return post-fix expression.
*/
public String convert(final String expression) {
return infixToPostFix(new CustomTokenizer(expression));
}
/**
* Evaluates whether symbol is operand.
* @param s symbol.
* @return true if operand.
*/
public static boolean isOperand(final String s) {
String symbol = s.toLowerCase(Locale.ENGLISH);
return (!operators.contains(symbol));
}
/**
* Determines whether one symbol precedes another.
* @param s1 symbol 1
* @param s2 symbol 2
* @return true if symbol 1 precedes symbol 2
*/
boolean precedes(final String s1, final String s2) {
String symbol1 = s1.toLowerCase(Locale.ENGLISH);
String symbol2 = s2.toLowerCase(Locale.ENGLISH);
if (!precedenceMap.keySet().contains(symbol1)) {
return false;
}
if (!precedenceMap.keySet().contains(symbol2)) {
return false;
}
int index1 = ((Integer) precedenceMap.get(symbol1)).intValue();
int index2 = ((Integer) precedenceMap.get(symbol2)).intValue();
boolean precedesResult = (index1 < index2);
return precedesResult;
}
/**
* convert in-fix expression to post-fix.
* @param tokenizer tokenizer.
* @return post-fix expression.
*/
String infixToPostFix(final CustomTokenizer tokenizer) {
final String space = " ";
StringBuffer postfix = new StringBuffer();
Stack stack = new Stack();
while (tokenizer.hasMoreTokens()) {
String token = tokenizer.nextToken();
boolean inText = (token.startsWith("'") && (!token.endsWith("'"))) || (token.startsWith("\"") && (!token.endsWith("\"")));
String quoteChar = token.substring(0, 1);
if (inText) {
while (inText && tokenizer.hasMoreTokens()) {
token = token + " " + tokenizer.nextToken();
inText = !(token.endsWith(quoteChar));
}
}
if ("(".equals(token)) {
//recurse
postfix.append(infixToPostFix(tokenizer));
postfix.append(space);
} else if (")".equals(token)) {
//exit recursion level
while (stack.size() > 0) {
postfix.append(stack.pop().toString());
postfix.append(space);
}
return postfix.toString();
} else if (isOperand(token)) {
postfix.append(token);
postfix.append(space);
} else {
//operator..
//peek the stack..if the top element has a lower precedence than token
//(peeked + has lower precedence than token *),
// push token onto the stack
//otherwise, pop top element off stack and add to postfix string
//in a loop until lower precedence or empty..then push token
if (stack.size() > 0) {
String peek = stack.peek().toString();
if (precedes(peek, token)) {
stack.push(token);
} else {
boolean bypass = false;
do {
if (
(stack.size() > 0)
&& !precedes(stack.peek().toString(), token)) {
postfix.append(stack.pop().toString());
postfix.append(space);
} else {
bypass = true;
}
} while (!bypass);
stack.push(token);
}
} else {
stack.push(token);
}
}
}
while (stack.size() > 0) {
postfix.append(stack.pop().toString());
postfix.append(space);
}
return postfix.toString();
}
public static class CustomTokenizer {
private LinkedList linkedList = new LinkedList();
public CustomTokenizer(String input) {
parseInput(input, linkedList);
}
public void parseInput(String input, LinkedList linkedList) {
/*
Operators:
!
!=
==
~=
||
&&
like
exists
<
<=
>
>=
*/
//for operators, handle multi-char matches before single-char matches
//order does not matter for keywords
List keywords = LoggingEventFieldResolver.KEYWORD_LIST;
//remove PROP. from the keyword list...it is a keyword in that list, but is handled separately here from the other keywords since its name is not fixed
keywords.remove("PROP.");
int pos = 0;
while (pos < input.length()) {
if (nextValueIs(input, pos, "'") || nextValueIs(input, pos, "\"")) {
pos = handleQuotedString(input, pos, linkedList);
}
if (nextValueIs(input, pos, "PROP.")) {
pos = handleProperty(input, pos, linkedList);
}
boolean operatorFound = false;
for (Iterator iter = operators.iterator();iter.hasNext();) {
String operator = (String)iter.next();
if (nextValueIs(input, pos, operator)) {
operatorFound = true;
pos = handle(pos, linkedList, operator);
}
}
boolean keywordFound = false;
for (Iterator iter = keywords.iterator();iter.hasNext();) {
String keyword = (String)iter.next();
if (nextValueIs(input, pos, keyword)) {
keywordFound = true;
pos = handle(pos, linkedList, keyword);
}
}
if (operatorFound || keywordFound) {
continue;
}
if (nextValueIs(input, pos, ")")) {
pos = handle(pos, linkedList, ")");
} else if (nextValueIs(input, pos, "(")) {
pos = handle(pos, linkedList, "(");
} else if (nextValueIs(input, pos, " ")) {
pos++;
} else {
pos = handleText(input, pos, linkedList);
}
}
}
private boolean nextValueIs(String input, int pos, String value) {
return (input.length() >= (pos + value.length())) && (input.substring(pos, pos + value.length()).equalsIgnoreCase(value));
}
private int handle(int pos, LinkedList linkedList, String value) {
linkedList.add(value);
return pos + value.length();
}
private int handleQuotedString(String input, int pos, LinkedList linkedList) {
String quoteChar = input.substring(pos, pos + 1);
int nextSingleQuotePos = input.indexOf(quoteChar, pos + 1);
if (nextSingleQuotePos < 0) {
throw new IllegalArgumentException("Missing an end quote");
}
String result = input.substring(pos, nextSingleQuotePos + 1);
linkedList.add(result);
return nextSingleQuotePos + 1;
}
private int handleText(String input, int pos, LinkedList linkedList) {
StringBuffer text = new StringBuffer("");
int newPos = pos;
while (newPos < input.length()) {
if (nextValueIs(input, newPos, " ")) {
linkedList.add(text);
return newPos;
}
if (nextValueIs(input, newPos, "(")) {
linkedList.add(text);
return newPos;
}
if (nextValueIs(input, newPos, ")")) {
linkedList.add(text);
return newPos;
}
for (Iterator iter = operators.iterator();iter.hasNext();) {
String operator = (String)iter.next();
if (nextValueIs(input, newPos, operator)) {
linkedList.add(text);
return newPos;
}
}
text.append(input.substring(newPos, ++newPos));
}
//don't add empty text entry (may be at end)
if (!text.toString().trim().equals("")) {
linkedList.add(text);
}
return newPos;
}
private int handleProperty(String input, int pos, LinkedList linkedList) {
int propertyPos = pos + "PROP.".length();
StringBuffer propertyName = new StringBuffer("PROP.");
while (propertyPos < input.length()) {
if (nextValueIs(input, propertyPos, " ")) {
linkedList.add(propertyName);
return propertyPos;
}
if (nextValueIs(input, propertyPos, "(")) {
linkedList.add(propertyName);
return propertyPos;
}
if (nextValueIs(input, propertyPos, ")")) {
linkedList.add(propertyName);
return propertyPos;
}
for (Iterator iter = operators.iterator();iter.hasNext();) {
String operator = (String)iter.next();
if (nextValueIs(input, propertyPos, operator)) {
linkedList.add(propertyName);
return propertyPos;
}
}
propertyName.append(input.substring(propertyPos, ++propertyPos));
}
linkedList.add(propertyName);
return propertyPos;
}
public boolean hasMoreTokens() {
return linkedList.size() > 0;
}
public String nextToken() {
return linkedList.remove().toString();
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/InequalityRule.java 0000664 0000000 0000000 00000011717 12527427642 0030060 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
/**
* A Rule class implementing inequality evaluation.
* expects to be able to convert two values to longs.
* If a specific inequality evaluation class has been provided
* for the event field, the appropriate rule is returned.
* (For example, if the expression is Level < DEBUG,
* a LevelInequalityRule is returned).
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class InequalityRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = -5592986598528885122L;
/**
* field RESOLVER.
*/
private static final LoggingEventFieldResolver RESOLVER =
LoggingEventFieldResolver.getInstance();
/**
* Field name.
*/
private final String field;
/**
* Comparison value.
*/
private final String value;
/**
* Inequality symbol.
*/
private final String inequalitySymbol;
/**
* Create new instance.
* @param inequalitySymbol inequality symbol.
* @param field field
* @param value comparison value.
*/
private InequalityRule(
final String inequalitySymbol,
final String field,
final String value) {
super();
this.inequalitySymbol = inequalitySymbol;
if (!RESOLVER.isField(field)) {
throw new IllegalArgumentException("Invalid " + inequalitySymbol
+ " rule - " + field + " is not a supported field");
}
this.field = field;
this.value = value;
}
/**
* Create new instance from top two elements on stack.
* @param inequalitySymbol inequality symbol.
* @param stack stack.
* @return rule.
*/
public static Rule getRule(final String inequalitySymbol,
final Stack stack) {
if (stack.size() < 2) {
throw new IllegalArgumentException("Invalid " + inequalitySymbol
+ " rule - expected two parameters but received "
+ stack.size());
}
String p2 = stack.pop().toString();
String p1 = stack.pop().toString();
return getRule(inequalitySymbol, p1, p2);
}
/**
* Create new instance from top two elements on stack.
* @param inequalitySymbol inequality symbol.
* @param field field.
* @param value comparison value.
* @return rule.
*/
public static Rule getRule(final String inequalitySymbol,
final String field,
final String value) {
if (field.equalsIgnoreCase(LoggingEventFieldResolver.LEVEL_FIELD)) {
//push the value back on the stack and
// allow the level-specific rule pop values
return LevelInequalityRule.getRule(inequalitySymbol, value);
} else if (
field.equalsIgnoreCase(LoggingEventFieldResolver.TIMESTAMP_FIELD)) {
return TimestampInequalityRule.getRule(inequalitySymbol, value);
} else {
return new InequalityRule(inequalitySymbol, field, value);
}
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
long first = 0;
try {
first = new Long(RESOLVER.getValue(field, event).toString()).longValue();
} catch (NumberFormatException nfe) {
return false;
}
long second = 0;
try {
second = new Long(value).longValue();
} catch (NumberFormatException nfe) {
return false;
}
boolean result = false;
if ("<".equals(inequalitySymbol)) {
result = first < second;
} else if (">".equals(inequalitySymbol)) {
result = first > second;
} else if ("<=".equals(inequalitySymbol)) {
result = first <= second;
} else if (">=".equals(inequalitySymbol)) {
result = first >= second;
}
if (result && matches != null) {
Set entries = (Set) matches.get(field.toUpperCase());
if (entries == null) {
entries = new HashSet();
matches.put(field.toUpperCase(), entries);
}
entries.add(String.valueOf(first));
}
return result;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/LevelEqualsRule.java 0000664 0000000 0000000 00000010542 12527427642 0030151 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.io.IOException;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Level;
import org.apache.log4j.helpers.UtilLoggingLevel;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
/**
* A Rule class implementing equals against two levels.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class LevelEqualsRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = -3638386582899583994L;
/**
* Level.
*/
private transient Level level;
/**
* List of levels.
*/
private static List levelList = new LinkedList();
static {
populateLevels();
}
/**
* Create new instance.
* @param level level.
*/
private LevelEqualsRule(final Level level) {
super();
this.level = level;
}
/**
* Populate list of levels.
*/
private static void populateLevels() {
levelList = new LinkedList();
levelList.add(Level.FATAL.toString());
levelList.add(Level.ERROR.toString());
levelList.add(Level.WARN.toString());
levelList.add(Level.INFO.toString());
levelList.add(Level.DEBUG.toString());
Level trace = Level.toLevel(5000, null);
if (trace != null) {
levelList.add(trace.toString());
}
}
/**
* Create new rule.
* @param value name of level.
* @return instance of LevelEqualsRule.
*/
public static Rule getRule(final String value) {
Level thisLevel;
if (levelList.contains(value.toUpperCase())) {
thisLevel = Level.toLevel(value.toUpperCase());
} else {
thisLevel = UtilLoggingLevel.toLevel(value.toUpperCase());
}
return new LevelEqualsRule(thisLevel);
}
/**
* {@inheritDoc}
*/
public boolean evaluate(final LoggingEvent event, Map matches) {
//both util.logging and log4j contain 'info' - use the int values instead of equality
//info level set to the same value for both levels
Level eventLevel = event.getLevel();
boolean result = (level.toInt() == eventLevel.toInt());
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.LEVEL_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.LEVEL_FIELD, entries);
}
entries.add(eventLevel);
}
return result;
}
/**
* Deserialize the state of the object.
*
* @param in object input stream.
*
* @throws IOException if error in reading stream for deserialization.
*/
private void readObject(final java.io.ObjectInputStream in)
throws IOException {
populateLevels();
boolean isUtilLogging = in.readBoolean();
int levelInt = in.readInt();
if (isUtilLogging) {
level = UtilLoggingLevel.toLevel(levelInt);
} else {
level = Level.toLevel(levelInt);
}
}
/**
* Serialize the state of the object.
*
* @param out object output stream.
*
* @throws IOException if error in writing stream during serialization.
*/
private void writeObject(final java.io.ObjectOutputStream out)
throws IOException {
out.writeBoolean(level instanceof UtilLoggingLevel);
out.writeInt(level.toInt());
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/LevelInequalityRule.java 0000664 0000000 0000000 00000021057 12527427642 0031046 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Level;
import org.apache.log4j.helpers.UtilLoggingLevel;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
/**
* A Rule class implementing inequality evaluation for Levels (log4j and
* util.logging) using the toInt method.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class LevelInequalityRule {
/**
* Level list.
*/
private static List levelList;
/**
* List equivalents of java.util.logging levels.
*/
private static List utilLoggingLevelList;
static {
populateLevels();
}
/**
* Create new instance.
*/
private LevelInequalityRule() {
super();
}
/**
* Populate list of levels.
*/
private static void populateLevels() {
levelList = new LinkedList();
levelList.add(Level.FATAL.toString());
levelList.add(Level.ERROR.toString());
levelList.add(Level.WARN.toString());
levelList.add(Level.INFO.toString());
levelList.add(Level.DEBUG.toString());
Level trace = Level.toLevel(5000, null);
if (trace != null) {
levelList.add(trace.toString());
}
utilLoggingLevelList = new LinkedList();
utilLoggingLevelList.add(UtilLoggingLevel.SEVERE.toString());
utilLoggingLevelList.add(UtilLoggingLevel.WARNING.toString());
utilLoggingLevelList.add(UtilLoggingLevel.INFO.toString());
utilLoggingLevelList.add(UtilLoggingLevel.CONFIG.toString());
utilLoggingLevelList.add(UtilLoggingLevel.FINE.toString());
utilLoggingLevelList.add(UtilLoggingLevel.FINER.toString());
utilLoggingLevelList.add(UtilLoggingLevel.FINEST.toString());
}
/**
* Create new rule.
* @param inequalitySymbol inequality symbol.
* @param value Symbolic name of comparison level.
* @return instance of AbstractRule.
*/
public static Rule getRule(final String inequalitySymbol,
final String value) {
Level thisLevel;
//if valid util.logging levels are used against events
// with log4j levels, the
//DEBUG level is used and an illegalargumentexception won't be generated
//an illegalargumentexception is only generated
// if the user types a level name
//that doesn't exist as either a log4j or util.logging level name
if (levelList.contains(value.toUpperCase())) {
thisLevel = Level.toLevel(value.toUpperCase());
} else if (utilLoggingLevelList.contains(value.toUpperCase())) {
thisLevel = UtilLoggingLevel.toLevel(value.toUpperCase());
} else {
throw new IllegalArgumentException(
"Invalid level inequality rule - " + value
+ " is not a supported level");
}
if ("<".equals(inequalitySymbol)) {
return new LessThanRule(thisLevel);
}
if (">".equals(inequalitySymbol)) {
return new GreaterThanRule(thisLevel);
}
if ("<=".equals(inequalitySymbol)) {
return new LessThanEqualsRule(thisLevel);
}
if (">=".equals(inequalitySymbol)) {
return new GreaterThanEqualsRule(thisLevel);
}
return null;
}
/**
* Rule returning true if event level less than specified level.
*/
private static final class LessThanRule extends AbstractRule {
/**
* Comparison level.
*/
private final int newLevelInt;
/**
* Create new instance.
* @param level comparison level.
*/
public LessThanRule(final Level level) {
super();
newLevelInt = level.toInt();
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
Level eventLevel = event.getLevel();
boolean result = (eventLevel.toInt() < newLevelInt);
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.LEVEL_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.LEVEL_FIELD, entries);
}
entries.add(eventLevel);
}
return result;
}
}
/**
* Rule returning true if event level greater than specified level.
*/
private static final class GreaterThanRule extends AbstractRule {
/**
* Comparison level.
*/
private final int newLevelInt;
/**
* Create new instance.
* @param level comparison level.
*/
public GreaterThanRule(final Level level) {
super();
newLevelInt = level.toInt();
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
Level eventLevel = event.getLevel();
boolean result = (eventLevel.toInt() > newLevelInt);
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.LEVEL_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.LEVEL_FIELD, entries);
}
entries.add(eventLevel);
}
return result;
}
}
/**
* Rule returning true if event level greater than
* or equal to specified level.
*/
private static final class GreaterThanEqualsRule extends AbstractRule {
/**
* Comparison level.
*/
private final int newLevelInt;
/**
* Create new instance.
* @param level comparison level.
*/
public GreaterThanEqualsRule(final Level level) {
super();
newLevelInt = level.toInt();
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
Level eventLevel = event.getLevel();
boolean result = eventLevel.toInt() >= newLevelInt;
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.LEVEL_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.LEVEL_FIELD, entries);
}
entries.add(eventLevel);
}
return result;
}
}
/**
* Rule returning true if event level less than or
* equal to specified level.
*/
private static final class LessThanEqualsRule extends AbstractRule {
/**
* Comparison level.
*/
private final int newLevelInt;
/**
* Create new instance.
* @param level comparison level.
*/
public LessThanEqualsRule(final Level level) {
super();
newLevelInt = level.toInt();
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
Level eventLevel = event.getLevel();
boolean result = eventLevel.toInt() <= newLevelInt;
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.LEVEL_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.LEVEL_FIELD, entries);
}
entries.add(eventLevel);
}
return result;
}
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/LikeRule.java 0000664 0000000 0000000 00000011646 12527427642 0026621 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
import java.io.IOException;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;
/**
* A Rule class supporting java.util.regex regular expression syntax.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class LikeRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = -3375458885595683156L;
/**
* Resolver.
*/
private static final LoggingEventFieldResolver RESOLVER =
LoggingEventFieldResolver.getInstance();
/**
* Pattern.
*/
private transient Pattern pattern;
/**
* Regular expression matcher.
*/
private transient Matcher matcher = null;
/**
* Field.
*/
private transient String field;
/**
* Create new instance.
* @param field field
* @param pattern pattern
*/
private LikeRule(final String field, final Pattern pattern) {
super();
if (!RESOLVER.isField(field)) {
throw new IllegalArgumentException(
"Invalid LIKE rule - " + field + " is not a supported field");
}
this.field = field;
this.pattern = pattern;
}
/**
* Create new instance from top two elements of stack.
* @param stack stack
* @return new instance
*/
public static Rule getRule(final Stack stack) {
if (stack.size() < 2) {
throw new IllegalArgumentException(
"Invalid LIKE rule - expected two parameters but received "
+ stack.size());
}
String p2 = stack.pop().toString();
String p1 = stack.pop().toString();
return getRule(p1, p2);
}
/**
* Create new instance.
* @param field field
* @param pattern pattern
* @return new instance
*/
public static Rule getRule(final String field, final String pattern) {
try {
return new LikeRule(field, Pattern.compile(pattern, Pattern.CASE_INSENSITIVE));
} catch (PatternSyntaxException e) {
throw new IllegalArgumentException(
"Invalid LIKE rule - " + e.getMessage());
}
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
//no need to figure out what part of the string matched, just set the entire string as a match
Object input = RESOLVER.getValue(field, event);
if((input != null) && (pattern != null)) {
if (matcher == null) {
matcher = pattern.matcher(input.toString());
} else {
matcher.reset(input.toString());
}
boolean result = matcher.matches();
if (result && matches != null) {
Set entries = (Set) matches.get(field.toUpperCase());
if (entries == null) {
entries = new HashSet();
matches.put(field.toUpperCase(), entries);
}
entries.add(input);
}
return result;
}
return false;
}
/**
* Deserialize the state of the object.
*
* @param in object input stream
*
* @throws IOException if IOException during deserialization
* @throws ClassNotFoundException if class not found.
*/
private void readObject(final java.io.ObjectInputStream in)
throws IOException, ClassNotFoundException {
try {
field = (String) in.readObject();
String patternString = (String) in.readObject();
pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
} catch (PatternSyntaxException e) {
throw new IOException("Invalid LIKE rule - " + e.getMessage());
}
}
/**
* Serialize the state of the object.
*
* @param out object output stream
*
* @throws IOException if IOException during serialization
*/
private void writeObject(final java.io.ObjectOutputStream out)
throws IOException {
out.writeObject(field);
out.writeObject(pattern.pattern());
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/NotEqualsRule.java 0000664 0000000 0000000 00000006671 12527427642 0027652 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
/**
* A Rule class implementing not equals against two strings.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class NotEqualsRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = -1135478467213793211L;
/**
* Resolver.
*/
private static final LoggingEventFieldResolver RESOLVER =
LoggingEventFieldResolver.getInstance();
/**
* Field.
*/
private final String field;
/**
* Value.
*/
private final String value;
/**
* Create new instance.
* @param field field
* @param value value
*/
private NotEqualsRule(final String field, final String value) {
super();
if (!RESOLVER.isField(field)) {
throw new IllegalArgumentException(
"Invalid NOT EQUALS rule - " + field + " is not a supported field");
}
this.field = field;
this.value = value;
}
/**
* Get new instance.
* @param field field
* @param value value
* @return new instance.
*/
public static Rule getRule(final String field, final String value) {
if (field.equalsIgnoreCase(LoggingEventFieldResolver.LEVEL_FIELD)) {
return NotLevelEqualsRule.getRule(value);
} else {
return new NotEqualsRule(field, value);
}
}
/**
* Get new instance from top two elements of stack.
* @param stack stack.
* @return new instance.
*/
public static Rule getRule(final Stack stack) {
if (stack.size() < 2) {
throw new IllegalArgumentException(
"Invalid NOT EQUALS rule - expected two parameters but received "
+ stack.size());
}
String p2 = stack.pop().toString();
String p1 = stack.pop().toString();
if (p1.equalsIgnoreCase(LoggingEventFieldResolver.LEVEL_FIELD)) {
return NotLevelEqualsRule.getRule(p2);
} else {
return new NotEqualsRule(p1, p2);
}
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
Object p2 = RESOLVER.getValue(field, event);
boolean result = (p2 != null) && !(p2.toString().equals(value));
if (result && matches != null) {
//not equals - add the text that isn't equal (p2)
Set entries = (Set) matches.get(field.toUpperCase());
if (entries == null) {
entries = new HashSet();
matches.put(field.toUpperCase(), entries);
}
entries.add(value);
}
return result;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/NotLevelEqualsRule.java 0000664 0000000 0000000 00000010560 12527427642 0030632 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import java.io.IOException;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Set;
import org.apache.log4j.Level;
import org.apache.log4j.helpers.UtilLoggingLevel;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
/**
* A Rule class implementing not equals against two levels.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class NotLevelEqualsRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = -3638386582899583994L;
/**
* Level.
*/
private transient Level level;
/**
* List of levels.
*/
private static List levelList = new LinkedList();
static {
populateLevels();
}
/**
* Create new instance.
* @param level level.
*/
private NotLevelEqualsRule(final Level level) {
super();
this.level = level;
}
/**
* Populate list of levels.
*/
private static void populateLevels() {
levelList = new LinkedList();
levelList.add(Level.FATAL.toString());
levelList.add(Level.ERROR.toString());
levelList.add(Level.WARN.toString());
levelList.add(Level.INFO.toString());
levelList.add(Level.DEBUG.toString());
Level trace = Level.toLevel(5000, null);
if (trace != null) {
levelList.add(trace.toString());
}
}
/**
* Create new rule.
* @param value name of level.
* @return instance of NotLevelEqualsRule.
*/
public static Rule getRule(final String value) {
Level thisLevel;
if (levelList.contains(value.toUpperCase())) {
thisLevel = Level.toLevel(value.toUpperCase());
} else {
thisLevel = UtilLoggingLevel.toLevel(value.toUpperCase());
}
return new NotLevelEqualsRule(thisLevel);
}
/**
* {@inheritDoc}
*/
public boolean evaluate(final LoggingEvent event, Map matches) {
//both util.logging and log4j contain 'info' - use the int values instead of equality
//info level set to the same value for both levels
Level eventLevel = event.getLevel();
boolean result = level.toInt() != eventLevel.toInt();
if (result && matches != null) {
Set entries = (Set) matches.get(LoggingEventFieldResolver.LEVEL_FIELD);
if (entries == null) {
entries = new HashSet();
matches.put(LoggingEventFieldResolver.LEVEL_FIELD, entries);
}
entries.add(eventLevel);
}
return result;
}
/**
* Deserialize the state of the object.
*
* @param in object input stream.
*
* @throws IOException if error in reading stream for deserialization.
*/
private void readObject(final java.io.ObjectInputStream in)
throws IOException {
populateLevels();
boolean isUtilLogging = in.readBoolean();
int levelInt = in.readInt();
if (isUtilLogging) {
level = UtilLoggingLevel.toLevel(levelInt);
} else {
level = Level.toLevel(levelInt);
}
}
/**
* Serialize the state of the object.
*
* @param out object output stream.
*
* @throws IOException if error in writing stream during serialization.
*/
private void writeObject(final java.io.ObjectOutputStream out)
throws IOException {
out.writeBoolean(level instanceof UtilLoggingLevel);
out.writeInt(level.toInt());
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/NotRule.java 0000664 0000000 0000000 00000005770 12527427642 0026476 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import org.apache.log4j.spi.LoggingEvent;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
/**
* A Rule class implementing logical not.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class NotRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = -6827159473117969306L;
/**
* Enclosed rule.
*/
private final Rule rule;
/**
* Create new instance.
* @param rule enclosed rule.
*/
private NotRule(final Rule rule) {
super();
this.rule = rule;
}
/**
* Create new instance.
* @param rule enclosed rule.
* @return new rule.
*/
public static Rule getRule(final Rule rule) {
return new NotRule(rule);
}
/**
* Create new instance from top element of stack.
* @param stack stack
* @return new rule.
*/
public static Rule getRule(final Stack stack) {
if (stack.size() < 1) {
throw new IllegalArgumentException(
"Invalid NOT rule - expected one rule but received "
+ stack.size());
}
Object o1 = stack.pop();
if (o1 instanceof Rule) {
Rule p1 = (Rule) o1;
return new NotRule(p1);
}
throw new IllegalArgumentException(
"Invalid NOT rule: - expected rule but received " + o1);
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
if (matches == null) {
return !(rule.evaluate(event, null));
}
Map tempMatches = new HashMap();
boolean result = !(rule.evaluate(event, tempMatches));
if (result) {
for (Iterator iter = tempMatches.entrySet().iterator();iter.hasNext();) {
Map.Entry entry = (Map.Entry)iter.next();
Object key = entry.getKey();
Set value = (Set)entry.getValue();
Set mainSet = (Set) matches.get(key);
if (mainSet == null) {
mainSet = new HashSet();
matches.put(key, mainSet);
}
mainSet.addAll(value);
}
}
return result;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/OrRule.java 0000664 0000000 0000000 00000010055 12527427642 0026306 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import org.apache.log4j.spi.LoggingEvent;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
/**
* A Rule class implementing logical or.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class OrRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = 2088765995061413165L;
/**
* rule 1.
*/
private final Rule rule1;
/**
* Rule 2.
*/
private final Rule rule2;
/**
* Create new instance.
* @param firstParam first rule
* @param secondParam second rule
*/
private OrRule(final Rule firstParam, final Rule secondParam) {
super();
this.rule1 = firstParam;
this.rule2 = secondParam;
}
/**
* Create new instance.
* @param firstParam first rule
* @param secondParam second rule
* @return new instance
*/
public static Rule getRule(final Rule firstParam, final Rule secondParam) {
return new OrRule(firstParam, secondParam);
}
/**
* Create new instance from top two elements of stack.
* @param stack stack
* @return new instance
*/
public static Rule getRule(final Stack stack) {
if (stack.size() < 2) {
throw new IllegalArgumentException(
"Invalid OR rule - expected two rules but received "
+ stack.size());
}
Object o2 = stack.pop();
Object o1 = stack.pop();
if ((o2 instanceof Rule) && (o1 instanceof Rule)) {
Rule p2 = (Rule) o2;
Rule p1 = (Rule) o1;
return new OrRule(p1, p2);
}
throw new IllegalArgumentException("Invalid OR rule: " + o2 + "..." + o1);
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
if (matches == null) {
return (rule1.evaluate(event, null) || rule2.evaluate(event, null));
}
Map tempMatches1 = new HashMap();
Map tempMatches2 = new HashMap();
//not short-circuiting because we want to build the matches list
boolean result1 = rule1.evaluate(event, tempMatches1);
boolean result2 = rule2.evaluate(event, tempMatches2);
boolean result = result1 || result2;
if (result) {
for (Iterator iter = tempMatches1.entrySet().iterator();iter.hasNext();) {
Map.Entry entry = (Map.Entry)iter.next();
Object key = entry.getKey();
Set value = (Set)entry.getValue();
Set mainSet = (Set) matches.get(key);
if (mainSet == null) {
mainSet = new HashSet();
matches.put(key, mainSet);
}
mainSet.addAll(value);
}
for (Iterator iter = tempMatches2.entrySet().iterator();iter.hasNext();) {
Map.Entry entry = (Map.Entry)iter.next();
Object key = entry.getKey();
Set value = (Set)entry.getValue();
Set mainSet = (Set) matches.get(key);
if (mainSet == null) {
mainSet = new HashSet();
matches.put(key, mainSet);
}
mainSet.addAll(value);
}
}
return result;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/PartialTextMatchRule.java 0000664 0000000 0000000 00000006326 12527427642 0031152 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.spi.LoggingEventFieldResolver;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.Stack;
/**
* A Rule class implementing case-insensitive
* partial-text matches against two strings.
*
* @author Scott Deboy (sdeboy@apache.org)
*/
public class PartialTextMatchRule extends AbstractRule {
/**
* Serialization ID.
*/
static final long serialVersionUID = 6963284773637727558L;
/**
* Resolver.
*/
private static final LoggingEventFieldResolver RESOLVER =
LoggingEventFieldResolver.getInstance();
/**
* Field.
*/
private final String field;
/**
* Value.
*/
private final String value;
/**
* Create new instance.
* @param field field
* @param value value
*/
private PartialTextMatchRule(final String field, final String value) {
super();
if (!RESOLVER.isField(field)) {
throw new IllegalArgumentException(
"Invalid partial text rule - " + field + " is not a supported field");
}
this.field = field;
this.value = value;
}
/**
* Create new instance.
* @param field field
* @param value value
* @return new instance
*/
public static Rule getRule(final String field, final String value) {
return new PartialTextMatchRule(field, value);
}
/**
* Create new instance from top two elements of stack.
* @param stack stack
* @return new instance
*/
public static Rule getRule(final Stack stack) {
if (stack.size() < 2) {
throw new IllegalArgumentException(
"invalid partial text rule - expected two parameters but received "
+ stack.size());
}
String p2 = stack.pop().toString();
String p1 = stack.pop().toString();
return new PartialTextMatchRule(p1, p2);
}
/** {@inheritDoc} */
public boolean evaluate(final LoggingEvent event, Map matches) {
Object p2 = RESOLVER.getValue(field, event);
boolean result = ((p2 != null) && (value != null) && (p2.toString().toLowerCase().indexOf(value.toLowerCase()) > -1));
if (result && matches != null) {
Set entries = (Set) matches.get(field.toUpperCase());
if (entries == null) {
entries = new HashSet();
matches.put(field.toUpperCase(), entries);
}
entries.add(value);
}
return result;
}
}
apache-log4j-extras1.2-1.2.17/src/main/java/org/apache/log4j/rule/Rule.java 0000664 0000000 0000000 00000004451 12527427642 0026010 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import org.apache.log4j.spi.LoggingEvent;
import java.beans.PropertyChangeListener;
import java.util.Map;
/**
* A Rule evaluates to true of false given a LoggingEvent object, and can notify
* listeners when the underlying implementation of this Rule has it's
* criteria changed by using the standard PropertyChangeListener infrastructure.
*
* @author Paul Smith (psmith@apache.org)
* @author Scott Deboy (sdeboy@apache.org)
*/
public interface Rule {
/**
* Returns true if this implementation of the rule accepts the LoggingEvent,
* or false if not.
*
*
* <!DOCTYPE log4j:eventSet [<!ENTITY data SYSTEM "data.xml">]>
*
* <log4j:eventSet xmlns:log4j="http://jakarta.apache.org/log4j/">
* &data
* </log4j:eventSet>
*
*
*
* The layout will detect the encoding and media-type specified in
* the transform. If no encoding is specified in the transform,
* an xsl:output element specifying the US-ASCII encoding will be inserted
* before processing the transform. If an encoding is specified in the transform,
* the same encoding should be explicitly specified for the appender.
*
* Extracting MDC values can be expensive when used with log4j releases
* prior to 1.2.15. Output of MDC values is enabled by default
* but be suppressed by setting properties to false.
*
* Extracting location info can be expensive regardless of log4j version.
* Output of location info is disabled by default but can be enabled
* by setting locationInfo to true.
*
* Embedded transforms in XML configuration should not
* depend on namespace prefixes defined earlier in the document
* as namespace aware parsing in not generally performed when
* using DOMConfigurator. The transform will serialize
* and reparse to get the namespace aware document needed.
*
*/
public final class XSLTLayout extends Layout
implements UnrecognizedElementHandler {
/**
* Namespace for XSLT.
*/
private static final String XSLT_NS = "http://www.w3.org/1999/XSL/Transform";
/**
* Namespace for log4j events.
*/
private static final String LOG4J_NS = "http://jakarta.apache.org/log4j/";
/**
* Whether location information should be written.
*/
private boolean locationInfo = false;
/**
* media-type (mime type) extracted from XSLT transform.
*/
private String mediaType = "text/plain";
/**
* Encoding extracted from XSLT transform.
*/
private Charset encoding;
/**
* Transformer factory.
*/
private SAXTransformerFactory transformerFactory;
/**
* XSLT templates.
*/
private Templates templates;
/**
* Output stream.
*/
private final ByteArrayOutputStream outputStream;
/**
* Whether throwable information should be ignored.
*/
private boolean ignoresThrowable = false;
/**
* Whether properties should be extracted.
*/
private boolean properties = true;
/**
* Whether activateOptions has been called.
*/
private boolean activated = false;
/**
* DateFormat for UTC time.
*/
private final CachedDateFormat utcDateFormat;
/**
* Default constructor.
*
*/
public XSLTLayout() {
outputStream = new ByteArrayOutputStream();
transformerFactory = (SAXTransformerFactory)
TransformerFactory.newInstance();
SimpleDateFormat zdf = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
zdf.setTimeZone(TimeZone.getTimeZone("UTC"));
utcDateFormat = new CachedDateFormat(zdf, 1000);
}
/**
* {@inheritDoc}
*/
public synchronized String getContentType() {
return mediaType;
}
/**
* The LocationInfo option takes a boolean value. By default, it is
* set to false which means there will be no location information output by
* this layout. If the the option is set to true, then the file name and line
* number of the statement at the origin of the log statement will be output.
*
*
#end
#end
#macro ( banner $banner $id )
#if ( $banner )
#if( $banner.href )
#else
#else
$banner.name
#end
##
#if( $banner.href )
#else
#foreach( $subitem in $item.items )
#menuItem( $subitem )
#end
#end
#end
" )
##
#if ( $position == "left" )
$img $menu.name
#else
$menu.name $img
#end
#else
$menu.name
#end
#end
#if ( $menu.items && $menu.items.size() > 0 )
#foreach( $item in $menu.items )
#menuItem( $item )
#end
#end
#end
#end
##
#macro ( copyright )
#if ( $project )
#if ( ${project.organization} && ${project.organization.name} )
#set ( $period = "" )
#else
#set ( $period = "." )
#end
##
#set ( $currentYear = ${currentDate.year} + 1900 )
##
#if ( ${project.inceptionYear} && ( ${project.inceptionYear} != ${currentYear.toString()} ) )
${project.inceptionYear}-${currentYear}${period}
#else
${currentYear}${period}
#end
##
#if ( ${project.organization} )
#if ( ${project.organization.name} && ${project.organization.url} )
${project.organization.name}.
#elseif ( ${project.organization.name} )
${project.organization.name}.
#end
#end
#end
#end
##
#macro ( publishDate $position $publishDate $version )
#if ( $publishDate && $publishDate.format )
#set ( $format = $publishDate.format )
#else
#set ( $format = "yyyy-MM-dd" )
#end
##
$dateFormat.applyPattern( $format )
##
#set ( $dateToday = $dateFormat.format( $currentDate ) )
##
#if ( $publishDate && $publishDate.position )
#set ( $datePosition = $publishDate.position )
#else
#set ( $datePosition = "left" )
#end
##
#if ( $version )
#if ( $version.position )
#set ( $versionPosition = $version.position )
#else
#set ( $versionPosition = "left" )
#end
#else
#set ( $version = "" )
#set ( $versionPosition = "left" )
#end
##
#set ( $breadcrumbs = $decoration.body.breadcrumbs )
#set ( $links = $decoration.body.links )
#if ( $datePosition.equalsIgnoreCase( "right" ) && $links && $links.size() > 0 )
#set ( $prefix = " |" )
#else
#set ( $prefix = "" )
#end
##
#if ( $datePosition.equalsIgnoreCase( $position ) )
#if ( ( $datePosition.equalsIgnoreCase( "right" ) ) || ( $datePosition.equalsIgnoreCase( "bottom" ) ) )
$prefix $i18n.getString( "site-renderer", $locale, "template.lastpublished" ): $dateToday
#if ( $versionPosition.equalsIgnoreCase( $position ) )
| $i18n.getString( "site-renderer", $locale, "template.version" ): ${project.version}
#end
#elseif ( ( $datePosition.equalsIgnoreCase( "navigation-bottom" ) ) || ( $datePosition.equalsIgnoreCase( "navigation-top" ) ) )
#end
#if( $poweredBy.isEmpty() )
#end
#else
#end
#end
##
w{rIu&Rʹ]cro* s sIRvQ 67MҡAZF;)ځse|]: +moy"Pio,
Jŗڦcp!k_,;*E(jxe 9dLBPR r#揳i ˰~<"(fWV*_FR1
0I 9鿼_ v m a I齢#/Wl6/$ !kr4̩^Mȭ^ZΟs ߛ pzg?w-^noO[7]qޙgre ;<,(X| rN .?X`z^lwUq_֭yϭF. ( Mk+$sBcsׄF:ded 9-<=}.#C57%C80b
Compression ActiveFileName Stop/Restart
Test1 NO BLANK NO
Test2 NO BLANK YES
Test3 YES BLANK NO
Test4 NO SET YES
Test5 NO SET NO
Test6 YES SET NO
*
* @author Ceki Gülcü
*/
public class TimeBasedRollingTest extends TestCase {
Logger logger = Logger.getLogger(TimeBasedRollingTest.class);
public TimeBasedRollingTest(String name) {
super(name);
}
public void setUp() {
Logger root = Logger.getRootLogger();
root.addAppender(
new ConsoleAppender(new PatternLayout("%d{ABSOLUTE} [%t] %level %c{2}#%M:%L - %m%n")));
}
public void tearDown() {
LogManager.shutdown();
}
private static boolean compare(final String actual, final String expected)
throws IOException {
return Compare.compare(TimeBasedRollingTest.class, actual, expected);
}
private static boolean gzCompare(final String actual, final String expected)
throws IOException {
return Compare.gzCompare(TimeBasedRollingTest.class, actual, expected);
}
private static void configure(final String configName) throws IOException {
String resourceName = configName;
int lastSlash = resourceName.lastIndexOf("/");
if (lastSlash >= 0) {
resourceName = resourceName.substring(lastSlash + 1);
}
InputStream is = TimeBasedRollingTest.class.getResourceAsStream(resourceName);
if (is == null) {
throw new FileNotFoundException("Could not find resource " + resourceName);
}
DOMConfigurator configurator = new DOMConfigurator();
configurator.doConfigure(is, LogManager.getLoggerRepository());
}
/**
* Test rolling without compression, activeFileName left blank, no stop/start
*/
public void test1() throws Exception {
PatternLayout layout = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa = new RollingFileAppender();
rfa.setLayout(layout);
String datePattern = "yyyy-MM-dd_HH_mm_ss";
TimeBasedRollingPolicy tbrp = new TimeBasedRollingPolicy();
tbrp.setFileNamePattern("target/test-tbr-1-%d{" + datePattern + "}");
tbrp.activateOptions();
rfa.setRollingPolicy(tbrp);
rfa.activateOptions();
logger.addAppender(rfa);
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[4];
Calendar cal = Calendar.getInstance();
for (int i = 0; i < 4; i++) {
filenames[i] = "target/test-tbr-1-" + sdf.format(cal.getTime());
cal.add(Calendar.SECOND, 1);
}
System.out.println("Waiting until next second and 100 millis.");
delayUntilNextSecond(100);
System.out.println("Done waiting.");
for (int i = 0; i < 5; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
for (int i = 0; i < 4; i++) {
assertTrue(compare(filenames[i], "witness/rolling/tbr-test1." + i));
}
}
/**
* No compression, with stop/restart, activeFileName left blank
*/
public void test2() throws Exception {
String datePattern = "yyyy-MM-dd_HH_mm_ss";
PatternLayout layout1 = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa1 = new RollingFileAppender();
rfa1.setLayout(layout1);
TimeBasedRollingPolicy tbrp1 = new TimeBasedRollingPolicy();
tbrp1.setFileNamePattern("target/test2-%d{" + datePattern + "}");
tbrp1.activateOptions();
rfa1.setRollingPolicy(tbrp1);
rfa1.activateOptions();
logger.addAppender(rfa1);
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[4];
Calendar cal = Calendar.getInstance();
for (int i = 0; i < 4; i++) {
filenames[i] = "target/test2-" + sdf.format(cal.getTime());
cal.add(Calendar.SECOND, 1);
}
System.out.println("Waiting until next second and 100 millis.");
delayUntilNextSecond(100);
System.out.println("Done waiting.");
for (int i = 0; i <= 2; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
logger.removeAppender(rfa1);
rfa1.close();
PatternLayout layout2 = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa2 = new RollingFileAppender();
rfa2.setLayout(layout2);
TimeBasedRollingPolicy tbrp2 = new TimeBasedRollingPolicy();
tbrp2.setFileNamePattern("target/test2-%d{" + datePattern + "}");
tbrp2.activateOptions();
rfa2.setRollingPolicy(tbrp2);
rfa2.activateOptions();
logger.addAppender(rfa2);
for (int i = 3; i <= 4; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
rfa2.close();
for (int i = 0; i < 4; i++) {
assertTrue(compare(filenames[i], "witness/rolling/tbr-test2." + i));
}
}
/**
* With compression, activeFileName left blank, no stop/restart
*/
public void test3() throws Exception {
PatternLayout layout = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa = new RollingFileAppender();
rfa.setLayout(layout);
String datePattern = "yyyy-MM-dd_HH_mm_ss";
TimeBasedRollingPolicy tbrp = new TimeBasedRollingPolicy();
tbrp.setFileNamePattern("target/test3-%d{" + datePattern + "}.gz");
tbrp.activateOptions();
rfa.setRollingPolicy(tbrp);
rfa.activateOptions();
logger.addAppender(rfa);
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[4];
Calendar cal = Calendar.getInstance();
for (int i = 0; i < 3; i++) {
filenames[i] = "target/test3-" + sdf.format(cal.getTime()) + ".gz";
cal.add(Calendar.SECOND, 1);
}
filenames[3] = "target/test3-" + sdf.format(cal.getTime());
System.out.println("Waiting until next second and 100 millis.");
delayUntilNextSecond(100);
System.out.println("Done waiting.");
for (int i = 0; i < 5; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
rfa.close();
for (int i = 0; i < 3; i++) {
assertTrue(gzCompare(filenames[i], "witness/rolling/tbr-test3." + i + ".gz"));
}
assertTrue(compare(filenames[3], "witness/rolling/tbr-test3.3"));
}
/**
* Without compression, activeFileName set, with stop/restart
*/
public void test4() throws Exception {
String datePattern = "yyyy-MM-dd_HH_mm_ss";
PatternLayout layout1 = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa1 = new RollingFileAppender();
rfa1.setLayout(layout1);
TimeBasedRollingPolicy tbrp1 = new TimeBasedRollingPolicy();
rfa1.setFile("target/test4.log");
tbrp1.setFileNamePattern("target/test4-%d{" + datePattern + "}");
tbrp1.activateOptions();
rfa1.setRollingPolicy(tbrp1);
rfa1.setAppend(false);
rfa1.activateOptions();
logger.addAppender(rfa1);
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[4];
Calendar cal = Calendar.getInstance();
for (int i = 0; i < 3; i++) {
filenames[i] = "target/test4-" + sdf.format(cal.getTime());
cal.add(Calendar.SECOND, 1);
}
filenames[3] = "target/test4.log";
System.out.println("Waiting until next second and 100 millis.");
delayUntilNextSecond(100);
System.out.println("Done waiting.");
for (int i = 0; i <= 2; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
logger.removeAppender(rfa1);
rfa1.close();
PatternLayout layout2 = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa2 = new RollingFileAppender();
rfa2.setLayout(layout2);
TimeBasedRollingPolicy tbrp2 = new TimeBasedRollingPolicy();
tbrp2.setFileNamePattern("target/test4-%d{" + datePattern + "}");
rfa2.setFile("target/test4.log");
tbrp2.activateOptions();
rfa2.setRollingPolicy(tbrp2);
rfa2.activateOptions();
logger.addAppender(rfa2);
for (int i = 3; i <= 4; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
rfa2.close();
for (int i = 0; i < 4; i++) {
assertTrue(compare(filenames[i], "witness/rolling/tbr-test4." + i));
}
}
/**
* No compression, activeFileName set, without stop/restart
*/
public void test5() throws Exception {
PatternLayout layout = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa = new RollingFileAppender();
rfa.setLayout(layout);
String datePattern = "yyyy-MM-dd_HH_mm_ss";
TimeBasedRollingPolicy tbrp = new TimeBasedRollingPolicy();
tbrp.setFileNamePattern("target/test5-%d{" + datePattern + "}");
rfa.setFile("target/test5.log");
tbrp.activateOptions();
rfa.setRollingPolicy(tbrp);
rfa.setAppend(false);
rfa.activateOptions();
logger.addAppender(rfa);
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[4];
Calendar cal = Calendar.getInstance();
for (int i = 0; i < 3; i++) {
filenames[i] = "target/test5-" + sdf.format(cal.getTime());
cal.add(Calendar.SECOND, 1);
}
filenames[3] = "target/test5.log";
System.out.println("Waiting until next second and 100 millis.");
delayUntilNextSecond(100);
System.out.println("Done waiting.");
for (int i = 0; i < 5; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
for (int i = 0; i < 4; i++) {
assertTrue(compare(filenames[i], "witness/rolling/tbr-test5." + i));
}
}
/**
* With compression, activeFileName set, no stop/restart,
*/
public void test6() throws Exception {
PatternLayout layout = new PatternLayout("%c{1} - %m%n");
RollingFileAppender rfa = new RollingFileAppender();
rfa.setLayout(layout);
String datePattern = "yyyy-MM-dd_HH_mm_ss";
TimeBasedRollingPolicy tbrp = new TimeBasedRollingPolicy();
tbrp.setFileNamePattern("target/test6-%d{" + datePattern + "}.gz");
rfa.setFile("target/test6.log");
tbrp.activateOptions();
rfa.setRollingPolicy(tbrp);
rfa.setAppend(false);
rfa.activateOptions();
logger.addAppender(rfa);
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[4];
Calendar cal = Calendar.getInstance();
for (int i = 0; i < 3; i++) {
filenames[i] = "target/test6-" + sdf.format(cal.getTime()) + ".gz";
cal.add(Calendar.SECOND, 1);
}
filenames[3] = "target/test6.log";
System.out.println("Waiting until next second and 100 millis.");
delayUntilNextSecond(100);
System.out.println("Done waiting.");
for (int i = 0; i < 5; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
rfa.close();
for (int i = 0; i < 3; i++) {
assertTrue(gzCompare(filenames[i], "witness/rolling/tbr-test6." + i + ".gz"));
}
assertTrue(compare(filenames[3], "witness/rolling/tbr-test6.3"));
}
public void testWithJoran1() throws Exception {
configure("./input/rolling/time1.xml");
String datePattern = "yyyy-MM-dd_HH_mm_ss";
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[4];
Calendar cal = Calendar.getInstance();
for (int i = 0; i < 4; i++) {
filenames[i] = "target/test1-" + sdf.format(cal.getTime());
cal.add(Calendar.SECOND, 1);
}
System.out.println("Waiting until next second and 100 millis.");
delayUntilNextSecond(100);
System.out.println("Done waiting.");
for (int i = 0; i < 5; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
for (int i = 0; i < 4; i++) {
assertTrue(compare(filenames[i], "witness/rolling/tbr-test1." + i));
}
}
public void XXXtestWithJoran10() throws Exception {
configure("./input/rolling/time2.xml");
String datePattern = "yyyy-MM-dd";
SimpleDateFormat sdf = new SimpleDateFormat(datePattern);
String[] filenames = new String[0];
Calendar cal = Calendar.getInstance();
filenames[0] = "target/test1-" + sdf.format(cal.getTime());
for (int i = 0; i < 5; i++) {
logger.debug("Hello---" + i);
Thread.sleep(500);
}
for (int i = 0; i < 1; i++) {
assertTrue(compare(filenames[i], "witness/rolling/tbr-test10." + i));
}
}
void delayUntilNextSecond(int millis) {
long now = System.currentTimeMillis();
Calendar cal = Calendar.getInstance();
cal.setTime(new Date(now));
cal.set(Calendar.MILLISECOND, millis);
cal.add(Calendar.SECOND, 1);
long next = cal.getTime().getTime();
try {
Thread.sleep(next - now);
} catch (Exception e) {
}
}
void delayUntilNextMinute(int seconds) {
long now = System.currentTimeMillis();
Calendar cal = Calendar.getInstance();
cal.setTime(new Date(now));
cal.set(Calendar.SECOND, seconds);
cal.add(Calendar.MINUTE, 1);
long next = cal.getTime().getTime();
try {
Thread.sleep(next - now);
} catch (Exception e) {
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rolling/helper/ 0000775 0000000 0000000 00000000000 12527427642 0026243 5 ustar 00root root 0000000 0000000 FileNamePatternTestCase.java 0000664 0000000 0000000 00000011250 12527427642 0033500 0 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rolling/helper /*
* 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 org.apache.log4j.rolling.helper;
import junit.framework.TestCase;
import org.apache.log4j.rolling.RollingPolicyBase;
import org.apache.log4j.rolling.RolloverDescription;
import java.util.Calendar;
/**
* Tests for FileNamePattern.
*
* @author Ceki
* @author Curt Arnold
*
*/
public final class FileNamePatternTestCase extends TestCase {
/**
* Construct new test.
* @param name test name
*/
public FileNamePatternTestCase(final String name) {
super(name);
}
private static class FileNameTestRollingPolicy extends RollingPolicyBase {
public FileNameTestRollingPolicy(final String pattern) {
setFileNamePattern(pattern);
parseFileNamePattern();
}
public void activateOptions() {
}
public RolloverDescription initialize(final String activeName, final boolean append) {
return null;
}
public RolloverDescription rollover(final String activeName) {
return null;
}
public String format(Object obj) {
StringBuffer buf = new StringBuffer();
formatFileName(obj, buf);
return buf.toString();
}
}
private void assertDatePattern(final String pattern, final int year,
final int month, final int day, final int hour, final int min,
final String expected) {
Calendar cal = Calendar.getInstance();
cal.set(year, month, day, hour, min);
FileNameTestRollingPolicy policy = new FileNameTestRollingPolicy(pattern);
assertEquals(expected,
policy.format(cal.getTime()));
}
private void assertIntegerPattern(final String pattern, final int value,
final String expected) {
FileNameTestRollingPolicy policy = new FileNameTestRollingPolicy(pattern);
assertEquals(expected, policy.format(new Integer(value)));
}
public void testFormatInteger1() {
assertIntegerPattern("t", 3, "t");
}
public void testFormatInteger2() {
assertIntegerPattern("foo", 3, "foo");
}
public void testFormatInteger3() {
assertIntegerPattern("foo%", 3, "foo%");
}
public void testFormatInteger4() {
assertIntegerPattern("%ifoo", 3, "3foo");
}
public void testFormatInteger5() {
assertIntegerPattern("foo%ixixo", 3, "foo3xixo");
}
public void testFormatInteger6() {
assertIntegerPattern("foo%i.log", 3, "foo3.log");
}
public void testFormatInteger7() {
assertIntegerPattern("foo.%i.log", 3, "foo.3.log");
}
public void testFormatInteger8() {
assertIntegerPattern("%ifoo%", 3, "3foo%");
}
public void testFormatInteger9() {
assertIntegerPattern("%ifoo%%", 3, "3foo%");
}
public void testFormatInteger10() {
assertIntegerPattern("%%foo", 3, "%foo");
}
public void testFormatInteger11() {
assertIntegerPattern("foo%ibar%i", 3, "foo3bar3");
}
public void testFormatDate1() {
assertDatePattern("foo%d{yyyy.MM.dd}", 2003, 4, 20, 17, 55,
"foo2003.05.20");
}
public void testFormatDate2() {
assertDatePattern("foo%d{yyyy.MM.dd HH:mm}", 2003, 4, 20, 17, 55,
"foo2003.05.20 17:55");
}
public void testFormatDate3() {
assertDatePattern("%d{yyyy.MM.dd HH:mm} foo", 2003, 4, 20, 17, 55,
"2003.05.20 17:55 foo");
}
/**
* A %d is treated as %d{yyyy-MM-dd} if followed by a malformed format specifier.
*
*/
public void testFormatDate4() {
assertDatePattern("foo%dyyyy.MM.dd}", 2003, 4, 20, 17, 55,
"foo2003-05-20yyyy.MM.dd}");
}
/**
* A %d is treated as %d{yyyy-MM-dd} if followed by a malformed format specifier.
*
*/
public void testFormatDate5() {
assertDatePattern("foo%d{yyyy.MM.dd", 2003, 4, 20, 17, 55,
"foo2003-05-20{yyyy.MM.dd");
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/ 0000775 0000000 0000000 00000000000 12527427642 0024265 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/AndRuleTest.java 0000664 0000000 0000000 00000012772 12527427642 0027333 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Stack;
/**
* Test for AndRule.
*/
public class AndRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public AndRuleTest(final String testName) {
super(testName);
}
/**
* AndRule.getRule(Stack) throws exception if only one rule provided.
*/
public void test1() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
try {
AndRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* AndRule.getRule(Stack) throws exception if non-rules are provided.
*/
public void test2() {
Stack stack = new Stack();
stack.push("Hello");
stack.push("World");
try {
AndRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* Test And of Level and Time.
*/
public void test3() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Rule rule = AndRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Test And of Level and Time when Level does not match.
*/
public void test4() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Rule rule = AndRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Test And of Level and Time when Time does not match.
*/
public void test5() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2009/05/21 00:44:45"));
Rule rule = AndRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Test deserialized And.
*/
public void test6() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Rule rule = (Rule) SerializationTestHelper.serializeClone(AndRule.getRule(stack));
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Test deserialized And when Level doesn't match.
*/
public void test7() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Rule rule = (Rule) SerializationTestHelper.serializeClone(AndRule.getRule(stack));
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/EqualsRuleTest.java 0000664 0000000 0000000 00000011754 12527427642 0030062 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Stack;
/**
* Test for EqualsRule.
*/
public class EqualsRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public EqualsRuleTest(final String testName) {
super(testName);
}
/**
* getRule() with only one entry on stack should throw IllegalArgumentException.
*/
public void test1() {
Stack stack = new Stack();
stack.push("Hello");
try {
EqualsRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule() with bad field name should throw IllegalArgumentException.
*/
public void test2() {
Stack stack = new Stack();
stack.push("Hello");
stack.push("World");
try {
EqualsRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule with "level" and "info" should return a LevelEqualsRule.
*/
public void test3() {
Stack stack = new Stack();
stack.push("level");
stack.push("info");
Rule rule = EqualsRule.getRule(stack);
assertEquals(0, stack.size());
assertTrue(rule instanceof LevelEqualsRule);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "timestamp" and time should return a TimestampEqualsRule.
*/
public void test4() {
Stack stack = new Stack();
stack.push("timestamp");
stack.push("2008/05/21 00:45:44");
Rule rule = EqualsRule.getRule(stack);
assertEquals(0, stack.size());
assertTrue(rule instanceof TimestampEqualsRule);
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "msg" should return an EqualsRule.
*/
public void test5() {
Stack stack = new Stack();
stack.push("msg");
stack.push("Hello, World");
Rule rule = EqualsRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "msg" should return an EqualsRule.
*/
public void test6() {
Stack stack = new Stack();
stack.push("msg");
stack.push("Bonjour, Monde");
Rule rule = EqualsRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Check EqualsRule serialization.
*/
public void test7() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push("msg");
stack.push("Hello, World");
Rule rule = (Rule) SerializationTestHelper.serializeClone(EqualsRule.getRule(stack));
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/ExistsRuleTest.java 0000664 0000000 0000000 00000006657 12527427642 0030115 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Stack;
/**
* Test for ExistsRule.
*/
public class ExistsRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public ExistsRuleTest(final String testName) {
super(testName);
}
/**
* getRule() with no entry on stack should throw IllegalArgumentException.
*/
public void test1() {
Stack stack = new Stack();
try {
ExistsRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule() with bad field name should throw IllegalArgumentException.
*/
public void test2() {
Stack stack = new Stack();
stack.push("Hello");
try {
ExistsRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule with "msg".
*/
public void test3() {
Stack stack = new Stack();
stack.push("msg");
Rule rule = ExistsRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "msg".
*/
public void test4() {
Stack stack = new Stack();
stack.push("msg");
Rule rule = ExistsRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"", null);
assertFalse(rule.evaluate(event, null));
}
/**
* getRule with "msg".
*/
public void test5() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push("msg");
Rule rule = (Rule) SerializationTestHelper.serializeClone(ExistsRule.getRule(stack));
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/LevelEqualsRuleTest.java 0000664 0000000 0000000 00000012327 12527427642 0031047 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.helpers.UtilLoggingLevel;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
/**
* Test for LevelEqualsRule.
*/
public class LevelEqualsRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public LevelEqualsRuleTest(final String testName) {
super(testName);
}
/**
* Tests evaluate when levels are equal.
*/
public void test1() {
LevelEqualsRule rule = (LevelEqualsRule) LevelEqualsRule.getRule("info");
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate when levels are not equal.
*/
public void test2() {
LevelEqualsRule rule = (LevelEqualsRule) LevelEqualsRule.getRule("info");
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when levels are equal.
*/
public void test3() throws IOException, ClassNotFoundException {
LevelEqualsRule rule = (LevelEqualsRule)
SerializationTestHelper.serializeClone(LevelEqualsRule.getRule("info"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when levels are not equal.
*/
public void test4() throws IOException, ClassNotFoundException {
LevelEqualsRule rule = (LevelEqualsRule)
SerializationTestHelper.serializeClone(LevelEqualsRule.getRule("info"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Tests evaluate when levels are JDK 1.4 levels and equal.
*/
public void test5() {
LevelEqualsRule rule = (LevelEqualsRule) LevelEqualsRule.getRule("finer");
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINER,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate when levels are JDK 1.4 levels and not equal.
*/
public void test6() {
LevelEqualsRule rule = (LevelEqualsRule) LevelEqualsRule.getRule("finer");
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINE,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when levels are JDK 1.4 levels and equal.
*/
public void test7() throws IOException, ClassNotFoundException {
LevelEqualsRule rule = (LevelEqualsRule)
SerializationTestHelper.serializeClone(LevelEqualsRule.getRule("finer"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINER,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when levels are JDK 1.4 levels and not equal.
*/
public void test8() throws IOException, ClassNotFoundException {
LevelEqualsRule rule = (LevelEqualsRule)
SerializationTestHelper.serializeClone(LevelEqualsRule.getRule("finer"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINE,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/LevelInequalityRuleTest.java 0000664 0000000 0000000 00000011516 12527427642 0031740 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.helpers.UtilLoggingLevel;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
/**
* Test for LevelInequalityRule.
*/
public class LevelInequalityRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public LevelInequalityRuleTest(final String testName) {
super(testName);
}
/**
* Test construction when level is unrecognized.
*/
public void test1() {
try {
LevelInequalityRule.getRule(">", "emergency");
fail("Expected IllegalArgumentException");
} catch(IllegalArgumentException ex) {
}
}
/**
* Tests construction when operator is unrecognized.
*/
public void test2() {
Rule rule = LevelInequalityRule.getRule("~", "iNfO");
assertNull(rule);
}
/**
* Tests evaluate of a deserialized clone when level satisfies rule.
*/
public void test3() throws IOException, ClassNotFoundException {
Rule rule = (Rule)
SerializationTestHelper.serializeClone(LevelInequalityRule.getRule(">=", "info"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when level does not satisfy rule.
*/
public void test4() throws IOException, ClassNotFoundException {
Rule rule = (Rule)
SerializationTestHelper.serializeClone(LevelInequalityRule.getRule("<", "info"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Tests evaluate when levels are JDK 1.4 levels and satisified.
*/
public void test5() {
Rule rule = (Rule) LevelInequalityRule.getRule(">=", "finer");
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINER,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate when levels are JDK 1.4 levels and not equal.
*/
public void test6() {
Rule rule = (Rule) LevelInequalityRule.getRule("<", "finer");
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINER,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when levels are JDK 1.4 levels and satisified.
*/
public void test7() throws IOException, ClassNotFoundException {
Rule rule = (Rule)
SerializationTestHelper.serializeClone(LevelInequalityRule.getRule(">=", "finer"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINER,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when levels are JDK 1.4 levels and not satified.
*/
public void test8() throws IOException, ClassNotFoundException {
Rule rule = (Rule)
SerializationTestHelper.serializeClone(LevelInequalityRule.getRule("<", "finer"));
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), UtilLoggingLevel.FINER,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/NotEqualsRuleTest.java 0000664 0000000 0000000 00000011444 12527427642 0030537 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Stack;
/**
* Test for NotEqualsRule.
*/
public class NotEqualsRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public NotEqualsRuleTest(final String testName) {
super(testName);
}
/**
* getRule() with only one entry on stack should throw IllegalArgumentException.
*/
public void test1() {
Stack stack = new Stack();
stack.push("Hello");
try {
NotEqualsRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule() with bad field name should throw IllegalArgumentException.
*/
public void test2() {
Stack stack = new Stack();
stack.push("Hello");
stack.push("World");
try {
NotEqualsRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule with "level" and "info".
*/
public void test3() {
Stack stack = new Stack();
stack.push("level");
stack.push("info");
Rule rule = NotEqualsRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.WARN,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "timestamp" and time.
*/
public void test4() {
Stack stack = new Stack();
stack.push("timestamp");
stack.push("2008/05/21 00:45:44");
Rule rule = NotEqualsRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2009, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "msg".
*/
public void test5() {
Stack stack = new Stack();
stack.push("msg");
stack.push("Hello, World");
Rule rule = NotEqualsRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* getRule with "msg".
*/
public void test6() {
Stack stack = new Stack();
stack.push("msg");
stack.push("Bonjour, Monde");
Rule rule = NotEqualsRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Check NotEqualsRule serialization.
*/
public void test7() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push("msg");
stack.push("Hello, World");
Rule rule = (Rule) SerializationTestHelper.serializeClone(NotEqualsRule.getRule(stack));
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/NotRuleTest.java 0000664 0000000 0000000 00000010641 12527427642 0027362 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Stack;
/**
* Test for NotRule.
*/
public class NotRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public NotRuleTest(final String testName) {
super(testName);
}
/**
* NotRule.getRule(Stack) throws exception if only one rule provided.
*/
public void test1() {
Stack stack = new Stack();
try {
NotRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* NotRule.getRule(Stack) throws exception if non-rules are provided.
*/
public void test2() {
Stack stack = new Stack();
stack.push("Hello");
try {
NotRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* Test Not of LevelEqualsRule.
*/
public void test3() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
Rule rule = NotRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Test Not of Level when Level does not match.
*/
public void test4() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
Rule rule = NotRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Test deserialized Not.
*/
public void test5() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
Rule rule = (Rule) SerializationTestHelper.serializeClone(NotRule.getRule(stack));
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Test deserialized Not.
*/
public void test6() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
Rule rule = (Rule) SerializationTestHelper.serializeClone(NotRule.getRule(stack));
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/OrRuleTest.java 0000664 0000000 0000000 00000014212 12527427642 0027200 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
import java.util.Stack;
/**
* Test for OrRule.
*/
public class OrRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public OrRuleTest(final String testName) {
super(testName);
}
/**
* OrRule.getRule(Stack) throws exception if only one rule provided.
*/
public void test1() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
try {
OrRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* OrRule.getRule(Stack) throws exception if non-rules are provided.
*/
public void test2() {
Stack stack = new Stack();
stack.push("Hello");
stack.push("World");
try {
OrRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* Test Or of Level and Time.
*/
public void test3() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Rule rule = OrRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Test Or of Level and Time when Level does not match.
*/
public void test4() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Rule rule = OrRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Test Or of Level and Time when Time does not match.
*/
public void test5() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2009/05/21 00:44:45"));
Rule rule = OrRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Test Or of Level and Time when Time and Level do not match.
*/
public void test6() {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2009/05/21 00:44:45"));
Rule rule = OrRule.getRule(stack);
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Test deserialized Or.
*/
public void test7() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Rule rule = (Rule) SerializationTestHelper.serializeClone(OrRule.getRule(stack));
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Test deserialized Or when neither rule match.
*/
public void test8() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push(LevelEqualsRule.getRule("INFO"));
stack.push(TimestampInequalityRule.getRule(">=", "2009/05/21 00:44:45"));
Rule rule = (Rule) SerializationTestHelper.serializeClone(OrRule.getRule(stack));
assertEquals(0, stack.size());
Calendar cal = new GregorianCalendar(2008, 04, 21, 00, 45, 44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/PartialTextMatchRuleTest.java 0000664 0000000 0000000 00000010346 12527427642 0032042 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Stack;
/**
* Test for PartialTextMatchRule.
*/
public class PartialTextMatchRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public PartialTextMatchRuleTest(final String testName) {
super(testName);
}
/**
* getRule() with only one entry on stack should throw IllegalArgumentException.
*/
public void test1() {
Stack stack = new Stack();
stack.push("Hello");
try {
PartialTextMatchRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule() with bad field name should throw IllegalArgumentException.
*/
public void test2() {
Stack stack = new Stack();
stack.push("Hello");
stack.push("World");
try {
PartialTextMatchRule.getRule(stack);
fail("Should have thrown IllegalArgumentException");
} catch (IllegalArgumentException ex) {
}
}
/**
* getRule with "level" and "nfo" should return a LevelEqualsRule.
*/
public void test3() {
Stack stack = new Stack();
stack.push("level");
stack.push("nfo");
Rule rule = PartialTextMatchRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "msg".
*/
public void test4() {
Stack stack = new Stack();
stack.push("msg");
stack.push("World");
Rule rule = PartialTextMatchRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* getRule with "msg".
*/
public void test5() {
Stack stack = new Stack();
stack.push("msg");
stack.push("Bonjour, Monde");
Rule rule = PartialTextMatchRule.getRule(stack);
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Check PartailTextMatchRule serialization.
*/
public void test6() throws IOException, ClassNotFoundException {
Stack stack = new Stack();
stack.push("msg");
stack.push("World");
Rule rule = (Rule) SerializationTestHelper.serializeClone(PartialTextMatchRule.getRule(stack));
assertEquals(0, stack.size());
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), System.currentTimeMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/TimestampEqualsRuleTest.java 0000664 0000000 0000000 00000007625 12527427642 0031750 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
/**
* Test for TimestampEqualsRule.
*/
public class TimestampEqualsRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public TimestampEqualsRuleTest(final String testName) {
super(testName);
}
/**
* Tests evaluate when timestamps are equal.
*/
public void test1() {
TimestampEqualsRule rule = (TimestampEqualsRule) TimestampEqualsRule.getRule("2008/05/21 00:45:44");
Calendar cal = new GregorianCalendar(2008,04,21,00,45,44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate when levels are not equal.
*/
public void test2() {
TimestampEqualsRule rule = (TimestampEqualsRule) TimestampEqualsRule.getRule("2008/05/21 00:45:44");
Calendar cal = new GregorianCalendar(2008,04,21,00,46,44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when timestamps are equal.
*/
public void test3() throws IOException, ClassNotFoundException {
TimestampEqualsRule rule = (TimestampEqualsRule)
SerializationTestHelper.serializeClone(TimestampEqualsRule.getRule("2008/05/21 00:45:44"));
Calendar cal = new GregorianCalendar(2008,04,21,00,45,44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when timestamps are not equal.
*/
public void test4() throws IOException, ClassNotFoundException {
TimestampEqualsRule rule = (TimestampEqualsRule)
SerializationTestHelper.serializeClone(TimestampEqualsRule.getRule("2008/05/21 00:45:44"));
Calendar cal = new GregorianCalendar(2008,04,21,00,46,44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
/**
* Tests constructor will badly formed time specification.
*/
public void test5() {
try {
TimestampEqualsRule.getRule("2008/May/21");
fail("IllegalArgumentException expected to be thrown");
} catch(IllegalArgumentException ex) {
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/rule/TimestampInequalityRuleTest.java 0000664 0000000 0000000 00000006220 12527427642 0032630 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.rule;
import junit.framework.TestCase;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.spi.LoggingEvent;
import org.apache.log4j.util.SerializationTestHelper;
import java.io.IOException;
import java.util.Calendar;
import java.util.GregorianCalendar;
/**
* Test for TimestampInequalityRule.
*/
public class TimestampInequalityRuleTest extends TestCase {
/**
* Create new test.
*
* @param testName test name.
*/
public TimestampInequalityRuleTest(final String testName) {
super(testName);
}
/**
* Test construction when timestamp is unrecognized.
*/
public void test1() {
try {
TimestampInequalityRule.getRule(">", "now");
fail("Expected IllegalArgumentException");
} catch(IllegalArgumentException ex) {
}
}
/**
* Tests construction when operator is unrecognized.
*/
public void test2() {
//
// unlike LevelInequalityRule, does not throw exception. Resulting rule never satisified.
//
TimestampInequalityRule.getRule("~", "2008/05/21 00:45:46");
}
/**
* Tests evaluate of a deserialized clone when rule is satisified.
*/
public void test3() throws IOException, ClassNotFoundException {
Rule rule = (Rule)
SerializationTestHelper.serializeClone(TimestampInequalityRule.getRule(">=", "2008/05/21 00:44:45"));
Calendar cal = new GregorianCalendar(2008,04,21,00,45,44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.INFO,
"Hello, World", null);
assertTrue(rule.evaluate(event, null));
}
/**
* Tests evaluate of a deserialized clone when rule is not satisfied.
*/
public void test4() throws IOException, ClassNotFoundException {
Rule rule = (Rule)
SerializationTestHelper.serializeClone(TimestampInequalityRule.getRule("<", "2008/05/21 00:44:44"));
Calendar cal = new GregorianCalendar(2008,04,21,00,45,44);
LoggingEvent event = new LoggingEvent("org.apache.log4j.Logger",
Logger.getRootLogger(), cal.getTimeInMillis(), Level.WARN,
"Hello, World", null);
assertFalse(rule.evaluate(event, null));
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/ 0000775 0000000 0000000 00000000000 12527427642 0024273 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/AbsoluteDateAndTimeFilter.java 0000664 0000000 0000000 00000002335 12527427642 0032125 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Pattern;
public class AbsoluteDateAndTimeFilter implements Filter {
private final Pattern pattern;
public AbsoluteDateAndTimeFilter() {
pattern = Pattern.compile(Filter.ABSOLUTE_DATE_AND_TIME_PAT);
}
public String filter(String in) {
if (pattern.matcher(in).find()) {
return pattern.matcher(in).replaceAll("");
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/AbsoluteTimeFilter.java 0000664 0000000 0000000 00000002316 12527427642 0030703 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class AbsoluteTimeFilter implements Filter {
public String filter(String in) {
String pat = Filter.ABSOLUTE_TIME_PAT;
Pattern pattern = Pattern.compile(pat);
Matcher matcher = pattern.matcher(in);
if (matcher.find()) {
return matcher.replaceAll("");
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/Compare.java 0000664 0000000 0000000 00000014015 12527427642 0026525 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.io.BufferedReader;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.util.zip.GZIPInputStream;
public class Compare {
static final int B1_NULL = -1;
static final int B2_NULL = -2;
private static final InputStream open(
final Class testClass,
final String fileName) throws IOException {
String resourceName = fileName;
if (fileName.startsWith("witness/")) {
resourceName = fileName.substring(fileName.lastIndexOf('/') + 1);
}
InputStream is = testClass.getResourceAsStream(resourceName);
if (is == null) {
File file = new File(fileName);
if (file.exists()) {
is = new FileInputStream(file);
} else {
throw new FileNotFoundException("Resource "
+ resourceName + " not found");
}
}
return is;
}
public static boolean compare(Class testClass,
final String file1,
final String file2)
throws IOException {
BufferedReader in1 = new BufferedReader(new FileReader(file1));
BufferedReader in2 = new BufferedReader(new InputStreamReader(
open(testClass, file2)));
try {
return compare(testClass, file1, file2, in1, in2);
} finally {
in1.close();
in2.close();
}
}
public static boolean compare(
Class testClass, String file1, String file2, BufferedReader in1, BufferedReader in2) throws IOException {
String s1;
int lineCounter = 0;
while ((s1 = in1.readLine()) != null) {
lineCounter++;
String s2 = in2.readLine();
if (!s1.equals(s2)) {
System.out.println(
"Files [" + file1 + "] and [" + file2 + "] differ on line "
+ lineCounter);
System.out.println("One reads: [" + s1 + "].");
System.out.println("Other reads:[" + s2 + "].");
outputFile(testClass, file1);
outputFile(testClass, file2);
return false;
}
}
// the second file is longer
if (in2.read() != -1) {
System.out.println(
"File [" + file2 + "] longer than file [" + file1 + "].");
outputFile(testClass, file1);
outputFile(testClass, file2);
return false;
}
return true;
}
/**
*
* Prints file on the console.
*
*/
private static void outputFile(Class testClass, String file)
throws IOException {
InputStream is = open(testClass, file);
BufferedReader in1 = new BufferedReader(new InputStreamReader(is));
String s1;
int lineCounter = 0;
System.out.println("--------------------------------");
System.out.println("Contents of " + file + ":");
while ((s1 = in1.readLine()) != null) {
lineCounter++;
System.out.print(lineCounter);
if (lineCounter < 10) {
System.out.print(" : ");
} else if (lineCounter < 100) {
System.out.print(" : ");
} else if (lineCounter < 1000) {
System.out.print(" : ");
} else {
System.out.print(": ");
}
System.out.println(s1);
}
in1.close();
}
public static boolean gzCompare(final Class testClass,
final String actual,
final String expected)
throws FileNotFoundException, IOException {
String resourceName = expected;
int lastSlash = expected.lastIndexOf("/");
if (lastSlash >= 0) {
resourceName = expected.substring(lastSlash + 1);
}
InputStream resourceStream = testClass.getResourceAsStream(resourceName);
if (resourceStream == null) {
throw new FileNotFoundException("Could not locate resource " + resourceName);
}
BufferedReader in1 = new BufferedReader(new InputStreamReader(new GZIPInputStream(new FileInputStream(actual))));
BufferedReader in2 = new BufferedReader(new InputStreamReader(new GZIPInputStream(resourceStream)));
try {
return gzCompare(testClass, actual, expected, in1, in2);
} finally {
in1.close();
in2.close();
}
}
public static boolean gzCompare(Class testClass, String file1, String file2, BufferedReader in1, BufferedReader in2) throws IOException {
String s1;
int lineCounter = 0;
while ((s1 = in1.readLine()) != null) {
lineCounter++;
String s2 = in2.readLine();
if (!s1.equals(s2)) {
System.out.println(
"Files [" + file1 + "] and [" + file2 + "] differ on line "
+ lineCounter);
System.out.println("One reads: [" + s1 + "].");
System.out.println("Other reads:[" + s2 + "].");
outputFile(testClass, file1);
outputFile(testClass, file2);
return false;
}
}
// the second file is longer
if (in2.read() != -1) {
System.out.println(
"File [" + file2 + "] longer than file [" + file1 + "].");
outputFile(testClass, file1);
outputFile(testClass, file2);
return false;
}
return true;
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/ControlFilter.java 0000664 0000000 0000000 00000002517 12527427642 0027731 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Pattern;
public class ControlFilter implements Filter {
String[] allowedPatterns;
public ControlFilter(String[] allowedPatterns) {
this.allowedPatterns = allowedPatterns;
}
public String filter(String in) throws UnexpectedFormatException {
int len = allowedPatterns.length;
for (int i = 0; i < len; i++) {
if (Pattern.compile(allowedPatterns[i]).matcher(in).find()) {
return in;
}
}
throw new UnexpectedFormatException("[" + in + "]");
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/Filter.java 0000664 0000000 0000000 00000003100 12527427642 0026355 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
public interface Filter {
// 06 avr. 2002 18:36:32,036
// 18 fevr. 2002 20:05:36,222
public static final String ABSOLUTE_DATE_AND_TIME_PAT =
"^\\d{1,2} .{2,6}\\.? 2\\d\\d\\d \\d{2}:\\d{2}:\\d{2},\\d{3}";
// 18:54:19,201
public static final String ABSOLUTE_TIME_PAT =
"^\\d{2}:\\d{2}:\\d{2},\\d{3}";
public static final String RELATIVE_TIME_PAT = "^\\d{1,10}";
final String BASIC_PAT = "\\[main\\] (FATAL|ERROR|WARN|INFO|DEBUG)";
final String ISO8601_PAT =
"^\\d{4}-\\d{2}-\\d{2} \\d{2}:\\d{2}:\\d{2},\\d{3}";
/**
* This filter transforms the input string and returns the results as
* output. If the input should be ignored, this method returns null.
*
*/
String filter(String in) throws UnexpectedFormatException;
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/ISO8601Filter.java 0000664 0000000 0000000 00000002246 12527427642 0027261 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.*;
public class ISO8601Filter implements Filter {
private final Pattern pattern;
public ISO8601Filter() {
pattern = Pattern.compile(ISO8601_PAT);
}
public String filter(String in) {
if (pattern.matcher(in).find()) {
return pattern.matcher(in).replaceAll("");
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/JunitTestRunnerFilter.java 0000664 0000000 0000000 00000004211 12527427642 0031425 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Pattern;
public class JunitTestRunnerFilter implements Filter {
private static final String[] PATTERNS = {
"at org.eclipse.jdt.internal.junit.runner.RemoteTestRunner",
"at org.apache.tools.ant",
"at junit.textui.TestRunner",
"at com.intellij",
"at java.lang.reflect.Method.invoke",
"at org.apache.maven.",
"at org.codehaus.",
"at org.junit.internal.runners.",
"at junit.framework.TestSuite",
"at junit.framework.TestResult"
};
private final Pattern[] patterns;
public JunitTestRunnerFilter() {
patterns = new Pattern[PATTERNS.length];
for (int i = 0; i < PATTERNS.length; i++) {
patterns[i] = Pattern.compile(PATTERNS[i]);
}
}
/**
* Filter out stack trace lines coming from the various JUnit TestRunners.
*/
public String filter(String in) {
if (in == null) {
return null;
}
//
// restore the one instance of Method.invoke that we actually want
//
if (in.indexOf("at junit.framework.TestCase.runTest") != -1) {
return "\tat java.lang.reflect.Method.invoke(X)\n" + in;
}
for (int i = 0; i < patterns.length; i++) {
if(patterns[i].matcher(in).find()) {
return null;
}
}
return in;
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/LineNumberFilter.java 0000664 0000000 0000000 00000002636 12527427642 0030353 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Pattern;
public class LineNumberFilter implements Filter {
private Pattern linePattern;
private Pattern nativePattern;
public LineNumberFilter() {
linePattern = Pattern.compile("\\(.*:\\d{1,4}\\)");
nativePattern = Pattern.compile("\\(Native Method\\)");
}
public String filter(final String in) {
if (linePattern.matcher(in).find()) {
return linePattern.matcher(in).replaceAll("(X)");
} else if (nativePattern.matcher(in).find()) {
return nativePattern.matcher(in).replaceAll("(X)");
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/MDCOrderFilter.java 0000664 0000000 0000000 00000003653 12527427642 0027712 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
/**
* This class switches MDC values into the order
* (unreasonably) expected by the witness files.
*/
public class MDCOrderFilter implements Filter {
/**
* Unexpected orders of keys.
* Note expected values are "va-one-one" and "va-one-two".
*/
private static final String[] patterns =
new String[] {
"{key2,va12}{key1,va11}",
"{key2,value2}{key1,value1}"
};
/**
* Replacement values.
*/
private static final String[] replacements =
new String[] {
"{key1,va11}{key2,va12}",
"{key1,value1}{key2,value2}"
};
/**
* Switch order of MDC keys when not in expected order.
*/
public String filter(final String in) {
if (in == null) {
return null;
}
for(int i = 0; i < patterns.length; i++) {
int ipos = in.indexOf(patterns[i]);
if (ipos >= 1) {
return in.substring(0, ipos)
+ replacements[i]
+ in.substring(ipos + patterns[i].length());
}
}
return in;
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/RelativeTimeFilter.java 0000664 0000000 0000000 00000002345 12527427642 0030702 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Pattern;
public class RelativeTimeFilter implements Filter {
private final Pattern relativePattern;
public RelativeTimeFilter() {
relativePattern = Pattern.compile(Filter.RELATIVE_TIME_PAT);
}
public String filter(String in) {
if (relativePattern.matcher(in).find()) {
return relativePattern.matcher(in).replaceAll("");
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/SerializationTestHelper.java 0000664 0000000 0000000 00000011460 12527427642 0031755 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import junit.framework.TestCase;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
/**
* Utiities for serialization tests.
*
* @author Curt Arnold
*/
public class SerializationTestHelper {
/**
* Private constructor.
*/
private SerializationTestHelper() {
}
/**
* Creates a clone by serializing object and
* deserializing byte stream.
* @param obj object to serialize and deserialize.
* @return clone
* @throws IOException on IO error.
* @throws ClassNotFoundException if class not found.
*/
public static Object serializeClone(final Object obj)
throws IOException, ClassNotFoundException {
ByteArrayOutputStream memOut = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(memOut);
objOut.writeObject(obj);
objOut.close();
ByteArrayInputStream src = new ByteArrayInputStream(memOut.toByteArray());
ObjectInputStream objIs = new ObjectInputStream(src);
return objIs.readObject();
}
/**
* Deserializes a specified file.
* @param witness serialization file, may not be null.
* @return deserialized object.
* @throws Exception thrown on IO or deserialization exception.
*/
public static Object deserializeStream(final String witness)
throws Exception {
FileInputStream fileIs = new FileInputStream(witness);
ObjectInputStream objIs = new ObjectInputStream(fileIs);
return objIs.readObject();
}
/**
* Checks the serialization of an object against an file
* containing the expected serialization.
*
* @param witness name of file containing expected serialization.
* @param obj object to be serialized.
* @param skip positions in serialized stream that should not be compared.
* @param endCompare position to stop comparison.
* @throws Exception thrown on IO or serialization exception.
*/
public static void assertSerializationEquals(
final String witness, final Object obj, final int[] skip,
final int endCompare) throws Exception {
ByteArrayOutputStream memOut = new ByteArrayOutputStream();
ObjectOutputStream objOut = new ObjectOutputStream(memOut);
objOut.writeObject(obj);
objOut.close();
assertStreamEquals(witness, memOut.toByteArray(), skip, endCompare);
}
/**
* Asserts the serialized form of an object.
* @param witness file name of expected serialization.
* @param actual byte array of actual serialization.
* @param skip positions to skip comparison.
* @param endCompare position to stop comparison.
* @throws IOException thrown on IO or serialization exception.
*/
public static void assertStreamEquals(
final String witness, final byte[] actual, final int[] skip,
final int endCompare) throws IOException {
File witnessFile = new File(witness);
if (witnessFile.exists()) {
int skipIndex = 0;
byte[] expected = new byte[actual.length];
FileInputStream is = new FileInputStream(witnessFile);
int bytesRead = is.read(expected);
is.close();
if(bytesRead < endCompare) {
TestCase.assertEquals(bytesRead, actual.length);
}
int endScan = actual.length;
if (endScan > endCompare) {
endScan = endCompare;
}
for (int i = 0; i < endScan; i++) {
if ((skipIndex < skip.length) && (skip[skipIndex] == i)) {
skipIndex++;
} else {
if (expected[i] != actual[i]) {
TestCase.assertEquals(
"Difference at offset " + i, expected[i], actual[i]);
}
}
}
} else {
//
// if the file doesn't exist then
// assume that we are setting up and need to write it
FileOutputStream os = new FileOutputStream(witnessFile);
os.write(actual);
os.close();
TestCase.fail("Writing witness file " + witness);
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/SunReflectFilter.java 0000664 0000000 0000000 00000002220 12527427642 0030352 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
/**
* The sun.reflect.* lines are not present in all JDKs.
*
* @author Ceki Gulcu
*/
public class SunReflectFilter implements Filter {
public String filter(String in) {
if(in == null) {
return null;
}
if (in.indexOf("at sun.reflect") != -1) {
return null;
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/Transformer.java 0000664 0000000 0000000 00000005023 12527427642 0027440 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.io.BufferedReader;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.IOException;
import java.io.PrintStream;
public class Transformer {
public
static
void transform(String in, String out, Filter[] filters) throws FileNotFoundException,
IOException,
UnexpectedFormatException {
String line;
BufferedReader input = new BufferedReader(new FileReader(in));
PrintStream output = new PrintStream(new FileOutputStream(out, false));
try {
// Initialization of input and output omitted
while ((line = input.readLine()) != null) {
// apply all filters
for (int i = 0; i < filters.length; i++) {
line = filters[i].filter(line);
}
if (line != null) {
output.println(line);
}
}
} finally {
input.close();
output.close();
}
}
public
static
void transform(String in, String out, Filter filter) throws FileNotFoundException,
IOException,
UnexpectedFormatException {
String line;
BufferedReader input = new BufferedReader(new FileReader(in));
PrintStream output = new PrintStream(new FileOutputStream(out));
try {
// Initialization of input and output omitted
while((line = input.readLine()) != null) {
line = filter.filter(line);
output.println(line);
}
} finally {
input.close();
output.close();
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/UnexpectedFormatException.java 0000664 0000000 0000000 00000001711 12527427642 0032272 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
public class UnexpectedFormatException extends Exception {
public UnexpectedFormatException(String msg) {
super(msg);
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/XMLDateFilter.java 0000664 0000000 0000000 00000002523 12527427642 0027544 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Pattern;
public class XMLDateFilter implements Filter {
private final static String PATTERN =
"\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}.\\d{3}";
private final Pattern pattern;
public XMLDateFilter() {
pattern = Pattern.compile(PATTERN);
}
public String filter(final String in) {
if (in != null && pattern.matcher(in).find()) {
return pattern.matcher(in).replaceAll("yyyy-MM-ddTHH:mm:ss.SSS");
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/XMLLineAttributeFilter.java 0000664 0000000 0000000 00000002504 12527427642 0031441 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Pattern;
public class XMLLineAttributeFilter implements Filter {
public String filter(final String in) {
if(in == null) {
return null;
}
if (Pattern.compile("line=\"\\d{1,3}\"").matcher(in).find()) {
return Pattern.compile("line=\"\\d{1,3}\"").matcher(in).replaceAll("line=\"X\"");
} else if (Pattern.compile("line=\"?\"").matcher(in).find()) {
return Pattern.compile("line=\"?\"").matcher(in).replaceAll("line=\"X\"");
}
return in;
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/util/XMLTimestampFilter.java 0000664 0000000 0000000 00000002371 12527427642 0030633 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.util;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class XMLTimestampFilter implements Filter {
public String filter(String in) {
if(in == null) {
return null;
}
Pattern pattern = Pattern.compile("timestamp=\"\\d{10,13}\"");
Matcher matcher = pattern.matcher(in);
if (matcher.find()) {
return matcher.replaceAll("timestamp=\"XXX\"");
} else {
return in;
}
}
}
apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/xml/ 0000775 0000000 0000000 00000000000 12527427642 0024116 5 ustar 00root root 0000000 0000000 apache-log4j-extras1.2-1.2.17/src/test/java/org/apache/log4j/xml/XSLTLayoutTest.java 0000664 0000000 0000000 00000033671 12527427642 0027623 0 ustar 00root root 0000000 0000000 /*
* 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 org.apache.log4j.xml;
import org.apache.log4j.Layout;
import org.apache.log4j.LayoutTest;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.NDC;
import org.apache.log4j.MDC;
import org.apache.log4j.PropertyConfigurator;
import org.apache.log4j.util.Transformer;
import org.apache.log4j.util.Filter;
import org.apache.log4j.util.LineNumberFilter;
import org.apache.log4j.util.JunitTestRunnerFilter;
import org.apache.log4j.util.XMLTimestampFilter;
import org.apache.log4j.util.Compare;
import org.apache.log4j.util.XMLDateFilter;
import org.apache.log4j.helpers.MDCKeySetExtractor;
import org.apache.log4j.spi.LoggingEvent;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import java.io.Reader;
import java.io.StringReader;
import java.io.InputStream;
import java.io.FileNotFoundException;
import java.util.Set;
import java.util.Iterator;
import java.util.Properties;
import java.util.Hashtable;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
/**
* Test for XSLTLayout.
*
*/
public class XSLTLayoutTest extends LayoutTest {
/**
* Construct new instance of XSLTLayoutTest.
*
* @param testName test name.
*/
public XSLTLayoutTest(final String testName) {
super(testName, "text/plain", false, null, null);
}
/**
* @{inheritDoc}
*/
protected Layout createLayout() {
return new XSLTLayout();
}
/**
* Parses the string as the body of an XML document and returns the document element.
* @param source source string.
* @return document element.
* @throws Exception if parser can not be constructed or source is not a valid XML document.
*/
private Element parse(final String source) throws Exception {
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(false);
factory.setCoalescing(true);
DocumentBuilder builder = factory.newDocumentBuilder();
Reader reader = new StringReader(source);
Document doc = builder.parse(new InputSource(reader));
return doc.getDocumentElement();
}
/**
* Checks a log4j:event element against expectations.
* @param element element, may not be null.
* @param event event, may not be null.
*/
private void checkEventElement(
final Element element, final LoggingEvent event) {
assertEquals("log4j:event", element.getTagName());
assertEquals(
"org.apache.log4j.xml.XSLTLayoutTest", element.getAttribute("logger"));
assertEquals(
Long.toString(event.timeStamp), element.getAttribute("timestamp"));
assertEquals("INFO", element.getAttribute("level"));
assertEquals(event.getThreadName(), element.getAttribute("thread"));
}
/**
* Checks a log4j:message element against expectations.
* @param element element, may not be null.
* @param message expected message.
*/
private void checkMessageElement(
final Element element, final String message) {
assertEquals("log4j:message", element.getTagName());
Node messageNode = element.getFirstChild();
assertNotNull(messageNode);
assertEquals(Node.TEXT_NODE, messageNode.getNodeType());
assertEquals(message, messageNode.getNodeValue());
assertNull(messageNode.getNextSibling());
}
/**
* Checks a log4j:message element against expectations.
* @param element element, may not be null.
* @param message expected message.
*/
private void checkNDCElement(final Element element, final String message) {
assertEquals("log4j:NDC", element.getTagName());
Node messageNode = element.getFirstChild();
assertNotNull(messageNode);
assertEquals(Node.TEXT_NODE, messageNode.getNodeType());
assertEquals(message, messageNode.getNodeValue());
assertNull(messageNode.getNextSibling());
}
/**
* Checks a log4j:throwable element against expectations.
* @param element element, may not be null.
* @param ex exception, may not be null.
*/
private void checkThrowableElement(
final Element element, final Exception ex) {
assertEquals("log4j:throwable", element.getTagName());
Node messageNode = element.getFirstChild();
assertNotNull(messageNode);
assertEquals(Node.TEXT_NODE, messageNode.getNodeType());
String msg = ex.toString();
assertEquals("Got " + messageNode.getNodeValue(), msg, messageNode.getNodeValue().substring(0, msg.length()));
assertNull(messageNode.getNextSibling());
}
/**
* Tests formatted results.
* @throws Exception if parser can not be constructed or source is not a valid XML document.
*/
public void testFormat() throws Exception {
clearMDC();
NDC.clear();
Logger logger = Logger.getLogger("org.apache.log4j.xml.XSLTLayoutTest");
LoggingEvent event =
new LoggingEvent(
"org.apache.log4j.Logger", logger, Level.INFO, "Hello, World", null);
XSLTLayout layout = (XSLTLayout) createLayout();
String result = layout.format(event);
Element parsedResult = parse(result);
checkEventElement(parsedResult, event);
int childElementCount = 0;
for (
Node node = parsedResult.getFirstChild(); node != null;
node = node.getNextSibling()) {
switch (node.getNodeType()) {
case Node.ELEMENT_NODE:
childElementCount++;
checkMessageElement((Element) node, "Hello, World");
break;
case Node.COMMENT_NODE:
break;
case Node.TEXT_NODE:
// should only be whitespace
break;
default:
fail("Unexpected node type");
break;
}
}
assertEquals(1, childElementCount);
}
/**
* Tests formatted results with an exception.
* @throws Exception if parser can not be constructed or source is not a valid XML document.
*/
public void testFormatWithException() throws Exception {
clearMDC();
NDC.clear();
Logger logger = Logger.getLogger("org.apache.log4j.xml.XSLTLayoutTest");
Exception ex = new IllegalArgumentException("'foo' is not a valid name");
LoggingEvent event =
new LoggingEvent(
"org.apache.log4j.Logger", logger, Level.INFO, "Hello, World", ex);
XSLTLayout layout = (XSLTLayout) createLayout();
String result = layout.format(event);
Element parsedResult = parse(result);
checkEventElement(parsedResult, event);
int childElementCount = 0;
for (
Node node = parsedResult.getFirstChild(); node != null;
node = node.getNextSibling()) {
switch (node.getNodeType()) {
case Node.ELEMENT_NODE:
childElementCount++;
if (childElementCount == 1) {
checkMessageElement((Element) node, "Hello, World");
} else {
checkThrowableElement((Element) node, ex);
}
break;
case Node.COMMENT_NODE:
break;
case Node.TEXT_NODE:
// should only be whitespace
break;
default:
fail("Unexpected node type");
break;
}
}
assertEquals(2, childElementCount);
}
/**
* Tests formatted results with an exception.
* @throws Exception if parser can not be constructed or source is not a valid XML document.
*/
public void testFormatWithNDC() throws Exception {
clearMDC();
NDC.clear();
Logger logger = Logger.getLogger("org.apache.log4j.xml.XSLTLayoutTest");
NDC.push("NDC goes here");
LoggingEvent event =
new LoggingEvent(
"org.apache.log4j.Logger", logger, Level.INFO, "Hello, World", null);
XSLTLayout layout = (XSLTLayout) createLayout();
String result = layout.format(event);
NDC.pop();
Element parsedResult = parse(result);
checkEventElement(parsedResult, event);
int childElementCount = 0;
for (
Node node = parsedResult.getFirstChild(); node != null;
node = node.getNextSibling()) {
switch (node.getNodeType()) {
case Node.ELEMENT_NODE:
childElementCount++;
if (childElementCount == 1) {
checkMessageElement((Element) node, "Hello, World");
} else {
checkNDCElement((Element) node, "NDC goes here");
}
break;
case Node.COMMENT_NODE:
break;
case Node.TEXT_NODE:
// should only be whitespace
break;
default:
fail("Unexpected node type");
break;
}
}
assertEquals(2, childElementCount);
}
/**
* Tests getLocationInfo and setLocationInfo.
*/
public void testGetSetLocationInfo() {
XSLTLayout layout = new XSLTLayout();
assertEquals(false, layout.getLocationInfo());
layout.setLocationInfo(true);
assertEquals(true, layout.getLocationInfo());
layout.setLocationInfo(false);
assertEquals(false, layout.getLocationInfo());
}
/**
* Tests activateOptions().
*/
public void testActivateOptions() {
XSLTLayout layout = new XSLTLayout();
layout.activateOptions();
}
/**
* Tests XML configuration and atom layout.
*/
public void testAtom() throws Exception {
InputStream is =
XSLTLayoutTest.class.getResourceAsStream("xsltLayout4.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(false);
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(is);
org.apache.log4j.extras.DOMConfigurator.configure(
doc.getDocumentElement());
Logger logger = Logger.getLogger("org.apache.log4j.xml.XSLTLayoutTest");
logger.debug("DEBUG message");
logger.info("INFO message");
Transformer.transform(
"target/temp", "target/filtered",
new Filter[] { new LineNumberFilter(),
new JunitTestRunnerFilter(),
new XMLTimestampFilter(),
new XMLDateFilter()});
assertTrue(Compare.compare(XSLTLayoutTest.class,
"target/filtered", "witness/xml/xsltLayout.4"));
}
/**
* Tests XML configuration and atom layout.
*/
public void testAtomNS() throws Exception {
InputStream is =
XSLTLayoutTest.class.getResourceAsStream("xsltLayout4.xml");
DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
factory.setNamespaceAware(true);
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.parse(is);
org.apache.log4j.extras.DOMConfigurator.configure(
doc.getDocumentElement());
Logger logger = Logger.getLogger("org.apache.log4j.xml.XSLTLayoutTest");
logger.debug("DEBUG message");
logger.info("INFO message");
Transformer.transform(
"target/temp", "target/filtered",
new Filter[] { new LineNumberFilter(),
new JunitTestRunnerFilter(),
new XMLTimestampFilter(),
new XMLDateFilter()});
assertTrue(Compare.compare(XSLTLayoutTest.class,
"target/filtered", "witness/xml/xsltLayout.4"));
}
/**
* Tests CDATA element within NDC content. See bug 37560.
*/
public void testNDCWithCDATA() throws Exception {
Logger logger = Logger.getLogger("com.example.bar");
Level level = Level.INFO;
String ndcMessage ="