Log4j2: Ability to log data with different log levels in multi user environment

Question

I'm using log4j2 in oracle adf 12c application.

One of the requirements of our customer is to have different log levels for different logged-in users and also to change the log levels dynamically for a user.Also the Administrator should have a control to stop all the logging.

i.e Lets say 'User A' needs Trace log level and 'User B' needs Error log level. If both the users are logged in simultaneously, the application should log in Trace level for 'User A' and in Error level for 'User B'. And if the 'User B' wants to log in FATAL level he should be able to change the configuration dynamically.

Following is the log4j2 config file.

    <?xml version="1.0" encoding="UTF-8"?>
<Configuration status="trace">
    <MapFilter onMatch="ACCEPT" operator="or">
        <KeyValuePair key="$${ctx:LOGLEVELYN}" value="Y"/>
    </MapFilter>
    <Appenders>
        <File name="file" fileName="./adfAppCustomLogs/TestLog4j2.log">
            <PatternLayout>
                <Pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} %-5level %class %L %M - %msg%xEx%n</Pattern>
            </PatternLayout>
        </File>
        <Console name="STDOUT" target="SYSTEM_OUT">
            <PatternLayout pattern="%m%n"/>
        </Console>
        <Routing name="AppRouting">
            <Routes pattern="$${ctx:LOGGEDSESSIONID}">
                <!-- This route is chosen if ThreadContext has no value for key ROUTINGKEY. -->
                <Route key="$${ctx:LOGGEDSESSIONID}">
                    <RollingFile name="Rolling-ALL" fileName="./adfAppCustomLogs/DefaultAll.log"
                                 filePattern="./adfAppCustomLogs/archive/${date:yyyy-MM}/DefaultAll-%d{MM-dd-yyyy}-%i.txt.gz">
                        <PatternLayout>
                            <Pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} %-5level %t %msg%xEx%n</Pattern>
                        </PatternLayout>
                        <Policies>
                            <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
                            <SizeBasedTriggeringPolicy size="10 MB"/>
                        </Policies>
                    </RollingFile>
                </Route>
                <!-- This route is chosen if ThreadContext has value 'user' for key ROUTINGKEY. -->
                <Route>
                    <RollingFile name="Rolling-OTHER-${ctx:LOGGEDSESSIONID}"
                                 fileName="./adfAppCustomLogs/${ctx:LOGINID}-${ctx:LOGGEDSESSIONID}.log"
                                 filePattern="./adfAppCustomLogs/archive/${date:yyyy-MM}/${ctx:LOGINID}-%d{MM-dd-yyyy}-%i.txt.gz">
                        <PatternLayout>
                            <Pattern>%d{YYYY-MM-dd HH:mm:ss.SSS} %-5level %t %msg%xEx%n</Pattern>
                        </PatternLayout>
                        <Policies>
                            <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
                            <SizeBasedTriggeringPolicy size="10 MB"/>
                        </Policies>
                        <!-- <DefaultRolloverStrategy max="100"/> -->
                    </RollingFile>
                </Route>
            </Routes>
        </Routing>
        <Async name="async" bufferSize="1000" includeLocation="true">
            <AppenderRef ref="AppRouting"/>
        </Async>
    </Appenders>
    <Loggers>
        <Root level="trace">
            <!--<AppenderRef ref="file" level="DEBUG"/> -->
            <AppenderRef ref="async"/>
            <!-- Uncomment the following if you want the log to be printed in weblogic console -->
             <AppenderRef ref="STDOUT"/> 
        </Root>
    </Loggers>
</Configuration>

I'm trying to create multiple loggers with a different loglevel for each one but nothing worked.

It would be great if you can give me some pointers or hints.

Answer 1

One of the requirements of our customer is to have different log levels for different logged-in users and also to change the log levels dynamically for a user. Also the Administrator should have a control to stop all the logging.

This would require having a separate logger for each user which I assume means for each Thread. Obviously you can't possibly configure all of these loggers in advance since you don't know how many users you will have at runtime. Therefore you need to dynamically create the loggers at runtime with calls to the log4j2 APIs. You can refer to the log4j2 manual for the full details.

Furthermore you will need to create administrative controls that will allow access to the log4j2 configuration and provide the ability to modify the configuration at runtime.

Here is a small example of how you can achieve the goal of having one logger per Thread and how to change the log level during runtime:

Here is the log4j2.xml configuration file:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="WARN">
    <Appenders>
        <Console name="STDOUT" target="SYSTEM_OUT">
            <PatternLayout pattern="%m%n" />
        </Console>
    </Appenders>
    <Loggers>
        <Logger name="example" level="trace">
            <AppenderRef ref="STDOUT" />
        </Logger>
        <Root level="WARN">
            <AppenderRef ref="STDOUT" />
        </Root>
    </Loggers>
</Configuration>

Here is the java code:

package example;
import org.apache.logging.log4j.Level;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.core.LoggerContext;
import org.apache.logging.log4j.core.config.AppenderRef;
import org.apache.logging.log4j.core.config.Configuration;
import org.apache.logging.log4j.core.config.LoggerConfig;

public class LogLvlByThreadMain {

    public static void main(String[] args) {
        Thread t1 = new Thread(new Runnable(){

            public void run() {
                addLogger(Thread.currentThread().getName());

                Logger log = LogManager.getLogger(Thread.currentThread().getName());
                log.info("here's the first thread");
                try {
                    Thread.sleep(5000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                log.debug("some debug in first thread");
                log.info("finishing first thread");
            }}, "Thread1");

        Thread t2 = new Thread(new Runnable(){

            public void run() {
                addLogger(Thread.currentThread().getName());

                Logger log = LogManager.getLogger(Thread.currentThread().getName());
                log.info("here's the second thread");

                changeLogLevel(Thread.currentThread().getName(), Level.DEBUG);

                log.debug("some debug in second thread");
            }}, "Thread2");

        t1.start();
        t2.start();
    }

    public static synchronized void addLogger(String name){
        AppenderRef ref = AppenderRef.createAppenderRef("STDOUT", null, null);
        AppenderRef[] refs = new AppenderRef[] {ref};

        LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
        Configuration config = ctx.getConfiguration();
        LoggerConfig loggerConfig = LoggerConfig.createLogger("false", Level.INFO, name,
                "true", refs, null, config, null );

        loggerConfig.addAppender(config.getAppender("STDOUT"), null, null);
        config.addLogger(name, loggerConfig);
        ctx.updateLoggers();
    }

    public static synchronized void changeLogLevel(String loggerName, Level lvl){
        LoggerContext ctx = (LoggerContext) LogManager.getContext(false);
        Configuration config = ctx.getConfiguration();
        LoggerConfig loggerCfg = config.getLoggerConfig(loggerName);
        loggerCfg.setLevel(lvl);
        ctx.updateLoggers();
    }

}

Note that you will have to think about synchronization problems with multiple threads changing the logging configuration on the fly - notice how the two methods above that alter the configuration are synchronized.

Output from the above code:

here's the second thread
here's the first thread
some debug in second thread
finishing first thread

This proves that the two threads have different log levels because if we had changed both of them we would have seen two "debug" logs not just the one from the second thread.