<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<!--
   Licensed to the Apache Software Foundation (ASF) under one or more
   contributor license agreements.  See the NOTICE file distributed with
   this work for additional information regarding copyright ownership.
   The ASF licenses this file to You under the Apache License, Version 2.0
   (the "License"); you may not use this file except in compliance with
   the License.  You may obtain a copy of the License at

       http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.
-->
<!-- Generated by Apache Maven Doxia at 2019-08-06 -->
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
	<head>
		<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
		<title>Log4j &#x2013; Frequently Asked Questions - Apache Log4j 2</title>
		<link rel="stylesheet" href="./css/bootstrap.min.css" type="text/css" />
		<link rel="stylesheet" href="./css/site.css" type="text/css" />
		<script type="text/javascript" src="./js/jquery.min.js"></script>
		<script type="text/javascript" src="./js/bootstrap.min.js"></script>
		<script type="text/javascript" src="./js/prettify.min.js"></script>
		<script type="text/javascript" src="./js/site.js"></script>
		<meta name="Date-Revision-yyyymmdd" content="20190806" />
		<meta http-equiv="Content-Language" content="en" />
		
				</head>
	<body class="composite">
		<a href="https://logging.apache.org/">
			<img class="logo-left" src="./images/ls-logo.jpg" alt="Apache logging services logo" />
		</a>
		<img class="logo-right" src="./images/logo.png" alt="Apache log4j logo" />
		<div class="clear"></div>

		<div class="navbar">
			<div class="navbar-inner">
				<div class="container-fluid">
					<a class="brand" href="https://logging.apache.org/log4j/2.x/">Apache Log4j 2 &trade;</a>
						<ul class="nav">
						<li>
					
				
				<a href="https://cwiki.apache.org/confluence/display/LOGGING/Log4j" class="external" target="_blank" title="Logging Wiki">Logging Wiki</a>
			</li>
					<li>
					
				
				<a href="https://www.apache.org/" class="external" target="_blank" title="Apache">Apache</a>
			</li>
					<li>
									<a href="../../" title="Logging Services">Logging Services</a>
			</li>
					<li>
					
				
				<a href="https://analysis.apache.org/dashboard/index/org.apache.logging.log4j:log4j" class="external" target="_blank" title="Sonar">Sonar</a>
			</li>
					<li>
					
				
				<a href="https://github.com/apache/logging-log4j2" class="external" target="_blank" title="GitHub">GitHub</a>
			</li>
		</ul>
				</div>
			</div>
		</div>

		<div class="container-fluid">
			<table class="layout-table">
				<tr>
					<td class="sidebar">
						<div class="well sidebar-nav">
										<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-home"></i>Apache Log4j™ 2</li>
																						<li class="none">
									<a href="index.html" title="About">About</a>
					</li>
 																<li class="none">
									<a href="download.html" title="Download">Download</a>
					</li>
 																																																																				<li class="collapsed">
									<a href="javadoc.html" title="Javadoc">Javadoc</a>
										</li>
 																																																																																															<li class="collapsed">
									<a href="maven-artifacts.html" title="Maven, Ivy, Gradle Artifacts">Maven, Ivy, Gradle Artifacts</a>
										</li>
 																<li class="none">
									<a href="runtime-dependencies.html" title="Runtime Dependencies">Runtime Dependencies</a>
					</li>
 																<li class="none">
									<a href="changelog.html" title="Changelog">Changelog</a>
					</li>
 																	<li class="none active">
									<a href="faq.html" title="FAQ">FAQ</a>
					</li>
 																																																																																																																	<li class="collapsed">
									<a href="performance.html" title="Performance">Performance</a>
										</li>
 																<li class="none">
									<a href="articles.html" title="Articles and Tutorials">Articles and Tutorials</a>
					</li>
 																<li class="none">
									<a href="thanks.html" title="Thanks">Thanks</a>
					</li>
 								</ul>
			<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-pencil"></i>For Contributors</li>
																						<li class="none">
									<a href="build.html" title="Building Log4j from Source">Building Log4j from Source</a>
					</li>
 																<li class="none">
									<a href="guidelines.html" title="Guidelines">Guidelines</a>
					</li>
 																<li class="none">
									<a href="javastyle.html" title="Style Guide">Style Guide</a>
					</li>
 								</ul>
			<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-book"></i>Manual</li>
																						<li class="none">
									<a href="manual/index.html" title="Introduction">Introduction</a>
					</li>
 																<li class="none">
									<a href="manual/architecture.html" title="Architecture">Architecture</a>
					</li>
 																<li class="none">
									<a href="manual/migration.html" title="Log4j 1.x Migration">Log4j 1.x Migration</a>
					</li>
 																																																																													<li class="collapsed">
									<a href="manual/api.html" title="Java API">Java API</a>
										</li>
 																<li class="none">
									<a href="manual/scala-api.html" title="Scala API">Scala API</a>
					</li>
 																																																																																																																																																																																																																				<li class="collapsed">
									<a href="manual/configuration.html" title="Configuration">Configuration</a>
										</li>
 																																																											<li class="collapsed">
									<a href="manual/usage.html" title="Usage">Usage</a>
										</li>
 																																																																																						<li class="collapsed">
									<a href="manual/webapp.html" title="Web Applications and JSPs">Web Applications and JSPs</a>
										</li>
 																																																																																																																																																					<li class="collapsed">
									<a href="manual/lookups.html" title="Lookups">Lookups</a>
										</li>
 																																																																																																																																																																																																																																																																																																					<li class="collapsed">
									<a href="manual/appenders.html" title="Appenders">Appenders</a>
										</li>
 																																																																																																																																			<li class="collapsed">
									<a href="manual/layouts.html" title="Layouts">Layouts</a>
										</li>
 																																																																																																																																			<li class="collapsed">
									<a href="manual/filters.html" title="Filters">Filters</a>
										</li>
 																																																																																						<li class="collapsed">
									<a href="manual/async.html" title="Async Loggers">Async Loggers</a>
										</li>
 																																																																																																								<li class="collapsed">
									<a href="manual/garbagefree.html" title="Garbage-free Logging">Garbage-free Logging</a>
										</li>
 																<li class="none">
									<a href="manual/jmx.html" title="JMX">JMX</a>
					</li>
 																<li class="none">
									<a href="manual/logsep.html" title="Logging Separation">Logging Separation</a>
					</li>
 																																																																																																																																																														<li class="collapsed">
									<a href="manual/extending.html" title="Extending Log4j">Extending Log4j</a>
										</li>
 																																																																																						<li class="collapsed">
									<a href="manual/plugins.html" title="Plugins">Plugins</a>
										</li>
 																																																																																															<li class="collapsed">
									<a href="manual/customconfig.html" title="Programmatic Log4j Configuration">Programmatic Log4j Configuration</a>
										</li>
 																																																																																						<li class="collapsed">
									<a href="manual/customloglevels.html" title="Custom Log Levels">Custom Log Levels</a>
										</li>
 								</ul>
			<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-tags"></i>Related Projects</li>
																						<li class="none">
					
				
				<a href="http://logging.apache.org/log4j/scala/index.html" class="external" target="_blank" title="Log4j-Scala">Log4j-Scala</a>
					</li>
 								</ul>
			<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-tags"></i>Legacy</li>
																						<li class="none">
					
				
				<a href="http://logging.apache.org/log4j/1.2/" class="external" target="_blank" title="Log4j 1.2">Log4j 1.2</a>
					</li>
 																<li class="none">
					
				
				<a href="http://logging.apache.org/log4j/log4j-2.3/" class="external" target="_blank" title="Log4j 2.3">Log4j 2.3</a>
					</li>
 								</ul>
			<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-cog"></i>Components</li>
																						<li class="none">
									<a href="log4j-api/index.html" title="API">API</a>
					</li>
 																<li class="none">
									<a href="log4j-core/index.html" title="Implementation">Implementation</a>
					</li>
 																<li class="none">
									<a href="log4j-jcl/index.html" title="Commons Logging Bridge">Commons Logging Bridge</a>
					</li>
 																<li class="none">
									<a href="log4j-1.2-api/index.html" title="Log4j 1.2 API">Log4j 1.2 API</a>
					</li>
 																<li class="none">
									<a href="log4j-slf4j-impl/index.html" title="SLF4J Binding">SLF4J Binding</a>
					</li>
 																<li class="none">
									<a href="log4j-jul/index.html" title="JUL Adapter">JUL Adapter</a>
					</li>
 																<li class="none">
									<a href="log4j-to-slf4j/index.html" title="Log4j 2 to SLF4J Adapter">Log4j 2 to SLF4J Adapter</a>
					</li>
 																<li class="none">
									<a href="log4j-flume-ng/index.html" title="Apache Flume Appender">Apache Flume Appender</a>
					</li>
 																<li class="none">
									<a href="log4j-taglib/index.html" title="Log4j Tag Library">Log4j Tag Library</a>
					</li>
 																<li class="none">
									<a href="log4j-jmx-gui/index.html" title="Log4j JMX GUI">Log4j JMX GUI</a>
					</li>
 																<li class="none">
									<a href="log4j-web/index.html" title="Log4j Web Application Support">Log4j Web Application Support</a>
					</li>
 																<li class="none">
									<a href="log4j-appserver/index.html" title="Log4j Application Server Integration">Log4j Application Server Integration</a>
					</li>
 																<li class="none">
									<a href="log4j-couchdb/index.html" title="Log4j CouchDB appender">Log4j CouchDB appender</a>
					</li>
 																<li class="none">
									<a href="log4j-mongodb2/index.html" title="Log4j MongoDB2 appender">Log4j MongoDB2 appender</a>
					</li>
 																<li class="none">
									<a href="log4j-mongodb3/index.html" title="Log4j MongoDB3 appender">Log4j MongoDB3 appender</a>
					</li>
 																<li class="none">
									<a href="log4j-cassandra/index.html" title="Log4j Cassandra appender">Log4j Cassandra appender</a>
					</li>
 																<li class="none">
									<a href="log4j-iostreams/index.html" title="Log4j IO Streams">Log4j IO Streams</a>
					</li>
 																<li class="none">
									<a href="log4j-liquibase/index.html" title="Log4j Liquibase Binding">Log4j Liquibase Binding</a>
					</li>
 																<li class="none">
									<a href="log4j-docker/index.html" title="Log4j Docker Support">Log4j Docker Support</a>
					</li>
 																<li class="none">
									<a href="log4j-spring-cloud-config/log4j-spring-cloud-config-client/index.html" title="Log4j Spring Cloud Config Client">Log4j Spring Cloud Config Client</a>
					</li>
 								</ul>
			<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-info-sign"></i>Project Information</li>
																						<li class="none">
									<a href="dependency-convergence.html" title="Dependency Convergence">Dependency Convergence</a>
					</li>
 																<li class="none">
									<a href="dependency-management.html" title="Dependency Management">Dependency Management</a>
					</li>
 																<li class="none">
									<a href="team-list.html" title="Project Team">Project Team</a>
					</li>
 																<li class="none">
									<a href="mail-lists.html" title="Mailing Lists">Mailing Lists</a>
					</li>
 																<li class="none">
									<a href="issue-tracking.html" title="Issue Tracking">Issue Tracking</a>
					</li>
 																<li class="none">
									<a href="license.html" title="Project License">Project License</a>
					</li>
 																<li class="none">
									<a href="source-repository.html" title="Source Repository">Source Repository</a>
					</li>
 																<li class="none">
									<a href="project-summary.html" title="Project Summary">Project Summary</a>
					</li>
 								</ul>
			<ul class="nav nav-list">
		 											 <li class="nav-header"><i class="icon-cog"></i>Project Reports</li>
																						<li class="none">
									<a href="changes-report.html" title="Changes Report">Changes Report</a>
					</li>
 																<li class="none">
									<a href="jira-report.html" title="JIRA Report">JIRA Report</a>
					</li>
 																<li class="none">
									<a href="rat-report.html" title="RAT Report">RAT Report</a>
					</li>
 								</ul>
							</div>
						<div id="poweredBy">
															<a href="http://maven.apache.org/" title="Built by Maven" class="poweredBy">
				<img class="poweredBy" alt="Built by Maven" src="./images/maven-feather.png" />
			</a>
									</div>
					</td>
					<td class="content">
						<!-- vim: set syn=markdown : -->
