or run

npx @tessl/cli init

Version

Tile

Overview

Evals

Files

docs

basic-logging.md fluent-logging.md index.md markers.md mdc.md service-providers.md

tile.json

tessl/maven-org-slf4j--slf4j-api

Simple Logging Facade for Java (SLF4J) API - a facade/abstraction layer for various logging frameworks.

Workspace: tessl
Visibility: Public
Created: 3 months ago
Last updated: 3 months ago
Describes: pkg:maven/org.slf4j/slf4j-api@2.0.x

To install, run

npx @tessl/cli install tessl/maven-org-slf4j--slf4j-api@2.0.0

SLF4J API

SLF4J (Simple Logging Facade for Java) is a logging facade that serves as an abstraction layer for various Java logging frameworks including java.util.logging, logback, reload4j, log4j 2.x, and logevents. The API allows developers to write logging code independent of any specific logging implementation, enabling runtime pluggability of logging frameworks.

SLF4J 2.0 introduces a modern fluent API while maintaining full backward compatibility with the traditional 1.x API.

Package Information

Package Name: slf4j-api
Package Type: maven
Language: Java

Installation:

<dependency>
  <groupId>org.slf4j</groupId>
  <artifactId>slf4j-api</artifactId>
  <version>2.0.17</version>
</dependency>

Core Imports

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

For event-based logging (SLF4J 2.0):

import org.slf4j.event.Level;
import org.slf4j.spi.LoggingEventBuilder;
import java.util.function.Supplier;

Basic Usage

import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

public class MyClass {
    private static final Logger logger = LoggerFactory.getLogger(MyClass.class);
    
    public void doSomething() {
        // Traditional logging
        logger.info("Starting processing");
        logger.debug("Processing item: {}", item.getName());
        logger.warn("Issue detected: {}", issue);
        logger.error("Failed to process", exception);
        
        // Fluent API (SLF4J 2.0)
        logger.atInfo()
            .addArgument(user.getId())
            .addKeyValue("action", "login")
            .log("User {} logged in");
    }
}

Architecture

SLF4J consists of several key components:

LoggerFactory: Static factory for obtaining Logger instances and managing service providers
Logger Interface: Main logging contract with methods for all log levels
Service Provider Interface: Pluggable architecture allowing different logging implementations
MDC (Mapped Diagnostic Context): Thread-local storage for contextual information
Markers: Named objects for enriching and categorizing log statements
Fluent API: Modern chainable logging interface introduced in SLF4J 2.0
Event System: Structured logging events with lazy evaluation support

Capabilities

Basic Logging Operations

Traditional logging interface with methods for all standard log levels (TRACE, DEBUG, INFO, WARN, ERROR). Includes parameter substitution and exception handling.

public interface Logger {
    String getName();
    
    // Level checking methods
    boolean isTraceEnabled();
    boolean isDebugEnabled();  
    boolean isInfoEnabled();
    boolean isWarnEnabled();
    boolean isErrorEnabled();
    boolean isEnabledForLevel(Level level);
    
    // Basic logging methods
    void trace(String msg);
    void debug(String msg);
    void info(String msg);
    void warn(String msg);
    void error(String msg);
    
    // Parameterized logging methods
    void info(String format, Object arg);
    void info(String format, Object arg1, Object arg2);
    void info(String format, Object... arguments);
    void info(String msg, Throwable t);
    
    // Fluent API entry points
    LoggingEventBuilder atTrace();
    LoggingEventBuilder atDebug();
    LoggingEventBuilder atInfo();
    LoggingEventBuilder atWarn();
    LoggingEventBuilder atError();
    LoggingEventBuilder atLevel(Level level);
    
    // Builder factory method (for SPI implementers)
    LoggingEventBuilder makeLoggingEventBuilder(Level level);
}

public final class LoggerFactory {
    public static Logger getLogger(String name);
    public static Logger getLogger(Class<?> clazz);
    public static ILoggerFactory getILoggerFactory();
}

Basic Logging

Fluent Logging API

Modern chainable logging interface introduced in SLF4J 2.0. Supports structured logging with key-value pairs, lazy evaluation, and builder pattern for complex log statements.

public interface Logger {
    LoggingEventBuilder atTrace();
    LoggingEventBuilder atDebug();
    LoggingEventBuilder atInfo();
    LoggingEventBuilder atWarn();
    LoggingEventBuilder atError();
    LoggingEventBuilder atLevel(Level level);
}

