log4j - Quick Guide

log4j - Overview

log4j is a reliable, fast and flexible logging framework (APIs) written in Java, which is distributed under the Apache Software License.

log4j has been ported to the C, C++, C#, Perl, Python, Ruby, and Eiffel languages.

log4j is highly configurable through external configuration files at runtime. It views the logging process in terms of levels of priorities and offers mechanisms to direct logging information to a great variety of destinations, such as a database, file, console, UNIX Syslog, etc.

log4j has three main components:

• loggers: Responsible for capturing logging information.

• appenders: Responsible for publishing logging information to various preferred destinations.

• layouts: Responsible for formatting logging information in different styles.

History of log4j

• Started in early 1996 as tracing API for the E.U. SEMPER (Secure Electronic Marketplace for Europe) project.

• After countless enhancements and several incarnations, the initial API has evolved to become log4j, a popular logging package for Java.

• The package is distributed under the Apache Software License, a full-fledged open source license certified by the open source initiative.

• The latest log4j version, including its full-source code, class files, and documentation can be found at https://logging.apache.org/log4j/2.x/download.html.

log4j Features

• It is thread-safe.

• It is optimized for speed.

• It is based on a named logger hierarchy.

• It supports multiple output appenders per logger.

• It supports internationalization.

• It is not restricted to a predefined set of facilities.

• Logging behavior can be set at runtime using a configuration file.

• It is designed to handle Java Exceptions from the start.

• It uses multiple levels, namely ALL, TRACE, DEBUG, INFO, WARN, ERROR and FATAL.

• The format of the log output can be easily changed by extending the Layout class.

• The target of the log output as well as the writing strategy can be altered by implementations of the Appender interface.

• It is fail-stop. However, although it certainly strives to ensure delivery, log4j does not guarantee that each log statement will be delivered to its destination.

Pros and Cons of Logging

Logging is an important component of the software development. A well-written logging code offers quick debugging, easy maintenance, and structured storage of an application's runtime information.

Logging does have its drawbacks also. It can slow down an application. If too verbose, it can cause scrolling blindness. To alleviate these concerns, log4j is designed to be reliable, fast and extensible.

Since logging is rarely the main focus of an application, the log4j API strives to be simple to understand and to use.

log4j - Installation

log4j API package is distributed under the Apache Software License, a full-fledged open source license certified by the open source initiative.

The latest log4j version, including full-source code, class files and documentation can be found at https://logging.apache.org/log4j/2.x/download.html.

To install log4j on your system, download apache-log4j-2.25.1-bin.zip from the specified URL and follow the steps give below.

Step 1

Unzip the downloaded file in D:\Projects\apache-log4j-2.25.1-bin directory.

Step 2

This step is optional and depends on what features you are going to use from log4j framework. If you already have following packages installed on your machine then it is fine, otherwise you need to install them to make log4j work.

• JavaMail API: The e-mail based logging feature in log4j requires the Java Mail API (mail.jar) to be installed on your machine from https://glassfish.org/.

• JavaBeans Activation Framework: The Java Mail API will also require that the JavaBeans Activation Framework (activation.jar) be installed on your machine from https://www.oracle.com/java/technologies/?er=221886.

• Java Message Service: The JMS-compatible features of log4j will require that both JMS and Java Naming and Directory Interface JNDI be installed on your machine from https://www.oracle.com/java/technologies/?er=221886.

• XML Parser: You need a JAXP-compatible XML parser to use log4j. Make sure you have Xerces.jar installed on your machine from http://xerces.apache.org/xerces-j/install.html.

Set CLASSPATH Variable

Set the CLASSPATH environment variable to point to the log4j jar location. Assuming, you have stored log4j and related jars in Projects folder on various Operating Systems as follows.

log4j - Architecture

log4j API follows a layered architecture where each layer provides different objects to perform different tasks. This layered architecture makes the design flexible and easy to extend in future.

There are two types of objects available with log4j framework.

• Core Objects: These are mandatory objects of the framework. They are required to use the framework.

• Support Objects: These are optional objects of the framework. They support core objects to perform additional but important tasks.

Core Objects

Core objects include the following types of objects −

Logger Object

The top-level layer is the Logger which provides the Logger object. The Logger object is responsible for capturing logging information and they are stored in a namespace hierarchy.

Layout Object

The layout layer provides objects which are used to format logging information in different styles. It provides support to appender objects before publishing logging information.

Layout objects play an important role in publishing logging information in a way that is human-readable and reusable.

Appender Object

This is a lower-level layer which provides Appender objects. The Appender object is responsible for publishing logging information to various preferred destinations such as a database, file, console, UNIX Syslog, etc.

The following virtual diagram shows the components of a log4J framework:

Support Objects

There are other important objects in the log4j framework that play a vital role in the logging framework:

Level Object

