CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-apache-logging-log4j--log4j-1-2-api

The Apache Log4j 1.x Compatibility API providing a bridge to Log4j 2.x implementations

—

Pending
Overview
Eval results
Files

builders.mddocs/

Configuration Builders

Configuration builders provide programmatic configuration capabilities that integrate with Log4j 2.x configuration system while maintaining Log4j 1.x compatibility. These builders enable type-safe, fluent configuration APIs.

Base Builder Interfaces

Builder Interface

public interface Builder<T> {
    // Build the configured object
    T build();
}

Returns:

  • T the built configuration object

Parser Interface

public interface Parser<T extends Builder<? extends Object>> {
    // Parse configuration and return builder
    T parse(Element element);
}

Parameters:

  • element - DOM Element containing configuration

Returns:

  • T builder configured from the element

Appender Builders

AppenderBuilder Interface

public interface AppenderBuilder<T extends Appender> extends Builder<T> {
    // Common appender configuration
    AppenderBuilder<T> setName(String name);
    AppenderBuilder<T> setLayout(Layout layout);
    AppenderBuilder<T> setFilter(Filter filter);
    AppenderBuilder<T> setErrorHandler(ErrorHandler errorHandler);
    
    // Build the appender
    @Override
    T build();
}

Parameters:

  • name - String name for the appender
  • layout - Layout for message formatting
  • filter - Filter for message filtering
  • errorHandler - ErrorHandler for error management

Returns:

  • AppenderBuilder<T> for method chaining
  • T the built appender

ConsoleAppenderBuilder

public class ConsoleAppenderBuilder implements AppenderBuilder<ConsoleAppender>, Parser<ConsoleAppenderBuilder> {
    // Builder methods
    public ConsoleAppenderBuilder setName(String name);
    public ConsoleAppenderBuilder setLayout(Layout layout);
    public ConsoleAppenderBuilder setFilter(Filter filter);
    public ConsoleAppenderBuilder setErrorHandler(ErrorHandler errorHandler);
    
    // Console-specific configuration
    public ConsoleAppenderBuilder setTarget(String target);
    public ConsoleAppenderBuilder setFollow(boolean follow);
    
    // Build and parse
    @Override
    public ConsoleAppender build();
    
    @Override
    public ConsoleAppenderBuilder parse(Element element);
}

Parameters:

  • name - String appender name
  • layout - Layout for formatting
  • filter - Filter for message filtering
  • errorHandler - ErrorHandler for errors
  • target - String target (SYSTEM_OUT or SYSTEM_ERR)
  • follow - Boolean follow setting
  • element - DOM Element for parsing

Returns:

  • ConsoleAppenderBuilder for chaining
  • ConsoleAppender built instance

FileAppenderBuilder

public class FileAppenderBuilder implements AppenderBuilder<FileAppender>, Parser<FileAppenderBuilder> {
    // Builder methods
    public FileAppenderBuilder setName(String name);
    public FileAppenderBuilder setLayout(Layout layout);
    public FileAppenderBuilder setFilter(Filter filter);
    public FileAppenderBuilder setErrorHandler(ErrorHandler errorHandler);
    
    // File-specific configuration
    public FileAppenderBuilder setFileName(String fileName);
    public FileAppenderBuilder setAppend(boolean append);
    public FileAppenderBuilder setBufferedIO(boolean bufferedIO);
    public FileAppenderBuilder setBufferSize(int bufferSize);
    
    // Build and parse
    @Override
    public FileAppender build();
    
    @Override
    public FileAppenderBuilder parse(Element element);
}

Parameters:

  • name - String appender name
  • layout - Layout for formatting
  • filter - Filter for filtering
  • errorHandler - ErrorHandler for errors
  • fileName - String path to log file
  • append - Boolean append flag
  • bufferedIO - Boolean buffering flag
  • bufferSize - Integer buffer size

Returns:

  • FileAppenderBuilder for chaining
  • FileAppender built instance

RollingFileAppenderBuilder

public class RollingFileAppenderBuilder implements AppenderBuilder<RollingFileAppender>, Parser<RollingFileAppenderBuilder> {
    // Inherited builder methods
    public RollingFileAppenderBuilder setName(String name);
    public RollingFileAppenderBuilder setLayout(Layout layout);
    public RollingFileAppenderBuilder setFilter(Filter filter);
    public RollingFileAppenderBuilder setErrorHandler(ErrorHandler errorHandler);
    public RollingFileAppenderBuilder setFileName(String fileName);
    public RollingFileAppenderBuilder setAppend(boolean append);
    
