[logback-user] Implementing MDC with ServerSocketReceiver

30 Jul 2019

      Hi,

I'm trying to implement a TCP server which logs to different appenders
depending on the message content. I'm using ServerSocketReceiver and
SiftingAppender strategy based on MDC value.

Here's my snippet:

siftingAppender.setAppenderFactory((Context context1, String
discriminatingValue) -> {

    Appender appender;
    if (DISCRIMINATOR_DEFAULT_VALUE.equals(discriminatingValue)) {
        ConsoleAppender<ILoggingEvent> consoleAppender = new
ConsoleAppender<>();
        consoleAppender.setContext(context);
        consoleAppender.setEncoder(consoleOnlyEncoder(context));
        consoleAppender.setName("MY_CONSOLE_APPENDER");
        consoleAppender.start();
        appender = consoleAppender;
    } else {
        RollingFileAppender rollingFileAppender =
rollingFileAppender("MY_ROLLING_APPENDER",
                "myPrefix." + discriminatingValue + ".%d{yyyy-MM-dd_HH-mm}.log",
                context);

        AsyncAppender asyncAppender =
asyncAppender(rollingFileAppender, context);

        appender = asyncAppender;
    }

    return appender;
});

Let's say that my MDC discriminator key is "filename". My first challenge
with this approach is that the MDC value is not serialized and sent to
server. So, I changed the message format to "filename={},msg{}" and I
created a Turbo Filter, which would check if the rawMessage is equal to
this expression and, if so, It would log using the MDC discriminator.
Here's the snippet:

private static void addMDCInterceptorTurboFilter(LoggerContext context) {
    String regex =
DISCRIMINATOR_KEY.concat("={},").concat(MESSAGE_KEY).concat("={}"); //
"filename={},msg={}"

    TurboFilter mdcInterceptorFilter = new TurboFilter() {
        @Override
        public FilterReply decide(Marker marker,
ch.qos.logback.classic.Logger logger, Level level,
                                  String rawMessage, Object[] params,
Throwable t) {

            if (params != null && regex.equals(rawMessage)) {
                MDC.put(DISCRIMINATOR_KEY, (String) params[0]);
                logger.log(marker, this.getClass().getName(),
Level.toLocationAwareLoggerInteger(level),
                        (String) params[1], null, null);
                MDC.remove(DISCRIMINATOR_KEY);

                return FilterReply.DENY;
            }

            return FilterReply.NEUTRAL;
        }
    };
    context.addTurboFilter(mdcInterceptorFilter);
    mdcInterceptorFilter.setName("MY_MDC_INTERCEPTOR_FILTER");
    mdcInterceptorFilter.start();
}

My challenge in the above approach is that neither the *rawMessage* nor
*params* are populated at this time. So I can't set the MDC properly.
Another approach that I tried was to set the filter to the SiftingAppender and
set the MDC there, but it didn't work either. Here's the snippet:

private Filter<ILoggingEvent> addMDCInterceptorFilter(String
keyDiscriminator, String messageKey) {
    String regex =
keyDiscriminator.concat("={},").concat(messageKey).concat("={}");
    Filter<ILoggingEvent> filter = new Filter<ILoggingEvent>() {
        @Override
        public FilterReply decide(ILoggingEvent event) {
            if (regex.equals(event.getMessage())) {
                MDC.put(keyDiscriminator, (String)event.getArgumentArray()[0]);
            } else {
                MDC.remove(keyDiscriminator);
            }

            return FilterReply.NEUTRAL;
        }
    };
    filter.start();
    return filter;
}

Could you guys guide me how to accomplish this scenario ? Please find the
full source for sake of completeness.

Thanks,

import ch.qos.logback.classic.AsyncAppender;
import ch.qos.logback.classic.Level;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.encoder.PatternLayoutEncoder;
import ch.qos.logback.classic.net.server.ServerSocketReceiver;
import ch.qos.logback.classic.sift.MDCBasedDiscriminator;
import ch.qos.logback.classic.sift.SiftingAppender;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.turbo.TurboFilter;
import ch.qos.logback.core.Appender;
import ch.qos.logback.core.ConsoleAppender;
import ch.qos.logback.core.Context;
import ch.qos.logback.core.encoder.Encoder;
import ch.qos.logback.core.rolling.RollingFileAppender;
import ch.qos.logback.core.rolling.RollingPolicy;
import ch.qos.logback.core.rolling.TimeBasedRollingPolicy;
import ch.qos.logback.core.spi.FilterReply;
import ch.qos.logback.core.util.StatusPrinter;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
import org.slf4j.Marker;

import java.nio.charset.Charset;

public class MySocketServer {

    private static final String DISCRIMINATOR_KEY = "filename";
    private static final String DISCRIMINATOR_DEFAULT_VALUE = "unknown";
    private static final String MESSAGE_KEY = "msg";

    public static void main(String[] args) throws InterruptedException {
        LoggerContext context = (LoggerContext)
LoggerFactory.getILoggerFactory();
        StatusPrinter.print(context);

        addMDCInterceptorTurboFilter(context);

        newServerSocketReceiver(context);
        addAppenders(context);

        Thread.sleep(Long.MAX_VALUE);
    }

    private static void newServerSocketReceiver(LoggerContext context) {
        ServerSocketReceiver serverSocketReceiver = new ServerSocketReceiver();
        serverSocketReceiver.setContext(context);
        serverSocketReceiver.setPort(6000);
        serverSocketReceiver.setAddress("localhost");
        serverSocketReceiver.start();
    }

