You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@logging.apache.org by rg...@apache.org on 2015/09/27 20:41:28 UTC
[36/50] [abbrv] logging-log4j2 git commit: Checkstyle
Checkstyle
Project: http://git-wip-us.apache.org/repos/asf/logging-log4j2/repo
Commit: http://git-wip-us.apache.org/repos/asf/logging-log4j2/commit/1236fac8
Tree: http://git-wip-us.apache.org/repos/asf/logging-log4j2/tree/1236fac8
Diff: http://git-wip-us.apache.org/repos/asf/logging-log4j2/diff/1236fac8
Branch: refs/heads/LOG4J2-1136
Commit: 1236fac8b2eddcd18ebe345c4d8270444f23ef07
Parents: 951cbbd
Author: rpopma <rp...@apache.org>
Authored: Thu Sep 24 14:09:38 2015 +0200
Committer: Ralph Goers <rg...@nextiva.com>
Committed: Sun Sep 27 10:47:30 2015 -0700
----------------------------------------------------------------------
.../org/apache/logging/log4j/core/Logger.java | 95 ++++---
.../logging/log4j/core/LoggerContext.java | 254 ++++++++++---------
.../log4j/core/appender/AbstractAppender.java | 47 ++--
.../appender/AbstractOutputStreamAppender.java | 27 +-
.../log4j/core/appender/AsyncAppender.java | 65 +++--
.../log4j/core/appender/ConsoleAppender.java | 68 ++---
.../core/appender/MemoryMappedFileManager.java | 17 +-
.../core/appender/RandomAccessFileManager.java | 4 +-
.../core/appender/RollingFileAppender.java | 3 +-
9 files changed, 308 insertions(+), 272 deletions(-)
----------------------------------------------------------------------
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/Logger.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/Logger.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/Logger.java
index 48f350b..40852a5 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/Logger.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/Logger.java
@@ -36,17 +36,16 @@ import org.apache.logging.log4j.util.Strings;
import org.apache.logging.log4j.util.Supplier;
/**
- * The core implementation of the {@link org.apache.logging.log4j.Logger} interface. Besides providing an
- * implementation of all the Logger methods, this class also provides some convenience methods for Log4j 1.x
- * compatibility as well as access to the {@link org.apache.logging.log4j.core.Filter Filters} and
- * {@link org.apache.logging.log4j.core.Appender Appenders} associated with this Logger. Note that access to these
- * underlying objects is provided primarily for use in unit tests or bridging legacy Log4j 1.x code. Future versions
- * of this class may or may not include the various methods that are noted as not being part of the public API.
+ * The core implementation of the {@link org.apache.logging.log4j.Logger} interface. Besides providing an implementation
+ * of all the Logger methods, this class also provides some convenience methods for Log4j 1.x compatibility as well as
+ * access to the {@link org.apache.logging.log4j.core.Filter Filters} and {@link org.apache.logging.log4j.core.Appender
+ * Appenders} associated with this Logger. Note that access to these underlying objects is provided primarily for use in
+ * unit tests or bridging legacy Log4j 1.x code. Future versions of this class may or may not include the various
+ * methods that are noted as not being part of the public API.
*
- * TODO All the isEnabled methods could be pushed into a filter interface. Not sure of the utility of having
- * isEnabled be able to examine the message pattern and parameters. (RG) Moving the isEnabled methods out of
- * Logger noticeably impacts performance. The message pattern and parameters are required so that they can be
- * used in global filters.
+ * TODO All the isEnabled methods could be pushed into a filter interface. Not sure of the utility of having isEnabled
+ * be able to examine the message pattern and parameters. (RG) Moving the isEnabled methods out of Logger noticeably
+ * impacts performance. The message pattern and parameters are required so that they can be used in global filters.
*/
public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
@@ -62,6 +61,7 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
/**
* The constructor.
+ *
* @param context The LoggerContext this Logger is associated with.
* @param messageFactory The message factory.
* @param name The name of the Logger.
@@ -73,13 +73,14 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
}
/**
- * This method is only used for 1.x compatibility.
- * Returns the parent of this Logger. If it doesn't already exist return a temporary Logger.
+ * This method is only used for 1.x compatibility. Returns the parent of this Logger. If it doesn't already exist
+ * return a temporary Logger.
+ *
* @return The parent Logger.
*/
public Logger getParent() {
- final LoggerConfig lc = privateConfig.loggerConfig.getName().equals(getName()) ? privateConfig.loggerConfig.getParent() :
- privateConfig.loggerConfig;
+ final LoggerConfig lc = privateConfig.loggerConfig.getName().equals(getName()) ? privateConfig.loggerConfig
+ .getParent() : privateConfig.loggerConfig;
if (lc == null) {
return null;
}
@@ -91,6 +92,7 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
/**
* Returns the LoggerContext this Logger is associated with.
+ *
* @return the LoggerContext.
*/
public LoggerContext getContext() {
@@ -114,13 +116,14 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
actualLevel = level;
} else {
final Logger parent = getParent();
- actualLevel = parent != null ? parent.getLevel() : privateConfig.level;
+ actualLevel = parent != null ? parent.getLevel() : privateConfig.loggerConfigLevel;
}
privateConfig = new PrivateConfig(privateConfig, actualLevel);
}
-
+
/*
* (non-Javadoc)
+ *
* @see org.apache.logging.log4j.util.Supplier#get()
*/
@Override
@@ -129,12 +132,13 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
}
@Override
- public void logMessage(final String fqcn, final Level level, final Marker marker, final Message message, final Throwable t) {
+ public void logMessage(final String fqcn, final Level level, final Marker marker, final Message message,
+ final Throwable t) {
final Message msg = message == null ? new SimpleMessage(Strings.EMPTY) : message;
-
+
// check if we need to reconfigure
privateConfig.config.getConfigurationMonitor().checkConfiguration();
-
+
final ReliabilityStrategy strategy = privateConfig.loggerConfig.getReliabilityStrategy();
strategy.log(this, getName(), fqcn, marker, level, msg, t);
}
@@ -166,6 +170,7 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
/**
* This method is not exposed through the public API and is used primarily for unit testing.
+ *
* @param appender The Appender to add to the Logger.
*/
public void addAppender(final Appender appender) {
@@ -174,6 +179,7 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
/**
* This method is not exposed through the public API and is used primarily for unit testing.
+ *
* @param appender The Appender to remove from the Logger.
*/
public void removeAppender(final Appender appender) {
@@ -182,14 +188,16 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
/**
* This method is not exposed through the public API and is used primarily for unit testing.
+ *
* @return A Map containing the Appender's name as the key and the Appender as the value.
*/
public Map<String, Appender> getAppenders() {
- return privateConfig.loggerConfig.getAppenders();
+ return privateConfig.loggerConfig.getAppenders();
}
/**
* This method is not exposed through the public API and is used primarily for unit testing.
+ *
* @return An Iterator over all the Filters associated with the Logger.
*/
// FIXME: this really ought to be an Iterable instead of an Iterator
@@ -213,11 +221,12 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
*/
@Override
public Level getLevel() {
- return privateConfig.level;
+ return privateConfig.loggerConfigLevel;
}
/**
* This method is not exposed through the public API and is used primarily for unit testing.
+ *
* @return The number of Filters associated with the Logger.
*/
public int filterCount() {
@@ -232,6 +241,7 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
/**
* This method is not exposed through the public API and is used primarily for unit testing.
+ *
* @param filter The Filter to add.
*/
public void addFilter(final Filter filter) {
@@ -239,8 +249,9 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
}
/**
- * This method is not exposed through the public API and is present only to support the Log4j 1.2
- * compatibility bridge.
+ * This method is not exposed through the public API and is present only to support the Log4j 1.2 compatibility
+ * bridge.
+ *
* @return true if the associated LoggerConfig is additive, false otherwise.
*/
public boolean isAdditive() {
@@ -248,8 +259,9 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
}
/**
- * This method is not exposed through the public API and is present only to support the Log4j 1.2
- * compatibility bridge.
+ * This method is not exposed through the public API and is present only to support the Log4j 1.2 compatibility
+ * bridge.
+ *
* @param additive Boolean value to indicate whether the Logger is additive or not.
*/
public void setAdditive(final boolean additive) {
@@ -257,14 +269,12 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
}
/**
- * Associates the Logger with a new Configuration. This method is not exposed through the
- * public API.
+ * Associates the Logger with a new Configuration. This method is not exposed through the public API.
*
- * There are two ways that could be used to guarantee all threads are aware of changes to
- * config. 1. synchronize this method. Accessors don't need to be synchronized as Java will
- * treat all variables within a synchronized block as volatile. 2. Declare the variable
- * volatile. Option 2 is used here as the performance cost is very low and it does a better
- * job at documenting how it is used.
+ * There are two ways that could be used to guarantee all threads are aware of changes to config. 1. synchronize
+ * this method. Accessors don't need to be synchronized as Java will treat all variables within a synchronized block
+ * as volatile. 2. Declare the variable volatile. Option 2 is used here as the performance cost is very low and it
+ * does a better job at documenting how it is used.
*
* @param newConfig The new Configuration.
*/
@@ -279,33 +289,35 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
protected class PrivateConfig implements Serializable {
private static final long serialVersionUID = 1L;
// config fields are public to make them visible to Logger subclasses
- public final LoggerConfig loggerConfig;
- public final Configuration config;
- private final Level level;
+ /** LoggerConfig to delegate the actual logging to. */
+ public final LoggerConfig loggerConfig; // SUPPRESS CHECKSTYLE
+ /** The current Configuration associated with the LoggerConfig. */
+ public final Configuration config; // SUPPRESS CHECKSTYLE
+ private final Level loggerConfigLevel;
private final int intLevel;
private final Logger logger;
public PrivateConfig(final Configuration config, final Logger logger) {
this.config = config;
this.loggerConfig = config.getLoggerConfig(getName());
- this.level = this.loggerConfig.getLevel();
- this.intLevel = this.level.intLevel();
+ this.loggerConfigLevel = this.loggerConfig.getLevel();
+ this.intLevel = this.loggerConfigLevel.intLevel();
this.logger = logger;
}
public PrivateConfig(final PrivateConfig pc, final Level level) {
this.config = pc.config;
this.loggerConfig = pc.loggerConfig;
- this.level = level;
- this.intLevel = this.level.intLevel();
+ this.loggerConfigLevel = level;
+ this.intLevel = this.loggerConfigLevel.intLevel();
this.logger = pc.logger;
}
public PrivateConfig(final PrivateConfig pc, final LoggerConfig lc) {
this.config = pc.config;
this.loggerConfig = lc;
- this.level = lc.getLevel();
- this.intLevel = this.level.intLevel();
+ this.loggerConfigLevel = lc.getLevel();
+ this.intLevel = this.loggerConfigLevel.intLevel();
this.logger = pc.logger;
}
@@ -378,6 +390,7 @@ public class Logger extends AbstractLogger implements Supplier<LoggerConfig> {
/**
* Returns a String representation of this instance in the form {@code "name:level[ in context_name]"}.
+ *
* @return A String describing this Logger instance.
*/
@Override
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java
index 6f37306..841080c 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/LoggerContext.java
@@ -33,7 +33,7 @@ import org.apache.logging.log4j.core.async.AsyncLogger;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.ConfigurationFactory;
import org.apache.logging.log4j.core.config.ConfigurationListener;
-import org.apache.logging.log4j.core.config.ConfigurationSource;
+import org.apache.logging.log4j.core.config.ConfigurationSource; // SUPPRESS CHECKSTYLE
import org.apache.logging.log4j.core.config.DefaultConfiguration;
import org.apache.logging.log4j.core.config.NullConfiguration;
import org.apache.logging.log4j.core.config.Reconfigurable;
@@ -50,87 +50,31 @@ import org.apache.logging.log4j.spi.LoggerContextFactory;
import static org.apache.logging.log4j.core.util.ShutdownCallbackRegistry.*;
/**
- * The LoggerContext is the anchor for the logging system. It maintains a list
- * of all the loggers requested by applications and a reference to the
- * Configuration. The Configuration will contain the configured loggers,
- * appenders, filters, etc and will be atomically updated whenever a reconfigure
- * occurs.
+ * The LoggerContext is the anchor for the logging system. It maintains a list of all the loggers requested by
+ * applications and a reference to the Configuration. The Configuration will contain the configured loggers, appenders,
+ * filters, etc and will be atomically updated whenever a reconfigure occurs.
*/
-public class LoggerContext extends AbstractLifeCycle implements org.apache.logging.log4j.spi.LoggerContext, ConfigurationListener {
-
- private static final long serialVersionUID = 1L;
-
- public static final String PROPERTY_CONFIG = "config";
- private static final Configuration NULL_CONFIGURATION = new NullConfiguration();
+public class LoggerContext extends AbstractLifeCycle implements org.apache.logging.log4j.spi.LoggerContext,
+ ConfigurationListener {
/**
- * Returns the current LoggerContext.
- * <p>
- * Avoids the type cast for:
- *</p>
- *<pre>(LoggerContext) LogManager.getContext();</pre>
- *
- * <p>
- * WARNING - The LoggerContext returned by this method may not be the LoggerContext used to create a Logger
- * for the calling class.
- * </p>
- * @return The current LoggerContext.
- * @see LogManager#getContext()
+ * Property name of the property change event fired if the configuration is changed.
*/
- public static LoggerContext getContext() {
- return (LoggerContext) LogManager.getContext();
- }
-
- /**
- * Returns a LoggerContext.
- * <p>
- * Avoids the type cast for:
- *</p>
- *<pre>(LoggerContext) LogManager.getContext(currentContext);</pre>
- *
- * @param currentContext if false the LoggerContext appropriate for the caller of this method is returned. For
- * example, in a web application if the caller is a class in WEB-INF/lib then one LoggerContext may be
- * returned and if the caller is a class in the container's classpath then a different LoggerContext may be
- * returned. If true then only a single LoggerContext will be returned.
- * @return a LoggerContext.
- * @see LogManager#getContext(boolean)
- */
- public static LoggerContext getContext(final boolean currentContext) {
- return (LoggerContext) LogManager.getContext(currentContext);
- }
+ public static final String PROPERTY_CONFIG = "config";
- /**
- * Returns a LoggerContext.
- * <p>
- * Avoids the type cast for:
- *</p>
- *<pre>(LoggerContext) LogManager.getContext(loader, currentContext, configLocation);</pre>
- *
- * @param loader The ClassLoader for the context. If null the context will attempt to determine the appropriate
- * ClassLoader.
- * @param currentContext if false the LoggerContext appropriate for the caller of this method is returned. For
- * example, in a web application if the caller is a class in WEB-INF/lib then one LoggerContext may be
- * returned and if the caller is a class in the container's classpath then a different LoggerContext may be
- * returned. If true then only a single LoggerContext will be returned.
- * @param configLocation The URI for the configuration to use.
- * @return a LoggerContext.
- * @see LogManager#getContext(ClassLoader, boolean, URI)
- */
- public static LoggerContext getContext(final ClassLoader loader, final boolean currentContext,
- final URI configLocation) {
- return (LoggerContext) LogManager.getContext(loader, currentContext, configLocation);
- }
+ private static final long serialVersionUID = 1L;
+ private static final Configuration NULL_CONFIGURATION = new NullConfiguration();
private final ConcurrentMap<String, Logger> loggers = new ConcurrentHashMap<>();
private final CopyOnWriteArrayList<PropertyChangeListener> propertyChangeListeners = new CopyOnWriteArrayList<>();
/**
- * The Configuration is volatile to guarantee that initialization of the
- * Configuration has completed before the reference is updated.
+ * The Configuration is volatile to guarantee that initialization of the Configuration has completed before the
+ * reference is updated.
*/
- private volatile Configuration config = new DefaultConfiguration();
+ private volatile Configuration configuration = new DefaultConfiguration();
private Object externalContext;
- private final String name;
+ private final String contextName;
private volatile URI configLocation;
private Cancellable shutdownCallback;
@@ -138,6 +82,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Constructor taking only a name.
+ *
* @param name The context name.
*/
public LoggerContext(final String name) {
@@ -146,6 +91,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Constructor taking a name and a reference to an external context.
+ *
* @param name The context name.
* @param externalContext The external context.
*/
@@ -155,26 +101,27 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Constructor taking a name, external context and a configuration URI.
+ *
* @param name The context name.
* @param externalContext The external context.
* @param configLocn The location of the configuration as a URI.
*/
public LoggerContext(final String name, final Object externalContext, final URI configLocn) {
- this.name = name;
+ this.contextName = name;
this.externalContext = externalContext;
this.configLocation = configLocn;
}
/**
- * Constructor taking a name external context and a configuration location
- * String. The location must be resolvable to a File.
+ * Constructor taking a name external context and a configuration location String. The location must be resolvable
+ * to a File.
*
* @param name The configuration location.
* @param externalContext The external context.
* @param configLocn The configuration location.
*/
public LoggerContext(final String name, final Object externalContext, final String configLocn) {
- this.name = name;
+ this.contextName = name;
this.externalContext = externalContext;
if (configLocn != null) {
URI uri;
@@ -189,6 +136,74 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
}
}
+ /**
+ * Returns the current LoggerContext.
+ * <p>
+ * Avoids the type cast for:
+ * </p>
+ *
+ * <pre>
+ * (LoggerContext) LogManager.getContext();
+ * </pre>
+ *
+ * <p>
+ * WARNING - The LoggerContext returned by this method may not be the LoggerContext used to create a Logger for the
+ * calling class.
+ * </p>
+ *
+ * @return The current LoggerContext.
+ * @see LogManager#getContext()
+ */
+ public static LoggerContext getContext() {
+ return (LoggerContext) LogManager.getContext();
+ }
+
+ /**
+ * Returns a LoggerContext.
+ * <p>
+ * Avoids the type cast for:
+ * </p>
+ *
+ * <pre>
+ * (LoggerContext) LogManager.getContext(currentContext);
+ * </pre>
+ *
+ * @param currentContext if false the LoggerContext appropriate for the caller of this method is returned. For
+ * example, in a web application if the caller is a class in WEB-INF/lib then one LoggerContext may be
+ * returned and if the caller is a class in the container's classpath then a different LoggerContext may
+ * be returned. If true then only a single LoggerContext will be returned.
+ * @return a LoggerContext.
+ * @see LogManager#getContext(boolean)
+ */
+ public static LoggerContext getContext(final boolean currentContext) {
+ return (LoggerContext) LogManager.getContext(currentContext);
+ }
+
+ /**
+ * Returns a LoggerContext.
+ * <p>
+ * Avoids the type cast for:
+ * </p>
+ *
+ * <pre>
+ * (LoggerContext) LogManager.getContext(loader, currentContext, configLocation);
+ * </pre>
+ *
+ * @param loader The ClassLoader for the context. If null the context will attempt to determine the appropriate
+ * ClassLoader.
+ * @param currentContext if false the LoggerContext appropriate for the caller of this method is returned. For
+ * example, in a web application if the caller is a class in WEB-INF/lib then one LoggerContext may be
+ * returned and if the caller is a class in the container's classpath then a different LoggerContext may
+ * be returned. If true then only a single LoggerContext will be returned.
+ * @param configLocation The URI for the configuration to use.
+ * @return a LoggerContext.
+ * @see LogManager#getContext(ClassLoader, boolean, URI)
+ */
+ public static LoggerContext getContext(final ClassLoader loader, final boolean currentContext,
+ final URI configLocation) {
+ return (LoggerContext) LogManager.getContext(loader, currentContext, configLocation);
+ }
+
@Override
public void start() {
LOGGER.debug("Starting LoggerContext[name={}, {}]...", getName(), this);
@@ -197,7 +212,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
if (this.isInitialized() || this.isStopped()) {
this.setStarting();
reconfigure();
- if (this.config.isShutdownHookEnabled()) {
+ if (this.configuration.isShutdownHookEnabled()) {
setUpShutdownHook();
}
this.setStarted();
@@ -211,6 +226,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Starts with a specific configuration.
+ *
* @param config The new Configuration.
*/
public void start(final Configuration config) {
@@ -218,7 +234,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
if (configLock.tryLock()) {
try {
if (this.isInitialized() || this.isStopped()) {
- if (this.config.isShutdownHookEnabled()) {
+ if (this.configuration.isShutdownHookEnabled()) {
setUpShutdownHook();
}
this.setStarted();
@@ -241,8 +257,8 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
@Override
public void run() {
final LoggerContext context = LoggerContext.this;
- LOGGER.debug(SHUTDOWN_HOOK_MARKER, "Stopping LoggerContext[name={}, {}]", context.getName(),
- context);
+ LOGGER.debug(SHUTDOWN_HOOK_MARKER, "Stopping LoggerContext[name={}, {}]",
+ context.getName(), context);
context.stop();
}
@@ -252,9 +268,11 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
}
});
} catch (final IllegalStateException e) {
- LOGGER.fatal(SHUTDOWN_HOOK_MARKER, "Unable to register shutdown hook because JVM is shutting down.", e);
+ LOGGER.fatal(SHUTDOWN_HOOK_MARKER,
+ "Unable to register shutdown hook because JVM is shutting down.", e);
} catch (final SecurityException e) {
- LOGGER.error(SHUTDOWN_HOOK_MARKER, "Unable to register shutdown hook due to security restrictions", e);
+ LOGGER.error(SHUTDOWN_HOOK_MARKER, "Unable to register shutdown hook due to security restrictions",
+ e);
}
}
}
@@ -279,8 +297,8 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
shutdownCallback.cancel();
shutdownCallback = null;
}
- final Configuration prev = config;
- config = NULL_CONFIGURATION;
+ final Configuration prev = configuration;
+ configuration = NULL_CONFIGURATION;
updateLoggers();
prev.stop();
externalContext = null;
@@ -298,11 +316,12 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
* @return the name.
*/
public String getName() {
- return name;
+ return contextName;
}
/**
* Sets the external context.
+ *
* @param context The external context.
*/
public void setExternalContext(final Object context) {
@@ -311,6 +330,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Returns the external context.
+ *
* @return The external context.
*/
@Override
@@ -320,6 +340,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Obtains a Logger from the Context.
+ *
* @param name The name of the Logger to return.
* @return The Logger.
*/
@@ -331,8 +352,8 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Gets a collection of the current loggers.
* <p>
- * Whether this collection is a copy of the underlying collection or not is undefined. Therefore, modify this collection at your own
- * risk.
+ * Whether this collection is a copy of the underlying collection or not is undefined. Therefore, modify this
+ * collection at your own risk.
* </p>
*
* @return a collection of the current loggers.
@@ -343,10 +364,10 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Obtains a Logger from the Context.
+ *
* @param name The name of the Logger to return.
- * @param messageFactory The message factory is used only when creating a
- * logger, subsequent use does not change the logger but will log
- * a warning if mismatched.
+ * @param messageFactory The message factory is used only when creating a logger, subsequent use does not change the
+ * logger but will log a warning if mismatched.
* @return The Logger.
*/
@Override
@@ -364,6 +385,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Determines if the specified Logger exists.
+ *
* @param name The Logger name to search for.
* @return True if the Logger exists, false otherwise.
*/
@@ -373,34 +395,36 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
}
/**
- * Returns the current Configuration. The Configuration will be replaced
- * when a reconfigure occurs.
+ * Returns the current Configuration. The Configuration will be replaced when a reconfigure occurs.
*
* @return The Configuration.
*/
public Configuration getConfiguration() {
- return config;
+ return configuration;
}
/**
- * Adds a Filter to the Configuration. Filters that are added through the API will be lost
- * when a reconfigure occurs.
+ * Adds a Filter to the Configuration. Filters that are added through the API will be lost when a reconfigure
+ * occurs.
+ *
* @param filter The Filter to add.
*/
public void addFilter(final Filter filter) {
- config.addFilter(filter);
+ configuration.addFilter(filter);
}
/**
* Removes a Filter from the current Configuration.
+ *
* @param filter The Filter to remove.
*/
public void removeFilter(final Filter filter) {
- config.removeFilter(filter);
+ configuration.removeFilter(filter);
}
/**
* Sets the Configuration to be used.
+ *
* @param config The new Configuration.
* @return The previous Configuration.
*/
@@ -408,7 +432,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
Objects.requireNonNull(config, "No Configuration was provided");
configLock.lock();
try {
- final Configuration prev = this.config;
+ final Configuration prev = this.configuration;
config.addListener(this);
final ConcurrentMap<String, String> map = config.getComponent(Configuration.CONTEXT_PROPERTIES);
@@ -418,9 +442,9 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
LOGGER.debug("Ignoring {}, setting hostName to 'unknown'", ex.toString());
map.putIfAbsent("hostName", "unknown");
}
- map.putIfAbsent("contextName", name);
+ map.putIfAbsent("contextName", contextName);
config.start();
- this.config = config;
+ this.configuration = config;
updateLoggers();
if (prev != null) {
prev.removeListener(this);
@@ -464,9 +488,10 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Returns the initial configuration location or {@code null}. The returned value may not be the location of the
- * current configuration. Use
- * {@link #getConfiguration()}.{@link Configuration#getConfigurationSource() getConfigurationSource()}.{@link
- * ConfigurationSource#getLocation() getLocation()} to get the actual source of the current configuration.
+ * current configuration. Use {@link #getConfiguration()}.{@link Configuration#getConfigurationSource()
+ * getConfigurationSource()}.{@link ConfigurationSource#getLocation() getLocation()} to get the actual source of the
+ * current configuration.
+ *
* @return the initial configuration location or {@code null}
*/
public URI getConfigLocation() {
@@ -475,6 +500,7 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
/**
* Sets the configLocation to the specified value and reconfigures this context.
+ *
* @param configLocation the location of the new configuration
*/
public void setConfigLocation(final URI configLocation) {
@@ -488,17 +514,17 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
*/
private void reconfigure(final URI configURI) {
final ClassLoader cl = ClassLoader.class.isInstance(externalContext) ? (ClassLoader) externalContext : null;
- LOGGER.debug("Reconfiguration started for context[name={}] at URI {} ({}) with optional ClassLoader: {}", name,
- configURI, this, cl);
- final Configuration instance = ConfigurationFactory.getInstance().getConfiguration(name, configURI, cl);
+ LOGGER.debug("Reconfiguration started for context[name={}] at URI {} ({}) with optional ClassLoader: {}",
+ contextName, configURI, this, cl);
+ final Configuration instance = ConfigurationFactory.getInstance().getConfiguration(contextName, configURI, cl);
setConfiguration(instance);
/*
- * instance.start(); Configuration old = setConfiguration(instance);
- * updateLoggers(); if (old != null) { old.stop(); }
+ * instance.start(); Configuration old = setConfiguration(instance); updateLoggers(); if (old != null) {
+ * old.stop(); }
*/
- LOGGER.debug("Reconfiguration complete for context[name={}] at URI {} ({}) with optional ClassLoader: {}", name,
- configURI, this, cl);
+ LOGGER.debug("Reconfiguration complete for context[name={}] at URI {} ({}) with optional ClassLoader: {}",
+ contextName, configURI, this, cl);
}
/**
@@ -514,11 +540,12 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
* Causes all Loggers to be updated against the current Configuration.
*/
public void updateLoggers() {
- updateLoggers(this.config);
+ updateLoggers(this.configuration);
}
/**
* Causes all Logger to be updated against the specified Configuration.
+ *
* @param config The Configuration.
*/
public void updateLoggers(final Configuration config) {
@@ -528,20 +555,19 @@ public class LoggerContext extends AbstractLifeCycle implements org.apache.loggi
}
/**
- * Causes a reconfiguration to take place when the underlying configuration
- * file changes.
+ * Causes a reconfiguration to take place when the underlying configuration file changes.
*
* @param reconfigurable The Configuration that can be reconfigured.
*/
@Override
public synchronized void onChange(final Reconfigurable reconfigurable) {
- LOGGER.debug("Reconfiguration started for context {} ({})", name, this);
+ LOGGER.debug("Reconfiguration started for context {} ({})", contextName, this);
final Configuration newConfig = reconfigurable.reconfigure();
if (newConfig != null) {
setConfiguration(newConfig);
- LOGGER.debug("Reconfiguration completed for {} ({})", name, this);
+ LOGGER.debug("Reconfiguration completed for {} ({})", contextName, this);
} else {
- LOGGER.debug("Reconfiguration failed for {} ({})", name, this);
+ LOGGER.debug("Reconfiguration failed for {} ({})", contextName, this);
}
}
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractAppender.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractAppender.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractAppender.java
index df04706..af01fc1 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractAppender.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractAppender.java
@@ -27,33 +27,21 @@ import org.apache.logging.log4j.core.filter.AbstractFilterable;
import org.apache.logging.log4j.core.util.Integers;
/**
- * Abstract base class for Appenders. Although Appenders do not have to extend this class, doing so
- * will simplify their implementation.
+ * Abstract base class for Appenders. Although Appenders do not have to extend this class, doing so will simplify their
+ * implementation.
*/
-public abstract class AbstractAppender extends AbstractFilterable
- implements Appender {
+public abstract class AbstractAppender extends AbstractFilterable implements Appender {
private static final long serialVersionUID = 1L;
+ private final String name;
private final boolean ignoreExceptions;
-
- private ErrorHandler handler = new DefaultErrorHandler(this);
-
private final Layout<? extends Serializable> layout;
-
- private final String name;
-
- public static int parseInt(final String s, final int defaultValue) {
- try {
- return Integers.parseInt(s, defaultValue);
- } catch (final NumberFormatException e) {
- LOGGER.error("Could not parse \"{}\" as an integer, using default value {}: {}", s, defaultValue, e);
- return defaultValue;
- }
- }
+ private ErrorHandler handler = new DefaultErrorHandler(this);
/**
* Constructor that defaults to suppressing exceptions.
+ *
* @param name The Appender name.
* @param filter The Filter to associate with the Appender.
* @param layout The layout to use to format the event.
@@ -64,22 +52,33 @@ public abstract class AbstractAppender extends AbstractFilterable
/**
* Constructor.
+ *
* @param name The Appender name.
* @param filter The Filter to associate with the Appender.
* @param layout The layout to use to format the event.
- * @param ignoreExceptions If true, exceptions will be logged and suppressed. If false errors will be
- * logged and then passed to the application.
+ * @param ignoreExceptions If true, exceptions will be logged and suppressed. If false errors will be logged and
+ * then passed to the application.
*/
protected AbstractAppender(final String name, final Filter filter, final Layout<? extends Serializable> layout,
- final boolean ignoreExceptions) {
+ final boolean ignoreExceptions) {
super(filter);
this.name = name;
this.layout = layout;
this.ignoreExceptions = ignoreExceptions;
}
+ public static int parseInt(final String s, final int defaultValue) {
+ try {
+ return Integers.parseInt(s, defaultValue);
+ } catch (final NumberFormatException e) {
+ LOGGER.error("Could not parse \"{}\" as an integer, using default value {}: {}", s, defaultValue, e);
+ return defaultValue;
+ }
+ }
+
/**
* Handle an error with a message using the {@link ErrorHandler} configured for this Appender.
+ *
* @param msg The message.
*/
public void error(final String msg) {
@@ -89,6 +88,7 @@ public abstract class AbstractAppender extends AbstractFilterable
/**
* Handle an error with a message, exception, and a logging event, using the {@link ErrorHandler} configured for
* this Appender.
+ *
* @param msg The message.
* @param event The LogEvent.
* @param t The Throwable.
@@ -99,6 +99,7 @@ public abstract class AbstractAppender extends AbstractFilterable
/**
* Handle an error with a message and an exception using the {@link ErrorHandler} configured for this Appender.
+ *
* @param msg The message.
* @param t The Throwable.
*/
@@ -108,6 +109,7 @@ public abstract class AbstractAppender extends AbstractFilterable
/**
* Returns the ErrorHandler, if any.
+ *
* @return The ErrorHandler.
*/
@Override
@@ -117,6 +119,7 @@ public abstract class AbstractAppender extends AbstractFilterable
/**
* Returns the Layout for the appender.
+ *
* @return The Layout used to format the event.
*/
@Override
@@ -126,6 +129,7 @@ public abstract class AbstractAppender extends AbstractFilterable
/**
* Returns the name of the Appender.
+ *
* @return The name of the Appender.
*/
@Override
@@ -146,6 +150,7 @@ public abstract class AbstractAppender extends AbstractFilterable
/**
* The handler must be set before the appender is started.
+ *
* @param handler The ErrorHandler to use.
*/
@Override
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
index 9df5936..3e09a61 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AbstractOutputStreamAppender.java
@@ -35,13 +35,10 @@ public abstract class AbstractOutputStreamAppender<M extends OutputStreamManager
private static final long serialVersionUID = 1L;
/**
- * Immediate flush means that the underlying writer or output stream
- * will be flushed at the end of each append operation. Immediate
- * flush is slower but ensures that each append request is actually
- * written. If <code>immediateFlush</code> is set to
- * {@code false}, then there is a good chance that the last few
- * logs events are not actually written to persistent media if and
- * when the application crashes.
+ * Immediate flush means that the underlying writer or output stream will be flushed at the end of each append
+ * operation. Immediate flush is slower but ensures that each append request is actually written. If
+ * <code>immediateFlush</code> is set to {@code false}, then there is a good chance that the last few logs events
+ * are not actually written to persistent media if and when the application crashes.
*/
protected final boolean immediateFlush;
@@ -49,18 +46,17 @@ public abstract class AbstractOutputStreamAppender<M extends OutputStreamManager
private final ReadWriteLock rwLock = new ReentrantReadWriteLock();
private final Lock readLock = rwLock.readLock();
-
+
/**
- * Instantiate a WriterAppender and set the output destination to a
- * new {@link java.io.OutputStreamWriter} initialized with <code>os</code>
- * as its {@link java.io.OutputStream}.
+ * Instantiate a WriterAppender and set the output destination to a new {@link java.io.OutputStreamWriter}
+ * initialized with <code>os</code> as its {@link java.io.OutputStream}.
+ *
* @param name The name of the Appender.
* @param layout The layout to format the message.
* @param manager The OutputStreamManager.
*/
- protected AbstractOutputStreamAppender(final String name, final Layout<? extends Serializable> layout, final Filter filter,
- final boolean ignoreExceptions, final boolean immediateFlush,
- final M manager) {
+ protected AbstractOutputStreamAppender(final String name, final Layout<? extends Serializable> layout,
+ final Filter filter, final boolean ignoreExceptions, final boolean immediateFlush, final M manager) {
super(name, filter, layout, ignoreExceptions);
this.manager = manager;
this.immediateFlush = immediateFlush;
@@ -98,8 +94,7 @@ public abstract class AbstractOutputStreamAppender<M extends OutputStreamManager
* Most subclasses of <code>AbstractOutputStreamAppender</code> will need to override this method.
* </p>
*
- * @param event
- * The LogEvent.
+ * @param event The LogEvent.
*/
@Override
public void append(final LogEvent event) {
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AsyncAppender.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AsyncAppender.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AsyncAppender.java
index 4b6c740..0c0378c 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AsyncAppender.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/AsyncAppender.java
@@ -41,10 +41,9 @@ import org.apache.logging.log4j.core.config.plugins.PluginFactory;
import org.apache.logging.log4j.core.impl.Log4jLogEvent;
/**
- * Appends to one or more Appenders asynchronously. You can configure an
- * AsyncAppender with one or more Appenders and an Appender to append to if the
- * queue is full. The AsyncAppender does not allow a filter to be specified on
- * the Appender references.
+ * Appends to one or more Appenders asynchronously. You can configure an AsyncAppender with one or more Appenders and an
+ * Appender to append to if the queue is full. The AsyncAppender does not allow a filter to be specified on the Appender
+ * references.
*/
@Plugin(name = "Async", category = "Core", elementType = "appender", printObject = true)
public final class AsyncAppender extends AbstractAppender {
@@ -53,6 +52,9 @@ public final class AsyncAppender extends AbstractAppender {
private static final int DEFAULT_QUEUE_SIZE = 128;
private static final String SHUTDOWN = "Shutdown";
+ private static final AtomicLong THREAD_SEQUENCE = new AtomicLong(1);
+ private static ThreadLocal<Boolean> isAppenderThread = new ThreadLocal<>();
+
private final BlockingQueue<Serializable> queue;
private final int queueSize;
private final boolean blocking;
@@ -62,14 +64,10 @@ public final class AsyncAppender extends AbstractAppender {
private final boolean includeLocation;
private AppenderControl errorAppender;
private AsyncThread thread;
- private static final AtomicLong threadSequence = new AtomicLong(1);
- private static ThreadLocal<Boolean> isAppenderThread = new ThreadLocal<>();
-
private AsyncAppender(final String name, final Filter filter, final AppenderRef[] appenderRefs,
- final String errorRef, final int queueSize, final boolean blocking,
- final boolean ignoreExceptions, final Configuration config,
- final boolean includeLocation) {
+ final String errorRef, final int queueSize, final boolean blocking, final boolean ignoreExceptions,
+ final Configuration config, final boolean includeLocation) {
super(name, filter, null, ignoreExceptions);
this.queue = new ArrayBlockingQueue<>(queueSize);
this.queueSize = queueSize;
@@ -127,8 +125,7 @@ public final class AsyncAppender extends AbstractAppender {
/**
* Actual writing occurs here.
*
- * @param logEvent
- * The LogEvent.
+ * @param logEvent The LogEvent.
*/
@Override
public void append(LogEvent logEvent) {
@@ -171,7 +168,7 @@ public final class AsyncAppender extends AbstractAppender {
appendSuccessful = queue.offer(serialized);
if (!appendSuccessful) {
LOGGER.warn("Interrupted while waiting for a free slot in the AsyncAppender LogEvent-queue {}",
- getName());
+ getName());
}
// set the interrupted flag again.
Thread.currentThread().interrupt();
@@ -190,6 +187,7 @@ public final class AsyncAppender extends AbstractAppender {
/**
* Create an AsyncAppender.
+ *
* @param appenderRefs The Appenders to reference.
* @param errorRef An optional Appender to write to if the queue is full or other errors occur.
* @param blocking True if the Appender should wait when the queue is full. The default is true.
@@ -199,7 +197,7 @@ public final class AsyncAppender extends AbstractAppender {
* @param filter The Filter or null.
* @param config The Configuration.
* @param ignoreExceptions If {@code "true"} (default) exceptions encountered when appending events are logged;
- * otherwise they are propagated to the caller.
+ * otherwise they are propagated to the caller.
* @return The AsyncAppender.
*/
@PluginFactory
@@ -209,8 +207,7 @@ public final class AsyncAppender extends AbstractAppender {
@PluginAttribute(value = "bufferSize", defaultInt = DEFAULT_QUEUE_SIZE) final int size,
@PluginAttribute("name") final String name,
@PluginAttribute(value = "includeLocation", defaultBoolean = false) final boolean includeLocation,
- @PluginElement("Filter") final Filter filter,
- @PluginConfiguration final Configuration config,
+ @PluginElement("Filter") final Filter filter, @PluginConfiguration final Configuration config,
@PluginAttribute(value = "ignoreExceptions", defaultBoolean = true) final boolean ignoreExceptions) {
if (name == null) {
LOGGER.error("No name provided for AsyncAppender");
@@ -220,8 +217,8 @@ public final class AsyncAppender extends AbstractAppender {
LOGGER.error("No appender references provided to AsyncAppender {}", name);
}
- return new AsyncAppender(name, filter, appenderRefs, errorRef,
- size, blocking, ignoreExceptions, config, includeLocation);
+ return new AsyncAppender(name, filter, appenderRefs, errorRef, size, blocking, ignoreExceptions, config,
+ includeLocation);
}
/**
@@ -237,7 +234,7 @@ public final class AsyncAppender extends AbstractAppender {
this.appenders = appenders;
this.queue = queue;
setDaemon(true);
- setName("AsyncAppenderThread" + threadSequence.getAndIncrement());
+ setName("AsyncAppenderThread" + THREAD_SEQUENCE.getAndIncrement());
}
@Override
@@ -268,7 +265,7 @@ public final class AsyncAppender extends AbstractAppender {
// Process any remaining items in the queue.
LOGGER.trace("AsyncAppender.AsyncThread shutting down. Processing remaining {} queue events.",
queue.size());
- int count= 0;
+ int count = 0;
int ignored = 0;
while (!queue.isEmpty()) {
try {
@@ -287,16 +284,14 @@ public final class AsyncAppender extends AbstractAppender {
// Here we ignore interrupts and try to process all remaining events.
}
}
- LOGGER.trace("AsyncAppender.AsyncThread stopped. Queue has {} events remaining. " +
- "Processed {} and ignored {} events since shutdown started.",
- queue.size(), count, ignored);
+ LOGGER.trace("AsyncAppender.AsyncThread stopped. Queue has {} events remaining. "
+ + "Processed {} and ignored {} events since shutdown started.", queue.size(), count, ignored);
}
/**
- * Calls {@link AppenderControl#callAppender(LogEvent) callAppender} on
- * all registered {@code AppenderControl} objects, and returns {@code true}
- * if at least one appender call was successful, {@code false} otherwise.
- * Any exceptions are silently ignored.
+ * Calls {@link AppenderControl#callAppender(LogEvent) callAppender} on all registered {@code AppenderControl}
+ * objects, and returns {@code true} if at least one appender call was successful, {@code false} otherwise. Any
+ * exceptions are silently ignored.
*
* @param event the event to forward to the registered appenders
* @return {@code true} if at least one appender call succeeded, {@code false} otherwise
@@ -323,8 +318,8 @@ public final class AsyncAppender extends AbstractAppender {
}
/**
- * Returns the names of the appenders that this asyncAppender delegates to
- * as an array of Strings.
+ * Returns the names of the appenders that this asyncAppender delegates to as an array of Strings.
+ *
* @return the names of the sink appenders
*/
public String[] getAppenderRefStrings() {
@@ -336,9 +331,9 @@ public final class AsyncAppender extends AbstractAppender {
}
/**
- * Returns {@code true} if this AsyncAppender will take a snapshot of the stack with
- * every log event to determine the class and method where the logging call
- * was made.
+ * Returns {@code true} if this AsyncAppender will take a snapshot of the stack with every log event to determine
+ * the class and method where the logging call was made.
+ *
* @return {@code true} if location is included with every event, {@code false} otherwise
*/
public boolean isIncludeLocation() {
@@ -346,8 +341,9 @@ public final class AsyncAppender extends AbstractAppender {
}
/**
- * Returns {@code true} if this AsyncAppender will block when the queue is full,
- * or {@code false} if events are dropped when the queue is full.
+ * Returns {@code true} if this AsyncAppender will block when the queue is full, or {@code false} if events are
+ * dropped when the queue is full.
+ *
* @return whether this AsyncAppender will block or drop events when the queue is full.
*/
public boolean isBlocking() {
@@ -356,6 +352,7 @@ public final class AsyncAppender extends AbstractAppender {
/**
* Returns the name of the appender that any errors are logged to or {@code null}.
+ *
* @return the name of the appender that any errors are logged to or {@code null}
*/
public String getErrorRef() {
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/ConsoleAppender.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/ConsoleAppender.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/ConsoleAppender.java
index 4838443..8006401 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/ConsoleAppender.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/ConsoleAppender.java
@@ -39,14 +39,12 @@ import org.apache.logging.log4j.core.util.Loader;
import org.apache.logging.log4j.util.PropertiesUtil;
/**
- * Appends log events to <code>System.out</code> or
- * <code>System.err</code> using a layout specified by the user. The
+ * Appends log events to <code>System.out</code> or <code>System.err</code> using a layout specified by the user. The
* default target is <code>System.out</code>.
- * TODO accessing System.out or .err as a byte stream instead of a writer
- * bypasses the JVM's knowledge of the proper encoding. (RG) Encoding
- * is handled within the Layout. Typically, a Layout will generate a String
- * and then call getBytes which may use a configured encoding or the system
- * default. OTOH, a Writer cannot print byte streams.
+ * <p>
+ * TODO accessing System.out or .err as a byte stream instead of a writer bypasses the JVM's knowledge of the proper
+ * encoding. (RG) Encoding is handled within the Layout. Typically, a Layout will generate a String and then call
+ * getBytes which may use a configured encoding or the system default. OTOH, a Writer cannot print byte streams.
*/
@Plugin(name = "Console", category = "Core", elementType = "appender", printObject = true)
public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputStreamManager> {
@@ -59,7 +57,7 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
/**
* Enumeration of console destinations.
*/
- public enum Target {
+ public static enum Target {
/** Standard output. */
SYSTEM_OUT,
/** Standard error output. */
@@ -67,25 +65,24 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
}
private ConsoleAppender(final String name, final Layout<? extends Serializable> layout, final Filter filter,
- final OutputStreamManager manager,
- final boolean ignoreExceptions) {
+ final OutputStreamManager manager, final boolean ignoreExceptions) {
super(name, layout, filter, ignoreExceptions, true, manager);
}
/**
* Creates a Console Appender.
+ *
* @param layout The layout to use (required).
* @param filter The Filter or null.
* @param targetStr The target ("SYSTEM_OUT" or "SYSTEM_ERR"). The default is "SYSTEM_OUT".
* @param follow If true will follow changes to the underlying output stream.
* @param name The name of the Appender (required).
- * @param ignore If {@code "true"} (default) exceptions encountered when appending events are logged; otherwise
- * they are propagated to the caller.
+ * @param ignore If {@code "true"} (default) exceptions encountered when appending events are logged; otherwise they
+ * are propagated to the caller.
* @return The ConsoleAppender.
*/
@PluginFactory
- public static ConsoleAppender createAppender(
- @PluginElement("Layout") Layout<? extends Serializable> layout,
+ public static ConsoleAppender createAppender(@PluginElement("Layout") Layout<? extends Serializable> layout,
@PluginElement("Filter") final Filter filter,
@PluginAttribute(value = "target", defaultString = "SYSTEM_OUT") final String targetStr,
@PluginAttribute("name") final String name,
@@ -114,6 +111,9 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
return new Builder();
}
+ /**
+ * Builds ConsoleAppender instances.
+ */
public static class Builder implements org.apache.logging.log4j.core.util.Builder<ConsoleAppender> {
@PluginElement("Layout")
@@ -137,33 +137,33 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
@PluginBuilderAttribute
private boolean ignoreExceptions = true;
- public Builder setLayout(final Layout<? extends Serializable> layout) {
- this.layout = layout;
+ public Builder setLayout(final Layout<? extends Serializable> aLayout) {
+ this.layout = aLayout;
return this;
}
- public Builder setFilter(final Filter filter) {
- this.filter = filter;
+ public Builder setFilter(final Filter aFilter) {
+ this.filter = aFilter;
return this;
}
- public Builder setTarget(final Target target) {
- this.target = target;
+ public Builder setTarget(final Target aTarget) {
+ this.target = aTarget;
return this;
}
- public Builder setName(final String name) {
- this.name = name;
+ public Builder setName(final String aName) {
+ this.name = aName;
return this;
}
- public Builder setFollow(final boolean follow) {
- this.follow = follow;
+ public Builder setFollow(final boolean shouldFollow) {
+ this.follow = shouldFollow;
return this;
}
- public Builder setIgnoreExceptions(final boolean ignoreExceptions) {
- this.ignoreExceptions = ignoreExceptions;
+ public Builder setIgnoreExceptions(final boolean shouldIgnoreExceptions) {
+ this.ignoreExceptions = shouldIgnoreExceptions;
return this;
}
@@ -173,7 +173,8 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
}
}
- private static OutputStreamManager getManager(final Target target, final boolean follow, final Layout<? extends Serializable> layout) {
+ private static OutputStreamManager getManager(final Target target, final boolean follow,
+ final Layout<? extends Serializable> layout) {
final OutputStream os = getOutputStream(follow, target);
final String managerName = target.name() + '.' + follow;
return OutputStreamManager.getManager(managerName, new FactoryData(os, managerName, layout), factory);
@@ -235,8 +236,7 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
}
@Override
- public void write(final byte[] b, final int off, final int len)
- throws IOException {
+ public void write(final byte[] b, final int off, final int len) throws IOException {
System.err.write(b, off, len);
}
@@ -269,8 +269,7 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
}
@Override
- public void write(final byte[] b, final int off, final int len)
- throws IOException {
+ public void write(final byte[] b, final int off, final int len) throws IOException {
System.out.write(b, off, len);
}
@@ -279,7 +278,7 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
System.out.write(b);
}
}
-
+
/**
* A delegating OutputStream that does not close its delegate.
*/
@@ -307,8 +306,7 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
}
@Override
- public void write(final byte[] b, final int off, final int len)
- throws IOException {
+ public void write(final byte[] b, final int off, final int len) throws IOException {
delegate.write(b, off, len);
}
@@ -328,6 +326,7 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
/**
* Constructor.
+ *
* @param os The OutputStream.
* @param type The name of the target.
* @param layout A Serializable layout
@@ -346,6 +345,7 @@ public final class ConsoleAppender extends AbstractOutputStreamAppender<OutputSt
/**
* Create an OutputStreamManager.
+ *
* @param name The name of the entity to manage.
* @param data The data required to create the entity.
* @return The OutputStreamManager
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/MemoryMappedFileManager.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/MemoryMappedFileManager.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/MemoryMappedFileManager.java
index 4998b7b..b6d2a20 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/MemoryMappedFileManager.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/MemoryMappedFileManager.java
@@ -41,23 +41,22 @@ import org.apache.logging.log4j.core.util.NullOutputStream;
* memory and writes to this memory region.
* <p>
*
- * @see <a
- * href="http://www.codeproject.com/Tips/683614/Things-to-Know-about-Memory-Mapped-File-in-Java">
- * http://www.codeproject.com/Tips/683614/Things-to-Know-about-Memory-Mapped-File-in-Java</a>
+ * @see <a href="http://www.codeproject.com/Tips/683614/Things-to-Know-about-Memory-Mapped-File-in-Java">
+ * http://www.codeproject.com/Tips/683614/Things-to-Know-about-Memory-Mapped-File-in-Java</a>
* @see <a href="http://bugs.java.com/view_bug.do?bug_id=6893654">http://bugs.java.com/view_bug.do?bug_id=6893654</a>
* @see <a href="http://bugs.java.com/view_bug.do?bug_id=4724038">http://bugs.java.com/view_bug.do?bug_id=4724038</a>
* @see <a
* href="http://stackoverflow.com/questions/9261316/memory-mapped-mappedbytebuffer-or-direct-bytebuffer-for-db-implementation">
- * http://stackoverflow.com/questions/9261316/memory-mapped-mappedbytebuffer-or-direct-bytebuffer-for-db-implementation</a>
+ * http://stackoverflow.com/questions/9261316/memory-mapped-mappedbytebuffer-or-direct-bytebuffer-for-db-implementation</a>
*
* @since 2.1
*/
public class MemoryMappedFileManager extends OutputStreamManager {
/**
- *
+ * Default length of region to map.
*/
- private static final int MAX_REMAP_COUNT = 10;
static final int DEFAULT_REGION_LENGTH = 32 * 1024 * 1024;
+ private static final int MAX_REMAP_COUNT = 10;
private static final MemoryMappedFileManagerFactory FACTORY = new MemoryMappedFileManagerFactory();
private static final double NANOS_PER_MILLISEC = 1000.0 * 1000.0;
@@ -104,8 +103,8 @@ public class MemoryMappedFileManager extends OutputStreamManager {
return isEndOfBatch.get();
}
- public void setEndOfBatch(final boolean isEndOfBatch) {
- this.isEndOfBatch.set(Boolean.valueOf(isEndOfBatch));
+ public void setEndOfBatch(final boolean endOfBatch) {
+ this.isEndOfBatch.set(Boolean.valueOf(endOfBatch));
}
@Override
@@ -293,7 +292,7 @@ public class MemoryMappedFileManager extends OutputStreamManager {
/**
* Factory to create a MemoryMappedFileManager.
*/
- private static class MemoryMappedFileManagerFactory
+ private static class MemoryMappedFileManagerFactory
implements ManagerFactory<MemoryMappedFileManager, FactoryData> {
/**
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RandomAccessFileManager.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RandomAccessFileManager.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RandomAccessFileManager.java
index 1110cbc..4d667d9 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RandomAccessFileManager.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RandomAccessFileManager.java
@@ -80,8 +80,8 @@ public class RandomAccessFileManager extends OutputStreamManager {
return isEndOfBatch.get();
}
- public void setEndOfBatch(final boolean isEndOfBatch) {
- this.isEndOfBatch.set(Boolean.valueOf(isEndOfBatch));
+ public void setEndOfBatch(final boolean endOfBatch) {
+ this.isEndOfBatch.set(Boolean.valueOf(endOfBatch));
}
@Override
http://git-wip-us.apache.org/repos/asf/logging-log4j2/blob/1236fac8/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RollingFileAppender.java
----------------------------------------------------------------------
diff --git a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RollingFileAppender.java b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RollingFileAppender.java
index d538a63..2521ae6 100644
--- a/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RollingFileAppender.java
+++ b/log4j-core/src/main/java/org/apache/logging/log4j/core/appender/RollingFileAppender.java
@@ -105,7 +105,8 @@ public final class RollingFileAppender extends AbstractOutputStreamAppender<Roll
}
/**
- * Returns the triggering policy
+ * Returns the triggering policy.
+ * @param <T> TriggeringPolicy type
* @return The TriggeringPolicy
*/
public <T extends TriggeringPolicy> T getTriggeringPolicy() {