    // Rolling-specific configuration
    public RollingFileAppenderBuilder setMaxFileSize(String maxFileSize);
    public RollingFileAppenderBuilder setMaxBackupIndex(int maxBackupIndex);
    
    // Build and parse
    @Override
    public RollingFileAppender build();
    
    @Override
    public RollingFileAppenderBuilder parse(Element element);
}

Parameters:

  • maxFileSize - String maximum file size (e.g., "10MB")
  • maxBackupIndex - Integer maximum backup files

Returns:

  • RollingFileAppenderBuilder for chaining
  • RollingFileAppender built instance

Layout Builders

LayoutBuilder Interface

public interface LayoutBuilder<T extends Layout> extends Builder<T> {
    // Build the layout
    @Override
    T build();
}

Returns:

  • T the built layout

PatternLayoutBuilder

public class PatternLayoutBuilder implements LayoutBuilder<PatternLayout>, Parser<PatternLayoutBuilder> {
    // Configuration
    public PatternLayoutBuilder setConversionPattern(String pattern);
    
    // Build and parse
    @Override
    public PatternLayout build();
    
    @Override
    public PatternLayoutBuilder parse(Element element);
}

Parameters:

  • pattern - String conversion pattern
  • element - DOM Element for parsing

Returns:

  • PatternLayoutBuilder for chaining
  • PatternLayout built instance

SimpleLayoutBuilder

public class SimpleLayoutBuilder implements LayoutBuilder<SimpleLayout>, Parser<SimpleLayoutBuilder> {
    // Build and parse
    @Override
    public SimpleLayout build();
    
    @Override
    public SimpleLayoutBuilder parse(Element element);
}

Parameters:

  • element - DOM Element for parsing

Returns:

  • SimpleLayoutBuilder for chaining
  • SimpleLayout built instance

Filter Builders

FilterBuilder Interface

public interface FilterBuilder extends Builder<Filter>, Parser<FilterBuilder> {
    // Build the filter
    @Override
    Filter build();
    
    // Parse configuration
    @Override
    FilterBuilder parse(Element element);
}

Parameters:

  • element - DOM Element for parsing

Returns:

  • Filter built instance
  • FilterBuilder configured from element

LevelRangeFilterBuilder

public class LevelRangeFilterBuilder implements FilterBuilder {
    // Configuration
    public LevelRangeFilterBuilder setLevelMin(Level levelMin);
    public LevelRangeFilterBuilder setLevelMax(Level levelMax);
    public LevelRangeFilterBuilder setAcceptOnMatch(boolean acceptOnMatch);
    
    // Build and parse
    @Override
    public Filter build();
    
    @Override
    public LevelRangeFilterBuilder parse(Element element);
}

Parameters:

  • levelMin - Level minimum level for range
  • levelMax - Level maximum level for range
  • acceptOnMatch - Boolean accept or deny on match
  • element - DOM Element for parsing

Returns:

  • LevelRangeFilterBuilder for chaining
  • Filter built instance

LevelMatchFilterBuilder

public class LevelMatchFilterBuilder implements FilterBuilder {
    // Configuration
    public LevelMatchFilterBuilder setLevel(Level level);
    public LevelMatchFilterBuilder setAcceptOnMatch(boolean acceptOnMatch);
    
    // Build and parse
    @Override
    public Filter build();
    
    @Override
    public LevelMatchFilterBuilder parse(Element element);
}

Parameters:

  • level - Level to match against
  • acceptOnMatch - Boolean accept or deny on match
  • element - DOM Element for parsing

Returns:

  • LevelMatchFilterBuilder for chaining
  • Filter built instance

Configuration Builder

ConfigurationBuilder

public class ConfigurationBuilder implements Builder<LoggerRepository> {
    // Logger configuration
    public ConfigurationBuilder addLogger(String name, Level level, boolean additivity);
    public ConfigurationBuilder addLogger(String name, Level level, boolean additivity, Appender... appenders);
    public ConfigurationBuilder setRootLogger(Level level, Appender... appenders);
    
    // Appender management
    public ConfigurationBuilder addAppender(Appender appender);
    public ConfigurationBuilder removeAppender(String name);
    
    // Repository configuration
    public ConfigurationBuilder setThreshold(Level threshold);
    
    // Build configuration
    @Override
    public LoggerRepository build();
    
    // Apply configuration
    public void configure();
}

Parameters:

  • name - String logger name
  • level - Level logging level
  • additivity - Boolean additivity flag
  • appenders - Appender array of appenders
  • appender - Appender to add or remove
  • threshold - Level global threshold

Returns:

  • ConfigurationBuilder for chaining
  • LoggerRepository built repository