<!-- Licensed to the Apache Software Foundation (ASF) under one or more
    contributor license agreements.  See the NOTICE file distributed with
    this work for additional information regarding copyright ownership.
    The ASF licenses this file to You under the Apache License, Version 2.0
    (the "License"); you may not use this file except in compliance with
    the License.  You may obtain a copy of the License at

         http://www.apache.org/licenses/LICENSE-2.0

    Unless required by applicable law or agreed to in writing, software
    distributed under the License is distributed on an "AS IS" BASIS,
    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    See the License for the specific language governing permissions and
    limitations under the License. --><h1>Frequently Asked Questions</h1>

<ul>
  
<li><a href="#missing_core">I&#x2019;m seeing this error &#x201c;Unable to locate a logging implementation, using SimpleLogger&#x201d;. What is wrong?</a></li>
  
<li><a href="#which_jars">Which JAR files do I need?</a></li>
  
<li><a href="#exclusions">How do I exclude conflicting dependencies?</a></li>
  
<li><a href="#config_location">How do I specify the configuration file location?</a></li>
  
<li><a href="#config_from_code">How do I configure log4j2 in code without a configuration file?</a></li>
  
<li><a href="#reconfig_from_code">How do I reconfigure log4j2 in code with a specific configuration file?</a></li>
  