    private static void addAppenders(LoggerContext context) {
        SiftingAppender siftingAppender = siftingAppender(context);

        ch.qos.logback.classic.Logger logger =
context.getLogger(ch.qos.logback.classic.Logger.ROOT_LOGGER_NAME);
        logger.detachAndStopAllAppenders();
        logger.addAppender(siftingAppender);
    }

    private static SiftingAppender siftingAppender(LoggerContext context) {
        SiftingAppender siftingAppender = new SiftingAppender();
        siftingAppender.setContext(context);
        siftingAppender.setName("MY_SIFT_APPENDER");
        siftingAppender.setDiscriminator(getMdcBasedDiscriminator(context));

        siftingAppender.setAppenderFactory((Context context1, String
discriminatingValue) -> {

            Appender appender;
            if (DISCRIMINATOR_DEFAULT_VALUE.equals(discriminatingValue)) {
                ConsoleAppender<ILoggingEvent> consoleAppender = new
ConsoleAppender<>();
                consoleAppender.setContext(context);
                consoleAppender.setEncoder(consoleOnlyEncoder(context));
                consoleAppender.setName("MY_CONSOLE_APPENDER");
                consoleAppender.start();
                appender = consoleAppender;
            } else {
                RollingFileAppender rollingFileAppender =
rollingFileAppender("MY_ROLLING_APPENDER",
                        "myPrefix." + discriminatingValue +
".%d{yyyy-MM-dd_HH-mm}.log",
                        context);

                AsyncAppender asyncAppender =
asyncAppender(rollingFileAppender, context);

                appender = asyncAppender;
            }

            return appender;
        });

        siftingAppender.start();
        return siftingAppender;
    }

    private static AsyncAppender asyncAppender(Appender appender,
LoggerContext context) {
        AsyncAppender asyncAppender = new AsyncAppender();
        asyncAppender.setContext(context);
        asyncAppender.setName("MY_ASYNC_BACKUP_APPENDER");
        asyncAppender.setQueueSize(512);
        asyncAppender.addAppender(appender);
        asyncAppender.start();
        return asyncAppender;
    }

    private static MDCBasedDiscriminator
getMdcBasedDiscriminator(LoggerContext context) {
        MDCBasedDiscriminator discriminator = new MDCBasedDiscriminator();
        discriminator.setContext(context);
        discriminator.setKey(DISCRIMINATOR_KEY);
        discriminator.setDefaultValue(DISCRIMINATOR_DEFAULT_VALUE);
        discriminator.start();
        return discriminator;
    }

    private static RollingFileAppender rollingFileAppender(String name,
                                                    String fileNamePattern,
                                                    LoggerContext context) {
        RollingFileAppender rollingFileAppender = new RollingFileAppender();
        rollingFileAppender.setContext(context);
        rollingFileAppender.setRollingPolicy(timeBasedRollingPolicy(rollingFileAppender,
fileNamePattern, context));
        rollingFileAppender.setEncoder(messageOnlyEncoder(context));
        rollingFileAppender.setName(name);
        rollingFileAppender.start();
        return rollingFileAppender;
    }

    private static RollingPolicy
timeBasedRollingPolicy(RollingFileAppender rollingFileAppender,
                                                 String fileNamePattern,
                                                 LoggerContext context) {
        final TimeBasedRollingPolicy timeBasedRollingPolicy = new
TimeBasedRollingPolicy();
        timeBasedRollingPolicy.setContext(context);
        timeBasedRollingPolicy.setFileNamePattern(fileNamePattern);
        timeBasedRollingPolicy.setParent(rollingFileAppender);
        timeBasedRollingPolicy.start();
        return timeBasedRollingPolicy;
    }

    private static Encoder messageOnlyEncoder(LoggerContext context) {
        final PatternLayoutEncoder patternLayoutEncoder = new
PatternLayoutEncoder();
        patternLayoutEncoder.setPattern("%mdc %msg%n");
        patternLayoutEncoder.setCharset(Charset.forName("utf-8"));
        patternLayoutEncoder.setContext(context);
        patternLayoutEncoder.start();
        return patternLayoutEncoder;
    }

    private static Encoder consoleOnlyEncoder(LoggerContext context) {
        final PatternLayoutEncoder patternLayoutEncoder = new
PatternLayoutEncoder();
        patternLayoutEncoder.setPattern("%-4relative [%thread]
%-5level %logger{35} - %msg %n");
        patternLayoutEncoder.setCharset(Charset.forName("utf-8"));
        patternLayoutEncoder.setContext(context);
        patternLayoutEncoder.start();
        return patternLayoutEncoder;
    }

    private static void addMDCInterceptorTurboFilter(LoggerContext context) {
        String regex =
DISCRIMINATOR_KEY.concat("={},").concat(MESSAGE_KEY).concat("={}"); //
"filename={},msg={}"

        TurboFilter mdcInterceptorFilter = new TurboFilter() {
            @Override
            public FilterReply decide(Marker marker,
ch.qos.logback.classic.Logger logger, Level level,
                                      String rawMessage, Object[]
params, Throwable t) {

                if (params != null && regex.equals(rawMessage)) {
                    MDC.put(DISCRIMINATOR_KEY, (String) params[0]);
                    logger.log(marker, this.getClass().getName(),
Level.toLocationAwareLoggerInteger(level),
                            (String) params[1], null, null);
                    MDC.remove(DISCRIMINATOR_KEY);

                    return FilterReply.DENY;
                }

                return FilterReply.NEUTRAL;
            }
        };
        context.addTurboFilter(mdcInterceptorFilter);
        mdcInterceptorFilter.setName("MY_MDC_INTERCEPTOR_FILTER");
        mdcInterceptorFilter.start();
    }
}

[logback-user] Implementing MDC with ServerSocketReceiver

Joaquim Jose