org.apache.geode.internal.logging.log4j.LogWriterAppender Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of geode-core Show documentation
Show all versions of geode-core Show documentation
Apache Geode provides a database-like consistency model, reliable transaction processing and a shared-nothing architecture to maintain very low latency performance with high concurrency processing
/*
* 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.geode.internal.logging.log4j;
import java.beans.PropertyChangeEvent;
import java.beans.PropertyChangeListener;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import org.apache.geode.internal.logging.LogConfig;
import org.apache.geode.internal.logging.LogService;
import org.apache.geode.internal.logging.ManagerLogWriter;
import org.apache.geode.internal.logging.PureLogWriter;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.core.LogEvent;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.appender.AbstractAppender;
import org.apache.logging.log4j.core.config.LoggerConfig;
import org.apache.logging.log4j.core.layout.PatternLayout;
/**
* A Log4j Appender which will copy all output to a LogWriter.
*
*/
public class LogWriterAppender extends AbstractAppender implements PropertyChangeListener {
private static final org.apache.logging.log4j.Logger logger = LogService.getLogger();
/** Is this thread in the process of appending? */
private static final ThreadLocal appending = new ThreadLocal() {
@Override
protected Boolean initialValue() {
return Boolean.FALSE;
}
};
private final PureLogWriter logWriter;
private final FileOutputStream fos; // TODO:LOG:CLEANUP: why do we track this outside
// ManagerLogWriter? doesn't rolling invalidate it?
private final AppenderContext[] appenderContexts;
private final String appenderName;
private final String logWriterLoggerName;
private LogWriterAppender(final AppenderContext[] appenderContexts, final String name,
final PureLogWriter logWriter, final FileOutputStream fos) {
super(LogWriterAppender.class.getName() + "-" + name, null,
PatternLayout.createDefaultLayout());
this.appenderContexts = appenderContexts;
this.appenderName = LogWriterAppender.class.getName() + "-" + name;
this.logWriterLoggerName = name;
this.logWriter = logWriter;
this.fos = fos;
}
/**
* Used by LogWriterAppenders and tests to create a new instance.
*
* @return The new instance.
*/
static final LogWriterAppender create(final AppenderContext[] contexts, final String name,
final PureLogWriter logWriter, final FileOutputStream fos) {
LogWriterAppender appender = new LogWriterAppender(contexts, name, logWriter, fos);
for (AppenderContext context : appender.appenderContexts) {
context.getLoggerContext().addPropertyChangeListener(appender);
}
appender.start();
for (AppenderContext context : appender.appenderContexts) {
context.getLoggerConfig().addAppender(appender, Level.ALL, null);
}
return appender;
}
@Override
public void append(final LogEvent event) {
// If already appending then don't send to avoid infinite recursion
if ((appending.get())) {
return;
}
appending.set(Boolean.TRUE);
try {
this.logWriter.put(LogWriterLogger.log4jLevelToLogWriterLevel(event.getLevel()),
event.getMessage().getFormattedMessage(), event.getThrown());
} finally {
appending.set(Boolean.FALSE);
}
}
@Override
public synchronized void propertyChange(final PropertyChangeEvent evt) {
if (logger.isDebugEnabled()) {
logger.debug("Responding to a property change event. Property name is {}.",
evt.getPropertyName());
}
if (evt.getPropertyName().equals(LoggerContext.PROPERTY_CONFIG)) {
for (AppenderContext context : this.appenderContexts) {
LoggerConfig loggerConfig = context.getLoggerConfig();
if (!loggerConfig.getAppenders().containsKey(this.appenderName)) {
loggerConfig.addAppender(this, Level.ALL, null);
}
}
}
}
/**
* Stop the appender and remove it from the Log4j configuration.
*/
protected void destroy() { // called 1st during disconnect
// add stdout appender to MAIN_LOGGER_NAME only if isUsingGemFireDefaultConfig -- see #51819
if (LogService.MAIN_LOGGER_NAME.equals(this.logWriterLoggerName)
&& LogService.isUsingGemFireDefaultConfig()) {
LogService.restoreConsoleAppender();
}
for (AppenderContext context : this.appenderContexts) {
context.getLoggerContext().removePropertyChangeListener(this);
context.getLoggerConfig().removeAppender(appenderName);
}
for (AppenderContext context : this.appenderContexts) { // do this second as log4j 2.6+ will
// re-add
context.getLoggerContext().updateLoggers();
}
stop();
cleanUp(); // 3rd
if (logger.isDebugEnabled()) {
logger.debug("A LogWriterAppender has been destroyed and cleanup is finished.");
}
}
private void cleanUp() { // was closingLogFile() -- called from destroy() as the final step
if (this.logWriter instanceof ManagerLogWriter) {
((ManagerLogWriter) this.logWriter).closingLogFile();
}
if (this.fos != null) {
try {
this.fos.close();
} catch (IOException ignore) {
}
}
}
@Override
public void stop() {
try {
if (this.logWriter instanceof ManagerLogWriter) {
((ManagerLogWriter) this.logWriter).shuttingDown();
}
} catch (RuntimeException e) {
logger.warn("RuntimeException encountered while shuttingDown LogWriterAppender", e);
}
super.stop();
}
protected void startupComplete() {
if (this.logWriter instanceof ManagerLogWriter) {
((ManagerLogWriter) this.logWriter).startupComplete();
}
}
protected void setConfig(final LogConfig cfg) {
if (this.logWriter instanceof ManagerLogWriter) {
((ManagerLogWriter) this.logWriter).setConfig(cfg);
}
}
public File getChildLogFile() {
if (this.logWriter instanceof ManagerLogWriter) {
return ((ManagerLogWriter) this.logWriter).getChildLogFile();
} else {
return null;
}
}
public File getLogDir() {
if (this.logWriter instanceof ManagerLogWriter) {
return ((ManagerLogWriter) this.logWriter).getLogDir();
} else {
return null;
}
}
public int getMainLogId() {
if (this.logWriter instanceof ManagerLogWriter) {
return ((ManagerLogWriter) this.logWriter).getMainLogId();
} else {
return -1;
}
}
public boolean useChildLogging() {
if (this.logWriter instanceof ManagerLogWriter) {
return ((ManagerLogWriter) this.logWriter).useChildLogging();
} else {
return false;
}
}
protected void configChanged() {
if (this.logWriter instanceof ManagerLogWriter) {
((ManagerLogWriter) this.logWriter).configChanged();
}
}
}