CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/maven-org-apache-logging-log4j--log4j-core

A versatile, industrial-grade, and reference implementation of the Log4j API with rich components for various logging use cases.

—

Pending
Overview
Eval results
Files

appenders.mddocs/

Appenders

Appenders are responsible for delivering log events to their destination. Log4j Core provides numerous built-in appenders for various output targets including files, consoles, databases, network sockets, and message queues.

Capabilities

Core Appender Interface

Base interface that all appenders must implement.

/**
 * Core appender interface for handling log events
 */
public interface Appender extends LifeCycle {
    /**
     * Append a log event to the destination
     * @param event LogEvent to append
     */
    void append(LogEvent event);
    
    /**
     * Get the appender name
     * @return Appender name
     */
    String getName();
    
    /**
     * Get the layout used by this appender
     * @return Layout instance or null
     */
    Layout<? extends Serializable> getLayout();
    
    /**
     * Check if exceptions should be ignored
     * @return true if exceptions are ignored
     */
    boolean ignoreExceptions();
    
    /**
     * Get the error handler
     * @return ErrorHandler instance
     */
    ErrorHandler getHandler();
    
    /**
     * Set the error handler
     * @param handler ErrorHandler to set
     */
    void setHandler(ErrorHandler handler);
}

Console Appender

Writes log events to System.out or System.err.

/**
 * Create ConsoleAppender with builder pattern
 * @return ConsoleAppender.Builder instance
 */
public static ConsoleAppender.Builder newBuilder();

/**
 * ConsoleAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<ConsoleAppender> {
    public Builder setName(String name);
    public Builder setLayout(Layout<? extends Serializable> layout);
    public Builder setFilter(Filter filter);
    public Builder setTarget(Target target);
    public Builder setFollow(boolean follow);
    public Builder setDirect(boolean direct);
    public Builder setBufferedIo(boolean bufferedIo);
    public Builder setBufferSize(int bufferSize);
    public ConsoleAppender build();
}

/**
 * Console target enumeration
 */
public enum Target {
    SYSTEM_OUT("SYSTEM_OUT"),
    SYSTEM_ERR("SYSTEM_ERR");
}

Usage Examples:

import org.apache.logging.log4j.core.appender.ConsoleAppender;
import org.apache.logging.log4j.core.layout.PatternLayout;

// Create console appender to System.out
ConsoleAppender consoleAppender = ConsoleAppender.newBuilder()
    .setName("Console")
    .setTarget(ConsoleAppender.Target.SYSTEM_OUT)
    .setLayout(PatternLayout.createDefaultLayout())
    .build();

// Create console appender to System.err with custom layout
PatternLayout layout = PatternLayout.newBuilder()
    .withPattern("%d{yyyy-MM-dd HH:mm:ss} [%level] %logger{36} - %msg%n")
    .build();

ConsoleAppender errorAppender = ConsoleAppender.newBuilder()
    .setName("ErrorConsole")
    .setTarget(ConsoleAppender.Target.SYSTEM_ERR)
    .setLayout(layout)
    .build();

File Appender

Writes log events to a file.

/**
 * Create FileAppender with builder pattern
 * @return FileAppender.Builder instance
 */
public static FileAppender.Builder newBuilder();

/**
 * FileAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<FileAppender> {
    public Builder setName(String name);
    public Builder setLayout(Layout<? extends Serializable> layout);
    public Builder setFilter(Filter filter);
    public Builder withFileName(String fileName);
    public Builder withAppend(boolean append);
    public Builder withBufferedIo(boolean bufferedIo);
    public Builder withBufferSize(int bufferSize);
    public Builder setImmediateFlush(boolean immediateFlush);
    public FileAppender build();
}

Usage Examples:

import org.apache.logging.log4j.core.appender.FileAppender;

// Create basic file appender
FileAppender fileAppender = FileAppender.newBuilder()
    .setName("FileAppender")
    .withFileName("application.log")
    .withAppend(true)
    .setLayout(PatternLayout.createDefaultLayout())
    .build();

// Create file appender with buffering
FileAppender bufferedAppender = FileAppender.newBuilder()
    .setName("BufferedFile")
    .withFileName("logs/app.log")
    .withBufferedIo(true)
    .withBufferSize(8192)
    .setImmediateFlush(false)
    .setLayout(layout)
    .build();

Rolling File Appender

File appender that rolls over based on size, time, or other policies.

/**
 * Create RollingFileAppender with builder pattern
 * @return RollingFileAppender.Builder instance
 */
