This is an automated email from the git hooks/post-receive script. It was generated because a ref change was pushed to the repository containing the project "SLF4J: Simple Logging Facade for Java". The branch, master has been updated via 0165681d3ca125096a88a32f47ba975503178dc9 (commit) via 9f10490a05f7344f4b3ef657e8991f5d51934e2f (commit) via 3749a8521804cda6f22269923ad3ac5628e3a6cc (commit) from d5118ad23879d7ac029a93e5aeac8f674c693005 (commit) Those revisions listed above that are new to this repository have not appeared on any other notification email; so we list those revisions in full, below. - Log ----------------------------------------------------------------- http://git.qos.ch/gitweb/?p=slf4j.git;a=commit;h=0165681d3ca125096a88a32f47b... http://github.com/ceki/slf4j/commit/0165681d3ca125096a88a32f47ba975503178dc9 commit 0165681d3ca125096a88a32f47ba975503178dc9 Author: Ceki Gulcu <ceki@qos.ch> Date: Tue Oct 19 17:37:35 2010 +0200 support for log4j in Jboss, untainted by s/logging/loxx/ refactoring typo diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java new file mode 100644 index 0000000..e675d89 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java @@ -0,0 +1,134 @@ +/* + * 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. + */ + +package org.apache.log4j; + +import org.apache.log4j.spi.Filter; +import org.apache.log4j.spi.ErrorHandler; +import org.apache.log4j.spi.Layout; +import org.apache.log4j.spi.LoggingEvent; + +/** + * Implement this interface for your own strategies for outputting log + * statements. + * + * @author Ceki Gülcü + */ +public interface Appender { + + /** + * Add a filter to the end of the filter list. + * + * @since 0.9.0 + */ + void addFilter(Filter newFilter); + + /** + * Returns the head Filter. The Filters are organized in a linked list + * and so all Filters on this Appender are available through the result. + * + * @return the head Filter or null, if no Filters are present + * @since 1.1 + */ + public Filter getFilter(); + + /** + * Clear the list of filters by removing all the filters in it. + * + * @since 0.9.0 + */ + public void clearFilters(); + + /** + * Release any resources allocated within the appender such as file + * handles, network connections, etc. + * <p/> + * <p>It is a programming error to append to a closed appender. + * + * @since 0.8.4 + */ + public void close(); + + /** + * Log in <code>Appender</code> specific way. When appropriate, + * Loggers will call the <code>doAppend</code> method of appender + * implementations in order to log. + */ + public void doAppend(LoggingEvent event); + + + /** + * Get the name of this appender. The name uniquely identifies the + * appender. + */ + public String getName(); + + + /** + * Set the {@link ErrorHandler} for this appender. + * + * @since 0.9.0 + */ + public void setErrorHandler(ErrorHandler errorHandler); + + /** + * Returns the {@link ErrorHandler} for this appender. + * + * @since 1.1 + */ + public ErrorHandler getErrorHandler(); + + /** + * Set the {@link Layout} for this appender. + * + * @since 0.8.1 + */ + public void setLayout(Layout layout); + + /** + * Returns this appenders layout. + * + * @since 1.1 + */ + public Layout getLayout(); + + + /** + * Set the name of this appender. The name is used by other + * components to identify this appender. + * + * @since 0.8.1 + */ + public void setName(String name); + + /** + * Configurators call this method to determine if the appender + * requires a layout. If this method returns <code>true</code>, + * meaning that layout is required, then the configurator will + * configure an layout using the configuration information at its + * disposal. If this method returns <code>false</code>, meaning that + * a layout is not required, then layout configuration will be + * skipped even if there is available layout configuration + * information at the disposal of the configurator.. + * <p/> + * <p>In the rather exceptional case, where the appender + * implementation admits a layout but can also work without it, then + * the appender should return <code>true</code>. + * + * @since 0.8.4 + */ + public boolean requiresLayout(); +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java new file mode 100644 index 0000000..c8c70b5 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java @@ -0,0 +1,179 @@ +/* + * 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. + */ + +package org.apache.log4j.helpers; + +/** + This class used to output log statements from within the log4j package. + + <p>Log4j components cannot make log4j logging calls. However, it is + sometimes useful for the user to learn about what log4j is + doing. You can enable log4j internal logging by defining the + <b>log4j.configDebug</b> variable. + + <p>All log4j internal debug calls go to <code>System.out</code> + where as internal error messages are sent to + <code>System.err</code>. All internal messages are prepended with + the string "log4j: ". + + @since 0.8.2 + @author Ceki Gülcü +*/ +public class LogLog { + + /** + Defining this value makes log4j print log4j-internal debug + statements to <code>System.out</code>. + + <p> The value of this string is <b>log4j.debug</b>. + + <p>Note that the search for all option names is case sensitive. */ + public static final String DEBUG_KEY="log4j.debug"; + + + /** + Defining this value makes log4j components print log4j-internal + debug statements to <code>System.out</code>. + + <p> The value of this string is <b>log4j.configDebug</b>. + + <p>Note that the search for all option names is case sensitive. + + @deprecated Use {@link #DEBUG_KEY} instead. + */ + public static final String CONFIG_DEBUG_KEY="log4j.configDebug"; + + protected static boolean debugEnabled = false; + + /** + In quietMode not even errors generate any output. + */ + private static boolean quietMode = false; + + private static final String PREFIX = "log4j: "; + private static final String ERR_PREFIX = "log4j:ERROR "; + private static final String WARN_PREFIX = "log4j:WARN "; + + static { + } + + /** + Allows to enable/disable log4j internal logging. + */ + static + public + void setInternalDebugging(boolean enabled) { + debugEnabled = enabled; + } + + /** + This method is used to output log4j internal debug + statements. Output goes to <code>System.out</code>. + */ + public + static + void debug(String msg) { + if(debugEnabled && !quietMode) { + System.out.println(PREFIX+msg); + } + } + + /** + This method is used to output log4j internal debug + statements. Output goes to <code>System.out</code>. + */ + public + static + void debug(String msg, Throwable t) { + if(debugEnabled && !quietMode) { + System.out.println(PREFIX+msg); + if(t != null) + t.printStackTrace(System.out); + } + } + + + /** + This method is used to output log4j internal error + statements. There is no way to disable error statements. + Output goes to <code>System.err</code>. + */ + public + static + void error(String msg) { + if(quietMode) + return; + System.err.println(ERR_PREFIX+msg); + } + + /** + This method is used to output log4j internal error + statements. There is no way to disable error statements. + Output goes to <code>System.err</code>. + */ + public + static + void error(String msg, Throwable t) { + if(quietMode) + return; + + System.err.println(ERR_PREFIX+msg); + if(t != null) { + t.printStackTrace(); + } + } + + /** + In quite mode no LogLog generates strictly no output, not even + for errors. + + @param quietMode A true for not + */ + public + static + void setQuietMode(boolean quietMode) { + LogLog.quietMode = quietMode; + } + + /** + This method is used to output log4j internal warning + statements. There is no way to disable warning statements. + Output goes to <code>System.err</code>. */ + public + static + void warn(String msg) { + if(quietMode) + return; + + System.err.println(WARN_PREFIX+msg); + } + + /** + This method is used to output log4j internal warnings. There is + no way to disable warning statements. Output goes to + <code>System.err</code>. */ + public + static + void warn(String msg, Throwable t) { + if(quietMode) + return; + + System.err.println(WARN_PREFIX+msg); + if(t != null) { + t.printStackTrace(); + } + } +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java new file mode 100644 index 0000000..4ce496d --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java @@ -0,0 +1,39 @@ +package org.apache.log4j.spi; + + +import org.apache.log4j.spi.LoggerRepository; +import java.net.URL; + +/** + Implemented by classes capable of configuring log4j using a URL. + + @since 1.0 + @author Anders Kristensen + */ +public interface Configurator { + + /** + Special level value signifying inherited behaviour. The current + value of this string constant is <b>inherited</b>. {@link #NULL} + is a synonym. */ + public static final String INHERITED = "inherited"; + + /** + Special level signifying inherited behaviour, same as {@link + #INHERITED}. The current value of this string constant is + <b>null</b>. */ + public static final String NULL = "null"; + + + + /** + Interpret a resource pointed by a URL and set up log4j accordingly. + + The configuration is done relative to the <code>hierarchy</code> + parameter. + + @param url The URL to parse + @param repository The hierarchy to operation upon. + */ + void doConfigure(URL url, LoggerRepository repository); +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java new file mode 100644 index 0000000..9317c70 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:46:24 + * To change this template use File | Settings | File Templates. + */ +public class ErrorHandler { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java new file mode 100644 index 0000000..5526e91 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:45:19 + * To change this template use File | Settings | File Templates. + */ +public class Filter { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java new file mode 100644 index 0000000..4c7603c --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java @@ -0,0 +1,43 @@ +/* + * 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. + */ + +package org.apache.log4j.spi; + +import org.apache.log4j.*; + +/** + Listen to events occuring within a {@link + org.apache.log4j.Hierarchy Hierarchy}. + + @author Ceki Gülcü + @since 1.2 + + */ +public interface HierarchyEventListener { + + + //public + //void categoryCreationEvent(Category cat); + + + public + void addAppenderEvent(Category cat, Appender appender); + + public + void removeAppenderEvent(Category cat, Appender appender); + + +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java new file mode 100644 index 0000000..ab740c1 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:46:12 + * To change this template use File | Settings | File Templates. + */ +public class Layout { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java new file mode 100644 index 0000000..cce2d3a --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java @@ -0,0 +1,37 @@ +/* + * 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. + */ + +package org.apache.log4j.spi; + +import org.apache.log4j.Logger; + +/** + + Implement this interface to create new instances of Logger or + a sub-class of Logger. + + <p>See <code>examples/subclass/MyLogger.java</code> for an example. + + @author Ceki Gülcü + @since version 0.8.5 + + */ +public interface LoggerFactory { + + public + Logger makeNewLoggerInstance(String name); + +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java new file mode 100644 index 0000000..36a2fa6 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java @@ -0,0 +1,98 @@ +/* + * 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. + */ + +package org.apache.log4j.spi; + +import org.apache.log4j.*; + +import java.util.Enumeration; + +/** + * A <code>LoggerRepository</code> is used to create and retrieve + * <code>Loggers</code>. The relation between loggers in a repository + * depends on the repository but typically loggers are arranged in a + * named hierarchy. + * <p/> + * <p>In addition to the creational methods, a + * <code>LoggerRepository</code> can be queried for existing loggers, + * can act as a point of registry for events related to loggers. + * + * @author Ceki Gülcü + * @since 1.2 + */ +public interface LoggerRepository { + + /** + * Add a {@link HierarchyEventListener} event to the repository. + */ + public void addHierarchyEventListener(HierarchyEventListener listener); + + /** + * Returns whether this repository is disabled for a given + * level. The answer depends on the repository threshold and the + * <code>level</code> parameter. See also {@link #setThreshold} + * method. + */ + boolean isDisabled(int level); + + /** + * Set the repository-wide threshold. All loxx requests below the + * threshold are immediately dropped. By default, the threshold is + * set to <code>Level.ALL</code> which has the lowest possible rank. + */ + public void setThreshold(Level level); + + /** + * Another form of {@link #setThreshold(Level)} accepting a string + * parameter instead of a <code>Level</code>. + */ + public void setThreshold(String val); + + public void emitNoAppenderWarning(Category cat); + + /** + * Get the repository-wide threshold. See {@link + * #setThreshold(Level)} for an explanation. + */ + public Level getThreshold(); + + public Logger getLogger(String name); + + public Logger getLogger(String name, LoggerFactory factory); + + public Logger getRootLogger(); + + public + abstract Logger exists(String name); + + public + abstract void shutdown(); + + public Enumeration getCurrentLoggers(); + + /** + * Deprecated. Please use {@link #getCurrentLoggers} instead. + */ + public Enumeration getCurrentCategories(); + + + public + abstract void fireAddAppenderEvent(Category logger, Appender appender); + + public + abstract void resetConfiguration(); + +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java new file mode 100644 index 0000000..acde46f --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:47:05 + * To change this template use File | Settings | File Templates. + */ +public class LoggingEvent { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java new file mode 100644 index 0000000..177feae --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java @@ -0,0 +1,32 @@ +/* + * Copyright 2001-2004 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. + */ +package org.apache.log4j.xml; + +import org.apache.log4j.spi.Configurator; +import org.apache.log4j.spi.LoggerRepository; + +import javax.xml.parsers.FactoryConfigurationError; +import java.net.URL; + + +public class DOMConfigurator implements Configurator { + static public void configure(URL url) throws FactoryConfigurationError { + } + + + public void doConfigure(URL url, LoggerRepository repository) { + } +} http://git.qos.ch/gitweb/?p=slf4j.git;a=commit;h=9f10490a05f7344f4b3ef657e89... http://github.com/ceki/slf4j/commit/9f10490a05f7344f4b3ef657e8991f5d51934e2f commit 9f10490a05f7344f4b3ef657e8991f5d51934e2f Author: Ceki Gulcu <ceki@qos.ch> Date: Tue Oct 19 17:22:20 2010 +0200 Revert "make log4j-over-slf4j run in jboss 4.2" This reverts commit 3749a8521804cda6f22269923ad3ac5628e3a6cc. diff --git a/jcl-over-slf4j/pom.xml b/jcl-over-slf4j/pom.xml index baedccc..7ea5b92 100644 --- a/jcl-over-slf4j/pom.xml +++ b/jcl-over-slf4j/pom.xml @@ -69,8 +69,8 @@ <configuration> <comparisonArtifacts> <comparisonArtifact> - <groupId>commons-loxx</groupId> - <artifactId>commons-loxx</artifactId> + <groupId>commons-logging</groupId> + <artifactId>commons-logging</artifactId> <version>1.1.1</version> </comparisonArtifact> </comparisonArtifacts> diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java index 275bea5..7886119 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java @@ -18,12 +18,12 @@ package org.apache.commons.logging; /** - * <p>A simple loxx interface abstracting loxx APIs. In order to be + * <p>A simple logging interface abstracting logging APIs. In order to be * instantiated successfully by {@link LogFactory}, classes that implement * this interface must have a constructor that takes a single String * parameter representing the "name" of this Log.</p> * - * <p> The six loxx levels used by <code>Log</code> are (in order): + * <p> The six logging levels used by <code>Log</code> are (in order): * <ol> * <li>trace (the least serious)</li> * <li>debug</li> @@ -33,11 +33,11 @@ package org.apache.commons.logging; * <li>fatal (the most serious)</li> * </ol> * The mapping of these log levels to the concepts used by the underlying - * loxx system is implementation dependent. + * logging system is implementation dependent. * The implementation should ensure, though, that this ordering behaves * as expected.</p> * - * <p>Performance is often a loxx concern. + * <p>Performance is often a logging concern. * By examining the appropriate property, * a component can avoid expensive operations (producing information * to be logged).</p> @@ -51,7 +51,7 @@ package org.apache.commons.logging; * </pre></code> * </p> * - * <p>Configuration of the underlying loxx system will generally be done + * <p>Configuration of the underlying logging system will generally be done * external to the Logging APIs, through whatever mechanism is supported by * that system.</p> * @@ -68,7 +68,7 @@ public interface Log { /** - * <p> Is debug loxx currently enabled? </p> + * <p> Is debug logging currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -78,7 +78,7 @@ public interface Log { /** - * <p> Is error loxx currently enabled? </p> + * <p> Is error logging currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -88,7 +88,7 @@ public interface Log { /** - * <p> Is fatal loxx currently enabled? </p> + * <p> Is fatal logging currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -98,7 +98,7 @@ public interface Log { /** - * <p> Is info loxx currently enabled? </p> + * <p> Is info logging currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -108,7 +108,7 @@ public interface Log { /** - * <p> Is trace loxx currently enabled? </p> + * <p> Is trace logging currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -118,7 +118,7 @@ public interface Log { /** - * <p> Is warn loxx currently enabled? </p> + * <p> Is warn logging currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java index f631f1b..a839b1f 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java @@ -51,7 +51,7 @@ public abstract class LogFactory { /** * The name (<code>use_tccl</code>) of the key in the config file used to - * specify whether loxx classes should be loaded via the thread context + * specify whether logging classes should be loaded via the thread context * class loader (TCCL), or not. By default, the TCCL is used. * * <p> @@ -94,9 +94,9 @@ public abstract class LogFactory { "META-INF/services/org.apache.commons.logging.LogFactory"; /** - * The name (<code>org.apache.commons.loxx.diagnostics.dest</code>) of - * the property used to enable internal commons-loxx diagnostic output, in - * order to get information on what loxx implementations are being + * The name (<code>org.apache.commons.logging.diagnostics.dest</code>) of + * the property used to enable internal commons-logging diagnostic output, in + * order to get information on what logging implementations are being * discovered, what classloaders they are loaded through, etc. * * <p> @@ -182,7 +182,7 @@ public abstract class LogFactory { * @param name * Logical name of the <code>Log</code> instance to be * returned (the meaning of this name is only known to the - * underlying loxx implementation that is being wrapped) + * underlying logging implementation that is being wrapped) * * @exception LogConfigurationException * if a suitable <code>Log</code> instance cannot be @@ -230,16 +230,16 @@ public abstract class LogFactory { * implementation class to be loaded. * </p> * <ul> - * <li>The <code>org.apache.commons.loxx.LogFactory</code> system + * <li>The <code>org.apache.commons.logging.LogFactory</code> system * property.</li> * <li>The JDK 1.3 Service Discovery mechanism</li> - * <li>Use the properties file <code>commons-loxx.properties</code> + * <li>Use the properties file <code>commons-logging.properties</code> * file, if found in the class path of this class. The configuration file is * in standard <code>java.util.Properties</code> format and contains the * fully qualified name of the implementation class with the key being the * system property defined above.</li> * <li>Fall back to a default implementation class ( - * <code>org.apache.commons.loxx.impl.SLF4FLogFactory</code>).</li> + * <code>org.apache.commons.logging.impl.SLF4FLogFactory</code>).</li> * </ul> * * <p> @@ -279,7 +279,7 @@ public abstract class LogFactory { * @param name * Logical name of the <code>Log</code> instance to be * returned (the meaning of this name is only known to the - * underlying loxx implementation that is being wrapped) + * underlying logging implementation that is being wrapped) * * @exception LogConfigurationException * if a suitable <code>Log</code> instance cannot be diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java index e435bee..727951c 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java @@ -25,7 +25,7 @@ import org.slf4j.LoggerFactory; import org.slf4j.spi.LocationAwareLogger; /** - * Implementation of {@link Log org.apache.commons.loxx.Log} interface which + * Implementation of {@link Log org.apache.commons.logging.Log} interface which * delegates all processing to a wrapped {@link Logger org.slf4j.Logger} * instance. * diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java index c05a116..44708bb 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java @@ -24,7 +24,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * Implementation of {@link Log org.apache.commons.loxx.Log} interface which + * Implementation of {@link Log org.apache.commons.logging.Log} interface which * delegates all processing to a wrapped {@link Logger org.slf4j.Logger} * instance. * diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java index 0614ba9..8a31118 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java @@ -141,7 +141,7 @@ public class SLF4JLogFactory extends LogFactory { * * @param name * Logical name of the <code>Log</code> instance to be returned - * (the meaning of this name is only known to the underlying loxx + * (the meaning of this name is only known to the underlying logging * implementation that is being wrapped) * * @exception LogConfigurationException @@ -177,7 +177,7 @@ public class SLF4JLogFactory extends LogFactory { // This method is never called by jcl-over-slf4j classes. However, // in certain deployment scenarios, in particular if jcl-over-slf4j.jar // is - // in the the web-app class loader and the official commons-loxx.jar is + // in the the web-app class loader and the official commons-logging.jar is // deployed in some parent class loader (e.g. commons/lib), then it is // possible // for the parent class loader to mask the classes shipping in diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java index 723f118..26a7941 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java @@ -37,24 +37,24 @@ import org.apache.commons.logging.LogConfigurationException; * to configure the behavior of this logger: * </p> * <ul> - * <li><code>org.apache.commons.loxx.simplelog.defaultlog</code> - Default - * loxx detail level for all instances of SimpleLog. Must be one of ("trace", + * <li><code>org.apache.commons.logging.simplelog.defaultlog</code> - Default + * logging detail level for all instances of SimpleLog. Must be one of ("trace", * "debug", "info", "warn", "error", or "fatal"). If not specified, defaults to * "info".</li> - * <li><code>org.apache.commons.loxx.simplelog.log.xxxxx</code> - Logging + * <li><code>org.apache.commons.logging.simplelog.log.xxxxx</code> - Logging * detail level for a SimpleLog instance named "xxxxx". Must be one of ("trace", * "debug", "info", "warn", "error", or "fatal"). If not specified, the default - * loxx detail level is used.</li> - * <li><code>org.apache.commons.loxx.simplelog.showlogname</code> - Set to + * logging detail level is used.</li> + * <li><code>org.apache.commons.logging.simplelog.showlogname</code> - Set to * <code>true</code> if you want the Log instance name to be included in output * messages. Defaults to <code>false</code>.</li> - * <li><code>org.apache.commons.loxx.simplelog.showShortLogname</code> - Set + * <li><code>org.apache.commons.logging.simplelog.showShortLogname</code> - Set * to <code>true</code> if you want the last component of the name to be * included in output messages. Defaults to <code>true</code>.</li> - * <li><code>org.apache.commons.loxx.simplelog.showdatetime</code> - Set to + * <li><code>org.apache.commons.logging.simplelog.showdatetime</code> - Set to * <code>true</code> if you want the current date and time to be included in * output messages. Default is <code>false</code>.</li> - * <li><code>org.apache.commons.loxx.simplelog.dateTimeFormat</code> - The + * <li><code>org.apache.commons.logging.simplelog.dateTimeFormat</code> - The * date and time format to be used in the output messages. The pattern * describing the date and time format is the same that is used in * <code>java.text.SimpleDateFormat</code>. If the format is not specified or is @@ -107,23 +107,23 @@ public class SimpleLog implements Log, Serializable { // ---------------------------------------------------- Log Level Constants - /** "Trace" level loxx. */ + /** "Trace" level logging. */ public static final int LOG_LEVEL_TRACE = 1; - /** "Debug" level loxx. */ + /** "Debug" level logging. */ public static final int LOG_LEVEL_DEBUG = 2; - /** "Info" level loxx. */ + /** "Info" level logging. */ public static final int LOG_LEVEL_INFO = 3; - /** "Warn" level loxx. */ + /** "Warn" level logging. */ public static final int LOG_LEVEL_WARN = 4; - /** "Error" level loxx. */ + /** "Error" level logging. */ public static final int LOG_LEVEL_ERROR = 5; - /** "Fatal" level loxx. */ + /** "Fatal" level logging. */ public static final int LOG_LEVEL_FATAL = 6; - /** Enable all loxx levels */ + /** Enable all logging levels */ public static final int LOG_LEVEL_ALL = (LOG_LEVEL_TRACE - 1); - /** Enable no loxx levels */ + /** Enable no logging levels */ public static final int LOG_LEVEL_OFF = (LOG_LEVEL_FATAL + 1); // ------------------------------------------------------------ Initializer @@ -245,11 +245,11 @@ public class SimpleLog implements Log, Serializable { /** * <p> - * Set loxx level. + * Set logging level. * </p> * * @param currentLogLevel - * new loxx level + * new logging level */ public void setLevel(int currentLogLevel) { @@ -259,7 +259,7 @@ public class SimpleLog implements Log, Serializable { /** * <p> - * Get loxx level. + * Get logging level. * </p> */ public int getLevel() { @@ -271,7 +271,7 @@ public class SimpleLog implements Log, Serializable { /** * <p> - * Do the actual loxx. This method assembles the message and then calls + * Do the actual logging. This method assembles the message and then calls * <code>write()</code> to cause it to be written. * </p> * diff --git a/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java b/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java index 1855b5b..850b989 100644 --- a/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java +++ b/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java @@ -70,23 +70,23 @@ import org.slf4j.spi.LocationAwareLogger; * SLF4JBridgeHandler.install(); * * // usual pattern: get a Logger and then log a message - * java.util.loxx.Logger julLogger = java.util.loxx.Logger + * java.util.logging.Logger julLogger = java.util.logging.Logger * .getLogger("org.wombat"); * julLogger.fine("hello world"); // this will get redirected to SLF4J * </pre> * * <p> - * Please note that translating a java.util.loxx event into SLF4J incurs the + * Please note that translating a java.util.logging event into SLF4J incurs the * cost of constructing {@link LogRecord} instance regardless of whether the * SLF4J logger is disabled for the given level. <b>Consequently, j.u.l. to - * SLF4J translation can seriously impact on the cost of disabled loxx + * SLF4J translation can seriously impact on the cost of disabled logging * statements (60 fold increase) and a measurable impact on enabled log * statements (20% overall increase). </b> * </p> * * <p> * If application performance is a concern, then use of SLF4JBridgeHandler is - * appropriate only if few j.u.l. loxx statements are in play. + * appropriate only if few j.u.l. logging statements are in play. * * @author Christian Stein * @author Joern Huxhorn @@ -97,7 +97,7 @@ import org.slf4j.spi.LocationAwareLogger; */ public class SLF4JBridgeHandler extends Handler { - // The caller is java.util.loxx.Logger + // The caller is java.util.logging.Logger private static final String FQCN = java.util.logging.Logger.class.getName(); private static final String UNKNOWN_LOGGER_NAME = "unknown.jul.logger"; @@ -110,7 +110,7 @@ public class SLF4JBridgeHandler extends Handler { * Adds a SLF4JBridgeHandler instance to jul's root logger. * * <p> - * This handler will redirect jul loxx to SLF4J. However, only logs enabled + * This handler will redirect jul logging to SLF4J. However, only logs enabled * in j.u.l. will be redirected. For example, if a log statement invoking a * j.u.l. logger disabled that statement, by definition, will <em>not</em> * reach any SLF4JBridgeHandler instance and cannot be redirected. @@ -162,7 +162,7 @@ public class SLF4JBridgeHandler extends Handler { } /** - * Return the Logger instance that will be used for loxx. + * Return the Logger instance that will be used for logging. */ protected Logger getSLF4JLogger(LogRecord record) { String name = record.getLoggerName(); @@ -238,7 +238,7 @@ public class SLF4JBridgeHandler extends Handler { /** * Publish a LogRecord. * <p> - * The loxx request was made initially to a Logger object, which + * The logging request was made initially to a Logger object, which * initialized the LogRecord and forwarded it here. * <p> * This handler ignores the Level attached to the LogRecord, as SLF4J cares @@ -256,9 +256,9 @@ public class SLF4JBridgeHandler extends Handler { Logger slf4jLogger = getSLF4JLogger(record); String message = record.getMessage(); // can be null! - // this is a check to avoid calling the underlying loxx system + // this is a check to avoid calling the underlying logging system // with a null message. While it is legitimate to invoke j.u.l. with - // a null message, other loxx frameworks do not support this. + // a null message, other logging frameworks do not support this. // see also http://bugzilla.slf4j.org/show_bug.cgi?id=108 if (message == null) { message = ""; diff --git a/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java b/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java index 79d9718..71588c2 100644 --- a/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java +++ b/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java @@ -39,7 +39,7 @@ public class SLF4JBridgeHandlerPerfTest extends TestCase { static int RUN_LENGTH = 100*1000; - // set to false to test enabled loxx performance + // set to false to test enabled logging performance boolean disabledLogger = true; FileAppender fileAppender; diff --git a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java index d724b10..eeff93b 100644 --- a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java +++ b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java @@ -1,5 +1,5 @@ /** - * Logback: the reliable, generic, fast and flexible loxx framework. + * Logback: the reliable, generic, fast and flexible logging framework. * * Copyright (C) 1999-2006, QOS.ch * diff --git a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java index 6cfbb07..54c6e9f 100644 --- a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java +++ b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java @@ -1,5 +1,5 @@ /** - * Logback: the reliable, generic, fast and flexible loxx framework. + * Logback: the reliable, generic, fast and flexible logging framework. * * Copyright (C) 1999-2006, QOS.ch * diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java deleted file mode 100644 index e675d89..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java +++ /dev/null @@ -1,134 +0,0 @@ -/* - * 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. - */ - -package org.apache.log4j; - -import org.apache.log4j.spi.Filter; -import org.apache.log4j.spi.ErrorHandler; -import org.apache.log4j.spi.Layout; -import org.apache.log4j.spi.LoggingEvent; - -/** - * Implement this interface for your own strategies for outputting log - * statements. - * - * @author Ceki Gülcü - */ -public interface Appender { - - /** - * Add a filter to the end of the filter list. - * - * @since 0.9.0 - */ - void addFilter(Filter newFilter); - - /** - * Returns the head Filter. The Filters are organized in a linked list - * and so all Filters on this Appender are available through the result. - * - * @return the head Filter or null, if no Filters are present - * @since 1.1 - */ - public Filter getFilter(); - - /** - * Clear the list of filters by removing all the filters in it. - * - * @since 0.9.0 - */ - public void clearFilters(); - - /** - * Release any resources allocated within the appender such as file - * handles, network connections, etc. - * <p/> - * <p>It is a programming error to append to a closed appender. - * - * @since 0.8.4 - */ - public void close(); - - /** - * Log in <code>Appender</code> specific way. When appropriate, - * Loggers will call the <code>doAppend</code> method of appender - * implementations in order to log. - */ - public void doAppend(LoggingEvent event); - - - /** - * Get the name of this appender. The name uniquely identifies the - * appender. - */ - public String getName(); - - - /** - * Set the {@link ErrorHandler} for this appender. - * - * @since 0.9.0 - */ - public void setErrorHandler(ErrorHandler errorHandler); - - /** - * Returns the {@link ErrorHandler} for this appender. - * - * @since 1.1 - */ - public ErrorHandler getErrorHandler(); - - /** - * Set the {@link Layout} for this appender. - * - * @since 0.8.1 - */ - public void setLayout(Layout layout); - - /** - * Returns this appenders layout. - * - * @since 1.1 - */ - public Layout getLayout(); - - - /** - * Set the name of this appender. The name is used by other - * components to identify this appender. - * - * @since 0.8.1 - */ - public void setName(String name); - - /** - * Configurators call this method to determine if the appender - * requires a layout. If this method returns <code>true</code>, - * meaning that layout is required, then the configurator will - * configure an layout using the configuration information at its - * disposal. If this method returns <code>false</code>, meaning that - * a layout is not required, then layout configuration will be - * skipped even if there is available layout configuration - * information at the disposal of the configurator.. - * <p/> - * <p>In the rather exceptional case, where the appender - * implementation admits a layout but can also work without it, then - * the appender should return <code>true</code>. - * - * @since 0.8.4 - */ - public boolean requiresLayout(); -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java index 9a46d1f..5aaae14 100644 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java @@ -26,13 +26,13 @@ import org.slf4j.spi.LocationAwareLogger; * <code>org.apache.log4j.Category</code> class (as found in log4j 1.2) by * delegation of all calls to a {@link org.slf4j.Logger} instance. * </p> - * + * * <p> * Log4j's <code>trace</code>, <code>debug()</code>, <code>info()</code>, * <code>warn()</code>, <code>error()</code> printing methods are directly * mapped to their SLF4J equivalents. Log4j's <code>fatal()</code> printing * method is mapped to SLF4J's <code>error()</code> method with a FATAL marker. - * + * * @author Sébastien Pennec * @author Ceki Gülcü */ @@ -65,7 +65,7 @@ public class Category { /** * Returns the obvious. - * + * * @return */ public String getName() { @@ -74,10 +74,10 @@ public class Category { /** * Return the level in effect for this category/logger. - * + * * <p> * The result is computed by simulation. - * + * * @return */ public Level getEffectiveLevel() { @@ -99,7 +99,7 @@ public class Category { /** * Returns the assigned {@link Level}, if any, for this Category. This * implementation always returns null. - * + * * @return Level - the assigned Level, can be <code>null</code>. */ final public Level getLevel() { @@ -145,7 +145,7 @@ public class Category { * Determines whether the priority passed as parameter is enabled in the * underlying SLF4J logger. Each log4j priority is mapped directly to its * SLF4J equivalent, except for FATAL which is mapped as ERROR. - * + * * @param p * the priority to check against * @return true if this logger is enabled for the given level, false @@ -171,7 +171,6 @@ public class Category { void differentiatedLog(Marker marker, String fqcn, int level, Object message, Throwable t) { - String m = convertToString(message); if (locationAwareLogger != null) { locationAwareLogger.log(marker, fqcn, level, m, null, t); @@ -301,8 +300,6 @@ public class Category { switch (p.level) { case Level.TRACE_INT: return LocationAwareLogger.TRACE_INT; - case Level.X_TRACE_INT: - return LocationAwareLogger.TRACE_INT; case Priority.DEBUG_INT: return LocationAwareLogger.DEBUG_INT; case Priority.INFO_INT: diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java index beaf221..36ae571 100644 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java @@ -44,12 +44,9 @@ public class Level extends Priority implements Serializable { */ public static final int TRACE_INT = 5000; - // match jboss' xlevel - public static final int X_TRACE_INT = DEBUG_INT - 100; - /** The <code>OFF</code> has the highest possible rank and is - intended to turn off loxx. */ + intended to turn off logging. */ final static public Level OFF = new Level(OFF_INT, "OFF", 0); /** @@ -90,7 +87,7 @@ public class Level extends Priority implements Serializable { /** The <code>ALL</code> has the lowest possible rank and is intended to - turn on all loxx. */ + turn on all logging. */ final static public Level ALL = new Level(ALL_INT, "ALL", 7); /** diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java index 937e8a8..483de04 100644 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java @@ -1,12 +1,12 @@ /* * Copyright 2001-2004 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. @@ -21,16 +21,16 @@ import org.slf4j.spi.LocationAwareLogger; /** * <p> * This class is a minimal implementation of the original - * <code>org.apache.log4j.Logger</code> class (as found in log4j 1.2) + * <code>org.apache.log4j.Logger</code> class (as found in log4j 1.2) * delegating all calls to a {@link org.slf4j.Logger} instance. * </p> * - * @author Ceki Gülcü + * @author Ceki Gülcü * */ public class Logger extends Category { - + private static final String LOGGER_FQCN = Logger.class.getName(); - + Logger(String name) { super(name); } @@ -42,25 +42,25 @@ public class Logger extends Category { public static Logger getLogger(Class clazz) { return getLogger(clazz.getName()); } - + /** * Does the obvious. - * + * * @return */ public static Logger getRootLogger() { return Log4jLoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME); } - + /** - * Delegates to {@link org.slf4j.Logger#isTraceEnabled} + * Delegates to {@link org.slf4j.Logger#isTraceEnabled} * method of SLF4J. */ public boolean isTraceEnabled() { return slf4jLogger.isTraceEnabled(); } - + /** * Delegates to {@link org.slf4j.Logger#trace(String)} method in SLF4J. */ @@ -69,7 +69,7 @@ public class Logger extends Category { } /** - * Delegates to {@link org.slf4j.Logger#trace(String,Throwable)} + * Delegates to {@link org.slf4j.Logger#trace(String,Throwable)} * method in SLF4J. */ public void trace(Object message, Throwable t) { diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java deleted file mode 100644 index c8c70b5..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java +++ /dev/null @@ -1,179 +0,0 @@ -/* - * 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. - */ - -package org.apache.log4j.helpers; - -/** - This class used to output log statements from within the log4j package. - - <p>Log4j components cannot make log4j logging calls. However, it is - sometimes useful for the user to learn about what log4j is - doing. You can enable log4j internal logging by defining the - <b>log4j.configDebug</b> variable. - - <p>All log4j internal debug calls go to <code>System.out</code> - where as internal error messages are sent to - <code>System.err</code>. All internal messages are prepended with - the string "log4j: ". - - @since 0.8.2 - @author Ceki Gülcü -*/ -public class LogLog { - - /** - Defining this value makes log4j print log4j-internal debug - statements to <code>System.out</code>. - - <p> The value of this string is <b>log4j.debug</b>. - - <p>Note that the search for all option names is case sensitive. */ - public static final String DEBUG_KEY="log4j.debug"; - - - /** - Defining this value makes log4j components print log4j-internal - debug statements to <code>System.out</code>. - - <p> The value of this string is <b>log4j.configDebug</b>. - - <p>Note that the search for all option names is case sensitive. - - @deprecated Use {@link #DEBUG_KEY} instead. - */ - public static final String CONFIG_DEBUG_KEY="log4j.configDebug"; - - protected static boolean debugEnabled = false; - - /** - In quietMode not even errors generate any output. - */ - private static boolean quietMode = false; - - private static final String PREFIX = "log4j: "; - private static final String ERR_PREFIX = "log4j:ERROR "; - private static final String WARN_PREFIX = "log4j:WARN "; - - static { - } - - /** - Allows to enable/disable log4j internal logging. - */ - static - public - void setInternalDebugging(boolean enabled) { - debugEnabled = enabled; - } - - /** - This method is used to output log4j internal debug - statements. Output goes to <code>System.out</code>. - */ - public - static - void debug(String msg) { - if(debugEnabled && !quietMode) { - System.out.println(PREFIX+msg); - } - } - - /** - This method is used to output log4j internal debug - statements. Output goes to <code>System.out</code>. - */ - public - static - void debug(String msg, Throwable t) { - if(debugEnabled && !quietMode) { - System.out.println(PREFIX+msg); - if(t != null) - t.printStackTrace(System.out); - } - } - - - /** - This method is used to output log4j internal error - statements. There is no way to disable error statements. - Output goes to <code>System.err</code>. - */ - public - static - void error(String msg) { - if(quietMode) - return; - System.err.println(ERR_PREFIX+msg); - } - - /** - This method is used to output log4j internal error - statements. There is no way to disable error statements. - Output goes to <code>System.err</code>. - */ - public - static - void error(String msg, Throwable t) { - if(quietMode) - return; - - System.err.println(ERR_PREFIX+msg); - if(t != null) { - t.printStackTrace(); - } - } - - /** - In quite mode no LogLog generates strictly no output, not even - for errors. - - @param quietMode A true for not - */ - public - static - void setQuietMode(boolean quietMode) { - LogLog.quietMode = quietMode; - } - - /** - This method is used to output log4j internal warning - statements. There is no way to disable warning statements. - Output goes to <code>System.err</code>. */ - public - static - void warn(String msg) { - if(quietMode) - return; - - System.err.println(WARN_PREFIX+msg); - } - - /** - This method is used to output log4j internal warnings. There is - no way to disable warning statements. Output goes to - <code>System.err</code>. */ - public - static - void warn(String msg, Throwable t) { - if(quietMode) - return; - - System.err.println(WARN_PREFIX+msg); - if(t != null) { - t.printStackTrace(); - } - } -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java deleted file mode 100644 index 4ce496d..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java +++ /dev/null @@ -1,39 +0,0 @@ -package org.apache.log4j.spi; - - -import org.apache.log4j.spi.LoggerRepository; -import java.net.URL; - -/** - Implemented by classes capable of configuring log4j using a URL. - - @since 1.0 - @author Anders Kristensen - */ -public interface Configurator { - - /** - Special level value signifying inherited behaviour. The current - value of this string constant is <b>inherited</b>. {@link #NULL} - is a synonym. */ - public static final String INHERITED = "inherited"; - - /** - Special level signifying inherited behaviour, same as {@link - #INHERITED}. The current value of this string constant is - <b>null</b>. */ - public static final String NULL = "null"; - - - - /** - Interpret a resource pointed by a URL and set up log4j accordingly. - - The configuration is done relative to the <code>hierarchy</code> - parameter. - - @param url The URL to parse - @param repository The hierarchy to operation upon. - */ - void doConfigure(URL url, LoggerRepository repository); -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java deleted file mode 100644 index 9317c70..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.apache.log4j.spi; - -/** - * Created by IntelliJ IDEA. - * User: ceki - * Date: 19 oct. 2010 - * Time: 11:46:24 - * To change this template use File | Settings | File Templates. - */ -public class ErrorHandler { -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java deleted file mode 100644 index 5526e91..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.apache.log4j.spi; - -/** - * Created by IntelliJ IDEA. - * User: ceki - * Date: 19 oct. 2010 - * Time: 11:45:19 - * To change this template use File | Settings | File Templates. - */ -public class Filter { -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java deleted file mode 100644 index 4c7603c..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java +++ /dev/null @@ -1,43 +0,0 @@ -/* - * 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. - */ - -package org.apache.log4j.spi; - -import org.apache.log4j.*; - -/** - Listen to events occuring within a {@link - org.apache.log4j.Hierarchy Hierarchy}. - - @author Ceki Gülcü - @since 1.2 - - */ -public interface HierarchyEventListener { - - - //public - //void categoryCreationEvent(Category cat); - - - public - void addAppenderEvent(Category cat, Appender appender); - - public - void removeAppenderEvent(Category cat, Appender appender); - - -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java deleted file mode 100644 index ab740c1..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.apache.log4j.spi; - -/** - * Created by IntelliJ IDEA. - * User: ceki - * Date: 19 oct. 2010 - * Time: 11:46:12 - * To change this template use File | Settings | File Templates. - */ -public class Layout { -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java deleted file mode 100644 index cce2d3a..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java +++ /dev/null @@ -1,37 +0,0 @@ -/* - * 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. - */ - -package org.apache.log4j.spi; - -import org.apache.log4j.Logger; - -/** - - Implement this interface to create new instances of Logger or - a sub-class of Logger. - - <p>See <code>examples/subclass/MyLogger.java</code> for an example. - - @author Ceki Gülcü - @since version 0.8.5 - - */ -public interface LoggerFactory { - - public - Logger makeNewLoggerInstance(String name); - -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java deleted file mode 100644 index 36a2fa6..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java +++ /dev/null @@ -1,98 +0,0 @@ -/* - * 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. - */ - -package org.apache.log4j.spi; - -import org.apache.log4j.*; - -import java.util.Enumeration; - -/** - * A <code>LoggerRepository</code> is used to create and retrieve - * <code>Loggers</code>. The relation between loggers in a repository - * depends on the repository but typically loggers are arranged in a - * named hierarchy. - * <p/> - * <p>In addition to the creational methods, a - * <code>LoggerRepository</code> can be queried for existing loggers, - * can act as a point of registry for events related to loggers. - * - * @author Ceki Gülcü - * @since 1.2 - */ -public interface LoggerRepository { - - /** - * Add a {@link HierarchyEventListener} event to the repository. - */ - public void addHierarchyEventListener(HierarchyEventListener listener); - - /** - * Returns whether this repository is disabled for a given - * level. The answer depends on the repository threshold and the - * <code>level</code> parameter. See also {@link #setThreshold} - * method. - */ - boolean isDisabled(int level); - - /** - * Set the repository-wide threshold. All loxx requests below the - * threshold are immediately dropped. By default, the threshold is - * set to <code>Level.ALL</code> which has the lowest possible rank. - */ - public void setThreshold(Level level); - - /** - * Another form of {@link #setThreshold(Level)} accepting a string - * parameter instead of a <code>Level</code>. - */ - public void setThreshold(String val); - - public void emitNoAppenderWarning(Category cat); - - /** - * Get the repository-wide threshold. See {@link - * #setThreshold(Level)} for an explanation. - */ - public Level getThreshold(); - - public Logger getLogger(String name); - - public Logger getLogger(String name, LoggerFactory factory); - - public Logger getRootLogger(); - - public - abstract Logger exists(String name); - - public - abstract void shutdown(); - - public Enumeration getCurrentLoggers(); - - /** - * Deprecated. Please use {@link #getCurrentLoggers} instead. - */ - public Enumeration getCurrentCategories(); - - - public - abstract void fireAddAppenderEvent(Category logger, Appender appender); - - public - abstract void resetConfiguration(); - -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java deleted file mode 100644 index acde46f..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java +++ /dev/null @@ -1,11 +0,0 @@ -package org.apache.log4j.spi; - -/** - * Created by IntelliJ IDEA. - * User: ceki - * Date: 19 oct. 2010 - * Time: 11:47:05 - * To change this template use File | Settings | File Templates. - */ -public class LoggingEvent { -} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java deleted file mode 100644 index 177feae..0000000 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java +++ /dev/null @@ -1,32 +0,0 @@ -/* - * Copyright 2001-2004 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. - */ -package org.apache.log4j.xml; - -import org.apache.log4j.spi.Configurator; -import org.apache.log4j.spi.LoggerRepository; - -import javax.xml.parsers.FactoryConfigurationError; -import java.net.URL; - - -public class DOMConfigurator implements Configurator { - static public void configure(URL url) throws FactoryConfigurationError { - } - - - public void doConfigure(URL url, LoggerRepository repository) { - } -} diff --git a/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java b/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java index a568197..851b60c 100644 --- a/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java @@ -44,11 +44,11 @@ public interface ILoggerFactory { * * <p>If the name parameter is equal to {@link Logger#ROOT_LOGGER_NAME}, that is * the string value "ROOT" (case insensitive), then the root logger of the - * underlying loxx system is returned. + * underlying logging system is returned. * * <p>Null-valued name arguments are considered invalid. * - * <p>Certain extremely simple loxx systems, e.g. NOP, may always + * <p>Certain extremely simple logging systems, e.g. NOP, may always * return the same logger instance regardless of the requested name. * * @param name the name of the Logger to return diff --git a/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java b/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java index 24254fd..b278dc4 100644 --- a/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java @@ -30,7 +30,7 @@ package org.slf4j; * instances. * * <p>See the section <a href="http://slf4j.org/faq.html#3">Implementing - * the SLF4J API</a> in the FAQ for details on how to make your loxx + * the SLF4J API</a> in the FAQ for details on how to make your logging * system conform to SLF4J. * * @author Ceki Gülcü diff --git a/slf4j-api/src/main/java/org/slf4j/Logger.java b/slf4j-api/src/main/java/org/slf4j/Logger.java index b93fdc6..13efdcd 100644 --- a/slf4j-api/src/main/java/org/slf4j/Logger.java +++ b/slf4j-api/src/main/java/org/slf4j/Logger.java @@ -27,7 +27,7 @@ package org.slf4j; /** * The org.slf4j.Logger interface is the main user entry point of SLF4J API. - * It is expected that loxx takes place through concrete implementations + * It is expected that logging takes place through concrete implementations * of this interface. * * <h3>Typical usage pattern:</h3> diff --git a/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java b/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java index a9e6ae7..c2063f3 100644 --- a/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java @@ -38,7 +38,7 @@ import org.slf4j.impl.StaticLoggerBinder; /** * The <code>LoggerFactory</code> is a utility class producing Loggers for - * various loxx APIs, most notably for log4j, logback and JDK 1.4 loxx. + * various logging APIs, most notably for log4j, logback and JDK 1.4 logging. * Other implementations such as {@link org.slf4j.impl.NOPLogger NOPLogger} and * {@link org.slf4j.impl.SimpleLogger SimpleLogger} are also supported. * diff --git a/slf4j-api/src/main/java/org/slf4j/MDC.java b/slf4j-api/src/main/java/org/slf4j/MDC.java index 319d3cf..1670061 100644 --- a/slf4j-api/src/main/java/org/slf4j/MDC.java +++ b/slf4j-api/src/main/java/org/slf4j/MDC.java @@ -33,19 +33,19 @@ import org.slf4j.impl.StaticMDCBinder; import org.slf4j.spi.MDCAdapter; /** - * This class hides and serves as a substitute for the underlying loxx + * This class hides and serves as a substitute for the underlying logging * system's MDC implementation. * * <p> - * If the underlying loxx system offers MDC functionality, then SLF4J's MDC, + * If the underlying logging system offers MDC functionality, then SLF4J's MDC, * i.e. this class, will delegate to the underlying system's MDC. Note that at - * this time, only two loxx systems, namely log4j and logback, offer MDC + * this time, only two logging systems, namely log4j and logback, offer MDC * functionality. If the underlying system does not support MDC, e.g. - * java.util.loxx, then SLF4J will use a {@link BasicMDCAdapter}. + * java.util.logging, then SLF4J will use a {@link BasicMDCAdapter}. * * <p> * Thus, as a SLF4J user, you can take advantage of MDC in the presence of log4j - * logback, or java.util.loxx, but without forcing these systems as + * logback, or java.util.logging, but without forcing these systems as * dependencies upon your users. * * <p> @@ -95,7 +95,7 @@ public class MDC { * can be null only if the underlying implementation supports it. * * <p> - * This method delegates all work to the MDC of the underlying loxx system. + * This method delegates all work to the MDC of the underlying logging system. * * @throws IllegalArgumentException * in case the "key" parameter is null @@ -117,7 +117,7 @@ public class MDC { * <code>key</code> parameter cannot be null. * * <p> - * This method delegates all work to the MDC of the underlying loxx system. + * This method delegates all work to the MDC of the underlying logging system. * * @return the string value identified by the <code>key</code> parameter. * @throws IllegalArgumentException diff --git a/slf4j-api/src/main/java/org/slf4j/Marker.java b/slf4j-api/src/main/java/org/slf4j/Marker.java index 7ccbc92..e29dbdb 100644 --- a/slf4j-api/src/main/java/org/slf4j/Marker.java +++ b/slf4j-api/src/main/java/org/slf4j/Marker.java @@ -28,9 +28,9 @@ import java.io.Serializable; import java.util.Iterator; /** - * Markers are named objects used to enrich log statements. Conforming loxx + * Markers are named objects used to enrich log statements. Conforming logging * system Implementations of SLF4J determine how information conveyed by markers - * are used, if at all. In particular, many conforming loxx systems ignore + * are used, if at all. In particular, many conforming logging systems ignore * marker data. * * <p> diff --git a/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java b/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java index a921a93..3cb8cfc 100644 --- a/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java @@ -30,7 +30,7 @@ import org.slf4j.impl.StaticMarkerBinder; /** * MarkerFactory is a utility class producing {@link Marker} instances as - * appropriate for the loxx system currently in use. + * appropriate for the logging system currently in use. * * <p> * This class is essentially implemented as a wrapper around an diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java index e18aaff..57589f5 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java @@ -30,7 +30,7 @@ import java.util.Map; import java.util.Set; /** - * Basic MDC implementation, which can be used with loxx systems that lack + * Basic MDC implementation, which can be used with logging systems that lack * out-of-the-box MDC support. * * This code is largely based on logback's <a diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java index 72e58f3..7686684 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java @@ -34,7 +34,7 @@ import org.slf4j.Marker; * An almost trivial implementation of the {@link IMarkerFactory} * interface which creates {@link BasicMarker} instances. * - * <p>Simple loxx systems can conform to the SLF4J API by binding + * <p>Simple logging systems can conform to the SLF4J API by binding * {@link org.slf4j.MarkerFactory} with an instance of this class. * * @author Ceki Gülcü diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java b/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java index d0bc2be..b4ccba7 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java @@ -29,7 +29,7 @@ import org.slf4j.Marker; /** - * This class serves as base for adapters or native implementations of loxx systems + * This class serves as base for adapters or native implementations of logging systems * lacking Marker support. In this implementation, methods taking marker data * simply invoke the corresponding method without the Marker argument, discarding * any marker data passed as argument. diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java index 9173631..7242e56 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java @@ -85,7 +85,7 @@ import java.util.Map; * which ships with the Java platform. This is justified by the fact that * SLF4J's implementation is 10 times faster than that of {@link MessageFormat}. * This local performance difference is both measurable and significant in the - * larger context of the complete loxx processing chain. + * larger context of the complete logging processing chain. * * <p> * See also {@link #format(String, Object)}, diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java b/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java index 6f4d0f7..b995cba 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java @@ -6,7 +6,7 @@ import org.slf4j.spi.MDCAdapter; /** * This adapter is an empty implementation of the {@link MDCAdapter} interface. - * It is used for all loxx systems which do not support mapped + * It is used for all logging systems which do not support mapped * diagnostic contexts such as JDK14, simple and NOP. * * @author Ceki Gülcü diff --git a/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java b/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java index 2fc7c4b..523589d 100644 --- a/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java +++ b/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java @@ -28,9 +28,9 @@ import org.slf4j.Logger; import org.slf4j.Marker; /** - * An <b>optional</b> interface helping integration with loxx systems capable of + * An <b>optional</b> interface helping integration with logging systems capable of * extracting location information. This interface is mainly used by SLF4J bridges - * such as jcl104-over-slf4j which need to provide hints so that the underlying loxx + * such as jcl104-over-slf4j which need to provide hints so that the underlying logging * system can extract the correct location information (method name, line number, etc.). * * diff --git a/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java b/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java index f585f0f..e81ccae 100644 --- a/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java +++ b/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java @@ -19,7 +19,7 @@ public class AgentOptions { */ public static final String IGNORE = "ignore"; /** - * Indicate the SLF4J level that should be used by the loxx statements + * Indicate the SLF4J level that should be used by the logging statements * added by the agent. Default is "info". */ public static final String LEVEL = "level"; @@ -31,7 +31,7 @@ public class AgentOptions { public static final String TIME = "time"; /** * Indicate that the agent should log actions to System.err, like adding - * loxx to methods, etc. + * logging to methods, etc. * */ public static final String VERBOSE = "verbose"; diff --git a/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java b/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java index 2c00fe9..761143a 100644 --- a/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java +++ b/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java @@ -31,7 +31,7 @@ import ch.qos.cal10n.IMessageConveyor; import ch.qos.cal10n.MessageParameterObj; /** - * A logger specialized in localized loxx. Localization is based in the <a + * A logger specialized in localized logging. Localization is based in the <a * href="http://cal10n.qos.ch">CAL10N project</p>. * * @author Ceki Gülcü diff --git a/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java b/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java index e3a46e2..635ef25 100644 --- a/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java +++ b/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java @@ -8,7 +8,7 @@ import org.slf4j.helpers.MessageFormatter; import org.slf4j.spi.LocationAwareLogger; /** - * A utility that provides standard mechanisms for loxx certain kinds of + * A utility that provides standard mechanisms for logging certain kinds of * activities. * * @author Ralph Goers @@ -147,7 +147,7 @@ public class XLogger extends LoggerWrapper implements Logger { * Log an exception being thrown allowing the log level to be specified. * * @param level - * the loxx level to use. + * the logging level to use. * @param throwable * the exception being caught. */ @@ -175,7 +175,7 @@ public class XLogger extends LoggerWrapper implements Logger { * Log an exception being caught allowing the log level to be specified. * * @param level - * the loxx level to use. + * the logging level to use. * @param throwable * the exception being caught. */ diff --git a/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java b/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java index 32d8db4..4f2fb4e 100644 --- a/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java +++ b/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java @@ -21,10 +21,10 @@ import org.slf4j.helpers.MessageFormatter; /** * <p> * LogTransformer does the work of analyzing each class, and if appropriate add - * log statements to each method to allow loxx entry/exit. + * log statements to each method to allow logging entry/exit. * </p> * <p> - * This class is based on the article <a href="http://today.java.net/pub/a/today/2008/04/24/add-loxx-at-class-load-time-wit..." + * This class is based on the article <a href="http://today.java.net/pub/a/today/2008/04/24/add-logging-at-class-load-time-..." * >Add Logging at Class Load Time with Java Instrumentation</a>. * </p> */ @@ -265,7 +265,7 @@ public class LogTransformer implements ClassFileTransformer { } /** - * process a single method - this means add entry/exit loxx if requested. + * process a single method - this means add entry/exit logging if requested. * It is only called for methods with a body. * * @param method diff --git a/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java b/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java index 0a6412c..31c57e0 100644 --- a/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java +++ b/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java @@ -33,7 +33,7 @@ import org.slf4j.helpers.MessageFormatter; /** * A wrapper over {@link org.apache.commons.logging.Log - * org.apache.commons.loxx.Log} in conformance with the {@link Logger} + * org.apache.commons.logging.Log} in conformance with the {@link Logger} * interface. * * @author Ceki Gülcü diff --git a/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java b/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java index 3bf78a7..1c9b0cc 100644 --- a/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java +++ b/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java @@ -44,9 +44,9 @@ import org.slf4j.helpers.MessageFormatter; import org.slf4j.spi.LocationAwareLogger; /** - * A wrapper over {@link java.util.logging.Logger java.util.loxx.Logger} in - * conformity with the {@link Logger} interface. Note that the loxx levels - * mentioned in this class refer to those defined in the java.util.loxx + * A wrapper over {@link java.util.logging.Logger java.util.logging.Logger} in + * conformity with the {@link Logger} interface. Note that the logging levels + * mentioned in this class refer to those defined in the java.util.logging * package. * * @author Ceki Gülcü diff --git a/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java b/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java index 5fad232..51cecb4 100644 --- a/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java +++ b/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java @@ -39,9 +39,9 @@ import org.slf4j.spi.LocationAwareLogger; * conforming to the {@link Logger} interface. * * <p> - * Note that the loxx levels mentioned in this class refer to those defined + * Note that the logging levels mentioned in this class refer to those defined * in the <a - * href="http://loxx.apache.org/log4j/docs/api/org/apache/log4j/Level.html"> + * href="http://logging.apache.org/log4j/docs/api/org/apache/log4j/Level.html"> * <code>org.apache.log4j.Level</code></a> class. * * <p> diff --git a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java index 394b27a..983d40f 100644 --- a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java +++ b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java @@ -16,12 +16,12 @@ public class JCLRuleSet implements RuleSet { private ArrayList<ConversionRule> conversionRuleList; public JCLRuleSet() { - // matching : import org.apache.commons.loxx.LogFactory; + // matching : import org.apache.commons.logging.LogFactory; SingleConversionRule cr0 = new SingleConversionRule(Pattern .compile("import\\s*+org.apache.commons.logging.LogFactory;"), "import org.slf4j.LoggerFactory;"); - // matching : import org.apache.commons.loxx.Log; + // matching : import org.apache.commons.logging.Log; SingleConversionRule cr1 = new SingleConversionRule(Pattern .compile("import\\s*+org.apache.commons.logging.Log;"), "import org.slf4j.Logger;"); diff --git a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java index b4255eb..9d13b65 100644 --- a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java +++ b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java @@ -5,7 +5,7 @@ import java.util.Iterator; import java.util.regex.Pattern; /** - * This class represents java.util.loxx (JUL) to SLF4J conversion rules + * This class represents java.util.logging (JUL) to SLF4J conversion rules * * @author Jean-Noel Charpin * @author Ceki Gulcu diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java index bfdc53f..f739150 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java @@ -86,11 +86,11 @@ public class JdkBundleTest extends ConfigurableBundleCreatorTests implements Int * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are + * JUnit, commons-logging, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other loxx bundles from getting mixed up with our test bundles. + * these other logging bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java index f805fdf..556335c 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java @@ -91,12 +91,12 @@ public class Log4JBundleTest extends ConfigurableBundleCreatorTests implements I * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are + * JUnit, commons-logging, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Except in the case of slf4j.log4j12 using the log4j bundle associated * with the Spring-OSGi testing framework our test bundles are using package - * import and export versions to keep these other loxx bundles from + * import and export versions to keep these other logging bundles from * getting mixed up with our test bundles. */ protected String[] getBundleLocations() { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java index 8024b3b..436c612 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java @@ -87,11 +87,11 @@ public class LogServiceBundleTest extends ConfigurableBundleCreatorTests impleme * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are + * JUnit, commons-logging, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other loxx bundles from getting mixed up with our test bundles. + * these other logging bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java index f82ed79..d9394af 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java @@ -84,11 +84,11 @@ public class NopBundleTest extends ConfigurableBundleCreatorTests implements Int * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are + * JUnit, commons-logging, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other loxx bundles from getting mixed up with our test bundles. + * these other logging bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java index bd029f3..29052ec 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java @@ -87,11 +87,11 @@ public class SimpleBundleTest extends ConfigurableBundleCreatorTests implements * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are + * JUnit, commons-logging, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other loxx bundles from getting mixed up with our test bundles. + * these other logging bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-test-bundle/pom.xml b/slf4j-osgi-test-bundle/pom.xml index 186710e..9567457 100644 --- a/slf4j-osgi-test-bundle/pom.xml +++ b/slf4j-osgi-test-bundle/pom.xml @@ -35,8 +35,8 @@ <scope>provided</scope> </dependency> - <!-- To get org.apache.commons.loxx package for - commons loxx testing.--> + <!-- To get org.apache.commons.logging package for + commons logging testing.--> <dependency> <groupId>org.slf4j</groupId> <artifactId>jcl-over-slf4j</artifactId> diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java index ff88a7f..cd95f28 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java @@ -46,7 +46,7 @@ import java.util.Hashtable; /** * <code>Activator</code> implements a simple bundle to test OSGi slf4j - * loxx components. + * logging components. * * Upon startup, shutdown, and receiving a service event, it logs event * details. diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java index 3db52ad..ad1ba13 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java @@ -36,7 +36,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** - * <code>CommonsLoggingTester</code> tests org.apache.commons.loxx functionality. + * <code>CommonsLoggingTester</code> tests org.apache.commons.logging functionality. * * @author John Conlon */ diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java index 022c82c..e5ea67f 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java @@ -45,7 +45,7 @@ public class ProbeImpl implements Probe{ /** * * @throws ClassNotFoundException If there is not a bundle exporting - * the org.apache.commons.loxx package + * the org.apache.commons.logging package * */ public boolean testCommonslogging() throws Exception{ diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java index 1510864..1229d2e 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java @@ -46,7 +46,7 @@ public interface Probe { * testCommonslogging * * @return true if all the tests were executed. - * @throws ClassNotFoundError if a org.apache.commons.loxx package + * @throws ClassNotFoundError if a org.apache.commons.logging package * could not be dynamically imported from the OSGi runtime. * @throws Exception if testing fails */ diff --git a/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java b/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java index 073741c..cf33b35 100644 --- a/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java +++ b/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java @@ -175,7 +175,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * This is our internal implementation for loxx regular (non-parameterized) + * This is our internal implementation for logging regular (non-parameterized) * log messages. * * @param level @@ -251,7 +251,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform single parameter substitution before loxx the message of level + * Perform single parameter substitution before logging the message of level * INFO according to the format outlined above. */ public void info(String format, Object arg) { @@ -259,7 +259,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before loxx the message of level + * Perform double parameter substitution before logging the message of level * INFO according to the format outlined above. */ public void info(String format, Object arg1, Object arg2) { @@ -267,7 +267,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before loxx the message of level + * Perform double parameter substitution before logging the message of level * INFO according to the format outlined above. */ public void info(String format, Object[] argArray) { @@ -297,7 +297,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform single parameter substitution before loxx the message of level + * Perform single parameter substitution before logging the message of level * WARN according to the format outlined above. */ public void warn(String format, Object arg) { @@ -305,7 +305,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before loxx the message of level + * Perform double parameter substitution before logging the message of level * WARN according to the format outlined above. */ public void warn(String format, Object arg1, Object arg2) { @@ -313,7 +313,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before loxx the message of level + * Perform double parameter substitution before logging the message of level * WARN according to the format outlined above. */ public void warn(String format, Object[] argArray) { @@ -343,7 +343,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform single parameter substitution before loxx the message of level + * Perform single parameter substitution before logging the message of level * ERROR according to the format outlined above. */ public void error(String format, Object arg) { @@ -351,7 +351,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before loxx the message of level + * Perform double parameter substitution before logging the message of level * ERROR according to the format outlined above. */ public void error(String format, Object arg1, Object arg2) { @@ -359,7 +359,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before loxx the message of level + * Perform double parameter substitution before logging the message of level * ERROR according to the format outlined above. */ public void error(String format, Object[] argArray) { http://git.qos.ch/gitweb/?p=slf4j.git;a=commit;h=3749a8521804cda6f22269923ad... http://github.com/ceki/slf4j/commit/3749a8521804cda6f22269923ad3ac5628e3a6cc commit 3749a8521804cda6f22269923ad3ac5628e3a6cc Author: Ceki Gulcu <ceki@qos.ch> Date: Tue Oct 19 17:19:10 2010 +0200 make log4j-over-slf4j run in jboss 4.2 diff --git a/jcl-over-slf4j/pom.xml b/jcl-over-slf4j/pom.xml index 7ea5b92..baedccc 100644 --- a/jcl-over-slf4j/pom.xml +++ b/jcl-over-slf4j/pom.xml @@ -69,8 +69,8 @@ <configuration> <comparisonArtifacts> <comparisonArtifact> - <groupId>commons-logging</groupId> - <artifactId>commons-logging</artifactId> + <groupId>commons-loxx</groupId> + <artifactId>commons-loxx</artifactId> <version>1.1.1</version> </comparisonArtifact> </comparisonArtifacts> diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java index 7886119..275bea5 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/Log.java @@ -18,12 +18,12 @@ package org.apache.commons.logging; /** - * <p>A simple logging interface abstracting logging APIs. In order to be + * <p>A simple loxx interface abstracting loxx APIs. In order to be * instantiated successfully by {@link LogFactory}, classes that implement * this interface must have a constructor that takes a single String * parameter representing the "name" of this Log.</p> * - * <p> The six logging levels used by <code>Log</code> are (in order): + * <p> The six loxx levels used by <code>Log</code> are (in order): * <ol> * <li>trace (the least serious)</li> * <li>debug</li> @@ -33,11 +33,11 @@ package org.apache.commons.logging; * <li>fatal (the most serious)</li> * </ol> * The mapping of these log levels to the concepts used by the underlying - * logging system is implementation dependent. + * loxx system is implementation dependent. * The implementation should ensure, though, that this ordering behaves * as expected.</p> * - * <p>Performance is often a logging concern. + * <p>Performance is often a loxx concern. * By examining the appropriate property, * a component can avoid expensive operations (producing information * to be logged).</p> @@ -51,7 +51,7 @@ package org.apache.commons.logging; * </pre></code> * </p> * - * <p>Configuration of the underlying logging system will generally be done + * <p>Configuration of the underlying loxx system will generally be done * external to the Logging APIs, through whatever mechanism is supported by * that system.</p> * @@ -68,7 +68,7 @@ public interface Log { /** - * <p> Is debug logging currently enabled? </p> + * <p> Is debug loxx currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -78,7 +78,7 @@ public interface Log { /** - * <p> Is error logging currently enabled? </p> + * <p> Is error loxx currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -88,7 +88,7 @@ public interface Log { /** - * <p> Is fatal logging currently enabled? </p> + * <p> Is fatal loxx currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -98,7 +98,7 @@ public interface Log { /** - * <p> Is info logging currently enabled? </p> + * <p> Is info loxx currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -108,7 +108,7 @@ public interface Log { /** - * <p> Is trace logging currently enabled? </p> + * <p> Is trace loxx currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) @@ -118,7 +118,7 @@ public interface Log { /** - * <p> Is warn logging currently enabled? </p> + * <p> Is warn loxx currently enabled? </p> * * <p> Call this method to prevent having to perform expensive operations * (for example, <code>String</code> concatenation) diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java index a839b1f..f631f1b 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/LogFactory.java @@ -51,7 +51,7 @@ public abstract class LogFactory { /** * The name (<code>use_tccl</code>) of the key in the config file used to - * specify whether logging classes should be loaded via the thread context + * specify whether loxx classes should be loaded via the thread context * class loader (TCCL), or not. By default, the TCCL is used. * * <p> @@ -94,9 +94,9 @@ public abstract class LogFactory { "META-INF/services/org.apache.commons.logging.LogFactory"; /** - * The name (<code>org.apache.commons.logging.diagnostics.dest</code>) of - * the property used to enable internal commons-logging diagnostic output, in - * order to get information on what logging implementations are being + * The name (<code>org.apache.commons.loxx.diagnostics.dest</code>) of + * the property used to enable internal commons-loxx diagnostic output, in + * order to get information on what loxx implementations are being * discovered, what classloaders they are loaded through, etc. * * <p> @@ -182,7 +182,7 @@ public abstract class LogFactory { * @param name * Logical name of the <code>Log</code> instance to be * returned (the meaning of this name is only known to the - * underlying logging implementation that is being wrapped) + * underlying loxx implementation that is being wrapped) * * @exception LogConfigurationException * if a suitable <code>Log</code> instance cannot be @@ -230,16 +230,16 @@ public abstract class LogFactory { * implementation class to be loaded. * </p> * <ul> - * <li>The <code>org.apache.commons.logging.LogFactory</code> system + * <li>The <code>org.apache.commons.loxx.LogFactory</code> system * property.</li> * <li>The JDK 1.3 Service Discovery mechanism</li> - * <li>Use the properties file <code>commons-logging.properties</code> + * <li>Use the properties file <code>commons-loxx.properties</code> * file, if found in the class path of this class. The configuration file is * in standard <code>java.util.Properties</code> format and contains the * fully qualified name of the implementation class with the key being the * system property defined above.</li> * <li>Fall back to a default implementation class ( - * <code>org.apache.commons.logging.impl.SLF4FLogFactory</code>).</li> + * <code>org.apache.commons.loxx.impl.SLF4FLogFactory</code>).</li> * </ul> * * <p> @@ -279,7 +279,7 @@ public abstract class LogFactory { * @param name * Logical name of the <code>Log</code> instance to be * returned (the meaning of this name is only known to the - * underlying logging implementation that is being wrapped) + * underlying loxx implementation that is being wrapped) * * @exception LogConfigurationException * if a suitable <code>Log</code> instance cannot be diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java index 727951c..e435bee 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLocationAwareLog.java @@ -25,7 +25,7 @@ import org.slf4j.LoggerFactory; import org.slf4j.spi.LocationAwareLogger; /** - * Implementation of {@link Log org.apache.commons.logging.Log} interface which + * Implementation of {@link Log org.apache.commons.loxx.Log} interface which * delegates all processing to a wrapped {@link Logger org.slf4j.Logger} * instance. * diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java index 44708bb..c05a116 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLog.java @@ -24,7 +24,7 @@ import org.slf4j.Logger; import org.slf4j.LoggerFactory; /** - * Implementation of {@link Log org.apache.commons.logging.Log} interface which + * Implementation of {@link Log org.apache.commons.loxx.Log} interface which * delegates all processing to a wrapped {@link Logger org.slf4j.Logger} * instance. * diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java index 8a31118..0614ba9 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SLF4JLogFactory.java @@ -141,7 +141,7 @@ public class SLF4JLogFactory extends LogFactory { * * @param name * Logical name of the <code>Log</code> instance to be returned - * (the meaning of this name is only known to the underlying logging + * (the meaning of this name is only known to the underlying loxx * implementation that is being wrapped) * * @exception LogConfigurationException @@ -177,7 +177,7 @@ public class SLF4JLogFactory extends LogFactory { // This method is never called by jcl-over-slf4j classes. However, // in certain deployment scenarios, in particular if jcl-over-slf4j.jar // is - // in the the web-app class loader and the official commons-logging.jar is + // in the the web-app class loader and the official commons-loxx.jar is // deployed in some parent class loader (e.g. commons/lib), then it is // possible // for the parent class loader to mask the classes shipping in diff --git a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java index 26a7941..723f118 100644 --- a/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java +++ b/jcl-over-slf4j/src/main/java/org/apache/commons/logging/impl/SimpleLog.java @@ -37,24 +37,24 @@ import org.apache.commons.logging.LogConfigurationException; * to configure the behavior of this logger: * </p> * <ul> - * <li><code>org.apache.commons.logging.simplelog.defaultlog</code> - Default - * logging detail level for all instances of SimpleLog. Must be one of ("trace", + * <li><code>org.apache.commons.loxx.simplelog.defaultlog</code> - Default + * loxx detail level for all instances of SimpleLog. Must be one of ("trace", * "debug", "info", "warn", "error", or "fatal"). If not specified, defaults to * "info".</li> - * <li><code>org.apache.commons.logging.simplelog.log.xxxxx</code> - Logging + * <li><code>org.apache.commons.loxx.simplelog.log.xxxxx</code> - Logging * detail level for a SimpleLog instance named "xxxxx". Must be one of ("trace", * "debug", "info", "warn", "error", or "fatal"). If not specified, the default - * logging detail level is used.</li> - * <li><code>org.apache.commons.logging.simplelog.showlogname</code> - Set to + * loxx detail level is used.</li> + * <li><code>org.apache.commons.loxx.simplelog.showlogname</code> - Set to * <code>true</code> if you want the Log instance name to be included in output * messages. Defaults to <code>false</code>.</li> - * <li><code>org.apache.commons.logging.simplelog.showShortLogname</code> - Set + * <li><code>org.apache.commons.loxx.simplelog.showShortLogname</code> - Set * to <code>true</code> if you want the last component of the name to be * included in output messages. Defaults to <code>true</code>.</li> - * <li><code>org.apache.commons.logging.simplelog.showdatetime</code> - Set to + * <li><code>org.apache.commons.loxx.simplelog.showdatetime</code> - Set to * <code>true</code> if you want the current date and time to be included in * output messages. Default is <code>false</code>.</li> - * <li><code>org.apache.commons.logging.simplelog.dateTimeFormat</code> - The + * <li><code>org.apache.commons.loxx.simplelog.dateTimeFormat</code> - The * date and time format to be used in the output messages. The pattern * describing the date and time format is the same that is used in * <code>java.text.SimpleDateFormat</code>. If the format is not specified or is @@ -107,23 +107,23 @@ public class SimpleLog implements Log, Serializable { // ---------------------------------------------------- Log Level Constants - /** "Trace" level logging. */ + /** "Trace" level loxx. */ public static final int LOG_LEVEL_TRACE = 1; - /** "Debug" level logging. */ + /** "Debug" level loxx. */ public static final int LOG_LEVEL_DEBUG = 2; - /** "Info" level logging. */ + /** "Info" level loxx. */ public static final int LOG_LEVEL_INFO = 3; - /** "Warn" level logging. */ + /** "Warn" level loxx. */ public static final int LOG_LEVEL_WARN = 4; - /** "Error" level logging. */ + /** "Error" level loxx. */ public static final int LOG_LEVEL_ERROR = 5; - /** "Fatal" level logging. */ + /** "Fatal" level loxx. */ public static final int LOG_LEVEL_FATAL = 6; - /** Enable all logging levels */ + /** Enable all loxx levels */ public static final int LOG_LEVEL_ALL = (LOG_LEVEL_TRACE - 1); - /** Enable no logging levels */ + /** Enable no loxx levels */ public static final int LOG_LEVEL_OFF = (LOG_LEVEL_FATAL + 1); // ------------------------------------------------------------ Initializer @@ -245,11 +245,11 @@ public class SimpleLog implements Log, Serializable { /** * <p> - * Set logging level. + * Set loxx level. * </p> * * @param currentLogLevel - * new logging level + * new loxx level */ public void setLevel(int currentLogLevel) { @@ -259,7 +259,7 @@ public class SimpleLog implements Log, Serializable { /** * <p> - * Get logging level. + * Get loxx level. * </p> */ public int getLevel() { @@ -271,7 +271,7 @@ public class SimpleLog implements Log, Serializable { /** * <p> - * Do the actual logging. This method assembles the message and then calls + * Do the actual loxx. This method assembles the message and then calls * <code>write()</code> to cause it to be written. * </p> * diff --git a/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java b/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java index 850b989..1855b5b 100644 --- a/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java +++ b/jul-to-slf4j/src/main/java/org/slf4j/bridge/SLF4JBridgeHandler.java @@ -70,23 +70,23 @@ import org.slf4j.spi.LocationAwareLogger; * SLF4JBridgeHandler.install(); * * // usual pattern: get a Logger and then log a message - * java.util.logging.Logger julLogger = java.util.logging.Logger + * java.util.loxx.Logger julLogger = java.util.loxx.Logger * .getLogger("org.wombat"); * julLogger.fine("hello world"); // this will get redirected to SLF4J * </pre> * * <p> - * Please note that translating a java.util.logging event into SLF4J incurs the + * Please note that translating a java.util.loxx event into SLF4J incurs the * cost of constructing {@link LogRecord} instance regardless of whether the * SLF4J logger is disabled for the given level. <b>Consequently, j.u.l. to - * SLF4J translation can seriously impact on the cost of disabled logging + * SLF4J translation can seriously impact on the cost of disabled loxx * statements (60 fold increase) and a measurable impact on enabled log * statements (20% overall increase). </b> * </p> * * <p> * If application performance is a concern, then use of SLF4JBridgeHandler is - * appropriate only if few j.u.l. logging statements are in play. + * appropriate only if few j.u.l. loxx statements are in play. * * @author Christian Stein * @author Joern Huxhorn @@ -97,7 +97,7 @@ import org.slf4j.spi.LocationAwareLogger; */ public class SLF4JBridgeHandler extends Handler { - // The caller is java.util.logging.Logger + // The caller is java.util.loxx.Logger private static final String FQCN = java.util.logging.Logger.class.getName(); private static final String UNKNOWN_LOGGER_NAME = "unknown.jul.logger"; @@ -110,7 +110,7 @@ public class SLF4JBridgeHandler extends Handler { * Adds a SLF4JBridgeHandler instance to jul's root logger. * * <p> - * This handler will redirect jul logging to SLF4J. However, only logs enabled + * This handler will redirect jul loxx to SLF4J. However, only logs enabled * in j.u.l. will be redirected. For example, if a log statement invoking a * j.u.l. logger disabled that statement, by definition, will <em>not</em> * reach any SLF4JBridgeHandler instance and cannot be redirected. @@ -162,7 +162,7 @@ public class SLF4JBridgeHandler extends Handler { } /** - * Return the Logger instance that will be used for logging. + * Return the Logger instance that will be used for loxx. */ protected Logger getSLF4JLogger(LogRecord record) { String name = record.getLoggerName(); @@ -238,7 +238,7 @@ public class SLF4JBridgeHandler extends Handler { /** * Publish a LogRecord. * <p> - * The logging request was made initially to a Logger object, which + * The loxx request was made initially to a Logger object, which * initialized the LogRecord and forwarded it here. * <p> * This handler ignores the Level attached to the LogRecord, as SLF4J cares @@ -256,9 +256,9 @@ public class SLF4JBridgeHandler extends Handler { Logger slf4jLogger = getSLF4JLogger(record); String message = record.getMessage(); // can be null! - // this is a check to avoid calling the underlying logging system + // this is a check to avoid calling the underlying loxx system // with a null message. While it is legitimate to invoke j.u.l. with - // a null message, other logging frameworks do not support this. + // a null message, other loxx frameworks do not support this. // see also http://bugzilla.slf4j.org/show_bug.cgi?id=108 if (message == null) { message = ""; diff --git a/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java b/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java index 71588c2..79d9718 100644 --- a/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java +++ b/jul-to-slf4j/src/test/java/org/slf4j/bridge/SLF4JBridgeHandlerPerfTest.java @@ -39,7 +39,7 @@ public class SLF4JBridgeHandlerPerfTest extends TestCase { static int RUN_LENGTH = 100*1000; - // set to false to test enabled logging performance + // set to false to test enabled loxx performance boolean disabledLogger = true; FileAppender fileAppender; diff --git a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java index eeff93b..d724b10 100644 --- a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java +++ b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j12Calls.java @@ -1,5 +1,5 @@ /** - * Logback: the reliable, generic, fast and flexible logging framework. + * Logback: the reliable, generic, fast and flexible loxx framework. * * Copyright (C) 1999-2006, QOS.ch * diff --git a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java index 54c6e9f..6cfbb07 100644 --- a/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java +++ b/log4j-over-slf4j/compatibility/src/main/java/test/Log4j13Calls.java @@ -1,5 +1,5 @@ /** - * Logback: the reliable, generic, fast and flexible logging framework. + * Logback: the reliable, generic, fast and flexible loxx framework. * * Copyright (C) 1999-2006, QOS.ch * diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java new file mode 100644 index 0000000..e675d89 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java @@ -0,0 +1,134 @@ +/* + * 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. + */ + +package org.apache.log4j; + +import org.apache.log4j.spi.Filter; +import org.apache.log4j.spi.ErrorHandler; +import org.apache.log4j.spi.Layout; +import org.apache.log4j.spi.LoggingEvent; + +/** + * Implement this interface for your own strategies for outputting log + * statements. + * + * @author Ceki Gülcü + */ +public interface Appender { + + /** + * Add a filter to the end of the filter list. + * + * @since 0.9.0 + */ + void addFilter(Filter newFilter); + + /** + * Returns the head Filter. The Filters are organized in a linked list + * and so all Filters on this Appender are available through the result. + * + * @return the head Filter or null, if no Filters are present + * @since 1.1 + */ + public Filter getFilter(); + + /** + * Clear the list of filters by removing all the filters in it. + * + * @since 0.9.0 + */ + public void clearFilters(); + + /** + * Release any resources allocated within the appender such as file + * handles, network connections, etc. + * <p/> + * <p>It is a programming error to append to a closed appender. + * + * @since 0.8.4 + */ + public void close(); + + /** + * Log in <code>Appender</code> specific way. When appropriate, + * Loggers will call the <code>doAppend</code> method of appender + * implementations in order to log. + */ + public void doAppend(LoggingEvent event); + + + /** + * Get the name of this appender. The name uniquely identifies the + * appender. + */ + public String getName(); + + + /** + * Set the {@link ErrorHandler} for this appender. + * + * @since 0.9.0 + */ + public void setErrorHandler(ErrorHandler errorHandler); + + /** + * Returns the {@link ErrorHandler} for this appender. + * + * @since 1.1 + */ + public ErrorHandler getErrorHandler(); + + /** + * Set the {@link Layout} for this appender. + * + * @since 0.8.1 + */ + public void setLayout(Layout layout); + + /** + * Returns this appenders layout. + * + * @since 1.1 + */ + public Layout getLayout(); + + + /** + * Set the name of this appender. The name is used by other + * components to identify this appender. + * + * @since 0.8.1 + */ + public void setName(String name); + + /** + * Configurators call this method to determine if the appender + * requires a layout. If this method returns <code>true</code>, + * meaning that layout is required, then the configurator will + * configure an layout using the configuration information at its + * disposal. If this method returns <code>false</code>, meaning that + * a layout is not required, then layout configuration will be + * skipped even if there is available layout configuration + * information at the disposal of the configurator.. + * <p/> + * <p>In the rather exceptional case, where the appender + * implementation admits a layout but can also work without it, then + * the appender should return <code>true</code>. + * + * @since 0.8.4 + */ + public boolean requiresLayout(); +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java index 5aaae14..9a46d1f 100644 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Category.java @@ -26,13 +26,13 @@ import org.slf4j.spi.LocationAwareLogger; * <code>org.apache.log4j.Category</code> class (as found in log4j 1.2) by * delegation of all calls to a {@link org.slf4j.Logger} instance. * </p> - * + * * <p> * Log4j's <code>trace</code>, <code>debug()</code>, <code>info()</code>, * <code>warn()</code>, <code>error()</code> printing methods are directly * mapped to their SLF4J equivalents. Log4j's <code>fatal()</code> printing * method is mapped to SLF4J's <code>error()</code> method with a FATAL marker. - * + * * @author Sébastien Pennec * @author Ceki Gülcü */ @@ -65,7 +65,7 @@ public class Category { /** * Returns the obvious. - * + * * @return */ public String getName() { @@ -74,10 +74,10 @@ public class Category { /** * Return the level in effect for this category/logger. - * + * * <p> * The result is computed by simulation. - * + * * @return */ public Level getEffectiveLevel() { @@ -99,7 +99,7 @@ public class Category { /** * Returns the assigned {@link Level}, if any, for this Category. This * implementation always returns null. - * + * * @return Level - the assigned Level, can be <code>null</code>. */ final public Level getLevel() { @@ -145,7 +145,7 @@ public class Category { * Determines whether the priority passed as parameter is enabled in the * underlying SLF4J logger. Each log4j priority is mapped directly to its * SLF4J equivalent, except for FATAL which is mapped as ERROR. - * + * * @param p * the priority to check against * @return true if this logger is enabled for the given level, false @@ -171,6 +171,7 @@ public class Category { void differentiatedLog(Marker marker, String fqcn, int level, Object message, Throwable t) { + String m = convertToString(message); if (locationAwareLogger != null) { locationAwareLogger.log(marker, fqcn, level, m, null, t); @@ -300,6 +301,8 @@ public class Category { switch (p.level) { case Level.TRACE_INT: return LocationAwareLogger.TRACE_INT; + case Level.X_TRACE_INT: + return LocationAwareLogger.TRACE_INT; case Priority.DEBUG_INT: return LocationAwareLogger.DEBUG_INT; case Priority.INFO_INT: diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java index 36ae571..beaf221 100644 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Level.java @@ -44,9 +44,12 @@ public class Level extends Priority implements Serializable { */ public static final int TRACE_INT = 5000; + // match jboss' xlevel + public static final int X_TRACE_INT = DEBUG_INT - 100; + /** The <code>OFF</code> has the highest possible rank and is - intended to turn off logging. */ + intended to turn off loxx. */ final static public Level OFF = new Level(OFF_INT, "OFF", 0); /** @@ -87,7 +90,7 @@ public class Level extends Priority implements Serializable { /** The <code>ALL</code> has the lowest possible rank and is intended to - turn on all logging. */ + turn on all loxx. */ final static public Level ALL = new Level(ALL_INT, "ALL", 7); /** diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java index 483de04..937e8a8 100644 --- a/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/Logger.java @@ -1,12 +1,12 @@ /* * Copyright 2001-2004 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. @@ -21,16 +21,16 @@ import org.slf4j.spi.LocationAwareLogger; /** * <p> * This class is a minimal implementation of the original - * <code>org.apache.log4j.Logger</code> class (as found in log4j 1.2) + * <code>org.apache.log4j.Logger</code> class (as found in log4j 1.2) * delegating all calls to a {@link org.slf4j.Logger} instance. * </p> * - * @author Ceki Gülcü + * @author Ceki Gülcü * */ public class Logger extends Category { - + private static final String LOGGER_FQCN = Logger.class.getName(); - + Logger(String name) { super(name); } @@ -42,25 +42,25 @@ public class Logger extends Category { public static Logger getLogger(Class clazz) { return getLogger(clazz.getName()); } - + /** * Does the obvious. - * + * * @return */ public static Logger getRootLogger() { return Log4jLoggerFactory.getLogger(org.slf4j.Logger.ROOT_LOGGER_NAME); } - + /** - * Delegates to {@link org.slf4j.Logger#isTraceEnabled} + * Delegates to {@link org.slf4j.Logger#isTraceEnabled} * method of SLF4J. */ public boolean isTraceEnabled() { return slf4jLogger.isTraceEnabled(); } - + /** * Delegates to {@link org.slf4j.Logger#trace(String)} method in SLF4J. */ @@ -69,7 +69,7 @@ public class Logger extends Category { } /** - * Delegates to {@link org.slf4j.Logger#trace(String,Throwable)} + * Delegates to {@link org.slf4j.Logger#trace(String,Throwable)} * method in SLF4J. */ public void trace(Object message, Throwable t) { diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java new file mode 100644 index 0000000..c8c70b5 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java @@ -0,0 +1,179 @@ +/* + * 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. + */ + +package org.apache.log4j.helpers; + +/** + This class used to output log statements from within the log4j package. + + <p>Log4j components cannot make log4j logging calls. However, it is + sometimes useful for the user to learn about what log4j is + doing. You can enable log4j internal logging by defining the + <b>log4j.configDebug</b> variable. + + <p>All log4j internal debug calls go to <code>System.out</code> + where as internal error messages are sent to + <code>System.err</code>. All internal messages are prepended with + the string "log4j: ". + + @since 0.8.2 + @author Ceki Gülcü +*/ +public class LogLog { + + /** + Defining this value makes log4j print log4j-internal debug + statements to <code>System.out</code>. + + <p> The value of this string is <b>log4j.debug</b>. + + <p>Note that the search for all option names is case sensitive. */ + public static final String DEBUG_KEY="log4j.debug"; + + + /** + Defining this value makes log4j components print log4j-internal + debug statements to <code>System.out</code>. + + <p> The value of this string is <b>log4j.configDebug</b>. + + <p>Note that the search for all option names is case sensitive. + + @deprecated Use {@link #DEBUG_KEY} instead. + */ + public static final String CONFIG_DEBUG_KEY="log4j.configDebug"; + + protected static boolean debugEnabled = false; + + /** + In quietMode not even errors generate any output. + */ + private static boolean quietMode = false; + + private static final String PREFIX = "log4j: "; + private static final String ERR_PREFIX = "log4j:ERROR "; + private static final String WARN_PREFIX = "log4j:WARN "; + + static { + } + + /** + Allows to enable/disable log4j internal logging. + */ + static + public + void setInternalDebugging(boolean enabled) { + debugEnabled = enabled; + } + + /** + This method is used to output log4j internal debug + statements. Output goes to <code>System.out</code>. + */ + public + static + void debug(String msg) { + if(debugEnabled && !quietMode) { + System.out.println(PREFIX+msg); + } + } + + /** + This method is used to output log4j internal debug + statements. Output goes to <code>System.out</code>. + */ + public + static + void debug(String msg, Throwable t) { + if(debugEnabled && !quietMode) { + System.out.println(PREFIX+msg); + if(t != null) + t.printStackTrace(System.out); + } + } + + + /** + This method is used to output log4j internal error + statements. There is no way to disable error statements. + Output goes to <code>System.err</code>. + */ + public + static + void error(String msg) { + if(quietMode) + return; + System.err.println(ERR_PREFIX+msg); + } + + /** + This method is used to output log4j internal error + statements. There is no way to disable error statements. + Output goes to <code>System.err</code>. + */ + public + static + void error(String msg, Throwable t) { + if(quietMode) + return; + + System.err.println(ERR_PREFIX+msg); + if(t != null) { + t.printStackTrace(); + } + } + + /** + In quite mode no LogLog generates strictly no output, not even + for errors. + + @param quietMode A true for not + */ + public + static + void setQuietMode(boolean quietMode) { + LogLog.quietMode = quietMode; + } + + /** + This method is used to output log4j internal warning + statements. There is no way to disable warning statements. + Output goes to <code>System.err</code>. */ + public + static + void warn(String msg) { + if(quietMode) + return; + + System.err.println(WARN_PREFIX+msg); + } + + /** + This method is used to output log4j internal warnings. There is + no way to disable warning statements. Output goes to + <code>System.err</code>. */ + public + static + void warn(String msg, Throwable t) { + if(quietMode) + return; + + System.err.println(WARN_PREFIX+msg); + if(t != null) { + t.printStackTrace(); + } + } +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java new file mode 100644 index 0000000..4ce496d --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java @@ -0,0 +1,39 @@ +package org.apache.log4j.spi; + + +import org.apache.log4j.spi.LoggerRepository; +import java.net.URL; + +/** + Implemented by classes capable of configuring log4j using a URL. + + @since 1.0 + @author Anders Kristensen + */ +public interface Configurator { + + /** + Special level value signifying inherited behaviour. The current + value of this string constant is <b>inherited</b>. {@link #NULL} + is a synonym. */ + public static final String INHERITED = "inherited"; + + /** + Special level signifying inherited behaviour, same as {@link + #INHERITED}. The current value of this string constant is + <b>null</b>. */ + public static final String NULL = "null"; + + + + /** + Interpret a resource pointed by a URL and set up log4j accordingly. + + The configuration is done relative to the <code>hierarchy</code> + parameter. + + @param url The URL to parse + @param repository The hierarchy to operation upon. + */ + void doConfigure(URL url, LoggerRepository repository); +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java new file mode 100644 index 0000000..9317c70 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:46:24 + * To change this template use File | Settings | File Templates. + */ +public class ErrorHandler { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java new file mode 100644 index 0000000..5526e91 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:45:19 + * To change this template use File | Settings | File Templates. + */ +public class Filter { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java new file mode 100644 index 0000000..4c7603c --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java @@ -0,0 +1,43 @@ +/* + * 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. + */ + +package org.apache.log4j.spi; + +import org.apache.log4j.*; + +/** + Listen to events occuring within a {@link + org.apache.log4j.Hierarchy Hierarchy}. + + @author Ceki Gülcü + @since 1.2 + + */ +public interface HierarchyEventListener { + + + //public + //void categoryCreationEvent(Category cat); + + + public + void addAppenderEvent(Category cat, Appender appender); + + public + void removeAppenderEvent(Category cat, Appender appender); + + +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java new file mode 100644 index 0000000..ab740c1 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:46:12 + * To change this template use File | Settings | File Templates. + */ +public class Layout { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java new file mode 100644 index 0000000..cce2d3a --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java @@ -0,0 +1,37 @@ +/* + * 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. + */ + +package org.apache.log4j.spi; + +import org.apache.log4j.Logger; + +/** + + Implement this interface to create new instances of Logger or + a sub-class of Logger. + + <p>See <code>examples/subclass/MyLogger.java</code> for an example. + + @author Ceki Gülcü + @since version 0.8.5 + + */ +public interface LoggerFactory { + + public + Logger makeNewLoggerInstance(String name); + +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java new file mode 100644 index 0000000..36a2fa6 --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java @@ -0,0 +1,98 @@ +/* + * 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. + */ + +package org.apache.log4j.spi; + +import org.apache.log4j.*; + +import java.util.Enumeration; + +/** + * A <code>LoggerRepository</code> is used to create and retrieve + * <code>Loggers</code>. The relation between loggers in a repository + * depends on the repository but typically loggers are arranged in a + * named hierarchy. + * <p/> + * <p>In addition to the creational methods, a + * <code>LoggerRepository</code> can be queried for existing loggers, + * can act as a point of registry for events related to loggers. + * + * @author Ceki Gülcü + * @since 1.2 + */ +public interface LoggerRepository { + + /** + * Add a {@link HierarchyEventListener} event to the repository. + */ + public void addHierarchyEventListener(HierarchyEventListener listener); + + /** + * Returns whether this repository is disabled for a given + * level. The answer depends on the repository threshold and the + * <code>level</code> parameter. See also {@link #setThreshold} + * method. + */ + boolean isDisabled(int level); + + /** + * Set the repository-wide threshold. All loxx requests below the + * threshold are immediately dropped. By default, the threshold is + * set to <code>Level.ALL</code> which has the lowest possible rank. + */ + public void setThreshold(Level level); + + /** + * Another form of {@link #setThreshold(Level)} accepting a string + * parameter instead of a <code>Level</code>. + */ + public void setThreshold(String val); + + public void emitNoAppenderWarning(Category cat); + + /** + * Get the repository-wide threshold. See {@link + * #setThreshold(Level)} for an explanation. + */ + public Level getThreshold(); + + public Logger getLogger(String name); + + public Logger getLogger(String name, LoggerFactory factory); + + public Logger getRootLogger(); + + public + abstract Logger exists(String name); + + public + abstract void shutdown(); + + public Enumeration getCurrentLoggers(); + + /** + * Deprecated. Please use {@link #getCurrentLoggers} instead. + */ + public Enumeration getCurrentCategories(); + + + public + abstract void fireAddAppenderEvent(Category logger, Appender appender); + + public + abstract void resetConfiguration(); + +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java new file mode 100644 index 0000000..acde46f --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java @@ -0,0 +1,11 @@ +package org.apache.log4j.spi; + +/** + * Created by IntelliJ IDEA. + * User: ceki + * Date: 19 oct. 2010 + * Time: 11:47:05 + * To change this template use File | Settings | File Templates. + */ +public class LoggingEvent { +} diff --git a/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java b/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java new file mode 100644 index 0000000..177feae --- /dev/null +++ b/log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java @@ -0,0 +1,32 @@ +/* + * Copyright 2001-2004 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. + */ +package org.apache.log4j.xml; + +import org.apache.log4j.spi.Configurator; +import org.apache.log4j.spi.LoggerRepository; + +import javax.xml.parsers.FactoryConfigurationError; +import java.net.URL; + + +public class DOMConfigurator implements Configurator { + static public void configure(URL url) throws FactoryConfigurationError { + } + + + public void doConfigure(URL url, LoggerRepository repository) { + } +} diff --git a/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java b/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java index 851b60c..a568197 100644 --- a/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/ILoggerFactory.java @@ -44,11 +44,11 @@ public interface ILoggerFactory { * * <p>If the name parameter is equal to {@link Logger#ROOT_LOGGER_NAME}, that is * the string value "ROOT" (case insensitive), then the root logger of the - * underlying logging system is returned. + * underlying loxx system is returned. * * <p>Null-valued name arguments are considered invalid. * - * <p>Certain extremely simple logging systems, e.g. NOP, may always + * <p>Certain extremely simple loxx systems, e.g. NOP, may always * return the same logger instance regardless of the requested name. * * @param name the name of the Logger to return diff --git a/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java b/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java index b278dc4..24254fd 100644 --- a/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/IMarkerFactory.java @@ -30,7 +30,7 @@ package org.slf4j; * instances. * * <p>See the section <a href="http://slf4j.org/faq.html#3">Implementing - * the SLF4J API</a> in the FAQ for details on how to make your logging + * the SLF4J API</a> in the FAQ for details on how to make your loxx * system conform to SLF4J. * * @author Ceki Gülcü diff --git a/slf4j-api/src/main/java/org/slf4j/Logger.java b/slf4j-api/src/main/java/org/slf4j/Logger.java index 13efdcd..b93fdc6 100644 --- a/slf4j-api/src/main/java/org/slf4j/Logger.java +++ b/slf4j-api/src/main/java/org/slf4j/Logger.java @@ -27,7 +27,7 @@ package org.slf4j; /** * The org.slf4j.Logger interface is the main user entry point of SLF4J API. - * It is expected that logging takes place through concrete implementations + * It is expected that loxx takes place through concrete implementations * of this interface. * * <h3>Typical usage pattern:</h3> diff --git a/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java b/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java index c2063f3..a9e6ae7 100644 --- a/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/LoggerFactory.java @@ -38,7 +38,7 @@ import org.slf4j.impl.StaticLoggerBinder; /** * The <code>LoggerFactory</code> is a utility class producing Loggers for - * various logging APIs, most notably for log4j, logback and JDK 1.4 logging. + * various loxx APIs, most notably for log4j, logback and JDK 1.4 loxx. * Other implementations such as {@link org.slf4j.impl.NOPLogger NOPLogger} and * {@link org.slf4j.impl.SimpleLogger SimpleLogger} are also supported. * diff --git a/slf4j-api/src/main/java/org/slf4j/MDC.java b/slf4j-api/src/main/java/org/slf4j/MDC.java index 1670061..319d3cf 100644 --- a/slf4j-api/src/main/java/org/slf4j/MDC.java +++ b/slf4j-api/src/main/java/org/slf4j/MDC.java @@ -33,19 +33,19 @@ import org.slf4j.impl.StaticMDCBinder; import org.slf4j.spi.MDCAdapter; /** - * This class hides and serves as a substitute for the underlying logging + * This class hides and serves as a substitute for the underlying loxx * system's MDC implementation. * * <p> - * If the underlying logging system offers MDC functionality, then SLF4J's MDC, + * If the underlying loxx system offers MDC functionality, then SLF4J's MDC, * i.e. this class, will delegate to the underlying system's MDC. Note that at - * this time, only two logging systems, namely log4j and logback, offer MDC + * this time, only two loxx systems, namely log4j and logback, offer MDC * functionality. If the underlying system does not support MDC, e.g. - * java.util.logging, then SLF4J will use a {@link BasicMDCAdapter}. + * java.util.loxx, then SLF4J will use a {@link BasicMDCAdapter}. * * <p> * Thus, as a SLF4J user, you can take advantage of MDC in the presence of log4j - * logback, or java.util.logging, but without forcing these systems as + * logback, or java.util.loxx, but without forcing these systems as * dependencies upon your users. * * <p> @@ -95,7 +95,7 @@ public class MDC { * can be null only if the underlying implementation supports it. * * <p> - * This method delegates all work to the MDC of the underlying logging system. + * This method delegates all work to the MDC of the underlying loxx system. * * @throws IllegalArgumentException * in case the "key" parameter is null @@ -117,7 +117,7 @@ public class MDC { * <code>key</code> parameter cannot be null. * * <p> - * This method delegates all work to the MDC of the underlying logging system. + * This method delegates all work to the MDC of the underlying loxx system. * * @return the string value identified by the <code>key</code> parameter. * @throws IllegalArgumentException diff --git a/slf4j-api/src/main/java/org/slf4j/Marker.java b/slf4j-api/src/main/java/org/slf4j/Marker.java index e29dbdb..7ccbc92 100644 --- a/slf4j-api/src/main/java/org/slf4j/Marker.java +++ b/slf4j-api/src/main/java/org/slf4j/Marker.java @@ -28,9 +28,9 @@ import java.io.Serializable; import java.util.Iterator; /** - * Markers are named objects used to enrich log statements. Conforming logging + * Markers are named objects used to enrich log statements. Conforming loxx * system Implementations of SLF4J determine how information conveyed by markers - * are used, if at all. In particular, many conforming logging systems ignore + * are used, if at all. In particular, many conforming loxx systems ignore * marker data. * * <p> diff --git a/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java b/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java index 3cb8cfc..a921a93 100644 --- a/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/MarkerFactory.java @@ -30,7 +30,7 @@ import org.slf4j.impl.StaticMarkerBinder; /** * MarkerFactory is a utility class producing {@link Marker} instances as - * appropriate for the logging system currently in use. + * appropriate for the loxx system currently in use. * * <p> * This class is essentially implemented as a wrapper around an diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java index 57589f5..e18aaff 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMDCAdapter.java @@ -30,7 +30,7 @@ import java.util.Map; import java.util.Set; /** - * Basic MDC implementation, which can be used with logging systems that lack + * Basic MDC implementation, which can be used with loxx systems that lack * out-of-the-box MDC support. * * This code is largely based on logback's <a diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java index 7686684..72e58f3 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/BasicMarkerFactory.java @@ -34,7 +34,7 @@ import org.slf4j.Marker; * An almost trivial implementation of the {@link IMarkerFactory} * interface which creates {@link BasicMarker} instances. * - * <p>Simple logging systems can conform to the SLF4J API by binding + * <p>Simple loxx systems can conform to the SLF4J API by binding * {@link org.slf4j.MarkerFactory} with an instance of this class. * * @author Ceki Gülcü diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java b/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java index b4ccba7..d0bc2be 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/MarkerIgnoringBase.java @@ -29,7 +29,7 @@ import org.slf4j.Marker; /** - * This class serves as base for adapters or native implementations of logging systems + * This class serves as base for adapters or native implementations of loxx systems * lacking Marker support. In this implementation, methods taking marker data * simply invoke the corresponding method without the Marker argument, discarding * any marker data passed as argument. diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java index 7242e56..9173631 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/MessageFormatter.java @@ -85,7 +85,7 @@ import java.util.Map; * which ships with the Java platform. This is justified by the fact that * SLF4J's implementation is 10 times faster than that of {@link MessageFormat}. * This local performance difference is both measurable and significant in the - * larger context of the complete logging processing chain. + * larger context of the complete loxx processing chain. * * <p> * See also {@link #format(String, Object)}, diff --git a/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java b/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java index b995cba..6f4d0f7 100644 --- a/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java +++ b/slf4j-api/src/main/java/org/slf4j/helpers/NOPMDCAdapter.java @@ -6,7 +6,7 @@ import org.slf4j.spi.MDCAdapter; /** * This adapter is an empty implementation of the {@link MDCAdapter} interface. - * It is used for all logging systems which do not support mapped + * It is used for all loxx systems which do not support mapped * diagnostic contexts such as JDK14, simple and NOP. * * @author Ceki Gülcü diff --git a/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java b/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java index 523589d..2fc7c4b 100644 --- a/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java +++ b/slf4j-api/src/main/java/org/slf4j/spi/LocationAwareLogger.java @@ -28,9 +28,9 @@ import org.slf4j.Logger; import org.slf4j.Marker; /** - * An <b>optional</b> interface helping integration with logging systems capable of + * An <b>optional</b> interface helping integration with loxx systems capable of * extracting location information. This interface is mainly used by SLF4J bridges - * such as jcl104-over-slf4j which need to provide hints so that the underlying logging + * such as jcl104-over-slf4j which need to provide hints so that the underlying loxx * system can extract the correct location information (method name, line number, etc.). * * diff --git a/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java b/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java index e81ccae..f585f0f 100644 --- a/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java +++ b/slf4j-ext/src/main/java/org/slf4j/agent/AgentOptions.java @@ -19,7 +19,7 @@ public class AgentOptions { */ public static final String IGNORE = "ignore"; /** - * Indicate the SLF4J level that should be used by the logging statements + * Indicate the SLF4J level that should be used by the loxx statements * added by the agent. Default is "info". */ public static final String LEVEL = "level"; @@ -31,7 +31,7 @@ public class AgentOptions { public static final String TIME = "time"; /** * Indicate that the agent should log actions to System.err, like adding - * logging to methods, etc. + * loxx to methods, etc. * */ public static final String VERBOSE = "verbose"; diff --git a/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java b/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java index 761143a..2c00fe9 100644 --- a/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java +++ b/slf4j-ext/src/main/java/org/slf4j/cal10n/LocLogger.java @@ -31,7 +31,7 @@ import ch.qos.cal10n.IMessageConveyor; import ch.qos.cal10n.MessageParameterObj; /** - * A logger specialized in localized logging. Localization is based in the <a + * A logger specialized in localized loxx. Localization is based in the <a * href="http://cal10n.qos.ch">CAL10N project</p>. * * @author Ceki Gülcü diff --git a/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java b/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java index 635ef25..e3a46e2 100644 --- a/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java +++ b/slf4j-ext/src/main/java/org/slf4j/ext/XLogger.java @@ -8,7 +8,7 @@ import org.slf4j.helpers.MessageFormatter; import org.slf4j.spi.LocationAwareLogger; /** - * A utility that provides standard mechanisms for logging certain kinds of + * A utility that provides standard mechanisms for loxx certain kinds of * activities. * * @author Ralph Goers @@ -147,7 +147,7 @@ public class XLogger extends LoggerWrapper implements Logger { * Log an exception being thrown allowing the log level to be specified. * * @param level - * the logging level to use. + * the loxx level to use. * @param throwable * the exception being caught. */ @@ -175,7 +175,7 @@ public class XLogger extends LoggerWrapper implements Logger { * Log an exception being caught allowing the log level to be specified. * * @param level - * the logging level to use. + * the loxx level to use. * @param throwable * the exception being caught. */ diff --git a/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java b/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java index 4f2fb4e..32d8db4 100644 --- a/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java +++ b/slf4j-ext/src/main/java/org/slf4j/instrumentation/LogTransformer.java @@ -21,10 +21,10 @@ import org.slf4j.helpers.MessageFormatter; /** * <p> * LogTransformer does the work of analyzing each class, and if appropriate add - * log statements to each method to allow logging entry/exit. + * log statements to each method to allow loxx entry/exit. * </p> * <p> - * This class is based on the article <a href="http://today.java.net/pub/a/today/2008/04/24/add-logging-at-class-load-time-..." + * This class is based on the article <a href="http://today.java.net/pub/a/today/2008/04/24/add-loxx-at-class-load-time-wit..." * >Add Logging at Class Load Time with Java Instrumentation</a>. * </p> */ @@ -265,7 +265,7 @@ public class LogTransformer implements ClassFileTransformer { } /** - * process a single method - this means add entry/exit logging if requested. + * process a single method - this means add entry/exit loxx if requested. * It is only called for methods with a body. * * @param method diff --git a/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java b/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java index 31c57e0..0a6412c 100644 --- a/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java +++ b/slf4j-jcl/src/main/java/org/slf4j/impl/JCLLoggerAdapter.java @@ -33,7 +33,7 @@ import org.slf4j.helpers.MessageFormatter; /** * A wrapper over {@link org.apache.commons.logging.Log - * org.apache.commons.logging.Log} in conformance with the {@link Logger} + * org.apache.commons.loxx.Log} in conformance with the {@link Logger} * interface. * * @author Ceki Gülcü diff --git a/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java b/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java index 1c9b0cc..3bf78a7 100644 --- a/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java +++ b/slf4j-jdk14/src/main/java/org/slf4j/impl/JDK14LoggerAdapter.java @@ -44,9 +44,9 @@ import org.slf4j.helpers.MessageFormatter; import org.slf4j.spi.LocationAwareLogger; /** - * A wrapper over {@link java.util.logging.Logger java.util.logging.Logger} in - * conformity with the {@link Logger} interface. Note that the logging levels - * mentioned in this class refer to those defined in the java.util.logging + * A wrapper over {@link java.util.logging.Logger java.util.loxx.Logger} in + * conformity with the {@link Logger} interface. Note that the loxx levels + * mentioned in this class refer to those defined in the java.util.loxx * package. * * @author Ceki Gülcü diff --git a/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java b/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java index 51cecb4..5fad232 100644 --- a/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java +++ b/slf4j-log4j12/src/main/java/org/slf4j/impl/Log4jLoggerAdapter.java @@ -39,9 +39,9 @@ import org.slf4j.spi.LocationAwareLogger; * conforming to the {@link Logger} interface. * * <p> - * Note that the logging levels mentioned in this class refer to those defined + * Note that the loxx levels mentioned in this class refer to those defined * in the <a - * href="http://logging.apache.org/log4j/docs/api/org/apache/log4j/Level.html"> + * href="http://loxx.apache.org/log4j/docs/api/org/apache/log4j/Level.html"> * <code>org.apache.log4j.Level</code></a> class. * * <p> diff --git a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java index 983d40f..394b27a 100644 --- a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java +++ b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JCLRuleSet.java @@ -16,12 +16,12 @@ public class JCLRuleSet implements RuleSet { private ArrayList<ConversionRule> conversionRuleList; public JCLRuleSet() { - // matching : import org.apache.commons.logging.LogFactory; + // matching : import org.apache.commons.loxx.LogFactory; SingleConversionRule cr0 = new SingleConversionRule(Pattern .compile("import\\s*+org.apache.commons.logging.LogFactory;"), "import org.slf4j.LoggerFactory;"); - // matching : import org.apache.commons.logging.Log; + // matching : import org.apache.commons.loxx.Log; SingleConversionRule cr1 = new SingleConversionRule(Pattern .compile("import\\s*+org.apache.commons.logging.Log;"), "import org.slf4j.Logger;"); diff --git a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java index 9d13b65..b4255eb 100644 --- a/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java +++ b/slf4j-migrator/src/main/java/org/slf4j/migrator/line/JULRuleSet.java @@ -5,7 +5,7 @@ import java.util.Iterator; import java.util.regex.Pattern; /** - * This class represents java.util.logging (JUL) to SLF4J conversion rules + * This class represents java.util.loxx (JUL) to SLF4J conversion rules * * @author Jean-Noel Charpin * @author Ceki Gulcu diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java index f739150..bfdc53f 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/jdk/test/JdkBundleTest.java @@ -86,11 +86,11 @@ public class JdkBundleTest extends ConfigurableBundleCreatorTests implements Int * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-logging, spring-core and the spring OSGi test bundle are + * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other logging bundles from getting mixed up with our test bundles. + * these other loxx bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java index 556335c..f805fdf 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/log4j/test/Log4JBundleTest.java @@ -91,12 +91,12 @@ public class Log4JBundleTest extends ConfigurableBundleCreatorTests implements I * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-logging, spring-core and the spring OSGi test bundle are + * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Except in the case of slf4j.log4j12 using the log4j bundle associated * with the Spring-OSGi testing framework our test bundles are using package - * import and export versions to keep these other logging bundles from + * import and export versions to keep these other loxx bundles from * getting mixed up with our test bundles. */ protected String[] getBundleLocations() { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java index 436c612..8024b3b 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/logservice/test/LogServiceBundleTest.java @@ -87,11 +87,11 @@ public class LogServiceBundleTest extends ConfigurableBundleCreatorTests impleme * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-logging, spring-core and the spring OSGi test bundle are + * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other logging bundles from getting mixed up with our test bundles. + * these other loxx bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java index d9394af..f82ed79 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/nop/test/NopBundleTest.java @@ -84,11 +84,11 @@ public class NopBundleTest extends ConfigurableBundleCreatorTests implements Int * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-logging, spring-core and the spring OSGi test bundle are + * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other logging bundles from getting mixed up with our test bundles. + * these other loxx bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java index 29052ec..bd029f3 100644 --- a/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java +++ b/slf4j-osgi-integration-test/src/test/java/org/slf4j/osgi/integration/simple/test/SimpleBundleTest.java @@ -87,11 +87,11 @@ public class SimpleBundleTest extends ConfigurableBundleCreatorTests implements * package phase of the maven build (these tests will run after the * packaging phase, in the integration-test phase). * - * JUnit, commons-logging, spring-core and the spring OSGi test bundle are + * JUnit, commons-loxx, spring-core and the spring OSGi test bundle are * automatically included so they do not need to be specified here. * * Our test bundles are using package import and export versions to keep - * these other logging bundles from getting mixed up with our test bundles. + * these other loxx bundles from getting mixed up with our test bundles. */ protected String[] getBundleLocations() { return new String[] { diff --git a/slf4j-osgi-test-bundle/pom.xml b/slf4j-osgi-test-bundle/pom.xml index 9567457..186710e 100644 --- a/slf4j-osgi-test-bundle/pom.xml +++ b/slf4j-osgi-test-bundle/pom.xml @@ -35,8 +35,8 @@ <scope>provided</scope> </dependency> - <!-- To get org.apache.commons.logging package for - commons logging testing.--> + <!-- To get org.apache.commons.loxx package for + commons loxx testing.--> <dependency> <groupId>org.slf4j</groupId> <artifactId>jcl-over-slf4j</artifactId> diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java index cd95f28..ff88a7f 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/Activator.java @@ -46,7 +46,7 @@ import java.util.Hashtable; /** * <code>Activator</code> implements a simple bundle to test OSGi slf4j - * logging components. + * loxx components. * * Upon startup, shutdown, and receiving a service event, it logs event * details. diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java index ad1ba13..3db52ad 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/CommonsLoggingTester.java @@ -36,7 +36,7 @@ import org.apache.commons.logging.Log; import org.apache.commons.logging.LogFactory; /** - * <code>CommonsLoggingTester</code> tests org.apache.commons.logging functionality. + * <code>CommonsLoggingTester</code> tests org.apache.commons.loxx functionality. * * @author John Conlon */ diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java index e5ea67f..022c82c 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/ProbeImpl.java @@ -45,7 +45,7 @@ public class ProbeImpl implements Probe{ /** * * @throws ClassNotFoundException If there is not a bundle exporting - * the org.apache.commons.logging package + * the org.apache.commons.loxx package * */ public boolean testCommonslogging() throws Exception{ diff --git a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java index 1229d2e..1510864 100644 --- a/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java +++ b/slf4j-osgi-test-bundle/src/main/java/org/slf4j/osgi/test/service/Probe.java @@ -46,7 +46,7 @@ public interface Probe { * testCommonslogging * * @return true if all the tests were executed. - * @throws ClassNotFoundError if a org.apache.commons.logging package + * @throws ClassNotFoundError if a org.apache.commons.loxx package * could not be dynamically imported from the OSGi runtime. * @throws Exception if testing fails */ diff --git a/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java b/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java index cf33b35..073741c 100644 --- a/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java +++ b/slf4j-simple/src/main/java/org/slf4j/impl/SimpleLogger.java @@ -175,7 +175,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * This is our internal implementation for logging regular (non-parameterized) + * This is our internal implementation for loxx regular (non-parameterized) * log messages. * * @param level @@ -251,7 +251,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform single parameter substitution before logging the message of level + * Perform single parameter substitution before loxx the message of level * INFO according to the format outlined above. */ public void info(String format, Object arg) { @@ -259,7 +259,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before logging the message of level + * Perform double parameter substitution before loxx the message of level * INFO according to the format outlined above. */ public void info(String format, Object arg1, Object arg2) { @@ -267,7 +267,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before logging the message of level + * Perform double parameter substitution before loxx the message of level * INFO according to the format outlined above. */ public void info(String format, Object[] argArray) { @@ -297,7 +297,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform single parameter substitution before logging the message of level + * Perform single parameter substitution before loxx the message of level * WARN according to the format outlined above. */ public void warn(String format, Object arg) { @@ -305,7 +305,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before logging the message of level + * Perform double parameter substitution before loxx the message of level * WARN according to the format outlined above. */ public void warn(String format, Object arg1, Object arg2) { @@ -313,7 +313,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before logging the message of level + * Perform double parameter substitution before loxx the message of level * WARN according to the format outlined above. */ public void warn(String format, Object[] argArray) { @@ -343,7 +343,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform single parameter substitution before logging the message of level + * Perform single parameter substitution before loxx the message of level * ERROR according to the format outlined above. */ public void error(String format, Object arg) { @@ -351,7 +351,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before logging the message of level + * Perform double parameter substitution before loxx the message of level * ERROR according to the format outlined above. */ public void error(String format, Object arg1, Object arg2) { @@ -359,7 +359,7 @@ public class SimpleLogger extends MarkerIgnoringBase { } /** - * Perform double parameter substitution before logging the message of level + * Perform double parameter substitution before loxx the message of level * ERROR according to the format outlined above. */ public void error(String format, Object[] argArray) { ----------------------------------------------------------------------- Summary of changes: .../src/main/java/org/apache/log4j/Appender.java | 134 +++++++++++++++ .../main/java/org/apache/log4j/helpers/LogLog.java | 179 ++++++++++++++++++++ .../java/org/apache/log4j/spi/Configurator.java | 39 +++++ .../java/org/apache/log4j/spi/ErrorHandler.java | 11 ++ .../src/main/java/org/apache/log4j/spi/Filter.java | 11 ++ .../apache/log4j/spi/HierarchyEventListener.java | 43 +++++ .../src/main/java/org/apache/log4j/spi/Layout.java | 11 ++ .../java/org/apache/log4j/spi/LoggerFactory.java | 37 ++++ .../org/apache/log4j/spi/LoggerRepository.java | 98 +++++++++++ .../java/org/apache/log4j/spi/LoggingEvent.java | 11 ++ .../java/org/apache/log4j/xml/DOMConfigurator.java | 32 ++++ 11 files changed, 606 insertions(+), 0 deletions(-) create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/Appender.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/helpers/LogLog.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Configurator.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/ErrorHandler.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Filter.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/HierarchyEventListener.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/Layout.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerFactory.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggerRepository.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/spi/LoggingEvent.java create mode 100644 log4j-over-slf4j/src/main/java/org/apache/log4j/xml/DOMConfigurator.java hooks/post-receive -- SLF4J: Simple Logging Facade for Java