or run

npx @tessl/cli init
Log in

Version

Tile

Overview

Evals

Files

docs

index.md
tile.json

tessl/maven-org-apache-logging-log4j--log4j-slf4j-impl

SLF4J 1 binding that forwards SLF4J logging calls to the Log4j 2 API

Workspace
tessl
Visibility
Public
Created
Last updated
Describes
mavenpkg:maven/org.apache.logging.log4j/log4j-slf4j-impl@2.25.x

To install, run

npx @tessl/cli install tessl/maven-org-apache-logging-log4j--log4j-slf4j-impl@2.25.0

index.mddocs/

Log4j SLF4J Implementation

Log4j SLF4J Implementation is a binding library that enables applications using the SLF4J 1.x logging facade to seamlessly integrate with Apache Log4j 2's logging implementation. It acts as a bridge between the SLF4J API and Log4j 2's core functionality, forwarding all SLF4J logging calls to the Log4j 2 API while preserving logging levels, markers, and MDC (Mapped Diagnostic Context) information.

Package Information

  • Package Name: log4j-slf4j-impl
  • Package Type: Maven
  • Group ID: org.apache.logging.log4j
  • Artifact ID: log4j-slf4j-impl
  • Language: Java
  • Installation: Add to Maven pom.xml:
<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j-slf4j-impl</artifactId>
    <version>2.25.1</version>
</dependency>

For Gradle:

implementation 'org.apache.logging.log4j:log4j-slf4j-impl:2.25.1'

Core Imports

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
import org.slf4j.MDC;

Basic Usage

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.Marker;
import org.slf4j.MarkerFactory;
import org.slf4j.MDC;

public class Example {
    private static final Logger logger = LoggerFactory.getLogger(Example.class);
    
    public void demonstrateLogging() {
        // Basic logging
        logger.info("Application started");
        logger.debug("Debug message with parameter: {}", "value");
        logger.error("Error occurred", new RuntimeException("Example exception"));
        
        // Marker-based logging
        Marker importantMarker = MarkerFactory.getMarker("IMPORTANT");
        logger.warn(importantMarker, "Important warning message");
        
        // MDC (Mapped Diagnostic Context) usage
        MDC.put("userId", "12345");
        MDC.put("sessionId", "abc-def-ghi");
        logger.info("User action performed"); // Will include MDC context
        MDC.clear();
    }
}

Architecture

The log4j-slf4j-impl library implements the SLF4J Service Provider Interface (SPI) pattern, providing three key binding components that SLF4J automatically discovers at runtime:

  • StaticLoggerBinder: Entry point for logger factory binding, manages logger creation through Log4j
  • StaticMarkerBinder: Entry point for marker factory binding, handles marker creation and management
  • StaticMDCBinder: Entry point for MDC adapter binding, delegates MDC operations to Log4j's ThreadContext

The implementation classes provide full SLF4J compatibility while leveraging Log4j 2's advanced features like asynchronous logging, flexible configuration, and high performance. This design ensures applications can migrate from other logging frameworks to Log4j 2 without requiring code changes at the application layer.

Capabilities

SLF4J Logger Factory Binding

The binding entry point that enables SLF4J to use Log4j 2 as the underlying logging implementation.

public final class StaticLoggerBinder implements LoggerFactoryBinder {
    public static String REQUESTED_API_VERSION = "1.6";
    public static StaticLoggerBinder getSingleton();
    public ILoggerFactory getLoggerFactory();
    public String getLoggerFactoryClassStr();
}

SLF4J Marker Factory Binding

The binding entry point for marker operations, delegating to Log4j's marker system.

public class StaticMarkerBinder implements MarkerFactoryBinder {
    public static final StaticMarkerBinder SINGLETON;
    public static StaticMarkerBinder getSingleton();
    public IMarkerFactory getMarkerFactory();
    public String getMarkerFactoryClassStr();
}

SLF4J MDC Binding

The binding entry point for Mapped Diagnostic Context operations, delegating to Log4j's ThreadContext.

public final class StaticMDCBinder {
    public static final StaticMDCBinder SINGLETON;
    public static StaticMDCBinder getSingleton();
    public MDCAdapter getMDCA();
    public String getMDCAdapterClassStr();
}

Log4j Logger Factory Implementation

Log4j implementation of SLF4J's ILoggerFactory interface, responsible for creating and managing logger instances.

