tessl/maven-org-slf4j--log4j-over-slf4j

Log4j 1.x API compatibility layer that implements Apache Log4j API over SLF4J for seamless migration

—

Pending

Overview

Eval results

Files

Core Logging

Name: tessl/maven-org-slf4j--log4j-over-slf4j
Author: tessl

Primary logging functionality providing logger creation, level checking, and message logging at all standard Log4j levels. All logging operations delegate to the underlying SLF4J implementation.

Capabilities

Logger Creation

Factory methods for creating logger instances by name, class, or accessing the root logger.

/**
 * Gets a logger instance by name
 * @param name The logger name
 * @return Logger instance
 */
public static Logger getLogger(String name);

/**
 * Gets a logger instance by class name
 * @param clazz The class to create logger for
 * @return Logger instance
 */
public static Logger getLogger(Class<?> clazz);

/**
 * Gets a logger instance with custom factory
 * @param name The logger name
 * @param loggerFactory Custom logger factory
 * @return Logger instance
 */
public static Logger getLogger(String name, LoggerFactory loggerFactory);

/**
 * Gets the root logger instance
 * @return Root logger
 */
public static Logger getRootLogger();

Usage Examples:

import org.apache.log4j.Logger;
import org.apache.log4j.LogManager;

// Get logger by class
Logger logger = Logger.getLogger(MyClass.class);

// Get logger by name
Logger namedLogger = Logger.getLogger("com.example.MyLogger");

// Get logger via LogManager (equivalent)
Logger managerLogger = LogManager.getLogger(MyClass.class);

// Get root logger
Logger rootLogger = Logger.getRootLogger();

Level Checking

Methods to check if logging is enabled at specific levels before performing expensive operations.

/**
 * Check if TRACE level is enabled
 * @return true if TRACE enabled
 */
public boolean isTraceEnabled();

/**
 * Check if DEBUG level is enabled
 * @return true if DEBUG enabled
 */
public boolean isDebugEnabled();

/**
 * Check if INFO level is enabled
 * @return true if INFO enabled
 */
public boolean isInfoEnabled();

/**
 * Check if WARN level is enabled
 * @return true if WARN enabled
 */
public boolean isWarnEnabled();

/**
 * Check if ERROR level is enabled
 * @return true if ERROR enabled
 */
public boolean isErrorEnabled();

/**
 * Check if specific priority is enabled
 * @param p Priority to check
 * @return true if enabled for priority
 */
public boolean isEnabledFor(Priority p);

Usage Examples:

// Check before expensive operations
if (logger.isDebugEnabled()) {
    logger.debug("Complex data: " + computeExpensiveDebugInfo());
}

// Check different levels
if (logger.isInfoEnabled()) {
    logger.info("Processing item " + item.getId());
}

// Check with Priority
if (logger.isEnabledFor(Level.WARN)) {
    logger.warn("Warning condition detected");
}

Basic Logging Methods

Core logging methods for each standard Log4j level, accepting both objects and throwables.

/**
 * Log message at TRACE level
 * @param message Message to log
 */
public void trace(Object message);

/**
 * Log message at TRACE level with throwable
 * @param message Message to log
 * @param t Throwable to log
 */
public void trace(Object message, Throwable t);

/**
 * Log message at DEBUG level
 * @param message Message to log
 */
public void debug(Object message);

/**
 * Log message at DEBUG level with throwable
 * @param message Message to log
 * @param t Throwable to log
 */
public void debug(Object message, Throwable t);

/**
 * Log message at INFO level
 * @param message Message to log
 */
public void info(Object message);

/**
 * Log message at INFO level with throwable
 * @param message Message to log
 * @param t Throwable to log
 */
public void info(Object message, Throwable t);

/**
 * Log message at WARN level
 * @param message Message to log
 */
public void warn(Object message);

/**
 * Log message at WARN level with throwable
 * @param message Message to log
 * @param t Throwable to log
 */
public void warn(Object message, Throwable t);

/**
 * Log message at ERROR level
 * @param message Message to log
 */
public void error(Object message);

/**
 * Log message at ERROR level with throwable
 * @param message Message to log
 * @param t Throwable to log
 */
public void error(Object message, Throwable t);

/**
 * Log message at TRACE level
 * @param message Message to log
 */
public void trace(Object message);

/**
 * Log message at TRACE level with throwable
 * @param message Message to log
 * @param t Throwable to log
 */
public void trace(Object message, Throwable t);

/**
 * Log message at FATAL level (mapped to ERROR in SLF4J with FATAL marker)
 * @param message Message to log
 */
public void fatal(Object message);

/**
 * Log message at FATAL level with throwable
 * @param message Message to log
 * @param t Throwable to log
 */
public void fatal(Object message, Throwable t);