public static RollingFileAppender.Builder newBuilder();

/**
 * RollingFileAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<RollingFileAppender> {
    public Builder setName(String name);
    public Builder setLayout(Layout<? extends Serializable> layout);
    public Builder setFilter(Filter filter);
    public Builder withFileName(String fileName);
    public Builder withFilePattern(String filePattern);
    public Builder withPolicy(TriggeringPolicy policy);
    public Builder withStrategy(RolloverStrategy strategy);
    public Builder withAppend(boolean append);
    public RollingFileAppender build();
}

Usage Examples:

import org.apache.logging.log4j.core.appender.RollingFileAppender;
import org.apache.logging.log4j.core.appender.rolling.SizeBasedTriggeringPolicy;
import org.apache.logging.log4j.core.appender.rolling.DefaultRolloverStrategy;

// Create size-based rolling appender
SizeBasedTriggeringPolicy policy = SizeBasedTriggeringPolicy.createPolicy("10MB");
DefaultRolloverStrategy strategy = DefaultRolloverStrategy.newBuilder()
    .withMax("10")
    .build();

RollingFileAppender rollingAppender = RollingFileAppender.newBuilder()
    .setName("RollingFile")
    .withFileName("logs/app.log")
    .withFilePattern("logs/app-%i.log.gz")
    .withPolicy(policy)
    .withStrategy(strategy)
    .withAppend(true)
    .setLayout(PatternLayout.createDefaultLayout())
    .build();

Async Appender

Wraps other appenders to provide asynchronous logging.

/**
 * Create AsyncAppender with builder pattern
 * @return AsyncAppender.Builder instance
 */
public static AsyncAppender.Builder newBuilder();

/**
 * AsyncAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<AsyncAppender> {
    public Builder setName(String name);
    public Builder setFilter(Filter filter);
    public Builder setAppenderRefs(AppenderRef[] appenderRefs);
    public Builder setBufferSize(int bufferSize);
    public Builder setShutdownTimeout(long shutdownTimeout);
    public Builder setIncludeLocation(boolean includeLocation);
    public Builder setBlockingQueueFactory(BlockingQueueFactory<LogEvent> blockingQueueFactory);
    public AsyncAppender build();
}

Usage Examples:

import org.apache.logging.log4j.core.appender.AsyncAppender;
import org.apache.logging.log4j.core.config.AppenderRef;

// Create async wrapper for file appender
AppenderRef ref = AppenderRef.createAppenderRef("FileAppender", null, null);
AppenderRef[] refs = new AppenderRef[] { ref };

AsyncAppender asyncAppender = AsyncAppender.newBuilder()
    .setName("AsyncFile")
    .setAppenderRefs(refs)
    .setBufferSize(2048)
    .setShutdownTimeout(3000)
    .setIncludeLocation(false)
    .build();

Socket Appender

Sends log events over TCP sockets.

/**
 * Create SocketAppender with builder pattern
 * @return SocketAppender.Builder instance
 */
public static SocketAppender.Builder newBuilder();

/**
 * SocketAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<SocketAppender> {
    public Builder setName(String name);
    public Builder setLayout(Layout<? extends Serializable> layout);
    public Builder setFilter(Filter filter);
    public Builder withHost(String host);
    public Builder withPort(int port);
    public Builder withProtocol(Protocol protocol);
    public Builder withReconnectDelayMillis(int reconnectDelayMillis);
    public SocketAppender build();
}

SMTP Appender

Sends log events via email.

/**
 * Create SmtpAppender with builder pattern
 * @return SmtpAppender.Builder instance
 */