public class Log4jLoggerFactory extends AbstractLoggerAdapter<Logger> implements ILoggerFactory {
    public Log4jLoggerFactory(Log4jMarkerFactory markerFactory);
    Log4jMarkerFactory getMarkerFactory();
    // Inherited from ILoggerFactory:
    // public Logger getLogger(String name);
}

Log4j Logger Implementation

SLF4J logger implementation that forwards all logging calls to Log4j's ExtendedLogger.

public class Log4jLogger implements LocationAwareLogger, Serializable {
    public static final String FQCN = "org.apache.logging.slf4j.Log4jLogger";
    
    // Trace level logging
    public void trace(String format);
    public void trace(String format, Object arg);
    public void trace(String format, Object arg1, Object arg2);
    public void trace(String format, Object... args);
    public void trace(String format, Throwable t);
    public boolean isTraceEnabled();
    public boolean isTraceEnabled(Marker marker);
    public void trace(Marker marker, String s);
    public void trace(Marker marker, String s, Object o);
    public void trace(Marker marker, String s, Object o, Object o1);
    public void trace(Marker marker, String s, Object... objects);
    public void trace(Marker marker, String s, Throwable throwable);
    
    // Debug level logging
    public void debug(String format);
    public void debug(String format, Object arg);
    public void debug(String format, Object arg1, Object arg2);
    public void debug(String format, Object... args);
    public void debug(String format, Throwable t);
    public boolean isDebugEnabled();
    public boolean isDebugEnabled(Marker marker);
    public void debug(Marker marker, String s);
    public void debug(Marker marker, String s, Object o);
    public void debug(Marker marker, String s, Object o, Object o1);
    public void debug(Marker marker, String s, Object... objects);
    public void debug(Marker marker, String s, Throwable throwable);
    
    // Info level logging
    public void info(String format);
    public void info(String format, Object arg);
    public void info(String format, Object arg1, Object arg2);
    public void info(String format, Object... args);
    public void info(String format, Throwable t);
    public boolean isInfoEnabled();
    public boolean isInfoEnabled(Marker marker);
    public void info(Marker marker, String s);
    public void info(Marker marker, String s, Object o);
    public void info(Marker marker, String s, Object o, Object o1);
    public void info(Marker marker, String s, Object... objects);
    public void info(Marker marker, String s, Throwable throwable);
    
    // Warn level logging
    public void warn(String format);
    public void warn(String format, Object arg);
    public void warn(String format, Object arg1, Object arg2);
    public void warn(String format, Object... args);
    public void warn(String format, Throwable t);
    public boolean isWarnEnabled();
    public boolean isWarnEnabled(Marker marker);
    public void warn(Marker marker, String s);
    public void warn(Marker marker, String s, Object o);
    public void warn(Marker marker, String s, Object o, Object o1);
    public void warn(Marker marker, String s, Object... objects);
    public void warn(Marker marker, String s, Throwable throwable);
    
    // Error level logging
    public void error(String format);
    public void error(String format, Object arg);
    public void error(String format, Object arg1, Object arg2);
    public void error(String format, Object... args);
    public void error(String format, Throwable t);
    public boolean isErrorEnabled();
    public boolean isErrorEnabled(Marker marker);
    public void error(Marker marker, String s);
    public void error(Marker marker, String s, Object o);
    public void error(Marker marker, String s, Object o, Object o1);
    public void error(Marker marker, String s, Object... objects);
    public void error(Marker marker, String s, Throwable throwable);
    
    // LocationAwareLogger interface
    public void log(Marker marker, String fqcn, int level, String message, Object[] params, Throwable throwable);
    
    // Logger interface
    public String getName();
}

Log4j Marker Factory Implementation

Log4j/SLF4J bridge for creating and managing SLF4J Markers based on Log4j markers.

public class Log4jMarkerFactory implements IMarkerFactory {
    public Marker getMarker(String name);
    public Marker getMarker(Marker marker);
    public boolean exists(String name);
    public boolean detachMarker(String name); // Always returns false
    public Marker getDetachedMarker(String name); // Returns regular marker
}

Log4j Marker Implementation

SLF4J Marker implementation that bridges to Log4j's marker system.

public class Log4jMarker implements Marker {
    public static final long serialVersionUID = 1590472L;
    
    public void add(Marker marker);
    public boolean contains(Marker marker);
    public boolean contains(String s);
    public String getName();
    public boolean hasChildren();
    public boolean hasReferences();
    public Iterator<Marker> iterator();
    public boolean remove(Marker marker);
    public boolean equals(Object obj);
    public int hashCode();
}

Log4j MDC Adapter Implementation

MDC adapter that delegates all operations to Log4j's ThreadContext.