<li><a href="#shutdown">How do I shut down log4j2 in code?</a></li>
  
<li><a href="#config_sep_appender_level">How do I send log messages with different levels to different appenders?</a></li>
  
<li><a href="#troubleshooting">How do I debug my configuration?</a></li>
  
<li><a href="#separate_log_files">How do I dynamically write to separate log files?</a></li>
  
<li><a href="#reconfig_level_from_code">How do I set a logger&#x2019;s level programmatically?</a></li>
  
<li><a href="#retention">How do I set my log archive retention policy? How do I delete old log archives?</a></li>
  
<li><a href="#api-tradeoffs">What are the trade-offs of using the Log4j 2 API versus the SLF4J API?</a></li>
  
<li><a href="#gc-free-slf4j">Is Log4j 2 still garbage-free when I use the SLF4J API?</a></li>
  
<li><a href="#gc-free-domain-object">How do I log my domain object without creating garbage?</a></li>
  
<li><a href="#logger-wrapper">How do I create a custom logger wrapper that shows the correct class, method and line number?</a></li>
</ul>
<p><a name="missing_core"></a></p>
<div class="section">
<div class="section">
<div class="section">
<h4><a name="Im_seeing_this_error_Unable_to_locate_a_logging_implementation_using_SimpleLogger._What_is_wrong"></a>I&#x2019;m seeing this error &#x201c;Unable to locate a logging implementation, using SimpleLogger&#x201d;. What is wrong?</h4>
<p>You have the log4j-api-2.x jar file in your classpath but you still need to add the log4j-core-2.x jar to the classpath. (Also, it looks like you are using an old version of Log4j 2. You may want to upgrade.)</p>
<p><a name="which_jars"></a></p></div>
<div class="section">
<h4><a name="Which_JAR_files_do_I_need"></a>Which JAR files do I need?</h4>
<p>You need at least the log4j-api-2.x and the log4j-core-2.x jar files.</p>
<p>The other jars are necessary if your application calls the API of another logging framework and you want to route logging calls to the Log4j 2 implementation.</p>
<p><img src="images/whichjar-2.x.png" alt="Diagram showing which JARs correspond to which systems" /></p>
<p><a name="which_jars_log4j-to-slf4j"></a> You can use the log4j-to-slf4j adapter jar when your application calls the Log4j 2 API and you want to route logging calls to a SLF4J implementation.</p>
<p><img src="images/whichjar-slf4j-2.x.png" alt="Diagram showing the dependency flow to use Log4j 2 API with SLF4J" /></p>
<p>Some of the Log4j components have features with optional dependencies. The component page will have more detail. For example, the <a href="log4j-core/index.html">log4j-core component page</a> has an outline of which log4j-core features have external dependencies.</p>
<p><a name="exclusions"></a></p></div>
<div class="section">
<h4><a name="How_do_I_exclude_conflicting_dependencies"></a>How do I exclude conflicting dependencies?</h4>
<p>There are several scenarios where you may end up with conflicting dependencies, especially transitively included ones. The following table shows for each Log4j dependency on the left (implicit groupId of <tt>org.apache.logging.log4j</tt>), the following dependencies on the right can be safely excluded (given in the format <tt>groupId:artifactId</tt>).</p>

