<?xml version="1.0" ?>
<!--
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.
-->
<document>

    <properties>
        <author email="nicko at apache dot org">Nicko Cadell</author>
        <title>Apache log4net Manual: Configuration</title>
    </properties>

    <meta name="keywords" content="log4net configuration, log4net" />

    <body>
        <section id="main" name="Apache log4net&#x2122; Manual - Configuration">

            <section id="config" name="Configuration">
                <p>
                    Inserting log requests into the application code requires a fair amount of 
                    planning and effort. Observation shows that approximately 4 percent of code is 
                    dedicated to logging. Consequently, even moderately sized applications will 
                    have thousands of logging statements embedded within their code. Given their 
                    number, it becomes imperative to manage these log statements without the need 
                    to modify them manually.
                </p>
                <p>
                    The log4net environment is fully configurable programmatically. However, it is 
                    far more flexible to configure log4net using configuration files. Currently, 
                    configuration files are written in XML.
                </p>
                <p>
                    Let us give a taste of how this is done with the help of an imaginary 
                    application
                    <span class="code">MyApp</span>
                    that uses log4net.
                </p>
                <div class="syntax"><pre class="code">
using Com.Foo;

// Import log4net classes.
<b>using log4net;
using log4net.Config;</b>

public class MyApp 
{
    // Define a static logger variable so that it references the
    // Logger instance named "MyApp".
    <strong>private static readonly</strong> ILog log = <strong>LogManager.GetLogger(typeof(MyApp));</strong>

    static void Main(string[] args) 
    {
        // Set up a simple configuration that logs on the console.
        <strong>BasicConfigurator.Configure();</strong>

        log.Info("Entering application.");
        Bar bar = new Bar();
        bar.DoIt();
        log.Info("Exiting application.");
    }
}</pre></div>
                <p>
                    <span class="code">MyApp</span>
                    begins by importing log4net related classes. It then defines a static logger 
                    variable with the name
                    <span class="code">MyApp</span>
                    which happens to be the fully qualified name of the class.
                </p>
                <p>
                    <span class="code">MyApp</span>
                    uses the following
                    <span class="code">Bar</span>
                    class:
                </p>
                <div class="syntax"><pre class="code">
// Import log4net classes.
using log4net;

<b>namespace Com.Foo</b>
{
    public class Bar 
    {
        <strong>private static readonly</strong> ILog log = <strong>LogManager.GetLogger(typeof(Bar));</strong>

        public void DoIt()
        {
            log.Debug("Did it again!");
        }
    }
}</pre></div>
                <p>
                    The invocation of the
                    <span class="code">BasicConfigurator.Configure()</span>
                    method creates a rather simple log4net setup. This method is hardwired to add 
                    to the <i>root</i> logger a
                    <span class="code">ConsoleAppender</span>. The output will be formatted using a
                    <span class="code">PatternLayout</span>
                    set to the pattern
                    <span class="code">"%-4timestamp [%thread] %-5level %logger %ndc - %message%newline"</span>.
                </p>
                <p>
                    Note that by default, the <i>root</i> logger is assigned to
                    <span class="code">Level.DEBUG</span>.
                </p>
                <p>
                    The output of <span class="code">MyApp</span> is:
                </p>
                <source language="text"><![CDATA[
0    [main] INFO  MyApp  - Entering application.
36   [main] DEBUG Com.Foo.Bar  - Did it again!
51   [main] INFO  MyApp  - Exiting application.]]></source>
                <p>
                    As a side note, let me mention that in log4net child loggers link only to their 
                    existing ancestors. In particular, the logger named
                    <span class="code">Com.Foo.Bar</span>
                    is linked directly to the
                    <i>root</i>
                    logger, thereby circumventing the unused
                    <span class="code">Com</span>
                    or
                    <span class="code">Com.Foo</span>
                    loggers. This significantly increases performance and reduces log4net's memory 
                    footprint.
                </p>
                <p>
                    The
                    <span class="code">MyApp</span>
                    class configures log4net by invoking
                    <span class="code">BasicConfigurator.Configure()</span>
                    method. Other classes only need to import the
                    <span class="code">log4net</span>
                    namespace, retrieve the loggers they wish to use, and log away.
                </p>
                <p>
                    The previous example always outputs the same log information. Fortunately, it 
                    is easy to modify
                    <span class="code">MyApp</span>
                    so that the log output can be controlled at run-time. Here is a slightly 
                    modified version.
                </p>
                <div class="syntax"><pre class="code">
using Com.Foo;

// Import log4net classes.
using log4net;
<b>using log4net.Config;</b>

public class MyApp 
{
    private static readonly ILog log = LogManager.GetLogger(typeof(MyApp));

