How to log messages to File and Console in Java using Log4j? Example Tutorial

Hello guys, if you are wondering how to use a logging library like Log4j or SLF4j in Java then you have come to the right place. In this tutorial, you will learn how to implement logging in your Java program using the Log4j library. Log4j is a Java based open source library from Apache Software Foundation, which is widely used for logging messages in Java applications. In order to use log4j in your application, you first need to download log4j.jar files from https://logging.apache.org/log4j/2.x/download.html site. You can download either the zip version or the tar version depending upon whether you are running your Java program in UNIX or Windows. If you are using Maven then you can also add the following dependency in your pom.xml file and Maven will take care of downloading JAR files. 

If you are writing programs in Eclipse or Command prompt make sure you add these JAR files into your CLASSPATH, if Java will not found these jars it will throw several compile-time errors and  ClassNotFoundException at runtime, in case it is not available when you run your program. For purpose of this program you can download the latest log4j JAR files: apache-log4j-2.3-src.zip, this contains log4j-2.3.jar file.

Maven users, please add following dependency in your application's pom.xml file :

<dependency>
    <groupId>org.apache.logging.log4j</groupId>
    <artifactId>log4j</artifactId>
    <version>2.3</version>
    <type>pom</type>
</dependency>

This tutorial is divided into two parts, in first we will learn how to log messages into console using Log4j and in second part we will learn how to log messages into a log file. 

How to log messages into console using Log4j? Example 

Logging messages into the console using Log4j involves configuring Log4j properly and then utilizing its logging methods in your Java code. Here's how you can do it:

Here are the steps you can follow to start logging message into console using Log4j API in Java

Add Log4j Library: Make sure you have the Log4j library added to your project's dependencies. You can download it from the Apache Log4j website or use a build tool like Maven or Gradle to manage dependencies.


Create a Log4j Configuration File: Create a Log4j configuration file (e.g., log4j2.xml or log4j.properties). Place this file in your application's classpath. Below is an example log4j2.xml configuration for logging messages to the console:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
        </Console>
    </Appenders>
    <Loggers>
        <Root level="debug">
            <AppenderRef ref="ConsoleAppender" />
        </Root>
    </Loggers>
</Configuration>

This configuration sets up a console appender to print log messages to the standard output (console). You can customize the log message format using the <PatternLayout> element.

Initialize Log4j:

In your Java code, initialize Log4j. Typically, you would do this in your application's entry point or configuration setup:

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

public class MyApp {
    private static final Logger logger = LogManager.getLogger(MyApp.class);

    public static void main(String[] args) {
        logger.debug("Debug message");
        logger.info("Info message");
        logger.warn("Warning message");
        logger.error("Error message");
        logger.fatal("Fatal message");
    }
}

Run Your Application:

When you run your application, Log4j will use the configured settings to log messages to the console.

Adjust the configuration and log levels (debug, info, warn, error, fatal) according to your needs. You can also customize the logging format by modifying the <PatternLayout> element in the configuration file.

Remember that the specifics might vary depending on the version of Log4j you're using. Always refer to the official Log4j documentation for the version you're working with.

How does it work?

In this program, we have created a Logger object by passing the .class instance of the class where it belongs. Now we will use this Logger instance to log messages. Remember, when we log messages we don't specify whether to display it on console or file, it's just a log message and later by changing log4j configuration, we will route that message to either console or file or both. 

In order to log messages, you can call any of Logger methods e.g. info(), error() or debug(). These method logs message on respective log levels. There are 6 log level in Log4j, trace < debug < info < warn < error < fatal. trace is on lowest priority and fatal is the highest priority log level. 

You can set your application's log level form log4j properties file, which we will see later in this tutorial. Once you set a log level, all messages from that log level and higher priority level will be logged but messages from lower priority level will be suppressed. 

For example, if you set the log level as ERROR, which we normally use in production then only messages which is logged with log level ERROR and FATAL will be logged. Similarly, if you set the log level to DEBUG, as we do in Development, it will print messages from debug, info, warn, error and fatal log level, but messages from TRACE log level will be suppressed. 

How to log message into a Log file?

Continuing from the previous steps, here's how you can configure Log4j to log messages to a file:

Modify Log4j Configuration:

