mdc does not showed up anymore when using logback.getMDCPropertyMap()

[bomanarakasura-unipin]

Hello, I was using old Otel Instrumentation v2.2.0-alpha.

Current problem

I have a custom Logger using Logback and this is a plain Java object that is not required to be registered using Bean or Configuration. You guys can just copy this code.

import ch.qos.logback.classic.Logger;
import ch.qos.logback.classic.LoggerContext;
import ch.qos.logback.classic.pattern.ThrowableHandlingConverter;
import ch.qos.logback.classic.pattern.ThrowableProxyConverter;
import ch.qos.logback.classic.spi.ILoggingEvent;
import ch.qos.logback.classic.spi.IThrowableProxy;
import ch.qos.logback.contrib.jackson.JacksonJsonFormatter;
import ch.qos.logback.contrib.json.JsonLayoutBase;
import ch.qos.logback.core.ConsoleAppender;
import ch.qos.logback.core.CoreConstants;
import com.fasterxml.jackson.databind.ObjectMapper;
import org.slf4j.LoggerFactory;

import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;

public class JsonLogFactory {

    public static Logger getLogger(Class<?> className) {

        final List<String> envs = List.of("dev", "staging", "production");
        final String env = System.getenv().getOrDefault("environment", "local");

        final Boolean isCloud = envs.contains(env);

        final LoggerContext logCtx = (LoggerContext) LoggerFactory.getILoggerFactory();

        final JacksonJsonFormatter jacksonJsonFormatter = new JacksonJsonFormatter();
        jacksonJsonFormatter.setPrettyPrint(true);

        final CustomJsonLayout jsonLayout = new CustomJsonLayout();
        jsonLayout.setJsonFormatter(jacksonJsonFormatter);
        jsonLayout.setTimestampFormat("yyyy-MM-dd' 'HH:mm:ssZ");
        jsonLayout.setAppendLineSeparator(true);
        jsonLayout.setCloud(isCloud);

        final ConsoleAppender logConsoleAppender = new ConsoleAppender();
        logConsoleAppender.setContext(logCtx);
        logConsoleAppender.setName("consoleJson");
        logConsoleAppender.setLayout(jsonLayout);
        logConsoleAppender.start();

        final Logger log = logCtx.getLogger(className);
        log.setAdditive(false);
        log.addAppender(logConsoleAppender);
        return log;
    }

}

class CustomJsonLayout extends JsonLayoutBase<ILoggingEvent> {
    public static final String TIMESTAMP_ATTR_NAME = "timestamp";
    public static final String LEVEL_ATTR_NAME = "level";
    public static final String THREAD_ATTR_NAME = "thread";
    public static final String MDC_ATTR_NAME = "mdc";
    public static final String LOGGER_ATTR_NAME = "logger";
    public static final String FORMATTED_MESSAGE_ATTR_NAME = "message";
    public static final String MESSAGE_ATTR_NAME = "raw-message";
    public static final String EXCEPTION_ATTR_NAME = "exception";
    public static final String CONTEXT_ATTR_NAME = "context";
    public static final String TRACE_INFORMATION = "trace-information";

    protected boolean includeLevel;
    protected boolean includeThreadName;
    protected boolean includeMDC;
    protected boolean includeLoggerName;
    protected boolean includeFormattedMessage;
    protected boolean includeMessage;
    protected boolean includeException;
    protected boolean includeContextName;
    protected boolean includeTraceInformation;
    protected boolean isCloud;

    private ThrowableHandlingConverter throwableProxyConverter;

    public CustomJsonLayout() {
        super();
        this.includeLevel = true;
        this.includeThreadName = true;
        this.includeMDC = true;
        this.includeLoggerName = true;
        this.includeFormattedMessage = true;
        this.includeException = true;
        this.includeContextName = true;
        this.throwableProxyConverter = new ThrowableProxyConverter();
        this.includeTraceInformation = true;
    }

    @Override
    public String doLayout(ILoggingEvent event) {
        final Map map = toJsonMap(event);
        if (map  == null || map.isEmpty()) {
            return null;
        }
        final ObjectMapper objectMapper = new ObjectMapper();
        String result = null;
        try {
            result = getJsonFormatter().toJsonString(map);
            if (isCloud) {
                result = result.replace("\n", "\r");
            }
            return isAppendLineSeparator() ? result + CoreConstants.LINE_SEPARATOR : result;
        } catch (Exception e) {
            return null;
        }
    }

    @Override
    public void start() {
        this.throwableProxyConverter.start();
        super.start();
    }

    @Override
    public void stop() {
        super.stop();
        this.throwableProxyConverter.stop();
    }

    @Override
    protected Map toJsonMap(ILoggingEvent event) {

        final Map<String, Object> map = new LinkedHashMap<String, Object>();

        addTimestamp(TIMESTAMP_ATTR_NAME, this.includeTimestamp, event.getTimeStamp(), map);
        add(LEVEL_ATTR_NAME, this.includeLevel, String.valueOf(event.getLevel()), map);
        add(THREAD_ATTR_NAME, this.includeThreadName, event.getThreadName(), map);
        addMap(MDC_ATTR_NAME, this.includeMDC, event.getMDCPropertyMap(), map);
        add(LOGGER_ATTR_NAME, this.includeLoggerName, event.getLoggerName(), map);
        add(FORMATTED_MESSAGE_ATTR_NAME, this.includeFormattedMessage, getObjectMessage(event.getFormattedMessage()), map);
        add(MESSAGE_ATTR_NAME, this.includeMessage, event.getMessage(), map);
        add(CONTEXT_ATTR_NAME, this.includeContextName, event.getLoggerContextVO().getName(), map);
        addThrowableInfo(EXCEPTION_ATTR_NAME, this.includeException, event, map);
        addCustomDataToJsonMap(map, event);
        add(TRACE_INFORMATION, this.includeTraceInformation, printTraceInformation(event.getCallerData()[0]), map);
        return map;
    }
    private String printTraceInformation(StackTraceElement callerDatum) {
        return String.format("%s at line %d", callerDatum.getClassName(), callerDatum.getLineNumber());
    }