    static void Main(string[] args) 
    {
        // BasicConfigurator replaced with XmlConfigurator.
        <strong>XmlConfigurator.Configure(new System.IO.FileInfo(args[0]));</strong>

        log.Info("Entering application.");
        Bar bar = new Bar();
        bar.DoIt();
        log.Info("Exiting application.");
    }
}</pre></div>
                <p>
                    This version of
                    <span class="code">MyApp</span>
                    instructs the 
                    <span class="code">XmlConfigurator</span>
                    to parse a configuration file and set up logging accordingly. The path to the 
                    configuration file is specified on the command line.
                </p>
                <p>
                    Here is a sample configuration file that results in exactly same output as the 
                    previous
                    <span class="code">BasicConfigurator</span>
                    based example.
                </p>
                <source language="xml"><![CDATA[
<log4net>
    <!-- A1 is set to be a ConsoleAppender -->
    <appender name="A1" type="log4net.Appender.ConsoleAppender">

        <!-- A1 uses PatternLayout -->
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%-4timestamp [%thread] %-5level %logger %ndc - %message%newline" />
        </layout>
    </appender>
    
    <!-- Set root logger level to DEBUG and its only appender to A1 -->
    <root>
        <level value="DEBUG" />
        <appender-ref ref="A1" />
    </root>
</log4net>]]></source>
                <p>
                    Suppose we are no longer interested in seeing the output of any component 
                    belonging to the
                    <span class="code">Com.Foo</span>
                    package. The following configuration file shows one possible way of achieving 
                    this.
                </p>
                <source language="xml"><![CDATA[
<log4net>
    <!-- A1 is set to be a ConsoleAppender -->
    <appender name="A1" type="log4net.Appender.ConsoleAppender">

        <!-- A1 uses PatternLayout -->
        <layout type="log4net.Layout.PatternLayout">
            <!-- Print the date in ISO 8601 format -->
            <conversionPattern value="%date [%thread] %-5level %logger %ndc - %message%newline" />
        </layout>
    </appender>
    
    <!-- Set root logger level to DEBUG and its only appender to A1 -->
    <root>
        <level value="DEBUG" />
        <appender-ref ref="A1" />
    </root>
    
    <!-- Print only messages of level WARN or above in the package Com.Foo -->
    <logger name="Com.Foo">
        <level value="WARN" />
    </logger>
</log4net>]]></source>
                <p>
                    The output of
                    <span class="code">MyApp</span>
                    configured with this file is shown below.
                </p>
                <source language="text">
2000-09-07 14:07:41,508 [main] INFO  MyApp - Entering application.
2000-09-07 14:07:41,529 [main] INFO  MyApp - Exiting application.</source>
                <p>
                    As the logger
                    <span class="code">Com.Foo.Bar</span>
                    does not have an assigned level, it inherits its level from
                    <span class="code">Com.Foo</span>, which was set to WARN in the configuration 
                    file. The log statement from the
                    <span class="code">Bar.DoIt</span>
                    method has the level DEBUG, lower than the logger level WARN. Consequently,
                    <span class="code">DoIt()</span>
                    method's log request is suppressed.
                </p>
                <p>
                    Here is another configuration file that uses multiple appenders.
                </p>
                <source language="C#"><![CDATA[
<log4net>
    <appender name="Console" type="log4net.Appender.ConsoleAppender">
        <layout type="log4net.Layout.PatternLayout">
            <!-- Pattern to output the caller's file name and line number -->
            <conversionPattern value="%5level [%thread] (%file:%line) - %message%newline" />
        </layout>
    </appender>
    
    <appender name="RollingFile" type="log4net.Appender.RollingFileAppender">
        <file value="example.log" />
        <appendToFile value="true" />
        <maximumFileSize value="100KB" />
        <maxSizeRollBackups value="2" />

        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%level %thread %logger - %message%newline" />
        </layout>
    </appender>
    
    <root>
        <level value="DEBUG" />
        <appender-ref ref="Console" />
        <appender-ref ref="RollingFile" />
    </root>
</log4net>]]></source>
                <p>
                    Calling the enhanced <span class="code">MyApp</span> with the this configuration file will output the 
                    following on the console.
                </p>
                <source language="text"><![CDATA[
 INFO [main] (MyApp.cs:16) - Entering application.
DEBUG [main] (Bar.cs:12) - Doing it again!
 INFO [main] (MyApp.cs:19) - Exiting application.]]></source>
                <p>
                    In addition, as the <i>root</i> logger has been allocated a second appender, output 
                    will also be directed to the
                    <span class="code">example.log</span>
                    file. This file will be rolled over when it reaches 100KB. When roll-over 
                    occurs, the old version of
                    <span class="code">example.log</span>
                    is automatically moved to
                    <span class="code">example.log.1</span>.
                </p>
                <p>
                    Note that to obtain these different logging behaviors we did not need to 
                    recompile code. We could just as easily have logged to an email address, 
                    redirected all
                    <span class="code">Com.Foo</span>
                    output to an NT Event logger, or forwarded logging events to a remote log4net 
                    server, which would log according to local server policy.
                </p>
                <p>
                    For more examples of configuring appenders using the <span class="code">XmlConfigurator</span>
                    see the <a href="../config-examples.html">Example Appender Configuration</a> 
                    document.
                </p>
                
                <section id="attributes" name="Configuration Attributes">
                    <p>
                        The log4net configuration can be configured using assembly-level attributes rather than
                        specified programmatically.
                    </p>
                    <ul>
                        <li>
                            <b>XmlConfiguratorAttribute</b>
                            <p>
                                The <span class="code">log4net.Config.XmlConfiguratorAttribute</span> Allows the
                                <span class="code">XmlConfigurator</span> to be configured using the following properties:
                            </p>
                            <ul>
                                <li>
                                    <b>ConfigFile</b>
                                    <p>
                                        If specified, this is the filename of the configuration file to use with the
                                        <span class="code">XmlConfigurator</span>. This file path is relative to the 
                                        application base directory (<span class="code">AppDomain.CurrentDomain.BaseDirectory</span>).
                                    </p>
                                    <p>
                                        This property cannot be used in conjunction with the 
                                        <span class="code">ConfigFileExtension</span> property.
                                    </p>
                                </li>
                                <li>
                                    <b>ConfigFileExtension</b>
                                    <p>
                                        If specified, this is the extension for the configuration file. The assembly 
                                        file name is used as the base name with the this extension appended. For example
                                        if the assembly is loaded from the a file <span class="code">TestApp.exe</span>
                                        and the <span class="code">ConfigFileExtension</span> property is set to
                                        <span class="code">log4net</span> then the configuration file name is 
                                        <span class="code">TestApp.exe.log4net</span>. This is equivalent to setting the
                                        <span class="code">ConfigFile</span> property to <span class="code">TestApp.exe.log4net</span>.
                                    </p>
                                    <p>
                                        The path to the configuration file is build by using the application base 
                                        directory (<span class="code">AppDomain.CurrentDomain.BaseDirectory</span>), 
                                        the assembly file name and the configuration file extension.
                                    </p>
                                    <p>
                                        This property cannot be used in conjunction with the 
                                        <span class="code">ConfigFile</span> property.
                                    </p>
                                </li>
                                <li>
                                    <b>Watch</b>
                                    <p>
                                        If this flag is specified and set to <span class="code">true</span>
                                        then the framework will watch the configuration file and will reload the config 
                                        each time the file is modified.
                                    </p>
                                </li>
                            </ul>
                            <p>
                                If neither of the <span class="code">ConfigFile</span> or <span class="code">ConfigFileExtension</span>
                                properties are specified, the application configuration file (e.g. <span class="code">TestApp.exe.config</span>) 
                                will be used as the log4net configuration file.
                            </p>
                            <p>
                                Example usage:
                            </p>
                            <div class="syntax"><pre class="code">
// Configure log4net using the .config file
<b>[assembly: log4net.Config.XmlConfigurator(Watch=true)]</b>
// This will cause log4net to look for a configuration file
// called TestApp.exe.config in the application base
// directory (i.e. the directory containing TestApp.exe)
// The config file will be watched for changes.
                            </pre></div>
                            <div class="syntax"><pre class="code">
// Configure log4net using the .log4net file
<b>[assembly: log4net.Config.XmlConfigurator(ConfigFileExtension="log4net",Watch=true)]</b>
// This will cause log4net to look for a configuration file
// called TestApp.exe.log4net in the application base
// directory (i.e. the directory containing TestApp.exe)
// The config file will be watched for changes.
                            </pre></div>
                            <p>
                                This attribute may only be used once per assembly.
                            </p>
                        </li>
                    </ul>
                    <p>
                        Using attributes can be a clearer method for defining where the application's
                        configuration will be loaded from. However it is worth noting that attributes
                        are purely passive. They are information only. Therefore if you use configuration
                        attributes you must invoke log4net to allow it to read the attributes. A simple
                        call to <span class="code">LogManager.GetLogger</span> will cause the attributes
                        on the calling assembly to be read and processed. <strong>Therefore it is imperative
                        to make a logging call as early as possible during the application start-up, and
                        certainly before any external assemblies have been loaded and invoked.</strong>
                    </p>
                </section>
                
                <section id="appSettings" name="appSettings">
                  <p>
                    If you use <a href="#attributes">attributes</a> to
                    configure log4net, two settings of the
                    <code>appSettings</code> section of your
                    application's configuration file can be used to
                    override the values given in your assembly's
                    attributes.
                  </p>
                  <p>
                    The setting with the key "log4net.Config"
                    overrides the configuration file name (and is
                    considered to be relative to your application's
                    base directory), the setting with the key
                    "log4net.Config.Watch" determines whether the file
                    should be monitored for changes.
                  </p>
                  <p>
                    Even though the assembly attribute
                  </p>
                  <div class="syntax"><pre class="code">