Usage Examples:

Logger logger = Logger.getLogger(MyClass.class);

// Basic logging at different levels
logger.trace("Entering method processData()");
logger.debug("Processing " + items.size() + " items");
logger.info("Successfully processed batch");
logger.warn("Low memory condition detected");
logger.error("Failed to process item");
logger.fatal("System is shutting down");

// Logging with exceptions
try {
    processData();
} catch (DataProcessingException e) {
    logger.error("Data processing failed", e);
} catch (CriticalSystemException e) {
    logger.fatal("Critical system failure", e);
}

Generic Logging Methods

Generic logging methods that accept Priority/Level parameters for dynamic level selection.

/**
 * Log message at specified priority
 * @param p Priority level
 * @param message Message to log
 */
public void log(Priority p, Object message);

/**
 * Log message at specified priority with throwable
 * @param p Priority level
 * @param message Message to log
 * @param t Throwable to log
 */
public void log(Priority p, Object message, Throwable t);

/**
 * Log message with FQCN at specified priority
 * @param FQCN Fully qualified class name
 * @param p Priority level
 * @param message Message to log
 * @param t Throwable to log
 */
public void log(String FQCN, Priority p, Object message, Throwable t);

Usage Examples:

// Dynamic level logging
Priority level = determineLogLevel();
logger.log(level, "Dynamic message at runtime level");

// With exception
try {
    operation();
} catch (Exception e) {
    logger.log(Level.ERROR, "Operation failed", e);
}

Logger Hierarchy Methods

Methods for accessing logger hierarchy information and properties.

/**
 * Get logger name
 * @return Logger name
 */
public String getName();

/**
 * Get parent logger (always returns null in this implementation)
 * @return Parent logger or null
 */
public final Category getParent();

/**
 * Get effective level based on SLF4J logger state
 * @return Effective Level
 */
public Level getEffectiveLevel();

/**
 * Get assigned level (always returns null in this implementation)
 * @return Assigned level or null
 */
public final Level getLevel();

/**
 * Get appender by name (always returns null in this implementation)
 * @param name Appender name
 * @return Appender or null
 */
public Appender getAppender(String name);

/**
 * Get all appenders (always returns empty enumeration in this implementation)
 * @return Empty enumeration
 */
public Enumeration getAllAppenders();

/**
 * Get additivity flag (always returns false in this implementation)
 * @return Additivity flag
 */
public boolean getAdditivity();

Usage Examples:

Logger logger = Logger.getLogger("com.example.MyClass");

// Get logger information
String name = logger.getName(); // "com.example.MyClass"
Level effectiveLevel = logger.getEffectiveLevel(); // Current effective level
Category parent = logger.getParent(); // null

Conditional Logging

Utility method for assertion-based logging.

/**
 * Log error message if assertion fails
 * @param assertion Boolean assertion to check
 * @param msg Error message to log if assertion fails
 */
public void assertLog(boolean assertion, String msg);

Usage Examples:

// Assertion-based logging
logger.assertLog(data != null, "Data cannot be null");
logger.assertLog(connection.isValid(), "Database connection is invalid");

Appender Management

Methods for managing appenders attached to loggers (compatibility methods that return null or empty collections).

/**
 * Get appender by name (always returns null in this implementation)
 * @param name Appender name to lookup
 * @return Appender instance or null
 */
public Appender getAppender(String name);

/**
 * Get all appenders (always returns empty enumeration)
 * @return Enumeration of appenders (empty)
 */
@SuppressWarnings("rawtypes")
public Enumeration getAllAppenders();

/**
 * Get priority (deprecated method, always returns null)
 * @return Priority or null
 * @deprecated Use getLevel() instead
 */
@Deprecated
public final Level getPriority();

Usage Examples:

Logger logger = Logger.getLogger(MyClass.class);

// Appender management (compatibility methods)
Appender consoleAppender = logger.getAppender("console"); // Always null
Enumeration<?> appenders = logger.getAllAppenders(); // Always empty

// Deprecated priority method
Level priority = logger.getPriority(); // Always null, use getLevel() instead

Install with Tessl CLI

npx tessl i tessl/maven-org-slf4j--log4j-over-slf4j

docs

appenders-layouts.md

configuration.md

core-logging.md

diagnostic-contexts.md

index.md

level-management.md

tile.json

tessl/maven-org-slf4j--log4j-over-slf4j

core-logging.md.css-3qkkll{font-size:var(--chakra-font-sizes-sm);font-weight:var(--chakra-font-weights-normal);color:var(--chakra-colors-gray-300);}docs/

Core Logging

Capabilities

Logger Creation

Level Checking

Basic Logging Methods

Generic Logging Methods

Logger Hierarchy Methods

Conditional Logging

Appender Management

core-logging.mddocs/