Log4j2 日志未指向正确的日志文件

Question

I am facing an issue with configuring log4j2 logs programmatically.

Please see the below code, I am creating 2 objects of the class App3, and I want to create 2 debug log files(a log file per App3 object), thereafter each object should be able to log to corresponding log file.

But my code is logging all the logs to the second log file after 2nd log is created. Can someone help on this.

Output of the program

file Name: app3_logger1.log_debug.log

2020-06-16 16:19:31,100 DEBUG app3_logger1.log [main] Hello from Log4j 2app3_logger1

file Name: app3_logger2.log_debug.log

2020-06-16 16:19:31,211 DEBUG app3_logger2.log [main] Hello from Log4j 2app3_logger2
2020-06-16 16:19:31,216 DEBUG app3_logger2.log [main] Hello from Log4j 2app3_logger2
2020-06-16 16:19:31,216 DEBUG app3_logger1.log [main] Hello from Log4j 2app3_logger1
2020-06-16 16:19:31,216 DEBUG app3_logger1.log [main] Hello from Log4j 2app3_logger1
2020-06-16 16:19:31,217 DEBUG app3_logger2.log [main] Hello from Log4j 2app3_logger2

Java Class - you just need to add log4j2 dependencies to compile

public class App3 {

public Logger logger;

public static void main(String[] args) {
    App3 app1 = new App3();
    app1.initializeYourLogger("app3_logger1.log", "%d %p %c [%t] %m%n");
    app1.testProg("app3_logger1");
    App3 app2 = new App3();
    app2.initializeYourLogger("app3_logger2.log", "%d %p %c [%t] %m%n");
    app2.testProg("app3_logger2");

    app2.testProg("app3_logger2");
    app1.testProg("app3_logger1");
    app1.testProg("app3_logger1");
    app2.testProg("app3_logger2");

}

public void testProg(String s) {
    logger.debug("Hello from Log4j 2" + s);
}

public void initializeYourLogger(String fileName, String pattern) {
    this.logger = LogManager.getLogger(fileName);
    ConfigurationBuilder<BuiltConfiguration> builder = ConfigurationBuilderFactory.newConfigurationBuilder();

    builder.setStatusLevel(Level.DEBUG);
    builder.setConfigurationName(fileName);

    AppenderComponentBuilder componentBuilder = builder.newAppender("log", "File");
    componentBuilder.add(builder.newLayout("PatternLayout").addAttribute("pattern", pattern));
    RootLoggerComponentBuilder rootLogger = builder.newRootLogger(Level.DEBUG);

    LayoutComponentBuilder layoutBuilder = builder.newLayout("PatternLayout").addAttribute("pattern", pattern);
    ComponentBuilder triggeringPolicy = builder.newComponent("Policies")
            .addComponent(builder.newComponent("SizeBasedTriggeringPolicy").addAttribute("size", "10MB"));

    componentBuilder = builder.newAppender("LogToRollingErrorFile", "RollingFile")
            .add(builder.newFilter("ThresholdFilter", Filter.Result.ACCEPT, Filter.Result.DENY)
                    .addAttribute("level", Level.ERROR))
            .addAttribute("fileName", fileName + "_error.log")
            .addAttribute("filePattern", fileName + "-%d{MM-dd-yy-HH-mm-ss}_error.log").add(layoutBuilder)
            .addComponent(triggeringPolicy);
    builder.add(componentBuilder);

    componentBuilder = builder.newAppender("LogToRollingDebugFile", "RollingFile")
            .add(builder.newFilter("ThresholdFilter", Filter.Result.ACCEPT, Filter.Result.DENY)
                    .addAttribute("level", Level.DEBUG))
            .addAttribute("fileName", fileName + "_debug.log")
            .addAttribute("filePattern", fileName + "-%d{MM-dd-yy-HH-mm-ss}_debug.log").add(layoutBuilder)
            .addComponent(triggeringPolicy);
    builder.add(componentBuilder);

    AppenderRefComponentBuilder rollingError = rootLogger.getBuilder().newAppenderRef("LogToRollingErrorFile");
    AppenderRefComponentBuilder rollingDebug = rootLogger.getBuilder().newAppenderRef("LogToRollingDebugFile");
    rootLogger.add(rollingError);
    rootLogger.add(rollingDebug);
    builder.add(rootLogger);
    Configurator.reconfigure(builder.build());
}

}

This is exactly what I want to do in log4j older version, I am still struggling with log4j2,

    private void initLogger(String serviceName, String instance) throws IOException {
    String loggerName = serviceName+"_"+instance;
    this.logger = Logger.getLogger(loggerName);
    this.logger.removeAllAppenders();

    PatternLayout layout = new PatternLayout();
    layout.setConversionPattern("%d: %m%n");

    String loggingFolder = this.properties.getLoggingFolder();
    String debugFileName = loggingFolder+"/"+loggerName+"_debug.log";
    String errorFileName = loggingFolder+"/"+loggerName+"_error.log";

    RollingFileAppender debugAppender = new RollingFileAppender(layout, debugFileName, true);
    debugAppender.setThreshold(Level.DEBUG);
    debugAppender.setMaxFileSize("10000000");
    debugAppender.setMaxBackupIndex(49);
    logger.addAppender(debugAppender);

    RollingFileAppender errorAppender = new RollingFileAppender(layout, errorFileName, true);
    errorAppender.setThreshold(Level.ERROR);
    errorAppender.setMaxFileSize("10000000");
    errorAppender.setMaxBackupIndex(49);
    logger.addAppender(debugAppender);
}

Answer 1

Actually, I am quite sure your Logger is being updated correctly. The problem is that both application instances are going to use the same Logging configuration.

If you look at Log4j's architecture you will see that the Loggers and the configuration are anchored in the LoggerContext. By default, Log4j uses the ClassLoaderContextSelector, which means that every ClassLoader can have its own LoggerContext. Your sample application only has a single ClassLoader and so will only have a single LoggerContext and, therefore, only a single Configuration.

So when you reconfigured the second time you simply replaced the prior configuration with the new one. Since the root logger is handling all log events it will route the events from both Loggers you have created to the file created in the second configuration.

If you want logs to end up in two different files then create a configuration with both files and figure out a way to route them to the correct file, either via logger names or filters.

Answer 2

As per observation, your logger is updated with the last initialization so after app2.initializeYourLogger() your object-level logger object updated with App2 configuration.

You need to return the logger object from initializeYourLogger() and also create separate Logger object.