Source Code for Apache Log4j Core Implementation
Apache Log4j Core Implementation
provides the functional components of the logging system. Users are free to
create their own plugins and include them in the logging configuration.
Apache Log4j Core is a required module to use Apache Log4j.
Bytecode (Java 8) for Apache Log4j Core Implementation is provided in a separate JAR file like log4j-core-2.14.1.jar.
Source Code files for Apache Log4j API are provided in both binary packge like apache-log4j-2.14.1-bin.zip and source package like apache-log4j-2.14.1-src.zip. You can download them at Apache Log4j Website.
You can also browse Source Code files for Apache Log4j Core Implementation 2.14.1 below.
✍: FYIcenter.com
⏎ org/apache/logging/log4j/core/config/AbstractConfiguration.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache license, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the license for the specific language governing permissions and
* limitations under the license.
*/
package org.apache.logging.log4j.core.config;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.Serializable;
import java.lang.ref.WeakReference;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashSet;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.CopyOnWriteArrayList;
import java.util.concurrent.TimeUnit;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.Appender;
import org.apache.logging.log4j.core.Filter;
import org.apache.logging.log4j.core.Layout;
import org.apache.logging.log4j.core.LifeCycle2;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.Version;
import org.apache.logging.log4j.core.appender.AsyncAppender;
import org.apache.logging.log4j.core.appender.ConsoleAppender;
import org.apache.logging.log4j.core.async.AsyncLoggerConfig;
import org.apache.logging.log4j.core.async.AsyncLoggerConfigDelegate;
import org.apache.logging.log4j.core.async.AsyncLoggerConfigDisruptor;
import org.apache.logging.log4j.core.config.plugins.util.PluginBuilder;
import org.apache.logging.log4j.core.config.plugins.util.PluginManager;
import org.apache.logging.log4j.core.config.plugins.util.PluginType;
import org.apache.logging.log4j.core.filter.AbstractFilterable;
import org.apache.logging.log4j.core.layout.PatternLayout;
import org.apache.logging.log4j.core.lookup.Interpolator;
import org.apache.logging.log4j.core.lookup.MapLookup;
import org.apache.logging.log4j.core.lookup.StrLookup;
import org.apache.logging.log4j.core.lookup.StrSubstitutor;
import org.apache.logging.log4j.core.net.Advertiser;
import org.apache.logging.log4j.core.script.AbstractScript;
import org.apache.logging.log4j.core.script.ScriptManager;
import org.apache.logging.log4j.core.script.ScriptRef;
import org.apache.logging.log4j.core.util.Constants;
import org.apache.logging.log4j.core.util.DummyNanoClock;
import org.apache.logging.log4j.core.util.Loader;
import org.apache.logging.log4j.core.util.NameUtil;
import org.apache.logging.log4j.core.util.NanoClock;
import org.apache.logging.log4j.core.util.Source;
import org.apache.logging.log4j.core.util.WatchManager;
import org.apache.logging.log4j.core.util.Watcher;
import org.apache.logging.log4j.core.util.WatcherFactory;
import org.apache.logging.log4j.util.PropertiesUtil;
/**
* The base Configuration. Many configuration implementations will extend this class.
*/
public abstract class AbstractConfiguration extends AbstractFilterable implements Configuration {
private static final int BUF_SIZE = 16384;
/**
* The root node of the configuration.
*/
protected Node rootNode;
/**
* Listeners for configuration changes.
*/
protected final List<ConfigurationListener> listeners = new CopyOnWriteArrayList<>();
/**
* Packages found in configuration "packages" attribute.
*/
protected final List<String> pluginPackages = new ArrayList<>();
/**
* The plugin manager.
*/
protected PluginManager pluginManager;
/**
* Shutdown hook is enabled by default.
*/
protected boolean isShutdownHookEnabled = true;
/**
* Shutdown timeout in milliseconds.
*/
protected long shutdownTimeoutMillis = 0;
/**
* The Script manager.
*/
protected ScriptManager scriptManager;
/**
* The Advertiser which exposes appender configurations to external systems.
*/
private Advertiser advertiser = new DefaultAdvertiser();
private Node advertiserNode = null;
private Object advertisement;
private String name;
private ConcurrentMap<String, Appender> appenders = new ConcurrentHashMap<>();
private ConcurrentMap<String, LoggerConfig> loggerConfigs = new ConcurrentHashMap<>();
private List<CustomLevelConfig> customLevels = Collections.emptyList();
private final ConcurrentMap<String, String> propertyMap = new ConcurrentHashMap<>();
private final StrLookup tempLookup = new Interpolator(propertyMap);
private final StrSubstitutor subst = new StrSubstitutor(tempLookup);
private LoggerConfig root = new LoggerConfig();
private final ConcurrentMap<String, Object> componentMap = new ConcurrentHashMap<>();
private final ConfigurationSource configurationSource;
private final ConfigurationScheduler configurationScheduler = new ConfigurationScheduler();
private final WatchManager watchManager = new WatchManager(configurationScheduler);
private AsyncLoggerConfigDisruptor asyncLoggerConfigDisruptor;
private NanoClock nanoClock = new DummyNanoClock();
private final WeakReference<LoggerContext> loggerContext;
/**
* Constructor.
*/
protected AbstractConfiguration(final LoggerContext loggerContext, final ConfigurationSource configurationSource) {
this.loggerContext = new WeakReference<>(loggerContext);
// The loggerContext is null for the NullConfiguration class.
// this.loggerContext = new WeakReference(Objects.requireNonNull(loggerContext, "loggerContext is null"));
this.configurationSource = Objects.requireNonNull(configurationSource, "configurationSource is null");
componentMap.put(Configuration.CONTEXT_PROPERTIES, propertyMap);
pluginManager = new PluginManager(Node.CATEGORY);
rootNode = new Node();
setState(State.INITIALIZING);
}
@Override
public ConfigurationSource getConfigurationSource() {
return configurationSource;
}
@Override
public List<String> getPluginPackages() {
return pluginPackages;
}
@Override
public Map<String, String> getProperties() {
return propertyMap;
}
@Override
public ScriptManager getScriptManager() {
return scriptManager;
}
public void setScriptManager(final ScriptManager scriptManager) {
this.scriptManager = scriptManager;
}
public PluginManager getPluginManager() {
return pluginManager;
}
public void setPluginManager(final PluginManager pluginManager) {
this.pluginManager = pluginManager;
}
@Override
public WatchManager getWatchManager() {
return watchManager;
}
@Override
public ConfigurationScheduler getScheduler() {
return configurationScheduler;
}
public Node getRootNode() {
return rootNode;
}
@Override
public AsyncLoggerConfigDelegate getAsyncLoggerConfigDelegate() {
// lazily instantiate only when requested by AsyncLoggers:
// loading AsyncLoggerConfigDisruptor requires LMAX Disruptor jar on classpath
if (asyncLoggerConfigDisruptor == null) {
asyncLoggerConfigDisruptor = new AsyncLoggerConfigDisruptor();
}
return asyncLoggerConfigDisruptor;
}
/**
* Initialize the configuration.
*/
@Override
public void initialize() {
LOGGER.debug(Version.getProductString() + " initializing configuration {}", this);
subst.setConfiguration(this);
try {
scriptManager = new ScriptManager(this, watchManager);
} catch (final LinkageError | Exception e) {
// LOG4J2-1920 ScriptEngineManager is not available in Android
LOGGER.info("Cannot initialize scripting support because this JRE does not support it.", e);
}
pluginManager.collectPlugins(pluginPackages);
final PluginManager levelPlugins = new PluginManager(Level.CATEGORY);
levelPlugins.collectPlugins(pluginPackages);
final Map<String, PluginType<?>> plugins = levelPlugins.getPlugins();
if (plugins != null) {
for (final PluginType<?> type : plugins.values()) {
try {
// Cause the class to be initialized if it isn't already.
Loader.initializeClass(type.getPluginClass().getName(), type.getPluginClass().getClassLoader());
} catch (final Exception e) {
LOGGER.error("Unable to initialize {} due to {}", type.getPluginClass().getName(), e.getClass()
.getSimpleName(), e);
}
}
}
setup();
setupAdvertisement();
doConfigure();
setState(State.INITIALIZED);
LOGGER.debug("Configuration {} initialized", this);
}
protected void initializeWatchers(Reconfigurable reconfigurable, ConfigurationSource configSource,
int monitorIntervalSeconds) {
if (configSource.getFile() != null || configSource.getURL() != null) {
if (monitorIntervalSeconds > 0) {
watchManager.setIntervalSeconds(monitorIntervalSeconds);
if (configSource.getFile() != null) {
final Source cfgSource = new Source(configSource);
final long lastModifeid = configSource.getFile().lastModified();
final ConfigurationFileWatcher watcher = new ConfigurationFileWatcher(this, reconfigurable,
listeners, lastModifeid);
watchManager.watch(cfgSource, watcher);
} else if (configSource.getURL() != null) {
monitorSource(reconfigurable, configSource);
}
} else if (watchManager.hasEventListeners() && configSource.getURL() != null
&& monitorIntervalSeconds >= 0) {
monitorSource(reconfigurable, configSource);
}
}
}
private void monitorSource(Reconfigurable reconfigurable, ConfigurationSource configSource) {
if (configSource.getLastModified() > 0) {
final Source cfgSource = new Source(configSource);
final Watcher watcher = WatcherFactory.getInstance(pluginPackages)
.newWatcher(cfgSource, this, reconfigurable, listeners, configSource.getLastModified());
if (watcher != null) {
watchManager.watch(cfgSource, watcher);
}
} else {
LOGGER.info("{} does not support dynamic reconfiguration", configSource.getURI());
}
}
/**
* Start the configuration.
*/
@Override
public void start() {
// Preserve the prior behavior of initializing during start if not initialized.
if (getState().equals(State.INITIALIZING)) {
initialize();
}
LOGGER.debug("Starting configuration {}", this);
this.setStarting();
if (watchManager.getIntervalSeconds() >= 0) {
watchManager.start();
}
if (hasAsyncLoggers()) {
asyncLoggerConfigDisruptor.start();
}
final Set<LoggerConfig> alreadyStarted = new HashSet<>();
for (final LoggerConfig logger : loggerConfigs.values()) {
logger.start();
alreadyStarted.add(logger);
}
for (final Appender appender : appenders.values()) {
appender.start();
}
if (!alreadyStarted.contains(root)) { // LOG4J2-392
root.start(); // LOG4J2-336
}
super.start();
LOGGER.debug("Started configuration {} OK.", this);
}
private boolean hasAsyncLoggers() {
if (root instanceof AsyncLoggerConfig) {
return true;
}
for (final LoggerConfig logger : loggerConfigs.values()) {
if (logger instanceof AsyncLoggerConfig) {
return true;
}
}
return false;
}
/**
* Tear down the configuration.
*/
@Override
public boolean stop(final long timeout, final TimeUnit timeUnit) {
this.setStopping();
super.stop(timeout, timeUnit, false);
LOGGER.trace("Stopping {}...", this);
// Stop the components that are closest to the application first:
// 1. Notify all LoggerConfigs' ReliabilityStrategy that the configuration will be stopped.
// 2. Stop the LoggerConfig objects (this may stop nested Filters)
// 3. Stop the AsyncLoggerConfigDelegate. This shuts down the AsyncLoggerConfig Disruptor
// and waits until all events in the RingBuffer have been processed.
// 4. Stop all AsyncAppenders. This shuts down the associated thread and
// waits until all events in the queue have been processed. (With optional timeout.)
// 5. Notify all LoggerConfigs' ReliabilityStrategy that appenders will be stopped.
// This guarantees that any event received by a LoggerConfig before reconfiguration
// are passed on to the Appenders before the Appenders are stopped.
// 6. Stop the remaining running Appenders. (It should now be safe to do so.)
// 7. Notify all LoggerConfigs that their Appenders can be cleaned up.
for (final LoggerConfig loggerConfig : loggerConfigs.values()) {
loggerConfig.getReliabilityStrategy().beforeStopConfiguration(this);
}
root.getReliabilityStrategy().beforeStopConfiguration(this);
final String cls = getClass().getSimpleName();
LOGGER.trace("{} notified {} ReliabilityStrategies that config will be stopped.", cls, loggerConfigs.size()
+ 1);
if (!loggerConfigs.isEmpty()) {
LOGGER.trace("{} stopping {} LoggerConfigs.", cls, loggerConfigs.size());
for (final LoggerConfig logger : loggerConfigs.values()) {
logger.stop(timeout, timeUnit);
}
}
LOGGER.trace("{} stopping root LoggerConfig.", cls);
if (!root.isStopped()) {
root.stop(timeout, timeUnit);
}
if (hasAsyncLoggers()) {
LOGGER.trace("{} stopping AsyncLoggerConfigDisruptor.", cls);
asyncLoggerConfigDisruptor.stop(timeout, timeUnit);
}
LOGGER.trace("{} notifying ReliabilityStrategies that appenders will be stopped.", cls);
for (final LoggerConfig loggerConfig : loggerConfigs.values()) {
loggerConfig.getReliabilityStrategy().beforeStopAppenders();
}
root.getReliabilityStrategy().beforeStopAppenders();
// Stop the appenders in reverse order in case they still have activity.
final Appender[] array = appenders.values().toArray(new Appender[appenders.size()]);
final List<Appender> async = getAsyncAppenders(array);
if (!async.isEmpty()) {
// LOG4J2-511, LOG4J2-392 stop AsyncAppenders first
LOGGER.trace("{} stopping {} AsyncAppenders.", cls, async.size());
for (final Appender appender : async) {
if (appender instanceof LifeCycle2) {
((LifeCycle2) appender).stop(timeout, timeUnit);
} else {
appender.stop();
}
}
}
LOGGER.trace("{} stopping remaining Appenders.", cls);
int appenderCount = 0;
for (int i = array.length - 1; i >= 0; --i) {
if (array[i].isStarted()) { // then stop remaining Appenders
if (array[i] instanceof LifeCycle2) {
((LifeCycle2) array[i]).stop(timeout, timeUnit);
} else {
array[i].stop();
}
appenderCount++;
}
}
LOGGER.trace("{} stopped {} remaining Appenders.", cls, appenderCount);
LOGGER.trace("{} cleaning Appenders from {} LoggerConfigs.", cls, loggerConfigs.size() + 1);
for (final LoggerConfig loggerConfig : loggerConfigs.values()) {
// LOG4J2-520, LOG4J2-392:
// Important: do not clear appenders until after all AsyncLoggerConfigs
// have been stopped! Stopping the last AsyncLoggerConfig will
// shut down the disruptor and wait for all enqueued events to be processed.
// Only *after this* the appenders can be cleared or events will be lost.
loggerConfig.clearAppenders();
}
root.clearAppenders();
if (watchManager.isStarted()) {
watchManager.stop(timeout, timeUnit);
}
configurationScheduler.stop(timeout, timeUnit);
if (advertiser != null && advertisement != null) {
advertiser.unadvertise(advertisement);
}
setStopped();
LOGGER.debug("Stopped {} OK", this);
return true;
}
private List<Appender> getAsyncAppenders(final Appender[] all) {
final List<Appender> result = new ArrayList<>();
for (int i = all.length - 1; i >= 0; --i) {
if (all[i] instanceof AsyncAppender) {
result.add(all[i]);
}
}
return result;
}
@Override
public boolean isShutdownHookEnabled() {
return isShutdownHookEnabled;
}
@Override
public long getShutdownTimeoutMillis() {
return shutdownTimeoutMillis;
}
public void setup() {
// default does nothing, subclasses do work.
}
protected Level getDefaultStatus() {
final String statusLevel = PropertiesUtil.getProperties().getStringProperty(
Constants.LOG4J_DEFAULT_STATUS_LEVEL, Level.ERROR.name());
try {
return Level.toLevel(statusLevel);
} catch (final Exception ex) {
return Level.ERROR;
}
}
protected void createAdvertiser(final String advertiserString, final ConfigurationSource configSource,
final byte[] buffer, final String contentType) {
if (advertiserString != null) {
final Node node = new Node(null, advertiserString, null);
final Map<String, String> attributes = node.getAttributes();
attributes.put("content", new String(buffer));
attributes.put("contentType", contentType);
attributes.put("name", "configuration");
if (configSource.getLocation() != null) {
attributes.put("location", configSource.getLocation());
}
advertiserNode = node;
}
}
private void setupAdvertisement() {
if (advertiserNode != null) {
final String nodeName = advertiserNode.getName();
final PluginType<?> type = pluginManager.getPluginType(nodeName);
if (type != null) {
final Class<? extends Advertiser> clazz = type.getPluginClass().asSubclass(Advertiser.class);
try {
advertiser = clazz.newInstance();
advertisement = advertiser.advertise(advertiserNode.getAttributes());
} catch (final InstantiationException e) {
LOGGER.error("InstantiationException attempting to instantiate advertiser: {}", nodeName, e);
} catch (final IllegalAccessException e) {
LOGGER.error("IllegalAccessException attempting to instantiate advertiser: {}", nodeName, e);
}
}
}
}
@SuppressWarnings("unchecked")
@Override
public <T> T getComponent(final String componentName) {
return (T) componentMap.get(componentName);
}
@Override
public void addComponent(final String componentName, final Object obj) {
componentMap.putIfAbsent(componentName, obj);
}
protected void preConfigure(final Node node) {
try {
for (final Node child : node.getChildren()) {
if (child.getType() == null) {
LOGGER.error("Unable to locate plugin type for " + child.getName());
continue;
}
final Class<?> clazz = child.getType().getPluginClass();
if (clazz.isAnnotationPresent(Scheduled.class)) {
configurationScheduler.incrementScheduledItems();
}
preConfigure(child);
}
} catch (final Exception ex) {
LOGGER.error("Error capturing node data for node " + node.getName(), ex);
}
}
protected void doConfigure() {
preConfigure(rootNode);
configurationScheduler.start();
if (rootNode.hasChildren() && rootNode.getChildren().get(0).getName().equalsIgnoreCase("Properties")) {
final Node first = rootNode.getChildren().get(0);
createConfiguration(first, null);
if (first.getObject() != null) {
subst.setVariableResolver((StrLookup) first.getObject());
}
} else {
final Map<String, String> map = this.getComponent(CONTEXT_PROPERTIES);
final StrLookup lookup = map == null ? null : new MapLookup(map);
subst.setVariableResolver(new Interpolator(lookup, pluginPackages));
}
boolean setLoggers = false;
boolean setRoot = false;
for (final Node child : rootNode.getChildren()) {
if (child.getName().equalsIgnoreCase("Properties")) {
if (tempLookup == subst.getVariableResolver()) {
LOGGER.error("Properties declaration must be the first element in the configuration");
}
continue;
}
createConfiguration(child, null);
if (child.getObject() == null) {
continue;
}
if (child.getName().equalsIgnoreCase("Scripts")) {
for (final AbstractScript script : child.getObject(AbstractScript[].class)) {
if (script instanceof ScriptRef) {
LOGGER.error("Script reference to {} not added. Scripts definition cannot contain script references",
script.getName());
} else if (scriptManager != null) {
scriptManager.addScript(script);
}
}
} else if (child.getName().equalsIgnoreCase("Appenders")) {
appenders = child.getObject();
} else if (child.isInstanceOf(Filter.class)) {
addFilter(child.getObject(Filter.class));
} else if (child.getName().equalsIgnoreCase("Loggers")) {
final Loggers l = child.getObject();
loggerConfigs = l.getMap();
setLoggers = true;
if (l.getRoot() != null) {
root = l.getRoot();
setRoot = true;
}
} else if (child.getName().equalsIgnoreCase("CustomLevels")) {
customLevels = child.getObject(CustomLevels.class).getCustomLevels();
} else if (child.isInstanceOf(CustomLevelConfig.class)) {
final List<CustomLevelConfig> copy = new ArrayList<>(customLevels);
copy.add(child.getObject(CustomLevelConfig.class));
customLevels = copy;
} else {
final List<String> expected = Arrays.asList("\"Appenders\"", "\"Loggers\"", "\"Properties\"",
"\"Scripts\"", "\"CustomLevels\"");
LOGGER.error("Unknown object \"{}\" of type {} is ignored: try nesting it inside one of: {}.",
child.getName(), child.getObject().getClass().getName(), expected);
}
}
if (!setLoggers) {
LOGGER.warn("No Loggers were configured, using default. Is the Loggers element missing?");
setToDefault();
return;
} else if (!setRoot) {
LOGGER.warn("No Root logger was configured, creating default ERROR-level Root logger with Console appender");
setToDefault();
// return; // LOG4J2-219: creating default root=ok, but don't exclude configured Loggers
}
for (final Map.Entry<String, LoggerConfig> entry : loggerConfigs.entrySet()) {
final LoggerConfig loggerConfig = entry.getValue();
for (final AppenderRef ref : loggerConfig.getAppenderRefs()) {
final Appender app = appenders.get(ref.getRef());
if (app != null) {
loggerConfig.addAppender(app, ref.getLevel(), ref.getFilter());
} else {
LOGGER.error("Unable to locate appender \"{}\" for logger config \"{}\"", ref.getRef(),
loggerConfig);
}
}
}
setParents();
}
protected void setToDefault() {
// LOG4J2-1176 facilitate memory leak investigation
setName(DefaultConfiguration.DEFAULT_NAME + "@" + Integer.toHexString(hashCode()));
final Layout<? extends Serializable> layout = PatternLayout.newBuilder()
.withPattern(DefaultConfiguration.DEFAULT_PATTERN)
.withConfiguration(this)
.build();
final Appender appender = ConsoleAppender.createDefaultAppenderForLayout(layout);
appender.start();
addAppender(appender);
final LoggerConfig rootLoggerConfig = getRootLogger();
rootLoggerConfig.addAppender(appender, null, null);
final Level defaultLevel = Level.ERROR;
final String levelName = PropertiesUtil.getProperties().getStringProperty(DefaultConfiguration.DEFAULT_LEVEL,
defaultLevel.name());
final Level level = Level.valueOf(levelName);
rootLoggerConfig.setLevel(level != null ? level : defaultLevel);
}
/**
* Set the name of the configuration.
*
* @param name The name.
*/
public void setName(final String name) {
this.name = name;
}
/**
* Returns the name of the configuration.
*
* @return the name of the configuration.
*/
@Override
public String getName() {
return name;
}
/**
* Add a listener for changes on the configuration.
*
* @param listener The ConfigurationListener to add.
*/
@Override
public void addListener(final ConfigurationListener listener) {
listeners.add(listener);
}
/**
* Remove a ConfigurationListener.
*
* @param listener The ConfigurationListener to remove.
*/
@Override
public void removeListener(final ConfigurationListener listener) {
listeners.remove(listener);
}
/**
* Returns the Appender with the specified name.
*
* @param appenderName The name of the Appender.
* @return the Appender with the specified name or null if the Appender cannot be located.
*/
@Override
@SuppressWarnings("unchecked")
public <T extends Appender> T getAppender(final String appenderName) {
return appenderName != null ? (T) appenders.get(appenderName) : null;
}
/**
* Returns a Map containing all the Appenders and their name.
*
* @return A Map containing each Appender's name and the Appender object.
*/
@Override
public Map<String, Appender> getAppenders() {
return appenders;
}
/**
* Adds an Appender to the configuration.
*
* @param appender The Appender to add.
*/
@Override
public void addAppender(final Appender appender) {
if (appender != null) {
appenders.putIfAbsent(appender.getName(), appender);
}
}
@Override
public StrSubstitutor getStrSubstitutor() {
return subst;
}
@Override
public void setAdvertiser(final Advertiser advertiser) {
this.advertiser = advertiser;
}
@Override
public Advertiser getAdvertiser() {
return advertiser;
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.ReliabilityStrategyFactory#getReliabilityStrategy(org.apache.logging.log4j
* .core.config.LoggerConfig)
*/
@Override
public ReliabilityStrategy getReliabilityStrategy(final LoggerConfig loggerConfig) {
return ReliabilityStrategyFactory.getReliabilityStrategy(loggerConfig);
}
/**
* Associates an Appender with a LoggerConfig. This method is synchronized in case a Logger with the same name is
* being updated at the same time.
*
* Note: This method is not used when configuring via configuration. It is primarily used by unit tests.
*
* @param logger The Logger the Appender will be associated with.
* @param appender The Appender.
*/
@Override
public synchronized void addLoggerAppender(final org.apache.logging.log4j.core.Logger logger,
final Appender appender) {
if (appender == null || logger == null) {
return;
}
final String loggerName = logger.getName();
appenders.putIfAbsent(appender.getName(), appender);
final LoggerConfig lc = getLoggerConfig(loggerName);
if (lc.getName().equals(loggerName)) {
lc.addAppender(appender, null, null);
} else {
final LoggerConfig nlc = new LoggerConfig(loggerName, lc.getLevel(), lc.isAdditive());
nlc.addAppender(appender, null, null);
nlc.setParent(lc);
loggerConfigs.putIfAbsent(loggerName, nlc);
setParents();
logger.getContext().updateLoggers();
}
}
/**
* Associates a Filter with a LoggerConfig. This method is synchronized in case a Logger with the same name is being
* updated at the same time.
*
* Note: This method is not used when configuring via configuration. It is primarily used by unit tests.
*
* @param logger The Logger the Footer will be associated with.
* @param filter The Filter.
*/
@Override
public synchronized void addLoggerFilter(final org.apache.logging.log4j.core.Logger logger, final Filter filter) {
final String loggerName = logger.getName();
final LoggerConfig lc = getLoggerConfig(loggerName);
if (lc.getName().equals(loggerName)) {
lc.addFilter(filter);
} else {
final LoggerConfig nlc = new LoggerConfig(loggerName, lc.getLevel(), lc.isAdditive());
nlc.addFilter(filter);
nlc.setParent(lc);
loggerConfigs.putIfAbsent(loggerName, nlc);
setParents();
logger.getContext().updateLoggers();
}
}
/**
* Marks a LoggerConfig as additive. This method is synchronized in case a Logger with the same name is being
* updated at the same time.
*
* Note: This method is not used when configuring via configuration. It is primarily used by unit tests.
*
* @param logger The Logger the Appender will be associated with.
* @param additive True if the LoggerConfig should be additive, false otherwise.
*/
@Override
public synchronized void setLoggerAdditive(final org.apache.logging.log4j.core.Logger logger, final boolean additive) {
final String loggerName = logger.getName();
final LoggerConfig lc = getLoggerConfig(loggerName);
if (lc.getName().equals(loggerName)) {
lc.setAdditive(additive);
} else {
final LoggerConfig nlc = new LoggerConfig(loggerName, lc.getLevel(), additive);
nlc.setParent(lc);
loggerConfigs.putIfAbsent(loggerName, nlc);
setParents();
logger.getContext().updateLoggers();
}
}
/**
* Remove an Appender. First removes any associations between LoggerConfigs and the Appender, removes the Appender
* from this appender list and then stops the appender. This method is synchronized in case an Appender with the
* same name is being added during the removal.
*
* @param appenderName the name of the appender to remove.
*/
public synchronized void removeAppender(final String appenderName) {
for (final LoggerConfig logger : loggerConfigs.values()) {
logger.removeAppender(appenderName);
}
final Appender app = appenderName != null ? appenders.remove(appenderName) : null;
if (app != null) {
app.stop();
}
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.Configuration#getCustomLevels()
*/
@Override
public List<CustomLevelConfig> getCustomLevels() {
return Collections.unmodifiableList(customLevels);
}
/**
* Locates the appropriate LoggerConfig for a Logger name. This will remove tokens from the package name as
* necessary or return the root LoggerConfig if no other matches were found.
*
* @param loggerName The Logger name.
* @return The located LoggerConfig.
*/
@Override
public LoggerConfig getLoggerConfig(final String loggerName) {
LoggerConfig loggerConfig = loggerConfigs.get(loggerName);
if (loggerConfig != null) {
return loggerConfig;
}
String substr = loggerName;
while ((substr = NameUtil.getSubName(substr)) != null) {
loggerConfig = loggerConfigs.get(substr);
if (loggerConfig != null) {
return loggerConfig;
}
}
return root;
}
@Override
public LoggerContext getLoggerContext() {
return loggerContext.get();
}
/**
* Returns the root Logger.
*
* @return the root Logger.
*/
@Override
public LoggerConfig getRootLogger() {
return root;
}
/**
* Returns a Map of all the LoggerConfigs.
*
* @return a Map with each entry containing the name of the Logger and the LoggerConfig.
*/
@Override
public Map<String, LoggerConfig> getLoggers() {
return Collections.unmodifiableMap(loggerConfigs);
}
/**
* Returns the LoggerConfig with the specified name.
*
* @param loggerName The Logger name.
* @return The LoggerConfig or null if no match was found.
*/
public LoggerConfig getLogger(final String loggerName) {
return loggerConfigs.get(loggerName);
}
/**
* Add a loggerConfig. The LoggerConfig must already be configured with Appenders, Filters, etc. After addLogger is
* called LoggerContext.updateLoggers must be called.
*
* @param loggerName The name of the Logger.
* @param loggerConfig The LoggerConfig.
*/
@Override
public synchronized void addLogger(final String loggerName, final LoggerConfig loggerConfig) {
loggerConfigs.putIfAbsent(loggerName, loggerConfig);
setParents();
}
/**
* Remove a LoggerConfig.
*
* @param loggerName The name of the Logger.
*/
@Override
public synchronized void removeLogger(final String loggerName) {
loggerConfigs.remove(loggerName);
setParents();
}
@Override
public void createConfiguration(final Node node, final LogEvent event) {
final PluginType<?> type = node.getType();
if (type != null && type.isDeferChildren()) {
node.setObject(createPluginObject(type, node, event));
} else {
for (final Node child : node.getChildren()) {
createConfiguration(child, event);
}
if (type == null) {
if (node.getParent() != null) {
LOGGER.error("Unable to locate plugin for {}", node.getName());
}
} else {
node.setObject(createPluginObject(type, node, event));
}
}
}
/**
* Invokes a static factory method to either create the desired object or to create a builder object that creates
* the desired object. In the case of a factory method, it should be annotated with
* {@link org.apache.logging.log4j.core.config.plugins.PluginFactory}, and each parameter should be annotated with
* an appropriate plugin annotation depending on what that parameter describes. Parameters annotated with
* {@link org.apache.logging.log4j.core.config.plugins.PluginAttribute} must be a type that can be converted from a
* string using one of the {@link org.apache.logging.log4j.core.config.plugins.convert.TypeConverter TypeConverters}
* . Parameters with {@link org.apache.logging.log4j.core.config.plugins.PluginElement} may be any plugin class or
* an array of a plugin class. Collections and Maps are currently not supported, although the factory method that is
* called can create these from an array.
*
* Plugins can also be created using a builder class that implements
* {@link org.apache.logging.log4j.core.util.Builder}. In that case, a static method annotated with
* {@link org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute} should create the builder class, and
* the various fields in the builder class should be annotated similarly to the method parameters. However, instead
* of using PluginAttribute, one should use
* {@link org.apache.logging.log4j.core.config.plugins.PluginBuilderAttribute} where the default value can be
* specified as the default field value instead of as an additional annotation parameter.
*
* In either case, there are also annotations for specifying a
* {@link org.apache.logging.log4j.core.config.Configuration} (
* {@link org.apache.logging.log4j.core.config.plugins.PluginConfiguration}) or a
* {@link org.apache.logging.log4j.core.config.Node} (
* {@link org.apache.logging.log4j.core.config.plugins.PluginNode}).
*
* Although the happy path works, more work still needs to be done to log incorrect parameters. These will generally
* result in unhelpful InvocationTargetExceptions.
*
* @param type the type of plugin to create.
* @param node the corresponding configuration node for this plugin to create.
* @param event the LogEvent that spurred the creation of this plugin
* @return the created plugin object or {@code null} if there was an error setting it up.
* @see org.apache.logging.log4j.core.config.plugins.util.PluginBuilder
* @see org.apache.logging.log4j.core.config.plugins.visitors.PluginVisitor
* @see org.apache.logging.log4j.core.config.plugins.convert.TypeConverter
*/
private Object createPluginObject(final PluginType<?> type, final Node node, final LogEvent event) {
final Class<?> clazz = type.getPluginClass();
if (Map.class.isAssignableFrom(clazz)) {
try {
return createPluginMap(node);
} catch (final Exception e) {
LOGGER.warn("Unable to create Map for {} of class {}", type.getElementName(), clazz, e);
}
}
if (Collection.class.isAssignableFrom(clazz)) {
try {
return createPluginCollection(node);
} catch (final Exception e) {
LOGGER.warn("Unable to create List for {} of class {}", type.getElementName(), clazz, e);
}
}
return new PluginBuilder(type).withConfiguration(this).withConfigurationNode(node).forLogEvent(event).build();
}
private static Map<String, ?> createPluginMap(final Node node) {
final Map<String, Object> map = new LinkedHashMap<>();
for (final Node child : node.getChildren()) {
final Object object = child.getObject();
map.put(child.getName(), object);
}
return map;
}
private static Collection<?> createPluginCollection(final Node node) {
final List<Node> children = node.getChildren();
final Collection<Object> list = new ArrayList<>(children.size());
for (final Node child : children) {
final Object object = child.getObject();
list.add(object);
}
return list;
}
private void setParents() {
for (final Map.Entry<String, LoggerConfig> entry : loggerConfigs.entrySet()) {
final LoggerConfig logger = entry.getValue();
String key = entry.getKey();
if (!key.isEmpty()) {
final int i = key.lastIndexOf('.');
if (i > 0) {
key = key.substring(0, i);
LoggerConfig parent = getLoggerConfig(key);
if (parent == null) {
parent = root;
}
logger.setParent(parent);
} else {
logger.setParent(root);
}
}
}
}
/**
* Reads an InputStream using buffered reads into a byte array buffer. The given InputStream will remain open after
* invocation of this method.
*
* @param is the InputStream to read into a byte array buffer.
* @return a byte array of the InputStream contents.
* @throws IOException if the {@code read} method of the provided InputStream throws this exception.
*/
protected static byte[] toByteArray(final InputStream is) throws IOException {
final ByteArrayOutputStream buffer = new ByteArrayOutputStream();
int nRead;
final byte[] data = new byte[BUF_SIZE];
while ((nRead = is.read(data, 0, data.length)) != -1) {
buffer.write(data, 0, nRead);
}
return buffer.toByteArray();
}
@Override
public NanoClock getNanoClock() {
return nanoClock;
}
@Override
public void setNanoClock(final NanoClock nanoClock) {
this.nanoClock = Objects.requireNonNull(nanoClock, "nanoClock");
}
}
⏎ org/apache/logging/log4j/core/config/AbstractConfiguration.java
Or download all of them as a single archive file:
File name: log4j-core-2.14.1-sources.jar File size: 1281358 bytes Release date: 2021-03-06 Download
⇒ Source Code for Apache Log4j JDK Logging Adapter
⇐ Source Code for Apache Log4j API
2015-11-03, 83621👍, 0💬
Related Topics:
