Interview Questions and Answers

Logging helps in debugging as well. Although debuggers are available but frankly it takes time to debug an application using a debugger. An application can be debugged more easily with few well-placed logging messages. So we can safely say that logging is a very good debugging tool. If logging is done sensibly and wisely, it can provide detailed context for application failures.
In distributed applications (e.g. web/remote applications), the logging is very important. The administrator can read logs to learn about the problems that occurred during some interval.
Java's built-in APIs provide logging options but they are not that flexible. Another option is to use Apache's open source logging framework called log4j. 

Drawbacks of logging applications:
There are some drawbacks of use logging in your application. For example: logging will
- pollute the code
- increase the size of the code
- reduce the speed

These are important points because, we ultimately want efficient applications. Log4J has the solution to this. You may turn on or turn off the logging at runtime by changing the configuration file. This means no change in the Java source code (binary).

• loggers
• appenders
• layouts

• Apache log4j is an open-source and due to this, it's completely free to use.
• You can easily save log information into either files or even databases.
• Can be used for projects of any size small, medium, or large.

The following are features of log4j:

• Log4j 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 a fail-stop. However, although it certainly strives to ensure delivery, log4j does not guarantee that each log statement will be delivered to its destination.

The two static methods in log4j for obtaining a logger object are:

• public static Logger getRootLogger()
• public static Logger getLogger(String name)

Log4j file is defined by the name log4j.properties, it keeps properties in key-value pairs. By default, the log manager looks for a file name log4j.properties in the CLASSPATH.

Package level logging is the standard logging of log4j, with this we would determine the package and the associated level.

Following are the Pros and Cons of Logging:

• Logging is an important component of 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 use.

The DEBUG log level designates fine-grained informational events that are most useful to debug an application.

The ERROR log level designates error events that might still allow the application to continue running.

The FATAL log level designates very severe error events that will presumably lead the application to abort.

The INFO log level designates informational messages that highlight the progress of the application at a coarse-grained level.

The OFF log level is the highest possible rank and is intended to turn off logging.

The TRACE log level designates finer-grained informational events than the DEBUG.

The WARN log level designates potentially harmful situations.

A log request of level p in a logger with level q is enabled if p >= q. This rule is at the heart of log4j. It assumes that levels are ordered. For the standard levels, we have ALL < DEBUG < INFO < WARN < ERROR < FATAL < OFF.

For example: if the log level is mentioned as 'WARN' in the log4j properties. Then the logs will be coming in the log file are: WARN, ERROR, FATAL

The following syntax defines the root logger with WARN mode turning DEBUG mode off.

# Define the root logger with appender file

log = /usr/home/log4j log4j.rootLogger = WARN, FILE

The log4j API provides the object org.apache.log4j.jdbc. JDBCAppender object can put logging information in a particular database.

Log4j level WARN gives a warning about an unpredicted event to the user. The messages coming out of this level may not stop the progress of the system.

The TRACE level provides more detailed information than the DEBUG level, and it will stay at the top of the hierarchy.

There are other support objects in the Log4j framework are:

• Level Object
• Filter Object
• Object Renderer
• Log Manager

Log4j is a thread-safe, log4j components are built to be used in multithread systems.

Yes, you can extend the layout class to create your own customized log format. Appenders can be parameterized to use the layout of your choice.

The system properties checked by log4j are

• Log4j debug, if true, log4j will show internal debugging messages to the console
• defaultInitOverride, if true, log4j will not execute default initialization
• configuration, URL for default initialization configuration file
• configurationClass, Class name for configurator to execute default initialization configuration file
• ignoreTCL, if true, the thread class loader will be overlooked when loading classes

Filter objects in log4j decide whether logging requests should be handled by a particular Appender or ignored.

You may have each process log to a socket Appender. The receiving socket server can receive all the events and send them to a single log file.

Both Threshold and LevelRangeFilter do the same thing.

However, the threshold should be faster. Filters enable you to implement your own logic, and you can also link them together if required. If you need a basic threshold functionality, then the “threshold” function will be enough.

The format characters used in log4j are

• L – it is used to output the line number from where the logging request was processed or issued
• m – It is used to output the application-supplied message related to the logging event
• p – It is used to output the priority of the logging event
• C – It is used to output the class name of the caller issuing the logging request

When any number is used along with the character it means the priority of the logging event should be justified to a width of 4 characters.

The best way to migrate from java.util logged to log4j is to use the global file search/replace method.  It will replace with “org.apache.log4j.Logger”.

Then verify the project with the build.

There could be two reasons why this might happen:

• Repeated configuration of log4j
• Attaching the same appenders to multiple loggers