<table border="0" class="table table-bordered">
  
<tr class="a">
    
<th>Log4j Dependency</th>
    
<th colspan="3">Dependencies to Exclude</th>
  </tr>
  
<tr class="b">
    
<td>[log4j-1.2-api](log4j-1.2-api)</td>
    
<td>log4j:log4j</td>
    
<td>org.slf4j:log4j-over-slf4j</td>
    
<td></td>
  </tr>
  
<tr class="a">
    
<td>[log4j-core](log4j-core)</td>
    
<td>log4j:log4j</td>
    
<td>ch.qos.logback:logback-core</td>
    
<td>org.apache.logging.log4j:log4j-to-slf4j</td>
  </tr>
  
<tr class="b">
    
<td>[log4j-jcl](log4j-jcl)</td>
    
<td>org.slf4j:jcl-over-slf4j</td>
    
<td></td>
    
<td></td>
  </tr>
  
<tr class="a">
    
<td>[log4j-jul](log4j-jul)</td>
    
<td>org.slf4j:jul-to-slf4j</td>
    
<td></td>
    
<td></td>
  </tr>
  
<tr class="b">
    
<td>[log4j-slf4j-impl](log4j-slf4j-impl)</td>
    
<td>org.apache.logging.log4j:log4j-to-slf4j</td>
    
<td>ch.qos.logback:logback-core</td>
    
<td></td>
  </tr>
</table>
<p>Using Apache Maven, dependencies can be globally excluded in your project like so:</p>

<div class="source">
<div class="source">
<pre>&lt;dependencies&gt;
  &lt;dependency&gt;
    &lt;groupId&gt;log4j&lt;/groupId&gt;
    &lt;artifactId&gt;log4j&lt;/artifactId&gt;
    &lt;version&gt;1.2.17&lt;/version&gt;
    &lt;scope&gt;provided&lt;/scope&gt;
  &lt;/dependency&gt;
&lt;/dependencies&gt;
</pre></div></div>
<p>Dependencies can be explicitly excluded for specific dependencies as well. For example, to use a project with Log4j 2 instead of Log4j 1.x:</p>

<div class="source">
<div class="source">
<pre>&lt;dependencies&gt;
  &lt;dependency&gt;
    &lt;groupId&gt;com.example&lt;/groupId&gt;
    &lt;artifactId&gt;example-project&lt;/artifactId&gt;
    &lt;version&gt;1.0&lt;/version&gt;
    &lt;exclusions&gt;
      &lt;exclusion&gt;
        &lt;groupId&gt;log4j&lt;/groupId&gt;
        &lt;artifactId&gt;log4j&lt;/artifactId&gt;
      &lt;/exclusion&gt;
      &lt;exclusion&gt;
        &lt;groupId&gt;org.slf4j&lt;/groupId&gt;
        &lt;artifactId&gt;slf4j-log4j12&lt;/artifactId&gt;
      &lt;/exclusion&gt;
    &lt;/exclusions&gt;
  &lt;/dependency&gt;
  &lt;dependency&gt;
    &lt;groupId&gt;org.apache.logging.log4j&lt;/groupId&gt;
    &lt;artifactId&gt;log4j-core&lt;/artifactId&gt;
    &lt;version&gt;2.12.1&lt;/version&gt;
  &lt;/dependency&gt;
  &lt;dependency&gt;
    &lt;groupId&gt;org.apache.logging.log4j&lt;/groupId&gt;
    &lt;artifactId&gt;log4j-slf4j-impl&lt;/artifactId&gt;
    &lt;version&gt;2.12.1&lt;/version&gt;
  &lt;/dependency&gt;
  &lt;dependency&gt;
    &lt;groupId&gt;org.apache.logging.log4j&lt;/groupId&gt;
    &lt;artifactId&gt;log4j-1.2-api&lt;/artifactId&gt;
    &lt;version&gt;2.12.1&lt;/version&gt;
  &lt;/dependency&gt;
