Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance. Project price only 1 $
You can buy this project and download/modify it how often you want.
/*
* 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.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 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.LogEvent;
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.WatchManager;
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 listeners = new CopyOnWriteArrayList<>();
/**
* Packages found in configuration "packages" attribute.
*/
protected final List pluginPackages = new ArrayList<>();
/**
* The plugin manager.
*/
protected PluginManager pluginManager;
/**
* Shutdown hook is enabled by default.
*/
protected boolean isShutdownHookEnabled = true;
/**
* 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 appenders = new ConcurrentHashMap<>();
private ConcurrentMap loggerConfigs = new ConcurrentHashMap<>();
private List customLevels = Collections.emptyList();
private final ConcurrentMap properties = new ConcurrentHashMap<>();
private final StrLookup tempLookup = new Interpolator(properties);
private final StrSubstitutor subst = new StrSubstitutor(tempLookup);
private LoggerConfig root = new LoggerConfig();
private final ConcurrentMap 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();
/**
* Constructor.
*/
protected AbstractConfiguration(final ConfigurationSource configurationSource) {
this.configurationSource = Objects.requireNonNull(configurationSource, "configurationSource is null");
componentMap.put(Configuration.CONTEXT_PROPERTIES, properties);
pluginManager = new PluginManager(Node.CATEGORY);
rootNode = new Node();
setState(State.INITIALIZING);
}
@Override
public ConfigurationSource getConfigurationSource() {
return configurationSource;
}
@Override
public List getPluginPackages() {
return pluginPackages;
}
@Override
public Map getProperties() {
return properties;
}
@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("Initializing configuration {}", this);
subst.setConfiguration(this);
scriptManager = new ScriptManager(watchManager);
pluginManager.collectPlugins(pluginPackages);
final PluginManager levelPlugins = new PluginManager(Level.CATEGORY);
levelPlugins.collectPlugins(pluginPackages);
final Map> 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);
}
/**
* 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 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 void stop() {
this.setStopping();
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();
}
}
LOGGER.trace("{} stopping root LoggerConfig.", cls);
if (!root.isStopped()) {
root.stop();
}
if (hasAsyncLoggers()) {
LOGGER.trace("{} stopping AsyncLoggerConfigDisruptor.", cls);
asyncLoggerConfigDisruptor.stop();
}
// Stop the appenders in reverse order in case they still have activity.
final Appender[] array = appenders.values().toArray(new Appender[appenders.size()]);
final List 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) {
appender.stop();
}
}
LOGGER.trace("{} notifying ReliabilityStrategies that appenders will be stopped.", cls);
for (final LoggerConfig loggerConfig : loggerConfigs.values()) {
loggerConfig.getReliabilityStrategy().beforeStopAppenders();
}
root.getReliabilityStrategy().beforeStopAppenders();
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
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();
}
configurationScheduler.stop();
super.stop();
if (advertiser != null && advertisement != null) {
advertiser.unadvertise(advertisement);
}
LOGGER.debug("Stopped {} OK", this);
}
private List getAsyncAppenders(final Appender[] all) {
final List 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;
}
public void setup() {
}
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 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 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 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 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 {
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 copy = new ArrayList<>(customLevels);
copy.add(child.getObject(CustomLevelConfig.class));
customLevels = copy;
} else {
final List 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 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 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 getAppender(final String appenderName) {
return (T) appenders.get(appenderName);
}
/**
* 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 getAppenders() {
return appenders;
}
/**
* Adds an Appender to the configuration.
*
* @param appender The Appender to add.
*/
@Override
public void addAppender(final Appender appender) {
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) {
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 = appenders.remove(appenderName);
if (app != null) {
app.stop();
}
}
/*
* (non-Javadoc)
*
* @see org.apache.logging.log4j.core.config.Configuration#getCustomLevels()
*/
@Override
public List 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;
}
/**
* 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 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 createPluginMap(final Node node) {
final Map 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 children = node.getChildren();
final Collection