Usage Examples

Console Appender Builder

import org.apache.log4j.builders.appender.ConsoleAppenderBuilder;
import org.apache.log4j.builders.layout.PatternLayoutBuilder;
import org.apache.log4j.*;

public class ConsoleAppenderBuilderExample {
    public void createConsoleAppender() {
        // Build pattern layout
        PatternLayout layout = new PatternLayoutBuilder()
            .setConversionPattern("%d{HH:mm:ss} %-5p %c{1} - %m%n")
            .build();
        
        // Build console appender
        ConsoleAppender appender = new ConsoleAppenderBuilder()
            .setName("console")
            .setLayout(layout)
            .setTarget(ConsoleAppender.SYSTEM_OUT)
            .setFollow(true)
            .build();
        
        // Add to logger
        Logger logger = Logger.getLogger("builder-example");
        logger.addAppender(appender);
        logger.setLevel(Level.INFO);
        
        logger.info("Console appender created with builder");
    }
}

File Appender Builder

import org.apache.log4j.builders.appender.FileAppenderBuilder;
import org.apache.log4j.builders.layout.PatternLayoutBuilder;
import org.apache.log4j.*;

public class FileAppenderBuilderExample {
    public void createFileAppender() {
        // Build layout
        PatternLayout layout = new PatternLayoutBuilder()
            .setConversionPattern("%d{ISO8601} [%t] %-5p %c - %m%n")
            .build();
        
        // Build file appender
        FileAppender appender = new FileAppenderBuilder()
            .setName("file")
            .setLayout(layout)
            .setFileName("application.log")
            .setAppend(true)
            .setBufferedIO(true)
            .setBufferSize(8192)
            .build();
        
        // Configure logger
        Logger logger = Logger.getLogger("file-example");
        logger.addAppender(appender);
        logger.setLevel(Level.DEBUG);
        
        logger.debug("File appender created with builder");
    }
}

Rolling File Appender Builder

import org.apache.log4j.builders.appender.RollingFileAppenderBuilder;
import org.apache.log4j.builders.layout.PatternLayoutBuilder;
import org.apache.log4j.*;

public class RollingFileBuilderExample {
    public void createRollingFileAppender() {
        // Build layout
        PatternLayout layout = new PatternLayoutBuilder()
            .setConversionPattern("%d %p %c - %m%n")
            .build();
        
        // Build rolling file appender
        RollingFileAppender appender = new RollingFileAppenderBuilder()
            .setName("rolling")
            .setLayout(layout)
            .setFileName("app.log")
            .setAppend(true)
            .setMaxFileSize("10MB")
            .setMaxBackupIndex(5)
            .build();
        
        // Configure logger
        Logger logger = Logger.getLogger("rolling-example");
        logger.addAppender(appender);
        logger.setLevel(Level.INFO);
        
        logger.info("Rolling file appender created");
    }
}

Filter Builder Usage

import org.apache.log4j.builders.filter.*;
import org.apache.log4j.builders.appender.ConsoleAppenderBuilder;
import org.apache.log4j.builders.layout.PatternLayoutBuilder;
import org.apache.log4j.*;

public class FilterBuilderExample {
    public void createFilteredAppender() {
        // Build level range filter (INFO to ERROR)
        Filter levelRangeFilter = new LevelRangeFilterBuilder()
            .setLevelMin(Level.INFO)
            .setLevelMax(Level.ERROR)
            .setAcceptOnMatch(true)
            .build();
        
        // Build level match filter (only WARN)
        Filter levelMatchFilter = new LevelMatchFilterBuilder()
            .setLevel(Level.WARN)
            .setAcceptOnMatch(true)
            .build();
        
        // Build layout
        PatternLayout layout = new PatternLayoutBuilder()
            .setConversionPattern("%-5p %c - %m%n")
            .build();
        
        // Build appender with filter
        ConsoleAppender appender = new ConsoleAppenderBuilder()
            .setName("filtered-console")
            .setLayout(layout)
            .setFilter(levelRangeFilter)
            .build();
        
        // Configure logger
        Logger logger = Logger.getLogger("filtered-example");
        logger.addAppender(appender);
        logger.setLevel(Level.DEBUG);
        
        // Test filtering
        logger.debug("Debug message - should be filtered out");
        logger.info("Info message - should appear");
        logger.warn("Warn message - should appear");
        logger.error("Error message - should appear");
    }
}

Complete Configuration Builder

import org.apache.log4j.builders.*;
import org.apache.log4j.builders.appender.*;
import org.apache.log4j.builders.layout.*;
import org.apache.log4j.*;