&lt;/dependencies&gt;
</pre></div></div>
<p>Dependencies can be globally excluded in Gradle like so:</p>

<div class="source">
<div class="source">
<pre>configurations {
  all*.exclude group: 'log4j', module: 'log4j'
}
</pre></div></div>
<p>The equivalent Gradle config for the above Maven exclusion would look like:</p>

<div class="source">
<div class="source">
<pre>dependencies {
  compile('com.example:example-project:1.0') {
    exclude group: 'log4j', module: 'log4j'
    exclude group: 'org.slf4j', module: 'slf4j-log4j12'
  }
  compile('org.apache.logging.log4j:log4j-core:2.12.1')
  compile('org.apache.logging.log4j:log4j-slf4j-impl:2.12.1')
  compile('org.apache.logging.log4j:log4j-1.2-api:2.12.1')
}
</pre></div></div>
<p><a name="config_location"></a></p></div>
<div class="section">
<h4><a name="How_do_I_specify_the_configuration_file_location"></a>How do I specify the configuration file location?</h4>
<p>By default, Log4j looks for a configuration file named <b>log4j2.xml</b> (not log4j.xml) in the classpath.</p>
<p>You can also specify the full path of the configuration file with this system property: <tt>-Dlog4j.configurationFile=path/to/log4j2.xml</tt></p>
<p>That property can also be included in a classpath resource file named <tt>log4j2.component.properties</tt>.</p>
<p>Web applications can specify the Log4j configuration file location with a servlet context parameter. See <a class="externalLink" href="http://logging.apache.org/log4j/2.x/manual/webapp.html#ContextParams">this section</a> of the Using Log4j 2 in Web Applications manual page.</p>
<p><a name="config_from_code"></a></p></div>
<div class="section">
<h4><a name="How_do_I_configure_log4j2_in_code_without_a_configuration_file"></a>How do I configure log4j2 in code without a configuration file?</h4>
<p>Starting with version 2.4, Log4j 2 provides an <a href="manual/customconfig.html">API for programmatic configuration</a> The new <a href="log4j-core/apidocs/org/apache/logging/log4j/core/config/builder/api/ConfigurationBuilder.html"><tt>ConfigurationBuilder</tt> API</a> allows you to create Configurations in code by constructing component definitions without requiring you to know about the internals of actual configuration objects like Loggers and Appenders.</p>
<p><a name="reconfig_from_code"></a></p></div>
<div class="section">
<h4><a name="How_do_I_reconfigure_log4j2_in_code_with_a_specific_configuration_file"></a>How do I reconfigure log4j2 in code with a specific configuration file?</h4>
<p>See the below example. Be aware that this LoggerContext class is not part of the public API so your code may break with any minor release.</p>

<div class="source">
<div class="source">
<pre>// import org.apache.logging.log4j.core.LoggerContext;

LoggerContext context = (org.apache.logging.log4j.core.LoggerContext) LogManager.getContext(false);
File file = new File(&quot;path/to/a/different/log4j2.xml&quot;);

// this will force a reconfiguration
context.setConfigLocation(file.toURI());
</pre></div></div>
<p><a name="shutdown"></a></p></div>
<div class="section">
<h4><a name="How_do_I_shut_down_log4j2_in_code"></a>How do I shut down log4j2 in code?</h4>
<p>Normally there is no need to do this manually. Each <tt>LoggerContext</tt> registers a shutdown hook that takes care of releasing resources when the JVM exits (unless system property <tt>log4j.shutdownHookEnabled</tt> is set to <tt>false</tt>). Web applications should include the log4j-web module in their classpath which disables the shutdown hook but instead cleans up log4j resources when the web application is stopped.</p>
<p>However, if you need to manually shut down Log4j, you can do so as in the below example. Note that there is an optional parameter for specifying which <tt>LoggerContext</tt> to shut down.</p>

<div class="source">
<div class="source">
<pre>import org.apache.logging.log4j.LogManager;

// ...

LogManager.shutdown();
</pre></div></div>
<p><a name="config_sep_appender_level"></a></p></div>
<div class="section">
<h4><a name="How_do_I_send_log_messages_with_different_levels_to_different_appenders"></a>How do I send log messages with different levels to different appenders?</h4>
<p>You don&#x2019;t need to declare separate loggers to achieve this. You can set the logging level on the <tt>AppenderRef</tt> element.</p>

