Hopefully a simple question but My google foo is failing me - I've got a maven project where we're using SLF4J with Log4J 1.2 bindings. We now want to move to Log4j 2 particularly for the performance improvement - however, I can't for the life of me find the maven dependency for the log4j 2.0 binding. In this tutorial, we're going to examine Lombok log annotations like @Slf4j, @Log4j or @Log. Use Log Annotations. Lombok provides several log annotations to work with different logging libraries.

Example: Capturing Multiple Logging Frameworks with Slf4j

This page describes how to configure Jetty for capturing multiple logging frameworks logging events into a single logging implementation handled by Slf4j.

When using Slf4j, you can configure a single logging solution for the variety of logging libraries available in common use. With careful setup, you can support all of the following logging APIs at the same time, with a single configuration file to control the output of events produces by these APIs.

Logging APIs that Slf4j supports:

Slf4j API
Logback API
Apache Log4j 1.2
JDK 1.4 Logging (aka java.util.logging)
Apache Commons Logging

To accomplish this you must make some careful choices, starting with a single underlying logging framework. This decision guides the rest of your choices about JARs to place on the Server classpath.

Table 20.1. Slf4j Logging Grid

Logging API	Slf4j Binding Jar	Slf4j Adapter Jar	Underlying Logging Framework
Logback API	n/a	logback-classic.jar	logback-core.jar
Log4j	log4j-over-slf4j.jar	slf4j-log4j12.jar	log4j.jar
JDK 1.4 Logging	jul-to-slf4j.jar	slf4j-jdk14.jar	(Core Java Classlib)
Commons Logging	jcl-over-slf4j.jar	slf4j-jcl.jar	commons-logging.jar

Logging API

The Logging API that you are either capturing events from and/or using to write out those events (for example, to disk).

Slf4j Binding JAR

Special JARs, created and maintained by the Slf4j project, that pretend to be the various Logging API implementation classes, but instead just route that Logging API's events to Slf4j to handle.

There MAY be multiple Slf4j binding JARs present on the classpath at the same time.

For a single logging API, if you choose to use the Slf4j binding JAR, then you MUST NOT include the SLf4j adapter JAR or underlying logging framework in the classpath as well.

Slf4j Adapter Jar

These JARs are created and maintained by the Slf4j project and route Slf4j logging events to a specific underlying logging framework.

There MUST NOT be multiple Slf4j adapter JARs present on the classpath at the same time.

Logging events that these adapter JARs capture can come from direct use of the Slf4j API or via one of the Slf4j binding JAR implementations.

Underlying Logging Framework

This is the last leg of your configuration, the implementation that processes, filters, and outputs the logging events to the console, logging directory on disk, or whatever else the underlying logging framework supports (like Socket, SMTP, Database, or even SysLog in the case of Logback).

Caution

There MUST NOT be multiple underlying logging frameworks on the classpath. If there are, the Slf4j framework fails to load.

Note

Some third party libraries provide their own implementations of common logging APIs; be careful not to accidentally include an underlying logging framework.

For example, if you are using SpringSource you likely have a com.springsource.org.apache.log4j.jar along with a log4j.jar, which have the same classes in them. In this example, use the com.springsource.org.apache.log4j.jar version and exclude the log4j.jar, as the SpringSource version includes extra metadata suitable for using SpringSource.

The following sections use Logback as the underlying Logging framework. This requires using logback-classic.jar and logback-core.jar, and excluding any other Slf4j adapter JAR or underlying logging framework.

It also requires including the other Slf4j binding JARs in the classpath, along with some special initialization for java.util.logging.

Quick Setup of Multiple Logging capture to Logback using Jetty 9.2.1+

A convenient replacement logging module has been created to bootstrap your ${jetty.base} directory for capturing all Jetty server logging from multiple logging frameworks into a single logging output file managed by logback.

That's cool and all, but tell me what that just did.

The replacement logging.mod performs a number of tasks.

mybase is a ${jetty.base} directory
The jetty-distribution is unpacked (and untouched) into /opt/jetty-dist/ and becomes the ${jetty.home} directory for this demonstration.
The curl command downloads the replacement logging.mod and puts it into the ${jetty.base}/modules/ directory for use by mybase only.
The start.jar --add-to-start=logging command performs a number of steps to make the logging module available to the ${jetty.base} configuration.
1. The --module=logging command is added to the ${jetty.base}/start.ini configuration
2. Required ${jetty.base} directories are created: ${jetty.base}/logs and ${jetty.base}/resources
3. Required libraries are downloaded (if not present already):
  - slf4j-api.jar - API jar for Slf4j (used by most of the rest of the jars)
  - log4j-over-slf4j.jar - Slf4j jar that captures all log4j emitted logging events
  - jul-to-slf4j.jar - Slf4j jar that captures all java.util.logging events
  - jcl-over-slf4j.jar - Slf4j jar that captures all commons-logging events
  - logback-classic.jar - the Slf4j adapter jar that routes all of the captured logging events to logback itself.
  - logback-core.jar - the logback implementation jar, that handles all of the filtering and output of the logging events.
  These libraries are put in the ${jetty.base}/lib/logging/ directory.
4. Required configuration files are downloaded (if not present already): jetty-logging.properties, and logback.xml
  The configuration files are put in the ${jetty.base}/resources/ directory.
5. Required java.util.logging initialization commands are downloaded (if not present already): jetty-logging.xml
  The xml file is put in the ${jetty.base}/etc/ directory.
At this point you have your mybase configured so that the jetty server itself will log using slf4j, and all other logging events from other Jetty Server components (such as database drivers, security layers, jsp, mail, and other 3rd party server components) are routed to logback for filtering and output.

You can verify the server classpath by using the start.jar --list-config command.

In essence, Jetty is now configured to emit its own logging events to slf4j, and various slf4j bridge jars are acting on behalf of log4j, java.util.logging, and commons-logging, routing all of the logging events to logback (a slf4j adapter) for routing (to console, file, etc...)

Log4j-over-slf4j-1.7.25 Maven

The information below is for developers who want to modify Log4j or contribute to Log4j. If your goal is to add logging to your application you don’t need to build from the source code, you can download the pre-built binaries instead.

Log4j 2 is hosted in the Apache Software Foundation’s Git repository. Details on obtaining the most cur

Log4j Over Slf4j Maven