public class Log4jMDCAdapter implements MDCAdapter {
    public void put(String key, String val);
    public String get(String key);
    public void remove(String key);
    public void clear();
    public Map<String, String> getCopyOfContextMap();
    public void setContextMap(Map<String, String> map);
}

SLF4J Logging Exception

Exception thrown when the SLF4J adapter encounters problems.

public class SLF4JLoggingException extends RuntimeException {
    public SLF4JLoggingException(String msg);
    public SLF4JLoggingException(String msg, Exception ex);
    public SLF4JLoggingException(Exception ex);
}

Throwable Consuming Message Factory

Message factory that eagerly removes trailing throwable arguments following Logback's algorithm.

public final class ThrowableConsumingMessageFactory implements MessageFactory2 {
    public Message newMessage(Object message);
    public Message newMessage(String message);
    public Message newMessage(String message, Object... params);
    public Message newMessage(CharSequence charSequence);
    public Message newMessage(String message, Object p0);
    public Message newMessage(String message, Object p0, Object p1);
    public Message newMessage(String message, Object p0, Object p1, Object p2);
    public Message newMessage(String message, Object p0, Object p1, Object p2, Object p3);
    public Message newMessage(String message, Object p0, Object p1, Object p2, Object p3, Object p4);
    public Message newMessage(String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5);
    public Message newMessage(String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6);
    public Message newMessage(String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6, Object p7);
    public Message newMessage(String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6, Object p7, Object p8);
    public Message newMessage(String message, Object p0, Object p1, Object p2, Object p3, Object p4, Object p5, Object p6, Object p7, Object p8, Object p9);
}

Types

SLF4J Standard Types

These are the standard SLF4J interfaces that the binding implementations provide:

// From SLF4J API
interface Logger {
    String ROOT_LOGGER_NAME = "ROOT";
    String getName();
    // Logging methods (implemented by Log4jLogger)
}

interface LocationAwareLogger extends Logger {
    int TRACE_INT = 00;
    int DEBUG_INT = 10;
    int INFO_INT = 20;
    int WARN_INT = 30;
    int ERROR_INT = 40;
    
    void log(Marker marker, String fqcn, int level, String message, Object[] argArray, Throwable t);
}

interface Marker extends Serializable {
    String getName();
    void add(Marker reference);
    boolean remove(Marker reference);
    boolean hasChildren();
    boolean hasReferences();
    Iterator<Marker> iterator();
    boolean contains(Marker other);
    boolean contains(String name);
    boolean equals(Object o);
    int hashCode();
}

interface ILoggerFactory {
    Logger getLogger(String name);
}

interface IMarkerFactory {
    Marker getMarker(String name);
    boolean exists(String name);
    boolean detachMarker(String name);
    Marker getDetachedMarker(String name);
}

interface MDCAdapter {
    void put(String key, String val);
    String get(String key);
    void remove(String key);
    void clear();
    Map<String, String> getCopyOfContextMap();
    void setContextMap(Map<String, String> contextMap);
}

Log4j 2 Core Types

These are key Log4j 2 types that the implementation uses internally:

// From Log4j 2 API (used internally)
interface ExtendedLogger {
    void logIfEnabled(String fqcn, Level level, org.apache.logging.log4j.Marker marker, 
                      String message, Object... params);
    boolean isEnabled(Level level, org.apache.logging.log4j.Marker marker, String message);
    void logMessage(String fqcn, Level level, org.apache.logging.log4j.Marker marker, 
                    Message message, Throwable t);
}

interface MessageFactory2 {
    Message newMessage(Object message);
    Message newMessage(String message);
    Message newMessage(String message, Object... params);
    // Additional overloads...
}

interface Message {
    String getFormattedMessage();
    String getFormat();
    Object[] getParameters();
    Throwable getThrowable();
}

Important Notes

  • Mutual Exclusivity: This library cannot coexist with log4j-to-slf4j (the reverse bridge) in the same classpath as they serve opposite purposes
  • Automatic Discovery: SLF4J automatically discovers and uses this binding when it's present on the classpath
  • MDC Integration: All MDC operations are transparently forwarded to Log4j's ThreadContext
  • Marker Compatibility: SLF4J markers are converted to Log4j markers preserving parent-child relationships
  • Serialization Support: Log4jLogger supports Java serialization for distributed logging scenarios
  • Location Awareness: The binding preserves caller location information for accurate log source reporting
  • Performance: Leverages Log4j 2's high-performance logging implementation including asynchronous logging capabilities