<div class="source">
<div class="source">
<pre>&lt;?xml version=&quot;1.0&quot; encoding=&quot;UTF-8&quot;?&gt;
&lt;Configuration status=&quot;WARN&quot;&gt;
  &lt;Appenders&gt;
    &lt;File name=&quot;file&quot; fileName=&quot;app.log&quot;&gt;
      &lt;PatternLayout&gt;
        &lt;Pattern&gt;%d %p %c{1.} [%t] %m %ex%n&lt;/Pattern&gt;
      &lt;/PatternLayout&gt;
    &lt;/File&gt;
    &lt;Console name=&quot;STDOUT&quot; target=&quot;SYSTEM_OUT&quot;&gt;
      &lt;PatternLayout pattern=&quot;%m%n&quot;/&gt;
    &lt;/Console&gt;
  &lt;/Appenders&gt;
  &lt;Loggers&gt;
    &lt;Root level=&quot;trace&quot;&gt;
      &lt;AppenderRef ref=&quot;file&quot; level=&quot;DEBUG&quot;/&gt;
      &lt;AppenderRef ref=&quot;STDOUT&quot; level=&quot;INFO&quot;/&gt;
    &lt;/Root&gt;
  &lt;/Loggers&gt;
&lt;/Configuration&gt;
</pre></div></div>
<p><a name="troubleshooting"></a></p></div>
<div class="section">
<h4><a name="How_do_I_debug_my_configuration"></a>How do I debug my configuration?</h4>
<p>First, make sure you have <a href="#which_jars">the right jar files</a> on your classpath. You need at least log4j-api and log4j-core.</p>
<p>Next, check the name of your configuration file. By default, log4j2 will look for a configuration file named <tt>log4j2.xml</tt> on the classpath. Note the &#x201c;2&#x201d; in the file name! (See the <a href="manual/configuration.html#AutomaticConfiguration">configuration manual page</a> for more details.)</p>
<p><b>From log4j-2.9 onward</b></p>
<p>From log4j-2.9 onward, log4j2 will print all internal logging to the console if system property <tt>log4j2.debug</tt> is defined (with any or no value).</p>
<p><b>Prior to log4j-2.9</b></p>
<p>Prior to log4j-2.9, there are two places where internal logging can be controlled:</p>
<p>If the configuration file is found correctly, log4j2 internal status logging can be controlled by setting <tt>&lt;Configuration status=&quot;trace&quot;&gt;</tt> in the configuration file. This will display detailed log4j2-internal log statements on the console about what happens during the configuration process. This may be useful to trouble-shoot configuration issues. By default the status logger level is WARN, so you only see notifications when there is a problem.</p>
<p>If the configuration file is not found correctly, you can still enable log4j2 internal status logging by setting system property <tt>-Dorg.apache.logging.log4j.simplelog.StatusLogger.level=TRACE</tt>.</p>
<p><a name="separate_log_files"></a></p></div>
<div class="section">
<h4><a name="How_do_I_dynamically_write_to_separate_log_files"></a>How do I dynamically write to separate log files?</h4>
<p>Look at the <a class="externalLink" href="http://logging.apache.org/log4j/2.x/manual/appenders.html#RoutingAppender">RoutingAppender</a>. You can define multiple routes in the configuration, and put values in the <tt>ThreadContext</tt> map that determine which log file subsequent events in this thread get logged to.</p>
<p>You can use the <tt>ThreadContext</tt> map value to determine the log file name.</p>