Update your Log4j configuration file (e.g., log4j2.xml or log4j.properties) to include a file appender. Here's an example of how to log messages to both the console and a file:

<?xml version="1.0" encoding="UTF-8"?>
<Configuration status="INFO">
    <Appenders>
        <Console name="ConsoleAppender" target="SYSTEM_OUT">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
        </Console>
        <File name="FileAppender" fileName="app.log">
            <PatternLayout pattern="%d{HH:mm:ss.SSS} [%t] %-5level %logger{36} - %msg%n" />
        </File>
    </Appenders>
    <Loggers>
        <Root level="debug">
            <AppenderRef ref="ConsoleAppender" />
            <AppenderRef ref="FileAppender" />
        </Root>
    </Loggers>
</Configuration>

In this example, the File appender is named "FileAppender" and logs messages to a file named "app.log". You can customize the file name and path as needed.

Initialize Log4j in Java Code:

The Java code remains the same. Log4j will use the updated configuration to log messages to both the console and the file:

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

public class MyApp {
    private static final Logger logger = LogManager.getLogger(MyApp.class);

    public static void main(String[] args) {
        logger.debug("Debug message");
        logger.info("Info message");
        logger.warn("Warning message");
        logger.error("Error message");
        logger.fatal("Fatal message");
    }
}

Run Your Application:

When you run your application, Log4j will log messages to both the console and the specified file ("app.log" in this case).

Remember to adjust the log file path, format, and log levels as needed. The above example demonstrates a basic setup. Make sure to follow best practices for log file management, such as log rotation and proper file naming conventions, especially in production environments.

How to deal with log4J related error?

When you run a program that utilizes Log4j for logging, there are several setup-related errors that you might encounter. Here are a few common setup-related errors and their potential causes:

1. Log4j Configuration File Not Found:

Error: log4j:WARN No appenders could be found for logger...

Cause: The Log4j configuration file (log4j2.xml or log4j.properties) is not located in the classpath or is named incorrectly.

Solution: Ensure the configuration file is present in the classpath and properly named.

2. Incorrect Configuration Syntax:

Error: ERROR StatusLogger No log4j2 configuration file found. Using default configuration...

Cause: There is a syntax error or misconfiguration in the Log4j configuration file.

Solution: Review the configuration file for syntax errors, missing elements, or incorrect settings.

3. Missing Log4j Library:

Error: java.lang.NoClassDefFoundError: org/apache/logging/log4j/LogManager

Cause: The Log4j library is not included in the classpath.

Solution: Add the Log4j library to your project's dependencies.

4. Conflicting Log4j Configurations:

Error: Logging behaves unexpectedly or logs appear in unexpected locations.

Cause: Multiple Log4j configuration files are present, causing conflicting configurations.

Solution: Ensure there is only one valid Log4j configuration file in the classpath.

5. Incorrect Log Level Configuration:

Error: Some log levels (e.g., DEBUG, INFO) do not produce output as expected.

Cause: The log level configuration in the Log4j configuration file is set too high, suppressing lower-level log messages.

Solution: Adjust the log level configuration to the desired level.

6. Permissions and File Access Issues:

Error: java.io.FileNotFoundException or java.io.IOException related to log files.

Cause: Insufficient permissions to write to the log file's location.

Solution: Ensure the application has appropriate write permissions for the specified log file directory.

7. Classpath and Resource Loading Issues:

Error: Unable to locate or load the Log4j configuration file or resources.

Cause: Issues with classpath settings or resource loading mechanisms.

Solution: Verify classpath settings and ensure the configuration file is accessible.

8. Log Output Not As Expected:

Error: Log messages are not appearing where expected or are not formatted correctly.

Cause: Issues in the Log4j configuration affecting log output.

Solution: Review and adjust the Log4j configuration file to achieve the desired log output.

Remember to carefully review the error messages and investigate the potential causes to address setup-related issues when working with Log4j.

In conclusion, understanding how to effectively use Log4j for logging in your Java applications is crucial for maintaining code quality, diagnosing issues, and monitoring application behavior. Log4j provides a flexible and configurable logging framework that allows you to control what information is logged, where it is logged, and how it is formatted. By following best practices and proper setup, you can harness the power of Log4j to enhance your development and troubleshooting processes.