public interface LoggingEventBuilder {
    LoggingEventBuilder setCause(Throwable cause);
    LoggingEventBuilder addMarker(Marker marker);
    LoggingEventBuilder addArgument(Object p);
    LoggingEventBuilder addArgument(Supplier<?> objectSupplier);
    LoggingEventBuilder addKeyValue(String key, Object value);
    LoggingEventBuilder addKeyValue(String key, Supplier<Object> valueSupplier);
    LoggingEventBuilder setMessage(String message);
    LoggingEventBuilder setMessage(Supplier<String> messageSupplier);
    void log();
    void log(String message);
    void log(String message, Object arg);
    void log(String message, Object arg0, Object arg1);
    void log(String message, Object... args);
    void log(Supplier<String> messageSupplier);
}

public enum Level {
    ERROR, WARN, INFO, DEBUG, TRACE;
    
    int toInt();
    static Level intToLevel(int levelInt);
}

Fluent Logging

Marker-Based Logging

Named objects for enriching and categorizing log statements. Markers can contain references to other markers and are evaluated by underlying logging implementations for filtering and routing.

public interface Marker {
    String getName();
    void add(Marker reference);
    boolean remove(Marker reference);
    boolean contains(Marker other);
    boolean contains(String name);
    boolean hasReferences();
}

public class MarkerFactory {
    public static Marker getMarker(String name);
    public static Marker getDetachedMarker(String name);
    public static IMarkerFactory getIMarkerFactory();
}

// Logger methods with marker support
public interface Logger {
    void info(Marker marker, String msg);
    void info(Marker marker, String format, Object arg);
    void info(Marker marker, String format, Object... arguments);
    boolean isInfoEnabled(Marker marker);
}

Markers

Mapped Diagnostic Context (MDC)

Thread-local contextual information storage for associating diagnostic data with log statements. Supports both key-value maps and stack-based operations.

public class MDC {
    // Basic MDC operations
    public static void put(String key, String val);
    public static String get(String key);
    public static void remove(String key);
    public static void clear();
    
    // Context map operations
    public static Map<String, String> getCopyOfContextMap();
    public static void setContextMap(Map<String, String> contextMap);
    
    // Stack operations (SLF4J 2.0)
    public static void pushByKey(String key, String value);
    public static String popByKey(String key);
    public static Deque<String> getCopyOfDequeByKey(String key);
    
    // Auto-cleanup support
    public static MDCCloseable putCloseable(String key, String val);
}

MDC Operations

Service Provider Interface

Pluggable architecture enabling different logging framework implementations. Provides factory interfaces and service provider contracts for extending SLF4J.

public interface SLF4JServiceProvider {
    ILoggerFactory getLoggerFactory();
    IMarkerFactory getMarkerFactory();
    MDCAdapter getMDCAdapter();
    String getRequestedApiVersion();
    void initialize();
}

public interface ILoggerFactory {
    Logger getLogger(String name);
}

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

Service Providers

Types

Core Types

// Logger factory interface
public interface ILoggerFactory {
    Logger getLogger(String name);
}

// Marker factory interface  
public interface IMarkerFactory {
    Marker getMarker(String name);
    boolean exists(String name);
    Marker getDetachedMarker(String name);
}

// MDC adapter interface
public 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);
    void pushByKey(String key, String value);
    String popByKey(String key);
    Deque<String> getCopyOfDequeByKey(String key);
}

// Auto-closeable MDC wrapper
public static class MDC.MDCCloseable implements Closeable {
    public void close();
}

Event Types

// Logging event interface
public interface LoggingEvent {
    Level getLevel();
    String getLoggerName();
    String getMessage();
    List<Object> getArguments();
    Object[] getArgumentArray();
    List<Marker> getMarkers();
    List<KeyValuePair> getKeyValuePairs();
    Throwable getThrowable();
    long getTimeStamp();
    String getThreadName();
    String getCallerBoundary();
}

// Key-value pair for structured logging
public class KeyValuePair {
    public final String key;
    public final Object value;
    
    public KeyValuePair(String key, Object value);
    public String toString();
    public boolean equals(Object o);
    public int hashCode();
}

Constants

// Logger constants
public interface Logger {
    String ROOT_LOGGER_NAME = "ROOT";
}

// Marker constants
public interface Marker {
    String ANY_MARKER = "*";
    String ANY_NON_NULL_MARKER = "+";
}

// Level integer constants
public class EventConstants {
    public static final int ERROR_INT = 40;
    public static final int WARN_INT = 30;
    public static final int INFO_INT = 20;
    public static final int DEBUG_INT = 10;
    public static final int TRACE_INT = 0;
}