<div class="source">
<div class="source">
<pre>&lt;Routing name=&quot;Routing&quot;&gt;
  &lt;Routes pattern=&quot;$${ctx:ROUTINGKEY}&quot;&gt;

    &lt;!-- This route is chosen if ThreadContext has value 'special' for key ROUTINGKEY. --&gt;
    &lt;Route key=&quot;special&quot;&gt;
      &lt;RollingFile name=&quot;Rolling-${ctx:ROUTINGKEY}&quot; fileName=&quot;logs/special-${ctx:ROUTINGKEY}.log&quot;
	filePattern=&quot;./logs/${date:yyyy-MM}/${ctx:ROUTINGKEY}-special-%d{yyyy-MM-dd}-%i.log.gz&quot;&gt;
	&lt;PatternLayout&gt;
	  &lt;pattern&gt;%d{ISO8601} [%t] %p %c{3} - %m%n&lt;/pattern&gt;
	&lt;/PatternLayout&gt;
	&lt;Policies&gt;
	  &lt;TimeBasedTriggeringPolicy interval=&quot;6&quot; modulate=&quot;true&quot; /&gt;
          &lt;SizeBasedTriggeringPolicy size=&quot;10 MB&quot; /&gt;
	&lt;/Policies&gt;
      &lt;/RollingFile&gt;
    &lt;/Route&gt;

    &lt;!-- This route is chosen if ThreadContext has no value for key ROUTINGKEY. --&gt;
    &lt;Route key=&quot;$${ctx:ROUTINGKEY}&quot;&gt;
      &lt;RollingFile name=&quot;Rolling-default&quot; fileName=&quot;logs/default.log&quot;
	filePattern=&quot;./logs/${date:yyyy-MM}/default-%d{yyyy-MM-dd}-%i.log.gz&quot;&gt;
        &lt;PatternLayout&gt;
	  &lt;pattern&gt;%d{ISO8601} [%t] %p %c{3} - %m%n&lt;/pattern&gt;
        &lt;/PatternLayout&gt;
        &lt;Policies&gt;
          &lt;TimeBasedTriggeringPolicy interval=&quot;6&quot; modulate=&quot;true&quot; /&gt;
          &lt;SizeBasedTriggeringPolicy size=&quot;10 MB&quot; /&gt;
        &lt;/Policies&gt;
      &lt;/RollingFile&gt;
    &lt;/Route&gt;

    &lt;!-- This route is chosen if ThreadContext has a value for ROUTINGKEY
         (other than the value 'special' which had its own route above).
         The value dynamically determines the name of the log file. --&gt;
    &lt;Route&gt;
      &lt;RollingFile name=&quot;Rolling-${ctx:ROUTINGKEY}&quot; fileName=&quot;logs/other-${ctx:ROUTINGKEY}.log&quot;
	filePattern=&quot;./logs/${date:yyyy-MM}/${ctx:ROUTINGKEY}-other-%d{yyyy-MM-dd}-%i.log.gz&quot;&gt;
	&lt;PatternLayout&gt;
	  &lt;pattern&gt;%d{ISO8601} [%t] %p %c{3} - %m%n&lt;/pattern&gt;
	&lt;/PatternLayout&gt;
	&lt;Policies&gt;
	  &lt;TimeBasedTriggeringPolicy interval=&quot;6&quot; modulate=&quot;true&quot; /&gt;
	  &lt;SizeBasedTriggeringPolicy size=&quot;10 MB&quot; /&gt;
	&lt;/Policies&gt;
      &lt;/RollingFile&gt;
    &lt;/Route&gt;
  &lt;/Routes&gt;
&lt;/Routing&gt;
</pre></div></div>
<p><a name="reconfig_level_from_code"></a></p></div>
<div class="section">
<h4><a name="How_do_I_set_a_loggers_level_programmatically"></a>How do I set a logger&#x2019;s level programmatically?</h4>
<p>You can set a logger&#x2019;s level with the class <a href="log4j-core/apidocs/org/apache/logging/log4j/core/config/Configurator.html"><tt>Configurator</tt></a> from Log4j Core. Be aware that the <tt>Configurator</tt> class is not part of the public API.</p>

<div class="source">
<div class="source">
<pre>// org.apache.logging.log4j.core.config.Configurator;

Configurator.setLevel(&quot;com.example.Foo&quot;, Level.DEBUG);

// You can also set the root logger:
Configurator.setRootLevel(Level.DEBUG);
</pre></div></div>
<p><a name="retention"></a></p></div>
<div class="section">
<h4><a name="How_do_I_set_my_log_archive_retention_policy_How_do_I_delete_old_log_archives"></a>How do I set my log archive retention policy? How do I delete old log archives?</h4>
<p>The <tt>DefaultRolloverStrategy</tt> of the Rolling File appender (and Rolling Random Access File appender) supports a <a href="manual/appenders.html#CustomDeleteOnRollover">Delete</a> element.</p>
<p>Starting at a specified base directory, you can delete all files for which some condition holds true, for example all files that match a given file name pattern and are older than some number of days. More complex conditions are possible, and if the built-in conditions are not sufficient, users can provide custom conditions by creating <a href="manual/appenders.html#DeletePathCondition">plugin conditions</a> or by writing a <a href="manual/appenders.html#ScriptCondition">script condition</a>.</p>
<p><a name="api-tradeoffs"></a></p></div>
<div class="section">
<h4><a name="What_are_the_trade-offs_of_using_the_Log4j_2_API_versus_the_SLF4J_API"></a>What are the trade-offs of using the Log4j 2 API versus the SLF4J API?</h4>
<p>The Log4j 2 API and SLF4J have a lot in common. They both share the objective of cleanly separating the logging API from the implementation. We believe that the Log4j 2 API can help make your application more performant while offering more functionality and more flexibility.</p>
<p>There may be a concern that using the Log4j 2 API will tightly couple your application to Log4j 2. This is not the case: applications coded to the Log4j 2 API always have the option to use any SLF4J-compliant library as their logging implementation with the log4j-to-slf4j adapter. See the <a href="#which_jars_log4j-to-slf4j">which jars</a> FAQ entry for details.</p>
<p>There are several advantages to using the Log4j 2 API:</p>

<ul>
  
<li>SLF4J forces your application to log Strings. The Log4j 2 API supports logging any CharSequence if you want to log text, but also supports logging any Object as is. It is the responsibility of the logging <i>implementation</i> to handle this object, and we consider it a design mistake to limit applications to logging Strings.</li>
  