public static SmtpAppender.Builder newBuilder();

/**
 * SmtpAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<SmtpAppender> {
    public Builder setName(String name);
    public Builder setLayout(Layout<? extends Serializable> layout);
    public Builder setFilter(Filter filter);
    public Builder setTo(String to);
    public Builder setCc(String cc);
    public Builder setBcc(String bcc);
    public Builder setFrom(String from);
    public Builder setSubject(String subject);
    public Builder setSmtpHost(String smtpHost);
    public Builder setSmtpPort(int smtpPort);
    public SmtpAppender build();
}

HTTP Appender

Sends log events via HTTP requests.

/**
 * Create HttpAppender with builder pattern
 * @return HttpAppender.Builder instance
 */
public static HttpAppender.Builder newBuilder();

/**
 * HttpAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<HttpAppender> {
    public Builder setName(String name);
    public Builder setLayout(Layout<? extends Serializable> layout);
    public Builder setFilter(Filter filter);
    public Builder setUrl(String url);
    public Builder setMethod(String method);
    public Builder setHeaders(Property[] headers);
    public Builder setConnectTimeoutMillis(int connectTimeoutMillis);
    public Builder setReadTimeoutMillis(int readTimeoutMillis);
    public HttpAppender build();
}

Syslog Appender

Sends log events to syslog daemon.

/**
 * Create SyslogAppender with builder pattern
 * @return SyslogAppender.Builder instance
 */
public static SyslogAppender.Builder newBuilder();

/**
 * SyslogAppender configuration builder
 */
public static final class Builder implements org.apache.logging.log4j.core.util.Builder<SyslogAppender> {
    public Builder setName(String name);
    public Builder setLayout(Layout<? extends Serializable> layout);
    public Builder setFilter(Filter filter);
    public Builder setHost(String host);
    public Builder setPort(int port);
    public Builder setProtocol(String protocol);
    public Builder setFacility(Facility facility);
    public SyslogAppender build();
}

Triggering Policies

Policies that determine when rolling file appenders should roll over.

Size Based Triggering Policy

/**
 * Create size-based triggering policy
 * @param size Maximum file size (e.g., "10MB", "1GB")
 * @return SizeBasedTriggeringPolicy instance
 */
public static SizeBasedTriggeringPolicy createPolicy(String size);

Time Based Triggering Policy

/**
 * Create time-based triggering policy with builder
 * @return TimeBasedTriggeringPolicy.Builder instance
 */
public static TimeBasedTriggeringPolicy.Builder newBuilder();

public static final class Builder implements org.apache.logging.log4j.core.util.Builder<TimeBasedTriggeringPolicy> {
    public Builder withInterval(int interval);
    public Builder withModulate(boolean modulate);
    public Builder withMaxRandomDelay(int maxRandomDelay);
    public TimeBasedTriggeringPolicy build();
}

Rollover Strategies

Strategies that control how files are rolled over and managed.

Default Rollover Strategy

/**
 * Create default rollover strategy with builder
 * @return DefaultRolloverStrategy.Builder instance
 */
public static DefaultRolloverStrategy.Builder newBuilder();

public static final class Builder implements org.apache.logging.log4j.core.util.Builder<DefaultRolloverStrategy> {
    public Builder withMax(String max);
    public Builder withMin(String min);
    public Builder withFileIndex(String fileIndex);
    public Builder withCompressionLevel(int compressionLevel);
    public DefaultRolloverStrategy build();
}

Install with Tessl CLI

npx tessl i tessl/maven-org-apache-logging-log4j--log4j-core

docs

appenders.md

async-logging.md

configuration.md

core-context.md

filters.md

index.md

layouts.md

lookups.md

plugins.md

tile.json