    private void add(String fieldName, boolean field, Object value, Map<String, Object> map) {
        if (field && value != null) {
            map.put(fieldName, value);
        }
    }

    private Object getObjectMessage(String message) {
        try {
            return ConfiguredObjectMapper.readValue(message, HashMap.class);
        } catch (Exception e) {
            return message;
        }

    }

    protected void addThrowableInfo(String fieldName, boolean field, ILoggingEvent value, Map<String, Object> map) {
        if (field && value != null) {
            final IThrowableProxy throwableProxy = value.getThrowableProxy();
            if (throwableProxy != null) {
                String ex = throwableProxyConverter.convert(value);
                if (ex != null && !ex.equals("")) {
                    map.put(fieldName, ex);
                }
            }
        }
    }

    protected void addCustomDataToJsonMap(Map<String, Object> map, ILoggingEvent event) {
        // Nothing to do in default implementation
    }

    public boolean isIncludeLevel() {
        return includeLevel;
    }

    public void setIncludeLevel(boolean includeLevel) {
        this.includeLevel = includeLevel;
    }

    public boolean isIncludeLoggerName() {
        return includeLoggerName;
    }

    public void setIncludeLoggerName(boolean includeLoggerName) {
        this.includeLoggerName = includeLoggerName;
    }

    public boolean isIncludeFormattedMessage() {
        return includeFormattedMessage;
    }

    public void setIncludeFormattedMessage(boolean includeFormattedMessage) {
        this.includeFormattedMessage = includeFormattedMessage;
    }

    public boolean isIncludeMessage() {
        return includeMessage;
    }

    public void setIncludeMessage(boolean includeMessage) {
        this.includeMessage = includeMessage;
    }

    public boolean isIncludeMDC() {
        return includeMDC;
    }

    public void setIncludeMDC(boolean includeMDC) {
        this.includeMDC = includeMDC;
    }

    public boolean isIncludeThreadName() {
        return includeThreadName;
    }

    public void setIncludeThreadName(boolean includeThreadName) {
        this.includeThreadName = includeThreadName;
    }

    public boolean isIncludeException() {
        return includeException;
    }

    public void setIncludeException(boolean includeException) {
        this.includeException = includeException;
    }

    public boolean isIncludeContextName() {
        return includeContextName;
    }

    public void setIncludeContextName(boolean includeContextName) {
        this.includeContextName = includeContextName;
    }

    public boolean isIncludeTraceInformation() {
        return includeTraceInformation;
    }

    public void setIncludeTraceInformation(boolean includeTraceInformation) {
        this.includeTraceInformation = includeTraceInformation;
    }

    public boolean isCloud() {
        return isCloud;
    }

    public void setCloud(boolean cloud) {
        isCloud = cloud;
    }

    public ThrowableHandlingConverter getThrowableProxyConverter() {
        return throwableProxyConverter;
    }

    public void setThrowableProxyConverter(ThrowableHandlingConverter throwableProxyConverter) {
        this.throwableProxyConverter = throwableProxyConverter;
    }
}

Above code prints mdc to console like this :

{
  "timestamp" : "2025-10-13 13:47:23+0700",
  "level" : "INFO",
  "thread" : "http-nio-8083-exec-1",
  "mdc" : {
    "traceId" : "888bde93c8985d18ff07f1a981c6b8e1",
    "spanId" : "f9de7067761f5a80"
  },

Take a look on that mdc object.

But after I updated the version to Otel Instrumentation 2.20.1 and Otel 1.54.1, mdc map does not showed up anymore.

How to reproduce

1. Create spring application
2. Add followings dependencies (in this case I am using Gradle), you can replace api with implementation :

(platform("io.opentelemetry:opentelemetry-bom:1.36.0"))
(platform("io.opentelemetry.instrumentation:opentelemetry-instrumentation-bom-alpha:2.2.0-alpha"))
api("io.opentelemetry:opentelemetry-exporter-otlp")
api("io.micrometer:micrometer-tracing-bridge-otel")
api("io.micrometer:micrometer-registry-otlp")

4. Create a class containing custom logger above.
5. Create an endpoint for testing, put a logger inside the endpoint's method.

@RestEndpoint
public class ExampleClass {
   private final Logger log = JsonLogFactory.getLogger(ExampleClass::class);

   @Get
   public ResponseEntity exampleEndpoint() {
     log.info("Testing log here");
     return ResponseEntity();
  }
}

Then, try to run your spring application, you will see mdc object on your log.

However, if you update the opentelemetry bom, the mdc object disappeared from your console log.

[laurit]

If you want someone to take a look then provide a minimal application that illustrates your issue along with any necessary instructions.

[bomanarakasura-unipin]

Sure, I have added more context to the question.

[laurit]

Providing a github repo that one could just clone and run would increase the chances of this getting looked at.