<li>The Log4j 2 API offers support for logging <a href="manual/messages.html">Message objects</a>. Messages allow support for interesting and complex constructs to be passed through the logging system and be efficiently manipulated. Users are free to create their own Message types and write custom Layouts, Filters and Lookups to manipulate them.</li>
  
<li>The Log4j 2 API has support for Java 8 <a href="manual/api.html#LambdaSupport">lambda expressions</a>.</li>
  
<li>The Log4j 2 API has better support for <a href="manual/garbagefree.html">garbage-free logging</a>: it avoids creating vararg arrays and avoids creating Strings when logging CharSequence objects.</li>
</ul>
<p><a name="gc-free-slf4j"></a></p></div>
<div class="section">
<h4><a name="Is_Log4j_2_still_garbage-free_when_I_use_the_SLF4J_API"></a>Is Log4j 2 still garbage-free when I use the SLF4J API?</h4>
<p>Yes, the log4j-slf4j-impl binding (together with log4j-core) implements the <tt>org.slf4j.Logger</tt> methods to be GC-free. However, bear in mind that there are some limitations:</p>
<p>The SLF4J API only offers up to two parameters for a parameterized message. More than that uses varargs which creates a temporary object for the parameter array. The Log4j 2.6 API has methods for up to ten unrolled parameters.</p>
<p>Another consideration is that the SLF4J API forces your application to log Strings. Log4j 2 API lets you log any java.lang.CharSequence, and even any Objects. Log4j can log any Object that implements <tt>java.lang.CharSequence</tt> or <tt>org.apache.logging.log4j.util.StringBuilderFormattable</tt> without creating garbage.</p>
<p>The [<tt>org.slf4j.spi.LocationAwareLogger::log</tt>](<a class="externalLink" href="http://www.slf4j.org/api/org/slf4j/spi/LocationAwareLogger.html#log(org.slf4j.Marker">http://www.slf4j.org/api/org/slf4j/spi/LocationAwareLogger.html#log(org.slf4j.Marker</a>, java.lang.String, int, java.lang.String, java.lang.Object[], java.lang.Throwable)) method is not yet implemented in a garbage-free manner in the log4j-slf4j-impl binding. It creates a new message object for each call.</p>
<p><a name="gc-free-domain-object"></a></p></div>
<div class="section">
<h4><a name="How_do_I_log_my_domain_object_without_creating_garbage"></a>How do I log my domain object without creating garbage?</h4>
<p>One option is to let the domain object implement java.lang.CharSequence. However, for many domain objects it may not be trivial to implement this without allocating temporary objects.</p>
<p>An alternative is to implement the <tt>org.apache.logging.log4j.util.StringBuilderFormattable</tt> interface. If an object is logged that implements this interface, its <tt>formatTo</tt> method is called instead of <tt>toString()</tt>.</p>

<div class="source">
<div class="source">
<pre>package org.apache.logging.log4j.util;
public interface StringBuilderFormattable {
    /**
     * Writes a text representation of this object into the specified {@code StringBuilder},
     * ideally without allocating temporary objects.
     *
     * @param buffer the StringBuilder to write into
     */
     void formatTo(StringBuilder buffer);
}
</pre></div></div>
<p><a name="logger-wrapper"></a></p></div>
<div class="section">
<h4><a name="How_do_I_create_a_custom_logger_wrapper_that_shows_the_correct_class_method_and_line_number"></a>How do I create a custom logger wrapper that shows the correct class, method and line number?</h4>
<p>Log4j remembers the fully qualified class name (FQCN) of the logger and uses this to walk the stack trace for every log event when configured to print location. (Be aware that logging with location is slow and may impact the performance of your application.)</p>
<p>The problem with custom logger wrappers is that they have a different FQCN than the actual logger, so Log4j can&#x2019;t find the place where your custom logger was called.</p>
<p>The solution is to provide the correct FQCN. The easiest way to do this is to let Log4j generate the logger wrapper for you. Log4j comes with a Logger wrapper generator tool. This tool was originally meant to support custom log levels and is documented <a class="externalLink" href="https://logging.apache.org/log4j/2.x/manual/customloglevels.html#CustomLoggers">here</a>.</p>
<p>The generated logger code will take care of the FQCN.</p></div></div></div>
					</td>
				</tr>
			</table>
		</div>

		<div class="footer">
							<p>Copyright &copy; 1999-2019 <a class="external" href="https://www.apache.org/">The Apache Software Foundation</a>. All Rights Reserved.</p>
				<p>Apache Logging, Apache Log4j, Log4j, Apache, the Apache feather logo, and the Apache Logging project logo are trademarks of The Apache Software Foundation.</p>
				<p>Site powered by <a class="external" href="http://getbootstrap.com/">Twitter Bootstrap</a>. Icons from <a class="external" href="http://glyphicons.com/">Glyphicons Free</a>.</p>
			</div>
		</div>
	</body>
</html>