<b>[assembly: log4net.Config.XmlConfigurator(Watch=false)]</b>
                  </pre></div>
                  <p>
                    would configure your application to use a
                    configuration file "TestApp.exe.config" and not
                    monitor it for changes you can override this to
                    use the file "log4net.config" and monitor it
                    instead by adding
                  </p>
                  <div class="syntax"><pre class="code"><![CDATA[
<appSettings>
  <add key="log4net.Config" value="log4net.config"/>
  <add key="log4net.Config.Watch" value="True"/>
</appSettings>]]>
                  </pre></div>

                  <p>
                    to your application's configuration file.
                  </p>
                </section>

                <section id="files" name="Configuration Files">
                    <p>
                        Typically the log4net configuration is specified using a file. This file can
                        be read in one of two ways:
                    </p>
                    <ul>
                        <li>Using the .NET <span class="code">System.Configuration</span> API</li>
                        <li>Reading the file contents directly</li>
                    </ul>
                    
                    <section id="dot-config" name=".config Files">
                        <p>    
                            The <span class="code">System.Configuration</span> API is only available if the
                            configuration data is in the application's config file; the file named 
                            <i>MyApp.exe.config</i> or <i>Web.config</i>. Because the <span class="code">System.Configuration</span> 
                            API does not support reloading of the config file the configuration settings 
                            cannot be watched using the <span class="code">log4net.Config.XmlConfigurator.ConfigureAndWatch</span> 
                            methods. The main advantage of using the <span class="code">System.Configuration</span>
                            APIs to read the configuration data is that it requires less permissions than accessing
                            the configuration file directly.
                        </p>
                        <p>
                            The only way to configure an application using the <span class="code">System.Configuration</span>
                            APIs is to call the <span class="code">log4net.Config.XmlConfigurator.Configure()</span> method or
                            the <span class="code">log4net.Config.XmlConfigurator.Configure(ILoggerRepository)</span> method.
                        </p>
                        <p>
                            In order to embed the configuration data in the .config file the section name must be
                            identified to the .NET config file parser using a <span class="code">configSections</span> element.
                            The section must specify the <span class="code">log4net.Config.Log4NetConfigurationSectionHandler</span>
                            that will be used to parse the config section. This type must be fully assembly qualified
                            because it is being loaded by the .NET config file parser not by log4net. The correct
                            assembly name for the log4net assembly must be specified.
                            The following is a simple example configuration file that specifies the correct
                            section handler to use for the log4net section.
                        </p>
                        <source language="xml"><![CDATA[
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="log4net" type="log4net.Config.Log4NetConfigurationSectionHandler, log4net" />
    </configSections>
    <log4net>
        <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender" >
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
            </layout>
        </appender>
        <root>
            <level value="INFO" />
            <appender-ref ref="ConsoleAppender" />
        </root>
    </log4net>
</configuration>]]></source>
                        <p>
                            In the above example the <span class="code">log4net</span> assembly is specified.
                            This assembly must be located where the .NET runtime can find it. For example it could
                            be located in the same directory as the application. If the log4net assembly is stored in
                            the GAC then the fully qualified assembly name must be specified including the culture,
                            version and public key.
                        </p>
                        <p>
                            When using the .config file to specify the configuration the section name and 
                            XML element name must be <span class="code">log4net</span>.
                        </p>
                    </section>
                    
                    <section id="reading" name="Reading Files Directly">
                        <p>
                            The XmlConfigurator can directly read any XML file and use it to configure log4net. 
                            This includes the application's .config file; the file named <i>MyApp.exe.config</i> 
                            or <i>Web.config</i>. The only reason not to read the configuration file directly is if the
                            application does not have sufficient permissions to read the file, then the configuration
                            must be loaded using the .NET configuration APIs (see above).
                        </p>
                        <p>
                            The file to read the configuration from can be specified using any of
                            the <span class="code">log4net.Config.XmlConfigurator</span> methods that
                            accept a <span class="code">System.IO.FileInfo</span> object. Because the
                            file system can be monitored for file change notifications the 
                            <span class="code">ConfigureAndWatch</span> methods can be used to monitor
                            the configuration file for modifications and automatically reconfigure log4net.
                        </p>
                        <p>
                            Additionally the <span class="code">log4net.Config.XmlConfiguratorAttribute</span>
                            can be used to specify the file to read the configuration from.
                        </p>
                        <p>
                            The configuration is read from the <span class="code">log4net</span> element
                            in the file. Only one <span class="code">log4net</span> element can be specified
                            in the file but it may be located anywhere in the XML hierarchy. For example it
                            may be the root element:
                        </p>
                        <source language="xml"><![CDATA[
<?xml version="1.0" encoding="utf-8" ?>
<log4net>
    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender" >
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
        </layout>
    </appender>
    <root>
        <level value="INFO" />
        <appender-ref ref="ConsoleAppender" />
    </root>
</log4net>]]></source>
                        <p>
                            Or it may be nested within other elements:
                        </p>
                        <source language="xml"><![CDATA[
<?xml version="1.0" encoding="utf-8" ?>
<configuration>
    <configSections>
        <section name="log4net" type="System.Configuration.IgnoreSectionHandler" />
    </configSections>
    <log4net>
        <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender" >
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
            </layout>
        </appender>
        <root>
            <level value="INFO" />
            <appender-ref ref="ConsoleAppender" />
        </root>
    </log4net>
</configuration>]]></source>
                        <p>
                            The above example shows how the configuration data can be embedded 
                            inside a .config file even though the file is being read directly
                            by log4net. An important note is that the .NET config file parser
                            will throw an exception if it finds an element that has not been
                            registered using the <span class="code">configSections</span> element.
                            Therefore in the above example the <span class="code">log4net</span>
                            section name is registered, but the type specified to handle the
                            section is <span class="code">System.Configuration.IgnoreSectionHandler</span>.
                            This is a built-in class that indicates that another method for reading
                            the config section will be employed.
                        </p>
                    </section>
                    
                </section>
                
                <section id="syntax" name="Configuration Syntax">
                    <p>
                        log4net includes a configuration reader that parses an XML DOM, the 
                        <span class="code">log4net.Config.XmlConfigurator</span>. This section defines the
                        syntax accepted by the configurator.
                    </p>
                    <p>
                        This is an example of a valid XML configuration. The root element
                        must be <span class="code">&lt;log4net&gt;</span>. Note that this does not mean
                        that this element cannot be embedded in another XML document. See the section above 
                        on <a href="#configuration.files">Configuration Files</a> for more information
                        on how to embed the XmlConfigurator XML in a configuration file.
                    </p>
                    <source language="xml"><![CDATA[
<log4net>
    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender" >
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
        </layout>
    </appender>
    <root>
        <level value="INFO" />
        <appender-ref ref="ConsoleAppender" />
    </root>
</log4net>]]></source>
                    <p>
                        The <span class="code">&lt;log4net&gt;</span> element supports the following attributes:
                    </p>
                    <div class="table">
                        <table>
                            <colgroup>
                                <col style="text-align: left; white-space: nowrap; width: 7em" />
                                <col style="text-align: left;" />
                            </colgroup>
                            <tr>
                                <th>Attribute</th>
                                <th>Description</th>
                            </tr>
                            <tr>
                                <td>debug</td>
                                <td>
                                    Optional attribute. Value must be either <span class="code">true</span> or <span class="code">false</span>.
                                    The default value is <span class="code">false</span>. Set this attribute to <span class="code">true</span>
                                    to enable internal log4net debugging for this configuration.
                                </td>
                            </tr>
                            <tr>
                                <td>update</td>
                                <td>
                                    Optional attribute. Value must be either <span class="code">Merge</span> or <span class="code">Overwrite</span>.
                                    The default value is <span class="code">Merge</span>. Set this attribute to <span class="code">Overwrite</span>
                                    to reset the configuration of the repository being configured before applying this configuration.
                                </td>
                            </tr>
                            <tr>
                                <td>threshold</td>
                                <td>
                                    Optional attribute. Value must be the name of a level registered on the repository.
                                    The default value is <span class="code">ALL</span>. Set this attribute to limit the messages
                                    that are logged across the whole repository, regardless of the logger that the message is logged to.
                                </td>
                            </tr>
                        </table>
                    </div>
                    <p>
                        The <span class="code">&lt;log4net&gt;</span> element supports the following child elements:
                    </p>
                    <div class="table">
                        <table>
                            <colgroup>
                                <col style="text-align: left; white-space: nowrap; width: 7em" />
                                <col style="text-align: left;" />
                            </colgroup>
                            <tr>
                                <th>Element</th>
                                <th>Description</th>
                            </tr>
                            <tr>
                                <td>appender</td>
                                <td>
                                    Zero or more elements allowed. Defines an appender.
                                </td>
                            </tr>
                            <tr>
                                <td>logger</td>
                                <td>
                                    Zero or more elements allowed. Defines the configuration of a logger.
                                </td>
                            </tr>
                            <tr>
                                <td>renderer</td>
                                <td>
                                    Zero or more elements allowed. Defines an object renderer.
                                </td>
                            </tr>
                            <tr>
                                <td>root</td>
                                <td>
                                    Optional element, maximum of one allowed. Defines the configuration of the root logger.
                                </td>
                            </tr>
                            <tr>
                                <td>param</td>
                                <td>
                                    Zero or more elements allowed. Repository specific parameters
                                </td>
                            </tr>
                        </table>
                    </div>
                    
                    <section id="appenders" name="Appenders">
                        <p>
                            Appenders may only be defined as child elements of the <span class="code">&lt;log4net&gt;</span>
                            element. Each appender must be uniquely named. The implementing type for the appender must be specified.
                        </p>
                        <p>
                            This example shows an appender of type <span class="code">log4net.Appender.ConsoleAppender</span> being
                            defined. The appender will be known as <i>ConsoleAppender</i>.
                        </p>
                        <source language="xml"><![CDATA[
<appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender" >
    <layout type="log4net.Layout.PatternLayout">
        <conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
    </layout>
</appender>]]></source>
                        
                        <p>
                            The <span class="code">&lt;appender&gt;</span> element supports the following attributes:
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Attribute</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>name</td>
                                    <td>
                                        Required attribute. Value must be a string name for this appender. The name must be unique
                                        among all the appenders defined in this configuration file. This name is used by the 
                                        <span class="code">&lt;appender-ref&gt;</span> element of a Logger to reference an appender.
                                    </td>
                                </tr>
                                <tr>
                                    <td>type</td>
                                    <td>
                                        Required attribute. Value must be the type name for this appender. If the appender is
                                        not defined in the log4net assembly this type name must be fully assembly qualified.
                                    </td>
                                </tr>
                            </table>
                        </div>
                        <p>
                            The <span class="code">&lt;appender&gt;</span> element supports the following child elements:
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Element</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>appender-ref</td>
                                    <td>
                                        Zero or more elements allowed. Allows the appender to reference other appenders.
                                        Not supported by all appenders.
                                    </td>
                                </tr>
                                <tr>
                                    <td>filter</td>
                                    <td>
                                        Zero or more elements allowed. Defines the filters used by this appender.
                                    </td>
                                </tr>
                                <tr>
                                    <td>layout</td>
                                    <td>
                                        Optional element, maximum of one allowed. Defines the layout used by this appender.
                                    </td>
                                </tr>
                                <tr>
                                    <td>param</td>
                                    <td>
                                        Zero or more elements allowed. Appender specific parameters.
                                    </td>
                                </tr>
                            </table>
                        </div>
                        
                        <p>
                            For examples of configuring appenders see the 
                            <a href="../config-examples.html">Example Appender Configuration</a> 
                            document.
                        </p>
                                                
                        <section id="filters" name="Filters">
                            <p>
                                Filters elements may only be defined as children of <span class="code">&lt;appender&gt;</span> elements.
                            </p>
                            <p>
                                The <span class="code">&lt;filter&gt;</span> element supports the following attributes:
                            </p>
                            <div class="table">
                                <table>
                                    <colgroup>
                                        <col style="text-align: left; white-space: nowrap; width: 7em" />
                                        <col style="text-align: left;" />
                                    </colgroup>
                                    <tr>
                                        <th>Attribute</th>
                                        <th>Description</th>
                                    </tr>
                                    <tr>
                                        <td>type</td>
                                        <td>
                                            Required attribute. Value must be the type name for this filter. If the filter is
                                            not defined in the log4net assembly this type name must be fully assembly qualified.
                                        </td>
                                    </tr>
                                </table>
                            </div>
                            <p>
                                The <span class="code">&lt;filter&gt;</span> element supports the following child elements:
                            </p>
                            <div class="table">
                                <table>
                                    <colgroup>
                                        <col style="text-align: left; white-space: nowrap; width: 7em" />
                                        <col style="text-align: left;" />
                                    </colgroup>
                                    <tr>
                                        <th>Element</th>
                                        <th>Description</th>
                                    </tr>
                                    <tr>
                                        <td>param</td>
                                        <td>
                                            Zero or more elements allowed. Filter specific parameters.
                                        </td>
                                    </tr>
                                </table>
                            </div>                            

                            <p>
                                Filters form a chain that the event has to pass through. Any filter along the way can accept the event 
                                and stop processing, deny the event and stop processing, or allow the event on to the next filter. 
                                If the event gets to the end of the filter chain without being denied it is implicitly accepted and will be logged.
                            </p>
                            <source language="xml"><![CDATA[
<filter type="log4net.Filter.LevelRangeFilter">
    <levelMin value="INFO" />
    <levelMax value="FATAL" />
</filter>]]></source>
                            <p>
                                This filter will deny events that have a level that is lower than <span class="code">INFO</span>
                                or higher than <span class="code">FATAL</span>. 
                                All events between <span class="code">INFO</span> and <span class="code">FATAL</span> will be logged.
                            </p>
                            <p>
                                If we want to only allow messages through that have a specific substring (e.g. 'database') 
                                then we need to specify the following filters:
                            </p>
                            <source language="xml"><![CDATA[
<filter type="log4net.Filter.StringMatchFilter">
    <stringToMatch value="database" />
</filter>
<filter type="log4net.Filter.DenyAllFilter" />]]></source>
                            <p>
                                The first filter will look for the substring 'database' in the message text of the event. 
                                If the text is found the filter will accept the message and filter processing will stop, 
                                the message will be logged. If the substring is not found the event will be passed to 
                                the next filter to process. If there is no next filter the event would be implicitly 
                                accepted and would be logged. But because we don't want the non matching events to be 
                                logged we need to use a <span class="code">log4net.Filter.DenyAllFilter</span>
                                that will just deny all events that reach it. This filter is only useful at the end of the filter chain.
                            </p>
                            <p>
                                If we want to allow events that have either 'database' or 'ldap' in the message text we can use the following filters:
                            </p>
                            <source language="xml"><![CDATA[
<filter type="log4net.Filter.StringMatchFilter">
    <stringToMatch value="database"/>
</filter>
<filter type="log4net.Filter.StringMatchFilter">
    <stringToMatch value="ldap"/>
</filter>
<filter type="log4net.Filter.DenyAllFilter" />]]></source>
                        </section>
                        
                        <section id="layouts" name="Layouts">
                            <p>
                                Layout elements may only be defined as children of <span class="code">&lt;appender&gt;</span> elements.
                            </p>
                            <p>
                                The <span class="code">&lt;layout&gt;</span> element supports the following attributes:
                            </p>
                            <div class="table">
                                <table>
                                    <colgroup>
                                        <col style="text-align: left; white-space: nowrap; width: 7em" />
                                        <col style="text-align: left;" />
                                    </colgroup>
                                    <tr>
                                        <th>Attribute</th>
                                        <th>Description</th>
                                    </tr>
                                    <tr>
                                        <td>type</td>
                                        <td>
                                            Required attribute. Value must be the type name for this layout. If the layout is
                                            not defined in the log4net assembly this type name must be fully assembly qualified.
                                        </td>
                                    </tr>
                                </table>
                            </div>
                            <p>
                                The <span class="code">&lt;layout&gt;</span> element supports the following child elements:
                            </p>
                            <div class="table">
                                <table>
                                    <colgroup>
                                        <col style="text-align: left; white-space: nowrap; width: 7em" />
                                        <col style="text-align: left;" />
                                    </colgroup>
                                    <tr>
                                        <th>Element</th>
                                        <th>Description</th>
                                    </tr>
                                    <tr>
                                        <td>param</td>
                                        <td>
                                            Zero or more elements allowed. Layout specific parameters.
                                        </td>
                                    </tr>
                                </table>
                            </div>
                            <p>
                                This example shows how to configure a layout that uses the <span class="code">log4net.Layout.PatternLayout</span>.
                            </p>
                            <source language="xml"><![CDATA[
<layout type="log4net.Layout.PatternLayout">
    <conversionPattern value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />
</layout>]]></source>
                            
                        </section>
                    </section>
                    
                    <section id="root" name="Root Logger">
                        <p>
                            Only one root logger element may only be defined and it must be a child of <span class="code">&lt;log4net&gt;</span> element.
                            The root logger is the root of the logger hierarchy. All loggers ultimately inherit from this logger.
                        </p>
                        <p>
                            An example root logger:
                        </p>
                        <source language="xml"><![CDATA[
<root>
    <level value="INFO" />
    <appender-ref ref="ConsoleAppender" />
</root>]]></source>
                        
                        <p>
                            The <span class="code">&lt;root&gt;</span> element supports no attributes.
                        </p>
                        <p>
                            The <span class="code">&lt;root&gt;</span> element supports the following child elements:
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Element</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>appender-ref</td>
                                    <td>
                                        Zero or more elements allowed. Allows the logger to reference appenders by name.
                                    </td>
                                </tr>
                                <tr>
                                    <td>level</td>
                                    <td>
                                        Optional element, maximum of one allowed. Defines the logging level for this logger.
                                        This logger will only accept event that are at this level or above.
                                    </td>
                                </tr>
                                <tr>
                                    <td>param</td>
                                    <td>
                                        Zero or more elements allowed. Logger specific parameters.
                                    </td>
                                </tr>
                            </table>
                        </div>
                    </section>
                    
                    <section id="loggers" name="Loggers">
                        <p>
                            Logger elements may only be defined as children of the <span class="code">&lt;log4net&gt;</span> element.
                        </p>
                        <p>
                            An example logger:
                        </p>
                        <source language="xml"><![CDATA[
<logger name="LoggerName">
    <level value="DEBUG" />
    <appender-ref ref="ConsoleAppender" />
</logger>]]></source>
                        
                        <p>
                            The <span class="code">&lt;logger&gt;</span> element supports the following attributes.
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Attribute</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>name</td>
                                    <td>
                                        Required attribute. Value must be the name of the logger.
                                    </td>
                                </tr>
                                <tr>
                                    <td>additivity</td>
                                    <td>
                                        Optional attribute. Value may be either <span class="code">true</span> or <span class="code">false</span>.
                                        The default value is <span class="code">true</span>. Set this attribute to <span class="code">false</span>
                                        to prevent this logger from inheriting the appenders defined on parent loggers.
                                    </td>
                                </tr>
                            </table>
                        </div>
                        <p>
                            The <span class="code">&lt;logger&gt;</span> element supports the following child elements:
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Element</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>appender-ref</td>
                                    <td>
                                        Zero or more elements allowed. Allows the logger to reference appenders by name.
                                    </td>
                                </tr>
                                <tr>
                                    <td>level</td>
                                    <td>
                                        Optional element, maximum of one allowed. Defines the logging level for this logger.
                                        This logger will only accept event that are at this level or above.
                                    </td>
                                </tr>
                                <tr>
                                    <td>param</td>
                                    <td>
                                        Zero or more elements allowed. Logger specific parameters.
                                    </td>
                                </tr>
                            </table>
                        </div>
                    </section>
                    
                    <section id="renderers" name="Renderers">
                        <p>
                            Renderer elements may only be defined as children of the <span class="code">&lt;log4net&gt;</span> element.
                        </p>
                        <p>
                            An example renderer:
                        </p>
                        <source language="xml"><![CDATA[
<renderer renderingClass="MyClass.MyRenderer" renderedClass="MyClass.MyFunkyObject" />]]></source>
                        
                        <p>
                            The <span class="code">&lt;renderer&gt;</span> element supports the following attributes.
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Attribute</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>renderingClass</td>
                                    <td>
                                        Required attribute. Value must be the type name for this renderer. If the type is
                                        not defined in the log4net assembly this type name must be fully assembly qualified.
                                        This is the type of the object that will take responsibility for rendering the
                                        <i>renderedClass</i>.
                                    </td>
                                </tr>
                                <tr>
                                    <td>renderedClass</td>
                                    <td>
                                        Required attribute. Value must be the type name for the target type for this renderer. If the type is
                                        not defined in the log4net assembly this type name must be fully assembly qualified.
                                        This is the name of the type that this renderer will render.
                                    </td>
                                </tr>
                            </table>
                        </div>
                        <p>
                            The <span class="code">&lt;renderer&gt;</span> element supports no child elements.
                        </p>
                    </section>
                    
                    <section id="param" name="Parameters">
                        <p>
                            Parameter elements may be children of many elements. See the specific elements above for details.
                        </p>
                        <p>
                            An example param:
                        </p>
                        <source language="xml"><![CDATA[
<param name="ConversionPattern" value="%date [%thread] %-5level %logger [%ndc] - %message%newline" />]]></source>
                        
                        <p>
                            The <span class="code">&lt;param&gt;</span> element supports the following attributes.
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Attribute</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>name</td>
                                    <td>
                                        Required attribute. Value must be the name of the parameter to set on the parent object.
                                    </td>
                                </tr>
                                <tr>
                                    <td>value</td>
                                    <td>
                                        Optional attribute. One of <i>value</i> or <i>type</i> attributes must be specified.
                                        The value of this attribute is a string that can be converted to the value of the
                                        parameter.
                                    </td>
                                </tr>
                                <tr>
                                    <td>type</td>
                                    <td>
                                        Optional attribute. One of <i>value</i> or <i>type</i> attributes must be specified.
                                        The value of this attribute is a type name to create and set as the value of the
                                        parameter. If the type is not defined in the log4net assembly this type name must 
                                        be fully assembly qualified.
                                    </td>
                                </tr>
                            </table>
                        </div>
                        <p>
                            The <span class="code">&lt;param&gt;</span> element supports the following child elements:
                        </p>
                        <div class="table">
                            <table>
                                <colgroup>
                                    <col style="text-align: left; white-space: nowrap; width: 7em" />
                                    <col style="text-align: left;" />
                                </colgroup>
                                <tr>
                                    <th>Element</th>
                                    <th>Description</th>
                                </tr>
                                <tr>
                                    <td>param</td>
                                    <td>
                                        Zero or more elements allowed. Parameter specific parameters.
                                    </td>
                                </tr>
                            </table>
                        </div>
                        <p>
                            An example param that uses nested param elements:
                        </p>
                        <source language="xml"><![CDATA[
<param name="evaluator" type="log4net.spi.LevelEvaluator">
    <param name="Threshold" value="WARN"/>
<param>]]></source>

                        <section id="extension" name="Extension Parameters">
                            <p>
                                Configuration parameters map directly to writable properties on an object.
                                The properties available depend on the actual type of the object being
                                configured. The log4net SDK documentation contains the API reference for
                                all the components included in the log4net assembly.
                            </p>
                            <p>
                                For 3rd party components please see their relevant API reference for 
                                details of the properties available.
                            </p>
                        </section>

                        <section id="new-param" name="Compact Parameter Syntax">
                            <p>
                                All parameters may alternately be specified using the parameter name as the element name
                                rather than using the <i>param</i> element and <i>name</i> attribute.
                            </p>
                            <p>
                                For example a param:
                            </p>
                            <source language="xml"><![CDATA[
<param name="evaluator" type="log4net.spi.LevelEvaluator">
    <param name="Threshold" value="WARN"/>
<param>]]></source>
                            <p>
                                may be written as:
                            </p>
                            <source language="xml"><![CDATA[
<evaluator type="log4net.spi.LevelEvaluator">
    <threshold value="WARN"/>
<evaluator>]]></source>
                        </section>
                    </section>
                </section>
                
            </section>

        </section>
    </body>
</document>