public class ConfigurationBuilderExample {
    public void buildCompleteConfiguration() {
        // Build console layout
        PatternLayout consoleLayout = new PatternLayoutBuilder()
            .setConversionPattern("%-5p %c{1} - %m%n")
            .build();
        
        // Build file layout
        PatternLayout fileLayout = new PatternLayoutBuilder()
            .setConversionPattern("%d{ISO8601} [%t] %-5p %c - %m%n")
            .build();
        
        // Build console appender
        ConsoleAppender consoleAppender = new ConsoleAppenderBuilder()
            .setName("console")
            .setLayout(consoleLayout)
            .setTarget(ConsoleAppender.SYSTEM_OUT)
            .build();
        
        // Build rolling file appender
        RollingFileAppender fileAppender = new RollingFileAppenderBuilder()
            .setName("file")
            .setLayout(fileLayout)
            .setFileName("app.log")
            .setMaxFileSize("10MB")
            .setMaxBackupIndex(3)
            .build();
        
        // Build complete configuration
        LoggerRepository repository = new ConfigurationBuilder()
            .addAppender(consoleAppender)
            .addAppender(fileAppender)
            .setRootLogger(Level.INFO, consoleAppender, fileAppender)
            .addLogger("com.myapp.dao", Level.DEBUG, false, fileAppender)
            .addLogger("org.springframework", Level.WARN, true)
            .setThreshold(Level.DEBUG)
            .build();
        
        // Apply configuration
        new ConfigurationBuilder()
            .addAppender(consoleAppender)
            .addAppender(fileAppender)
            .setRootLogger(Level.INFO, consoleAppender, fileAppender)
            .configure();
    }
}

XML Configuration Parsing

import org.apache.log4j.builders.appender.ConsoleAppenderBuilder;
import org.apache.log4j.builders.layout.PatternLayoutBuilder;
import org.w3c.dom.Element;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

public class XMLParsingExample {
    public void parseXMLConfiguration() throws Exception {
        // Example XML element parsing
        String xmlConfig = 
            "<appender name='console' class='org.apache.log4j.ConsoleAppender'>" +
            "  <param name='Target' value='System.out'/>" +
            "  <layout class='org.apache.log4j.PatternLayout'>" +
            "    <param name='ConversionPattern' value='%-5p %c - %m%n'/>" +
            "  </layout>" +
            "</appender>";
        
        // Parse XML (simplified example)
        DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
        DocumentBuilder builder = factory.newDocumentBuilder();
        
        // In real implementation, you would parse the actual XML
        // Element appenderElement = ...;
        
        // Parse with builders
        ConsoleAppenderBuilder appenderBuilder = new ConsoleAppenderBuilder();
        // ConsoleAppender appender = appenderBuilder.parse(appenderElement).build();
        
        // For demonstration, build manually
        PatternLayout layout = new PatternLayoutBuilder()
            .setConversionPattern("%-5p %c - %m%n")
            .build();
        
        ConsoleAppender appender = new ConsoleAppenderBuilder()
            .setName("console")
            .setTarget("System.out")
            .setLayout(layout)
            .build();
        
        Logger.getRootLogger().addAppender(appender);
    }
}

Fluent Configuration API

import org.apache.log4j.builders.*;
import org.apache.log4j.*;

public class FluentConfigurationExample {
    public void createFluentConfiguration() {
        // Fluent API for complex configuration
        new ConfigurationBuilder()
            // Root logger with console output
            .setRootLogger(Level.INFO, 
                new ConsoleAppenderBuilder()
                    .setName("root-console")
                    .setLayout(new PatternLayoutBuilder()
                        .setConversionPattern("%-5p %c{1} - %m%n")
                        .build())
                    .build())
            
            // Application logger with file output  
            .addLogger("com.myapp", Level.DEBUG, false,
                new RollingFileAppenderBuilder()
                    .setName("app-file")
                    .setFileName("myapp.log")
                    .setMaxFileSize("50MB")
                    .setMaxBackupIndex(10)
                    .setLayout(new PatternLayoutBuilder()
                        .setConversionPattern("%d{ISO8601} [%t] %-5p %c - %m%n")
                        .build())
                    .build())
            
            // Third-party library logger with warn level
            .addLogger("org.apache", Level.WARN, true)
            .addLogger("org.springframework", Level.WARN, true)
            
            // Apply the configuration
            .configure();
    }
}

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-logging-log4j--log4j-1-2-api

docs

appenders.md

builders.md

configuration.md

context.md

index.md

layouts.md

logging.md

spi.md

tile.json