Java Logging

August 4, 2023

What is Logging In Java?

Java Logging is a mechanism used to capture important messages generated by a Java application. It provides a way to track application behavior, diagnose issues, and monitor performance.

The Java Logging API is included in the Java Development Kit (JDK) and provides several built-in logging levels and handlers for directing log output to various destinations. Developers can also customize logging behavior through configuration files or programmatically.

To understand the Java Generics, Read the Complete Article.

Java Logging Components

The Java Logging API consists of several key components:

Logger: A Logger is the main class used to generate log messages. It can be configured to produce logs for different parts of an application or for different levels of severity.
Handler: A Handler is responsible for directing log messages to a particular destination, such as a file, console, or network socket.
Formatter: A Formatter specifies the format of the log messages generated by a Logger. It can be customized to include information such as timestamps, thread names, and logging levels.
Level: A Level is used to categorize log messages according to their severity. The Java Logging API defines several levels, including SEVERE, WARNING, INFO, CONFIG, FINE, FINER, and FINEST.
Filter: A Filter can be used to further refine the types of log messages that are produced by a Logger. It can be customized to include or exclude messages based on their content, source, or severity level.

Advantages of Java Logging:

Debugging: Logging can help developers identify and diagnose issues in their code by providing a detailed record of the application's behavior.

Monitoring: Logging can be used to monitor the performance of an application in production, allowing developers to identify performance bottlenecks or other issues.

Customization: The Java Logging API provides developers with a great deal of flexibility to customize logging behavior according to their needs, including the ability to set log levels, format log messages, and direct log output to different destinations.

Centralization: Logging can be used to centralize the logging of multiple applications or services, making it easier to manage and monitor logs across an entire system.

Introduction to java

static variable in java

If statement in Java

Switch Statement in Java

Abstraction in Java

Log Manager

LogManager is a class in the Java Logging API that manages the logging configuration for a Java application. It provides a central point for configuring logging behavior, including specifying the logging levels, output destinations, and formatting options for log messages.

Notes: The LogManager maintains a hierarchical namespace of Logger objects, which represent different parts of the application or different levels of logging severity.

Notes: The configuration of these Loggers can be customized through the LogManager's methods, such as getLogger(), readConfiguration(), addLogger(), and getLogManager().

To obtain an instance of the LogManager class in Java: LogManager logManager = LogManager.getLogManager();

Example 1: How logging works in java

Run

import java.util.logging.Level;
import java.util.logging.Logger;

public class Main {
    private static final Logger LOGGER = Logger.getLogger(Main.class.getName());

    public static void main(String[] args) {
        LOGGER.info("Starting the LoggingExample program");

        try {
            int result = 1 / 0;
        } catch (Exception e) {
            LOGGER.log(Level.SEVERE, "An error occurred", e);
        }

        LOGGER.info("Finishing the LoggingExample program");
    }
}

Output

Apr 14, 2023 7:03:53 AM Main main
INFO: Starting the LoggingExample program
Apr 14, 2023 7:03:53 AM Main main
SEVERE: An error occurred
java.lang.ArithmeticException: / by zero
	at Main.main(Main.java:11)

Apr 14, 2023 7:03:53 AM Main main
INFO: Finishing the LoggingExample program

Explanation:

This program uses the java.util.logging.Logger class to log messages to the console. The program starts by logging an informational message to indicate that it is starting. Then it attempts to divide by zero, which will generate an exception. The exception is caught and logged with a severity level of SEVERE, along with the stack trace of the exception. Finally, the program logs another informational message to indicate that it is finishing.

Example 2 : Logging the message

Run

import java.io.IOException;

import java.util.logging.*;

// CustomLoggingExample
  public class Main
{
  
private static final Logger LOGGER =
    Logger.getLogger (Main.class.getName ());
  
 
public static void main (String[]args) throws IOException
  {
    
      // Create a new console handler
    ConsoleHandler consoleHandler = new ConsoleHandler ();
    

      // Set the log level for the console handler
    consoleHandler.setLevel (Level.ALL);
    

      // Add the console handler to the logger
    LOGGER.addHandler (consoleHandler);
    

      // Set the log level for the logger
    LOGGER.setLevel (Level.INFO);
    

      // Log some messages with different levels
    LOGGER.severe ("This is a severe error");
    
LOGGER.warning ("This is a warning");
    
LOGGER.info ("This is an informational message");
    
LOGGER.config ("This is a configuration message");
    
LOGGER.fine ("This is a fine message");
    
LOGGER.finer ("This is a finer message");
    
LOGGER.finest ("This is a finest message");

} 
}

Output :

Apr 14, 2023 7:26:32 AM Main main
SEVERE: This is a severe error
Apr 14, 2023 7:26:32 AM Main main
SEVERE: This is a severe error
Apr 14, 2023 7:26:32 AM Main main
WARNING: This is a warning
Apr 14, 2023 7:26:32 AM Main main
WARNING: This is a warning
Apr 14, 2023 7:26:32 AM Main main
INFO: This is an informational message
Apr 14, 2023 7:26:32 AM Main main
INFO: This is an informational message

Explanation:

In this example, we first create a new ConsoleHandler object and set its logging level to Level.ALL, which means that it will log all messages regardless of their severity level. We then add this handler to the LOGGER object using its addHandler() method.

Next, we set the logging level for the LOGGER object itself to Level.INFO, which means that it will only log messages with a severity level of INFO or higher.

Finally, we log some messages using different severity levels to demonstrate how the logging behavior is affected by the console handler and logger settings.

Prime Course Trailer

Related Banners

Get PrepInsta Prime & get Access to all 200+ courses offered by PrepInsta in One Subscription

Get over 200+ course One Subscription

Courses like AI/ML, Cloud Computing, Ethical Hacking, C, C++, Java, Python, DSA (All Languages), Competitive Coding (All Languages), TCS, Infosys, Wipro, Amazon, DBMS, SQL and others