Log4J - Logging Java Applications
Course Schedule
Day 1 of 1
Log4j Concepts
-Logger
-Appender
-Layout
Installation of Log4j
Configuring Log4j
Demo examples on logging with Log4j , in core/web java apps
Lab exercises
Course Objectives
Understanding Logging with Log4j
Using Log4j within java applications
Understanding Logging with Log4j
Understanding Logging
What is Logging
Why Logging is required
Logging requirements
What is Log4j
Log4j Concepts
Installation of Log4j
Configuring Log4j
Logging Examples
What is Logging
Logging is writing the state of a program at various stages of its
execution to some repository such as a log file
Why Logging is required
By Logging, simple yet explanatory statements can be sent to
text file, console, or any other repository
A reliable monitoring and debugging solution can be achieved.
Logging requirements
An easy-to-use and efficient open source utility is required to
solve the Logging problems such as ..
- Logging , an overhead for the programmers
- Messy codes due to Logging statements
- Inserting log statements manually is tedious and timeconsuming
- Due to the ongoing upgrading and bug-fixing process for
application code ,managing the log statements in the code is
tedious
What is Log4j
Log4j is an open source logging API for Java
Log4j
- handles inserting log statements in application code and
managing them externally without touching application code,
by using external configuration files
- categorizes log statements according to user-specified
criteria and assigns different priority levels to these log
statements
What is Log4j
Log4j
- lets users choose from several destinations for log statements,
such as console, file, database, SMTP servers, GUI
components etc.
- facilitates creation of customized formats for log output and
provides default formats
Advantages of using log4j
Organizes the log output in separate categories , makes
pinpointing the source of an error easy
Log4j facilitates external configuration at runtime, makes the
management and modification of log statements very simple
Log4j assigns priority levels to loggers and log requests , helps
weed out unnecessary log output and allows only important log
statements to be logged
Log4j Concepts
Log4j is comprised of three main components:
- Logger
- Appender
- Layout
The functionalities of each of these components are accessible
through Java classes of the same name
Users can extend these basic classes to create their own loggers,
appenders, and layouts
Log4j Concepts - Logger
The component logger accepts log requests generated by log
statements
It then sends their output to appropriate destination
These destinations are termed as appenders
The logger component is accessible through the Logger class of
the log4j API
Log4j Concepts - Logger
This class provides a static method Logger.getLogger(name)
This method either
- retrieves an existing logger object by the given name
- or , creates a new logger of given name if none exists
The logger object is then used to .
- set properties of logger component
- invoke methods which generate log requests
debug(), info(), warn(), error(), fatal(), and log()
Log4j Concepts - Logger
Each class in the Java application being logged can have an
individual logger assigned to it or share a common logger with
other classes
Any number of loggers can be created for the application to suit
specific logging needs
It is a common practice to create one logger for each class, with
a name same as the fully-qualified class name
Log4j Concepts - Logger
Log4j provides a default root logger that all user-defined loggers
inherit from
Root logger is at the top of the logger hierarchy of all logger
objects created
If an application class doesn't have a logger assigned to it, it can
still be logged using the root logger
Root logger always exists and cannot be retrieved by name
Logger - ways to create a logger
retrieve the root logger:
Logger logger = Logger.getRootLogger();
create a new logger:
Logger logger = Logger.getLogger("MyLogger");
instantiate a static logger globally, based on the name of the
class:
static Logger logger = Logger.getLogger(test.class);
set the level with:
logger.setLevel((Level)Level.WARN);
Logger - Example
MyClass is a class in com.foo.sampleapp application package
It can have a logger named com.foo.sampleapp.MyClass
Instantiated using
Logger.getLogger("com.foo.sampleapp.MyClass")
Logger - Priority levels
Loggers can be assigned different levels of priorities
priority levels in ascending order of priority
- DEBUG
- INFO
- WARN
- ERROR
- FATAL
There are printing methods for each of these priority levels
mylogger.info("logstatement1");
- generates log request of priority level INFO for logstatement1
Logger - Priority levels
In addition, there are two special levels of logging available
- ALL : has lowest possible rank, is intended to turn on all
logging
- OFF : has highest possible rank,is intended to turn off
logging
The behavior of loggers is hierarchical
Logger - Priority levels
The root logger is assigned the default priority level DEBUG
All loggers inherit priority level from their parent or nearest
existing ancestor logger, which is in effect until they are
assigned another priority level
A logger object can be programmatically assigned a priority level
by invoking its method
- setLevel(Level.x)
Logger - Priority levels
A logger will enable only those log requests with a priority level
equal to or greater than its own
This technique helps prevent log statements of lesser
importance from being logged
This concept is the core of log4j functionality
Logger - Priority levels
The behavior of loggers is hierarchical. The following table
illustrates this
Logger Output Hierarchy
Logger - Priority levels
Few points to make .
A logger will only output messages that are of a level greater
than or equal to it
If the level of a logger is not set it will inherit the level of the
closest ancestor
If a logger is created in the package com.foo.bar and no level is
set for it, it will inherit the level of the logger created in
com.foo
If no logger was created in com.foo, the logger created in
com.foo.bar will inherit the level of the root logger
The root logger is always instantiated and available, the root
logger is assigned the level DEBUG
Priority levels - Example
/* Instantiate a logger named MyLogger */
Logger mylogger = Logger.getLogger("MyLogger");
/* Set logger priority l*/
mylogger.setLevel(Level.INFO);
/* statement logged, since INFO = INFO*/
mylogger.info(" values ");
/* statement not logged, since DEBUG < INFO*/
mylogger.debug(not logged");
/* statement logged, since ERROR >INFO*/
mylogger.error(logged");
Log4j Concepts - Appender
Appender component is interface to the destination of log
statements, a repository where the log statements are
written/recorded
A logger receives log request from log statements being
executed, enables appropriate ones, and sends their output to
the appender(s) assigned to it
The appender writes this output to repository associated with it
Log4j Concepts - Appender
There are various appenders available such as..
ConsoleAppender appends log events to System.out or
System.err using a layout specified by the user. The default
target is System.out
FileAppender appends log events to a file
WriterAppender appends log events to a Writer or an
OutputStream depending on the user's choice
RollingFileAppender extends FileAppender to backup the log files
when they reach a certain size
DailyRollingFileAppender extends FileAppender so that the
underlying file is rolled over at a user chosen frequency
Log4j Concepts - Appender
The various appenders available ...
SMTPAppender sends an e-mail when a specific logging event
occurs, typically on errors or fatal errors
SyslogAppender sends messages to a remote syslog daemon
TelnetAppender specializes in writing to a read-only socket
SocketAppender sends LoggingEvent objects to a remote a log
server, usually a SocketNode
SocketHubAppender sends LoggingEvent objects to a set of
remote log servers, usually a SocketNodes
Log4j Concepts - Appender
An appender is assigned to a logger using the addAppender( )
method of the Logger class, or through external configuration
files
A logger can be assigned one or more appenders that can be
different from appenders of another logger
This is useful for sending log outputs of different priority levels
to different destinations for better monitoring
Log4j Concepts - Appender
A logger also implicitly inherits appenders from its parents
Therefore, the log requests accepted by logger are sent to its
own appenders along with that of all its ancestors. This
phenomenon is known as appender additivity
Appender Creating Appenders
ConsoleAppender appender = new ConsoleAppender(new PatternLayout());
FileAppender appender = null;
try { appender = new FileAppender(new PatternLayout(),"filename"); }
catch(Exception e) {}
WriterAppender appender = null;
try {
appender =
new WriterAppender(new PatternLayout(),new FileOutputStream("filename"));
}
catch(Exception e) {}
Log4j Concepts - Layout
The Layout component defines the format in which the log
statements are written to the log destination by appender
Layout is used to specify the style and content of the log output
to be recorded
This is accomplished by assigning a layout to the appender
concerned
Log4j Concepts - Layout
The Layout component defines the format in which the log
statements are written to the log destination by appender
Layout is an abstract class in log4j API; it can be extended to
create user-defined layouts
Some readymade layouts are also available in log4j package;
they are PatternLayout, SimpleLayout, DateLayout, HTMLLayout,
and XMLLayout
Layout Type of Layouts
HTMLLayout formats the output as a HTML table
PatternLayout formats the output based on a conversion
pattern specified, or if none is specified, the default
conversion pattern
SimpleLayout formats the output in a very simple manner, it
prints the Level, then a dash '-' and then the log message
Installation Log4j
Download log4j-1.2.4.jar from http://logging.apache.org/log4j
Extract the log4j-1.2.4.jar at any desired location and include
its absolute path in the application's CLASSPATH
Now ,log4j API is accessible to user's application classes and can
be used for logging
Running Log4j
To log an application class, follow these steps
1. Import log4j package
2. Instantiate a logger object using Logger.getLogger( )
3. Instantiate layouts to be assigned to appenders
4. Instantiate appenders , passing layout object in constructor
5. Assign the appenders to the Logger invoking addAppender( )
6. Invoke printing methods on Logger to perform logging
Skip 3,4,5 in case of external configuration file used
First Logging Example
package com.patni.sampleapp;
import org.apache.log4j.*;
public class MyClass
{
static Logger myLogger = Logger.getLogger(MyClass.class.getName( ));
Appender myAppender;
SimpleLayout myLayout; Object x;
public MyClass()
{
myLogger.setLevel(Level.INFO); ...
myLayout = new SimpleLayout();
myAppender = new ConsoleAppender(myLayout);
...
myLogger.addAppender(myAppender); ...
}
public void do_something( int a, float b)
{
myLogger.info("Logged since INFO=INFO"); ...
myLogger.debug("not enabled, since DEBUG < INFO");
...
if (x == null)
{myLogger.error("enabled & logged ,since ERROR > INFO");...}
} public static void main(String args[]) { new MyClass().do_something(1,(float)1.2);}
}
Configuring Log4j
The log4j can be configured both programmatically and
externally using special configuration files
External configuration is most preferred, because to take effect
it doesn't require change in application code, recompilation, or
redeployment
Configuration files can be XML files or Java property files that
can be created and edited using any text editor or XML editor,
respectively
Configuring Log4j
The simplest configuration file will contain following
specifications that can be modified, both programmatically and
externally, to suit specific logging requirements
- priority level and name of appender assigned to root logger
- appender's type
- layout assigned to the appender
Programmatic Configuration
In the last example configuration was done programmatically
package com.patni.sampleapp;
import org.apache.log4j.*;
public class MyClass
{
static Logger myLogger = Logger.getLogger(MyClass.class.getName( ));
Appender myAppender;
SimpleLayout myLayout;
public MyClass()
{ myLogger.setLevel(Level.INFO); ...
myLayout = new SimpleLayout();
myAppender = new ConsoleAppender(myLayout);
myLogger.addAppender(myAppender); ...
}
...
Using Configuration Property Files
#A sample configuration file config-sample.properties in Java
#property format
# The root logger is assigned priority level DEBUG and an appender
# named myAppender
log4j.rootLogger=debug, myAppender
# The appender's type specified as ConsoleAppender, i.e. log output
# written to console
log4j.appender.myAppender=org.apache.log4j.ConsoleAppender
# The appender is assigned a layout SimpleLayout
# SimpleLayout will include only priority level of the log
# statement and the log statement itself in log output
log4j.appender.myAppender.layout=org.apache.log4j.SimpleLayout
Using Configuration Property Files
package com.patni.sampleapp;
import org.apache.log4j.*;
public class MyClass
{
static Logger myLogger = Logger.getLogger(MyClass.class.getName( ));
//no constructor required
public void do_something( int a, float b)
{
myLogger.info("Logged since INFO=INFO"); ...
myLogger.debug("not enabled, since DEBUG < INFO");
...
if (x == null)
{myLogger.error("enabled & logged ,since ERROR > INFO");...}
}
}
//Execute the file as
// java -Dlog4j.configuration=config-sample.propertis
com.patni.sampleapp.MyClass
Using Configuration Property Files
Another example
package com.patni.sampleapp;
import org.apache.log4j.*;
import org.apache.log4j.helpers.Loader;
import java.net.*;
public class MyClass
{
static Logger myLogger = Logger.getLogger(MyClass.class.getName( ));
public MyClass()
{
URL url = Loader.getResource("config-sample.properties");
PropertyConfigurator.configure(url);
}
public void do_something( int a, float b)
{
myLogger.info("Logged since INFO=INFO"); ...
myLogger.debug("not enabled, since DEBUG < INFO");
...
if (x == null)
{myLogger.error("enabled & logged ,since ERROR > INFO");...}
}
}
Using Configuration XML Files
A sample configuration file config-sample.xml in XML format
<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE log4j:configuration SYSTEM "log4j.dtd">
<log4j:configuration xmlns:log4j="http://jakarta.apache.org/log4j/">
<appender name="myAppender class="org.apache.log4j.ConsoleAppender">
<layout class="org.apache.log4j.SimpleLayout"/>
</appender>
<root>
<priority value="debug" />
<appender-ref ref="myAppender"/>
</root>
</log4j:configuration>
Using Configuration XML Files
package com.patni.sampleapp;
import org.apache.log4j.*;
import org.apache.log4j.helpers.Loader;
import org.apache.log4j.xml.DOMConfigurator;
import java.net.*;
public class MyClass
{
static Logger myLogger = Logger.getLogger(MyClass.class.getName( ));
public MyClass()
{
URL url = Loader.getResource("config-sample.xml");
DOMConfigurator.configure(url);
}
public void do_something( int a, float b)
{
myLogger.info("Logged since INFO=INFO"); ...
myLogger.debug("not enabled, since DEBUG < INFO");
if (x == null)
{myLogger.error("enabled & logged ,since ERROR > INFO");...}
...
Using Configuration Files
To use a log4j configuration file, it should be loaded using
following code, preferably inserted in startup class of the
application.
import org.apache.log4j.PropertyConfigurator; //.
PropertyConfigurator.configure("path/to/configuration_file");
// or
import org.apache.log4j.xml.DOMConfigurator; //.
DOMConfigurator.configure(path/to/xml file);
SimpleLayout and FileAppender
Example
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.FileAppender;
public class simpandfile
{ static Logger logger = Logger.getLogger(simpandfile.class);
public static void main(String args[])
{ SimpleLayout layout = new SimpleLayout();
FileAppender appender = null;
try { appender = new FileAppender(layout,"output1.txt",false); } catch(Exception e) {}
logger.addAppender(appender);
logger.setLevel((Level) Level.DEBUG);
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL"); } }
SimpleLayout and FileAppender
Example
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.SimpleLayout;
import org.apache.log4j.FileAppender;
public class simpandfile
{ static Logger logger = Logger.getLogger(simpandfile.class);
public static void main(String args[])
{ SimpleLayout layout = new SimpleLayout();
FileAppender appender = null;
try { appender = new FileAppender(layout,"output1.txt",false); } catch(Exception e) {}
logger.addAppender(appender);
logger.setLevel((Level) Level.DEBUG);
logger.debug("Here is some DEBUG");
logger.info("Here is some INFO");
logger.warn("Here is some WARN");
logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL"); } }
SimpleLayout and FileAppender
Example
Output of the above example is as shown below
DEBUG - Here is some DEBUG
INFO - Here is some INFO
WARN - Here is some WARN
ERROR - Here is some ERROR
FATAL - Here is some FATAL
HTMLLayout and WriterAppender
Example
import java.io.*;
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.HTMLLayout;
import org.apache.log4j.WriterAppender;
public class htmlandwrite
{ static Logger logger = Logger.getLogger(htmlandwrite.class);
public static void main(String args[])
{ HTMLLayout layout = new HTMLLayout();
WriterAppender appender = null;
try { FileOutputStream output = new FileOutputStream("output2.html");
appender = new WriterAppender(layout,output); } catch(Exception e) {}
logger.addAppender(appender); logger.setLevel((Level) Level.DEBUG);
logger.debug("Here is some DEBUG"); logger.info("Here is some INFO");
logger.warn("Here is some WARN"); logger.error("Here is some ERROR");
logger.fatal("Here is some FATAL"); } }
HTMLLayout and WriterAppender
Example
Output of the above example is as shown below
PatternLayout and ConsoleAppender
Example
import org.apache.log4j.Level;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.ConsoleAppender;
public class consandpatt { static Logger logger = ogger.getLogger(consandpatt.class);
public static void main(String args[])
{ // Note, %n is newline String pattern = "Milliseconds since program start: %r %n"; pattern +=
"Classname of caller: %C %n";
pattern += "Date in ISO8601 format: %d{ISO8601} %n";
pattern += "Location of log event: %l %n";
pattern += "Message: %m %n %n";
PatternLayout layout = new PatternLayout(pattern);
ConsoleAppender appender = new ConsoleAppender(layout);
logger.addAppender(appender); logger.setLevel((Level) Level.DEBUG); logger.debug("Here is
some DEBUG"); logger.info("Here is some INFO"); logger.warn("Here is some WARN");
logger.error("Here is some ERROR"); logger.fatal("Here is some FATAL"); } }
PatternLayout and ConsoleAppender
Example
Output of the above example is as shown below
Log4j Initialization in Web Containers
Most web containers load the classes of a web-application in a separate
class loader
You may have multiple copies of log4j classes loaded simultaneously
Each such copy will go through the default log4j initialization procedure
Different class loaders may load distinct copies of the same class
These copies of the same class are considered as totally unrelated by
the JVM
Placing logj-VERSION.jar in WEB-INF/lib directory of your webapplication will cause log4j classes to be loaded/unloaded whenever
your web-application is loaded/unloaded
Default Initialization under Tomcat
web-server environment
Log4j.jar is placed in the WEB-INF/lib directory of each of your
web-applications
Place the log4j.xml or log4j.properties under the WEBINF/classes
Log4j will find the properties file and initialization itself
Conclusion : Using log4j
The log4j API provides a means for inserting useful and
manageable log statements in the application code
Resources
Log4j is freely available to download from The Apache Jakarta
Project Web site http://logging.apache.org/log4j/
For documentation of the log4j API visit
http://jakarta.apache.org/log4j/docs/api/index.html
Thank you