The Level object defines the granularity and priority of any logging information. There are seven levels of logging defined within the API: OFF, DEBUG, INFO, ERROR, WARN, FATAL, and ALL.

Filter Object

The Filter object is used to analyze logging information and make further decisions on whether that information should be logged or not.

An Appender objects can have several Filter objects associated with them. If logging information is passed to a particular Appender object, all the Filter objects associated with that Appender need to approve the logging information before it can be published to the attached destination.

ObjectRenderer

The ObjectRenderer object is specialized in providing a String representation of different objects passed to the logging framework. This object is used by Layout objects to prepare the final logging information.

LogManager

The LogManager object manages the logging framework. It is responsible for reading the initial configuration parameters from a system-wide configuration file or a configuration class.

log4j - Configuration

The previous chapter explained the core components of log4j. This chapter explains how you can configure the core components using a configuration file. Configuring log4j involves assigning the Level, defining Appender, and specifying Layout objects in a configuration file.

The log4j2.properties file is a log4j configuration file which keeps properties in key-value pairs. By default, the LogManager looks for a file named log4j2.properties in the CLASSPATH.

• The level of the root logger is defined as DEBUG. The DEBUG attaches the appender named X to it.

• Set the appender named X to be a valid appender.

• Set the layout for the appender X.

log4j.properties Syntax:

Following is the syntax of log4j.properties file for an appender X:

# Define a console appender named X
appender.0.type = Console
appender.0.name = X
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %p - %m%n

# Define the root logger with appender X
rootLogger.level = INFO
rootLogger.appenderRef.0.ref = X
rootLogger.appenderRef.0.level = WARN

log4j.properties Example

Using the above syntax, we define the following in log4j.properties file:

• The level of the root logger is defined as DEBUG, The DEBUG appender named MAIN to it.

• The appender MAIN is defined with type File. It writes to a file named main.log located in the logs directory.

• The layout pattern defined is %p - %m%n, which means the printed logging message will be followed by a newline character.

# Define the file appender
appender.0.type = File
appender.0.name = MAIN
appender.0.fileName = logs/main.log
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %p - %m%n

# Define the root logger with appender file
rootLogger.level = INFO
rootLogger.appenderRef.0.ref = MAIN
rootLogger.appenderRef.0.level = DEBUG

It is important to note that log4j supports UNIX-style variable substitution such as ${variableName}.

Debug Level

We have used DEBUG with both the appenders. All the possible options are:

• TRACE
• DEBUG
• INFO
• WARN
• ERROR
• FATAL
• ALL

These levels are explained later in this tutorial.

Appenders

Apache log4j provides Appender objects which are primarily responsible for printing logging messages to different destinations such as consoles, files, sockets, NT event logs, etc.

Each Appender object has different properties associated with it, and these properties indicate the behavior of that object.

We can add an Appender object to a Logger by including the following setting in the configuration file with the following method:

log4j.logger.[logger-name]=level, appender1,appender..n

You can write same configuration in XML format as follows:

<logger name="com.apress.logging.log4j" additivity="false">
   <appender-ref ref="appender1"/>
   <appender-ref ref="appender2"/>
</logger>

If you are willing to add Appender object inside your program then you can use following method:

public void addAppender(Appender appender);

The addAppender() method adds an Appender to the Logger object. As the example configuration demonstrates, it is possible to add many Appender objects to a logger in a comma-separated list, each printing logging information to separate destinations.

We have used only one appender FileAppender in our example above. All the possible appender options are:

• AppenderSkeleton

• AsyncAppender

• ConsoleAppender

• DailyRollingFileAppender

• ExternallyRolledFileAppender

• FileAppender

• JDBCAppender

• JMSAppender

• LF5Appender

• NTEventLogAppender

• NullAppender

• RollingFileAppender

• SMTPAppender

• SocketAppender

• SocketHubAppender

• SyslogAppender

• TelnetAppender

• WriterAppender

We would cover FileAppender in Logging in Files and JDBC Appender would be covered in Logging in Database.

Layout

We have used PatternLayout with our appender. All the possible options are:

• JsonTemplateLayout

• DateLayout

• HTMLLayout

• PatternLayout

• SimpleLayout

• XMLLayout

Using HTMLLayout and XMLLayout, you can generate log in HTML and in XML format as well.

Layout Formatting

You would learn how to format a log message in chapter: Log Formatting.

log4j - Sample Program

We have seen how to create a configuration file in log4j - Configuration. This chapter describe how to generate debug messages and log them in a simple text file.

Following is a simple configuration file created for our example. Let us revise it once again:

• The appender CONSOLE is defined with type Console and writes to console.

• The layout pattern defined is %p - %m%n, which means the printed logging message will be followed by a newline character.

• The appender MAIN is defined with type File and writes to a file named main.log located in the logs directory.

• The layout type defined is JsonTemplateLayout, which means the printed logging message will be in JSON format.

• The level of the root logger is defined as DEBUG and attaches appenders named CONSOLE and MAIN with corresponding levels to it.

The contents of log4j2.properties file are as follows −

log4j2.properties

appender.0.type = Console
appender.0.name = CONSOLE
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %p - %m%n

appender.1.type = File
appender.1.name = MAIN
appender.1.fileName = logs/main.log
appender.1.layout.type = JsonTemplateLayout

rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = CONSOLE
rootLogger.appenderRef.0.level = WARN
rootLogger.appenderRef.1.ref = MAIN
rootLogger.appenderRef.0.level = INFO

Using log4j in Java Program

The following Java class is a very simple example that initializes, and then uses, the log4j logging library for Java applications.

Log4jDemo.java

package com.tutorialspoint;

import java.io.IOException;
import java.sql.SQLException;

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

public class Log4jDemo{

   /* Get actual class name by default to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args)throws IOException,SQLException{
      LOGGER.info("Hello this is a info message");
      LOGGER.debug("Hello this is an debug message");
      LOGGER.warn("Hello this is a warning message");
   }
}

Compile and Execute

Here are the steps to compile and run the above-mentioned program. Make sure you have set PATH and CLASSPATH appropriately before proceeding for the compilation and execution.

All the libraries should be available in CLASSPATH and your log4j2.properties file should be available in PATH. Follow the steps give below −

• Create log4j2.properties as shown above.

• Create Log4jDemo.java as shown above and compile it.

• Execute Log4jDemo binary to run the program.

Output

You would get the following result inside logs/main.log file −

{"@timestamp":"2025-09-04T10:36:40.322Z","ecs.version":"1.2.0","log.level":"INFO","message":"Hello this is a info message","process.thread.name":"main","log.logger":"com.tutorialspoint.Log4jDemo"}
{"@timestamp":"2025-09-04T10:36:40.325Z","ecs.version":"1.2.0","log.level":"DEBUG","message":"Hello this is an debug message","process.thread.name":"main","log.logger":"com.tutorialspoint.Log4jDemo"}
{"@timestamp":"2025-09-04T10:36:40.325Z","ecs.version":"1.2.0","log.level":"WARN","message":"Hello this is a warning message","process.thread.name":"main","log.logger":"com.tutorialspoint.Log4jDemo"}

INFO - Hello this is a info message
WARN - Hello this is a warning message

static Logger log = LogManager.getLogger(log4jDemo.class.getName());

package com.tutorialspoint;

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

public class Log4jDemo{
   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();
   
   public static void main(String[] args){
      LOGGER.trace("Trace Message!");
      LOGGER.debug("Debug Message!");
      LOGGER.info("Info Message!");
      LOGGER.warn("Warn Message!");
      LOGGER.error("Error Message!");
      LOGGER.fatal("Fatal Message!");
   }
}

appender.0.type = Console
appender.0.name = CONSOLE
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %p - %m%n

rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = CONSOLE

DEBUG - Debug Message!
INFO - Info Message!
WARN - Warn Message!
ERROR - Error Message!
FATAL - Fatal Message!

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();
   
   public static void main(String[] args) {
      LOGGER.atLevel(Level.WARN);
	   
      LOGGER.trace("Trace Message!");
      LOGGER.debug("Debug Message!");
      LOGGER.info("Info Message!");
      LOGGER.warn("Warn Message!");
      LOGGER.error("Error Message!");
      LOGGER.fatal("Fatal Message!");
   }
}

2025-09-04T13:41:43.223410900Z main ERROR Error Message!
2025-09-04T13:41:43.227410200Z main FATAL Fatal Message!

appender.0.type = Console
appender.0.name = CONSOLE
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %p - %m%n

rootLogger.level = WARN
rootLogger.appenderRef.0.ref = CONSOLE

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.trace("Trace Message!");
      LOGGER.debug("Debug Message!");
      LOGGER.info("Info Message!");
      LOGGER.warn("Warn Message!");
      LOGGER.error("Error Message!");
      LOGGER.fatal("Fatal Message!");
   }
}

WARN - Warn Message!
ERROR - Error Message!
FATAL - Fatal Message!

appender.0.type = Console
appender.0.name = logFile

<Appenders>
   <Console name="logFile">
      <PatternLayout pattern="%d [%t] %p %c - %m%n"/>
</Appenders>

# Define the appender
appender.0.type = Console
appender.0.name = CONSOLE

appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %d [%t] %p %c - %m%n

# Define the root logger with appender console
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = CONSOLE

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="logFile" packages="">
   <Appenders>
      <Console name="CONSOLE">
         <PatternLayout pattern="%d [%t] %p %c - %m%n"/>
      </Console>
   </Appenders>
   <Loggers>
      <Root level="debug">
         <AppenderRef ref="CONSOLE"/>
      </Root>
   </Loggers>
</Configuration>

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

2025-09-07 12:10:28,511 [main] DEBUG com.tutorialspoint.Log4jDemo - Hello this is an debug message
2025-09-07 12:10:28,517 [main] INFO com.tutorialspoint.Log4jDemo - Hello this is an info message

appender.0.type = JDBC
appender.0.name = JDBC
appender.0.tableName = logs

<appenders>
   <Jdbc name="databaseAppender" tableName="logs">
      <DriverManager url="jdbc:mysql://localhost:3306/tutorials" username="guest" password="guest123" />
      <Column name="level" pattern="%level" />
      <Column name="logger" pattern="%logger" />
      <Column name="message" pattern="%message" />
   </Jdbc>
</appenders>

CREATE TABLE LOGS
   (
    TIMESTAMP TIMESTAMP(6) NOT NULL,
    LOGGER  VARCHAR(50)    NOT NULL,
    LEVEL   VARCHAR(10)    NOT NULL,
    MESSAGE VARCHAR(1000)  NOT NULL
   );

appender.0.type = JDBC
appender.0.name = JDBC
appender.0.tableName = logs

appender.0.bufferSize = 10

appender.0.connectionSource.type= DriverManager
appender.0.connectionSource.connectionString = jdbc:mysql://localhost:3306/tutorials
appender.0.connectionSource.username = guest
appender.0.connectionSource.password = guest123
appender.0.connectionSource.driverClassName = com.mysql.cj.jdbc.Driver

appender.0.col[0].type = ColumnMapping
appender.0.col[0].name = timestamp
appender.0.col[0].columnType = java.util.Date

appender.0.col[1].type = ColumnMapping
appender.0.col[1].name = level
appender.0.col[1].pattern = %level

appender.0.col[2].type = ColumnMapping
appender.0.col[2].name = logger
appender.0.col[2].pattern = %logger

appender.0.col[3].type = ColumnMapping
appender.0.col[3].name = message
appender.0.col[3].pattern = %message

# Define the root logger with appender file
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = JDBC

<?xml version="1.0" encoding="UTF-8"?>
<configuration status="error">
  <appenders>
    <Jdbc name="databaseAppender" tableName="logs">
      <DriverManager url="jdbc:mysql://localhost:3306/tutorials" username="guest" password="guest123" />
      <Column name="level" pattern="%level" />
      <Column name="logger" pattern="%logger" />
      <Column name="message" pattern="%message" />
    </Jdbc>
  </appenders>
  <loggers>
    <root level="warn">
      <appender-ref ref="databaseAppender"/>
    </root>
  </loggers>
</configuration>

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

mysql >  select * from LOGS;
+----------------------------+------------------------------+-------+----------------------------------+
| TIMESTAMP                  | LOGGER                       | LEVEL | MESSAGE                          |
+----------------------------+------------------------------+-------+----------------------------------+
| 2025-09-07 13:53:25.617000 | com.tutorialspoint.log4jDemo | DEBUG | Hello this is an debug message   |
| 2025-09-07 13:53:25.620000 | com.tutorialspoint.log4jDemo | INFO  | Hello this is an info message    |
+----------------------------+------------------------------+-------+----------------------------------+
2 rows in set (0.00 sec)

• CsvParameterLayout

• CsvLogEventLayout

• HtmlLayout

• PatternLayout

• JsonTemplateLayout

The Layout Methods

This class provides a skeleton implementation of all the common operations across all other Layout objects and declares two abstract methods.

Apart from these abstract methods, the Layout class provides concrete implementation for the methods listed below:

Each subclass can return class-specific information by overriding the concrete implementation of these methods.

log4j - CSV Parameter Layout

If you want to generate your logging information in an CSV-formatted file, then you can use org.apache.logging.log4j.CSVParameterLayout to format your logging information.

The CSVParameterLayout class encodes only the parameters passed in the message of log event.

For example, consider the below log statements −

LOGGER.info("Record 1 {} {}", "arg1", "arg2");
LOGGER.error("Record 2 {} {} {}", "arg3", "arg4", "arg5", throwable);

The resulted logs will contain following entries in CSV format −

arg1,arg2
arg3,arg4,arg5

CSVParameterLayout Configuration

CSVParameterLayout can be configured with following parameters:

We need following jars in the classpath −

commons-csv-1.14.1.jar commons-codec-1.19.0.jar

Example - Usage of CSVParameterLayout

Following is a simple configuration file for CSVParameterLayout:

log4j2.properties

# Define the appender
appender.0.type = Console
appender.0.name = CONSOLE

appender.0.layout.type = CsvParameterLayout

# Define the root logger with appender Console
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = CONSOLE

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Record 1 {} {}", "arg1", "arg2");
      LOGGER.info("Record 2 {} {} {}", "arg1", "arg2", "arg3");
   }
}

Output

Compile and run the above program. Console will print the following log information:

arg1,arg2
arg1,arg2,arg3

log4j - CSV Log Event Layout

If you want to encode your complete logging information in an CSV-formatted file, then you can use org.apache.logging.log4j.CSVLogEventLayout to format your logging information.

The CSVLogEventLayout class encodes all details of the message of log event.

For example, consider the below log statements −

LOGGER.info("Record 1 {} {}", "arg1", "arg2");
LOGGER.error("Record 2 {} {} {}", "arg3", "arg4", "arg5", throwable);

The resulted logs will contain following entries in CSV format −

0,1757242265192,DEBUG,1,main,5,Record 1 arg1 arg2,org.apache.logging.log4j.spi.AbstractLogger,com.tutorialspoint.Log4jDemo,,,com.tutorialspoint.Log4jDemo.main(Log4jDemo.java:12),{},[]
0,1757242265199,INFO,1,main,5,Record 2 arg1 arg2 arg3,org.apache.logging.log4j.spi.AbstractLogger,com.tutorialspoint.Log4jDemo,,,com.tutorialspoint.Log4jDemo.main(Log4jDemo.java:13),{},[]

CSVLogEventLayout Fields

CSVLogEventLayout generate records with following fields of a log event:

• Time (in nanoseconds)

• Time (in milliseconds)

• Level

• Thread ID

• Thread name

• Thread priority

• Message (formatted, hence including parameters)

• Logger FQCN

• Logger name

• Marker

• Throwable

• Source

• Thread context map

• Thread context stack

CSVLogEventLayout Configuration

CSVLogEventLayout can be configured with following parameters:

We need following jars in the classpath −

commons-csv-1.14.1.jar commons-codec-1.19.0.jar

Example - Usage of CSVLogEventLayout

Following is a simple configuration file for CSVLogEventLayout:

log4j2.properties

# Define the appender
appender.0.type = Console
appender.0.name = CONSOLE

appender.0.layout.type = CSVLogEventLayout

# Define the root logger with appender Console
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = CONSOLE

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Record 1 {} {}", "arg1", "arg2");
      LOGGER.info("Record 2 {} {} {}", "arg1", "arg2", "arg3");
   }
}

Output

Compile and run the above program. Console will print the following log information:

0,1757242265192,DEBUG,1,main,5,Record 1 arg1 arg2,org.apache.logging.log4j.spi.AbstractLogger,com.tutorialspoint.Log4jDemo,,,com.tutorialspoint.Log4jDemo.main(Log4jDemo.java:12),{},[]
0,1757242265199,INFO,1,main,5,Record 2 arg1 arg2 arg3,org.apache.logging.log4j.spi.AbstractLogger,com.tutorialspoint.Log4jDemo,,,com.tutorialspoint.Log4jDemo.main(Log4jDemo.java:13),{},[]

log4j - HTMLLayout

If you want to generate your logging information in an HTML-formatted file, then you can use org.apache.logging.log4j.HTMLLayout to format your logging information.

The HTMLLayout class extends the abstract org.apache.logging.log4j.Layout class and overrides the format() method from its base class to provide HTML-style formatting.

It provides the following information to be displayed:

• The time elapsed from the start of the application before a particular logging event was generated.

• The name of the thread that invoked the logging request.

• The level associated with this logging request.

• The name of the logger and logging message.

• The optional location information for the program file and the line number from which this logging was invoked.

HTMLLayout Methods

HTMLLayout is a very simple Layout object that provides the following methods:

Example - Usage of HTMLLayout

Following is a simple configuration file for HTMLLayout:

log4j2.properties

// Define a File Appender with HTMLLayout
appender.0.type = File
appender.0.name = MAIN
appender.0.fileName = logs/htmlLayout.html
appender.0.layout.type = HTMLLayout
appender.0.layout.Title=HTML Layout Example
appender.0.layout.LocationInfo=true

rootLogger.level = DEBUG
// Attach the appender to rootLogger
rootLogger.appenderRef.0.ref = MAIN
rootLogger.appenderRef.0.level = INFO

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();
   
   public static void main(String[] args) {  
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

Output

Compile and run the above program. It would create an htmlLayout.html file in logs directory which would have the following log information:

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta charset="UTF-8"/>
<title>HTML Layout Example</title>
<style type="text/css">
<!--
body, table {font-family:arial,sans-serif; font-size: medium
;}th {background: #336699; color: #FFFFFF; text-align: left;}
-->
</style>
</head>
<body bgcolor="#FFFFFF" topmargin="6" leftmargin="6">
<hr size="1" noshade="noshade">
Log session start time Fri Sep 05 20:06:22 IST 2025<br>
<br>
<table cellspacing="0" cellpadding="4" border="1" bordercolor="#224466" width="100%">
<tr>
<th>Time</th>
<th>Thread</th>
<th>Level</th>
<th>Logger</th>
<th>File:Line</th>
<th>Message</th>
</tr>

<tr>
<td>637</td>
<td title="main thread">main</td>
<td title="Level">INFO</td>
<td title="com.tutorialspoint.Log4jDemo logger">com.tutorialspoint.Log4jDemo</td>
<td>Log4jDemo.java:14</td>
<td title="Message">Hello this is an info message</td>
</tr>
</table>
<br>
</body></html>

You would use a web browser to open htmlLayout.html file.

One of the big advantages of having the log file in HTML format is that it can be published as a web page for remote viewing.

log4j - PatternLayout

If you want to generate your logging information in a particular format based on a pattern, then you can use org.apache.log4j.PatternLayout to format your logging information.

The PatternLayout class extends the abstract org.apache.logging.log4j.Layout class and overrides the format() method to structure the logging information according to a supplied pattern.

PatternLayout is also a simple Layout object that provides the following-Bean Property which can be set using the configuration file:

Pattern Conversion Characters

The following table explains the characters used in the above pattern and all other characters that you can use in your custom pattern:

Format Modifiers

By default, the relevant information is displayed as output as is. However, with the aid of format modifiers, it is possible to change the minimum field width, the maximum field width, and justification.

Following table covers various modifiers scenarios:

Example - Usage of PatternLayout

Following is a simple configuration file for PatternLayout:

log4j2.properties

// Define a Console Appender with PatternLayout
appender.0.type = Console
appender.0.name = CONSOLE
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %d{yyyy-MM-dd}-%t-%x-%-5p-%-10c:%m%n

rootLogger.level = DEBUG
// Attach the appender to rootLogger
rootLogger.appenderRef.0.ref = CONSOLE

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

Compile and run the above program. It would print following log information on the console:

2025-09-05-main-[]-DEBUG-com.tutorialspoint.Log4jDemo:Hello this is an debug message
2025-09-05-main-[]-INFO -com.tutorialspoint.Log4jDemo:Hello this is an info message

log4j - Json Template Layout

If you want to encode your complete logging information in a JSON formatted file, then you can use org.apache.logging.log4j.JsonTemplateLayout to format your logging information.

JsonTemplateLayout is highly customizable, efficient layout. It is a garbage-free JSON generating layout as well. LogEvents are genereated according to the structure described by the JSON template provided in classpath.

CustomLayout.json

{
   "instant": { 
      "$resolver": "timestamp",
      "pattern": {
         "format": "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
         "timeZone": "UTC"
      }
   },
   "aConstant": 1, 
   "message": { 
      "$resolver": "message",
      "stringified": true
   }
}

log4j2.properties

appender.0.layout.type = JsonTemplateLayout
appender.0.layout.eventTemplateUri = classpath:CustomLayout.json

log4j2.xml

<Appenders>
   <Console name="logFile">
      <JsonTemplateLayout eventTemplateUri="classpath:CustomLayout.json"/>
</Appenders>

Example - Usage of JsonTemplateLayout

Following is a simple configuration file for JsonTemplateLayout:

log4j2.properties

# Define the appender
appender.0.type = Console
appender.0.name = CONSOLE

appender.0.layout.type = JsonTemplateLayout
appender.0.layout.eventTemplateUri = classpath:CustomLayout.json

# Define the root logger with appender Console
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = CONSOLE

Now create a template json in current classpath:

CustomLayout.json

{
   "instant": { 
      "$resolver": "timestamp",
      "pattern": {
         "format": "yyyy-MM-dd'T'HH:mm:ss.SSS'Z'",
         "timeZone": "UTC"
      }
   },
   "aConstant": 1, 
   "message": { 
      "$resolver": "message",
      "stringified": true
   }
}

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

Output

Compile and run the above program. Console will print the following log information:

{"instant":"2025-09-07T14:58:18.268Z","aConstant":1,"message":"Hello this is an debug message"}
{"instant":"2025-09-07T14:58:18.273Z","aConstant":1,"message":"Hello this is an info message"}

log4j - Logging in Files

Apache log4j provides various Appender objects, each of which can be used to log data in files as per customized needs.

File Appenders

Following are most commonly Use Cases:

• FileAppender

• Separate Folder per Month

• Daily log File Generation

XML Based Configuration

Following is a sample XML Based configuration of a FileAppender

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="logFile" packages="">
   <Appenders>
      <File name="logFile" fileName="logs/app.log">
      <PatternLayout>
         <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      </File>
   </Appenders>
   <Loggers>
      <Root level="error">
         <AppenderRef ref="logFile"/>
      </Root>
   </Loggers>
</Configuration>

We're using Appenders tag to contain a File tag to define the File Appender which is further writing to a log file app.log using PatternLayout.

Properties Based Configuration

Following is a sample properties Based configuration of a FileAppender

log4j2.properties

appender.0.type = File
appender.0.name = logFile
appender.0.fileName = logs/app.log
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %d %p %c{1.} [%t] %m%n

rootLogger.level = ERROR
rootLogger.appenderRef.0.ref = FILE

log4j - FileAppender

A FileAppender is an object of ObjectStreamAppender and is used to write to a file named using fileName parameter in log4j configuration.

log4j2.properties

appender.0.type = File
appender.0.name = logFile

log4j2.xml

<Appenders>
   <File name="logFile" fileName="logs/app.log">
      <PatternLayout>
         <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
   </File>
</Appenders>

FileAppender uses FileManger, a subclass of OutputStreamManager to perform the I/O.

FileAppender Configuration

FileAppender has the following configurable parameters:

RollFile Appender Configuration Examples

Following is a sample configuration file log4j2.properties for FileAppender −

log4j2.properties

# Define the file appender
appender.0.type = File

# Set the name of the file appender
appender.0.name = logFile

# Set the name of the file
appender.0.fileName = logs/app.log

# Define the layout for file appender
appender.0.layout.type = PatternLayout
appender.0.layout.pattern = %d %p %c{1.} [%t] %m%n

# Define the root logger with appender file
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = logFile

If you wish to have an XML configuration file equivalent to the above log4j.properties file, then here is the content:

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="logFile" packages="">
   <Appenders>
      <File name="logFile" fileName="logs/app.log">
      <PatternLayout>
         <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
      </PatternLayout>
      </File>
   </Appenders>
   <Loggers>
      <Root level="debug">
         <AppenderRef ref="logFile"/>
      </Root>
   </Loggers>
</Configuration>

Example - Usage of FileAppender

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

We're using log4j2.properties file.

Output

Compile and run the above program. It would create a app.log file in logs directory which would have the following log information:

2025-09-06 07:05:27,262 DEBUG c.t.Log4jDemo [main] Hello this is an debug message
2025-09-06 07:05:27,264 INFO c.t.Log4jDemo [main] Hello this is an info message

log4j - Separate folder per month

You may want to write your log messages into sepearate folder on monthly basis. We're creating a separate folder for each month.

To write your logging information into multiple files, you would have to use org.apache.logging.log4j.RollingFileAppender class which extends the FileAppender class and inherits all its properties.

log4j2.properties

appender.0.type = RollingFile
appender.0.name = logFile

log4j2.xml

<Appenders>
   <RollingFile name="logFile" filePattern="logs/%d{yyyy-MM}/%d{yyyy-MM-dd}.log.zip">
      <JsonTemplateLayout/>
      <DirectWriteRolloverStrategy>
         <Delete basePath="logs" maxDepth="2">            
            <IfLastModified age="P90D"/>
         </Delete>
      </DirectWriteRolloverStrategy>
      <TimeBasedTriggeringPolicy/>
   </RollingFile>
</Appenders>

RollingFileAppender Configuration

RollingFileAppender has the following configurable parameters:

RollingFileAppender Configuration Examples

Following is a sample configuration file log4j2.properties for RollingFileAppender −

log4j2.properties

# Define the rolling file appender
appender.0.type = RollingFile
appender.0.name = logFile

# Set the file pattern
appender.0.filePattern = logs/%d{yyyy-MM]/%d{yyyy-MM-dd}.log.zip
appender.0.layout.type = JsonTemplateLayout

# set the roll over startegy
# we're creating a new log file every day
# and deleting 15 days old log files
appender.0.strategy.type = DirectWriteRolloverStrategy
appender.0.strategy.delete.type = Delete
appender.0.strategy.delete.basePath = logs
appender.0.strategy.delete.maxDepth = 2
appender.0.strategy.delete.0.type = IfLastModified
appender.0.strategy.delete.0.age = P15D
appender.0.policy.type = TimeBasedTriggeringPolicy

# Define the root logger with appender file
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = logFile

If you wish to have an XML configuration file equivalent to the above log4j.properties file, then here is the content:

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="logFile" packages="">
   <Appenders>
      <RollingFile name="logFile" filePattern="logs/%d{yyyy-MM}/%d{yyyy-MM-dd}.log.zip">
         <JsonTemplateLayout/>
         <DirectWriteRolloverStrategy>
            <Delete basePath="logs" maxDepth="2">            
               <IfLastModified age="P90D"/>
            </Delete>
         </DirectWriteRolloverStrategy>
         <TimeBasedTriggeringPolicy/>
      </RollingFile>
   </Appenders>
   <Loggers>
      <Root level="debug">
         <AppenderRef ref="logFile"/>
      </Root>
   </Loggers>
</Configuration>

Example - Usage of FileAppender

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

We're using log4j2.properties file.

Output

Compile and run the above program. It would create a folder similar to 2025-09-07 folder in logs directory which contains a log file having the following log information:

{"@timestamp":"2025-09-07T03:33:26.911Z","ecs.version":"1.2.0","log.level":"DEBUG","message":"Hello this is an debug message","process.thread.name":"main","log.logger":"com.tutorialspoint.Log4jDemo"}
{"@timestamp":"2025-09-07T03:33:26.915Z","ecs.version":"1.2.0","log.level":"INFO","message":"Hello this is an info message","process.thread.name":"main","log.logger":"com.tutorialspoint.Log4jDemo"}

log4j - Daily Log File Generation

There may be a requirement to generate your log files on a daily basis to keep a clean record of your logging information.

To write your logging information into multiple files, you would have to use org.apache.logging.log4j.RollingFileAppender class which extends the FileAppender class and inherits all its properties.

log4j2.properties

appender.0.type = RollingFile
appender.0.name = logFile

log4j2.xml

<Appenders>
   <RollingFile name="logFile" filePattern="logs/app.%d{yyyy-MM-dd}.log.zip">
      <JsonTemplateLayout/>
      <DirectWriteRolloverStrategy>
         <Delete basePath="logs"> 
            <IfFileName regex="app\.\d{4}-\d{2}-\d{2}\.log\.zip"/> 
            <IfLastModified age="P15D"/>
         </Delete>
      </DirectWriteRolloverStrategy>
      <TimeBasedTriggeringPolicy/>
   </RollingFile>
</Appenders>

RollingFileAppender Configuration

RollingFileAppender has the following configurable parameters:

RollingFileAppender Configuration Examples

Following is a sample configuration file log4j2.properties for RollingFileAppender −

log4j2.properties

# Define the rolling file appender
appender.0.type = RollingFile
appender.0.name = logFile

# Set the file pattern
appender.0.filePattern = logs/app.%d{yyyy-MM-dd}.log.zip
appender.0.layout.type = JsonTemplateLayout

# set the roll over startegy
# we're creating a new log file every day
# and deleting 15 days old log files
appender.0.strategy.type = DirectWriteRolloverStrategy
appender.0.strategy.delete.type = Delete
appender.0.strategy.delete.basePath = logs
appender.0.strategy.delete.0.type = IfFileName
appender.0.strategy.delete.0.regex = app\\.\\d{4}-\\d{2}-\\d{2}\\.log\\.zip
appender.0.strategy.delete.1.type = IfLastModified
appender.0.strategy.delete.1.age = P15D
appender.0.policy.type = TimeBasedTriggeringPolicy

# Define the root logger with appender file
rootLogger.level = DEBUG
rootLogger.appenderRef.0.ref = logFile

If you wish to have an XML configuration file equivalent to the above log4j.properties file, then here is the content:

log4j2.xml

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="warn" name="logFile" packages="">
   <Appenders>
      <RollingFile name="logFile" filePattern="logs/app.%d{yyyy-MM-dd}.log.zip">
         <JsonTemplateLayout/>
         <DirectWriteRolloverStrategy>
            <Delete basePath="/var/log"> 
               <IfFileName regex="app\.\d{4}-\d{2}-\d{2}\.log\.gz"/> 
               <IfLastModified age="P15D"/>
            </Delete>
         </DirectWriteRolloverStrategy>
         <TimeBasedTriggeringPolicy/>
      </RollingFile>
   </Appenders>
   <Loggers>
      <Root level="debug">
         <AppenderRef ref="logFile"/>
      </Root>
   </Loggers>
</Configuration>

Example - Usage of FileAppender

Now consider the following Java Example which would generate logging information:

Log4jDemo.java

package com.tutorialspoint;

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

public class Log4jDemo{

   /* Get actual class name to be printed on */
   private static final Logger LOGGER = LogManager.getLogger();

   public static void main(String[] args) {
      LOGGER.debug("Hello this is an debug message");
      LOGGER.info("Hello this is an info message");
   }
}

We're using log4j2.properties file.

Output

Compile and run the above program. It would create a file similar to app.2025-09-06 file in logs directory which would have the following log information:

{"@timestamp":"2025-09-06T08:20:15.900Z","ecs.version":"1.2.0","log.level":"DEBUG","message":"Hello this is an debug message","process.thread.name":"main","log.logger":"com.tutorialspoint.Log4jDemo"}
{"@timestamp":"2025-09-06T08:20:15.904Z","ecs.version":"1.2.0","log.level":"INFO","message":"Hello this is an info message","process.thread.name":"main","log.logger":"com.tutorialspoint.Log4jDemo"}