##### Apache log4net

- About
- Download
- Release Notes
- License

##### Documentation

- Features
- Supported Frameworks
- Example Apps
- Config Examples
- Building
- FAQ
- How Tos
- SDK Reference

##### Manual

- Introduction
- Configuration
- Contexts
- Plugins
- Repositories
- Internals

##### Community

- Mailing Lists
- Issue Tracking

##### Development

- Repository
- Continuous Integration

##### Project Documentation

- Project Information
- Project Reports

##### Apache

- Home
- License
- Sponsorship
- Thanks
- Security
- Conferences

## Apache log4net™ Config Examples

## Overview

This document presents example configurations for the built-in appenders. These configurations are designed to work with the log4net.Config.DOMConfigurator and the log4net.Repository.Hierarchy.Hierarchy.

These examples are by no means exhaustive configurations for the appenders. For a full list of the parameters that can be specified to each appender and more details on each options see the SDK documentation for the appender.

## AdoNetAppender

For full details see the SDK Reference entry: log4net.Appender.AdoNetAppender.

The configuration of the AdoNetAppender depends on the provider selected for the target database. Here are some examples.

## MS SQL Server

The following example shows how to configure the AdoNetAppender to log messages to a SQL Server database. The events are written in batches of 100 (BufferSize). The ConnectionType specifies the fully qualified type name for the System.Data.IDbConnection to use to connect to the database. The ConnectionString is database provider specific. The CommandText is either a prepared statement or a stored procedure, in this case it is a prepared statement. Each parameter to the prepared statement or stored procedure is specified with its name, database type and a layout that renders the value for the parameter.

The database table definition is:

    CREATE TABLE [dbo].[Log] (
        [Id] [int] IDENTITY (1, 1) NOT NULL,
        [Date] [datetime] NOT NULL,
        [Thread] [varchar] (255) NOT NULL,
        [Level] [varchar] (50) NOT NULL,
        [Logger] [varchar] (255) NOT NULL,
        [Message] [varchar] (4000) NOT NULL,
        [Exception] [varchar] (2000) NULL
    )

The appender configuration is:

    <appender name="AdoNetAppender" type="log4net.Appender.AdoNetAppender">
        <bufferSize value="100" />
        <connectionType value="System.Data.SqlClient.SqlConnection, System.Data, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
        <connectionString value="data source=[database server];initial catalog=[database name];integrated security=false;persist security info=True;User ID=[user];Password=[password]" />
        <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message],[Exception]) VALUES (@log_date, @thread, @log_level, @logger, @message, @exception)" />
        <parameter>
            <parameterName value="@log_date" />
            <dbType value="DateTime" />
            <layout type="log4net.Layout.RawTimeStampLayout" />
        </parameter>
        <parameter>
            <parameterName value="@thread" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%thread" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@log_level" />
            <dbType value="String" />
            <size value="50" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%level" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@logger" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%logger" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@message" />
            <dbType value="String" />
            <size value="4000" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%message" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@exception" />
            <dbType value="String" />
            <size value="2000" />
            <layout type="log4net.Layout.ExceptionLayout" />
        </parameter>
    </appender>

## MS Access

This example shows how to write events to an Access Database.

    <appender name="AdoNetAppender_Access" type="log4net.Appender.AdoNetAppender">
        <connectionString value="Provider=Microsoft.Jet.OLEDB.4.0;Data Source=C:\log\access.mdb;User Id=;Password=;" />
        <commandText value="INSERT INTO Log ([Date],[Thread],[Level],[Logger],[Message]) VALUES (@log_date, @thread, @log_level, @logger, @message)" />
        <parameter>
            <parameterName value="@log_date" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%date" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@thread" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%thread" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@log_level" />
            <dbType value="String" />
            <size value="50" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%level" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@logger" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%logger" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@message" />
            <dbType value="String" />
            <size value="1024" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%message" />
            </layout>
        </parameter>
    </appender>

## Oracle9i

This example shows how to write events to an Oracle9i Database.

The database table definition is:

    create table log (
       Datetime timestamp(3),
       Thread varchar2(255),
       Log_Level varchar2(255),
       Logger varchar2(255),
       Message varchar2(4000)
       );

The appender configuration is:

    <appender name="AdoNetAppender_Oracle" type="log4net.Appender.AdoNetAppender">
        <connectionType value="System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.3300.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
        <connectionString value="data source=[mydatabase];User ID=[user];Password=[password]" />
        <commandText value="INSERT INTO Log (Datetime,Thread,Log_Level,Logger,Message) VALUES (:log_date, :thread, :log_level, :logger, :message)" />
        <bufferSize value="128" />
        <parameter>
            <parameterName value=":log_date" />
            <dbType value="DateTime" />
            <layout type="log4net.Layout.RawTimeStampLayout" />
        </parameter>
        <parameter>
            <parameterName value=":thread" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%thread" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value=":log_level" />
            <dbType value="String" />
            <size value="50" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%level" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value=":logger" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%logger" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value=":message" />
            <dbType value="String" />
            <size value="4000" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%message" />
            </layout>
        </parameter>
    </appender>

## Oracle8i

This example shows how to write events to an Oracle8i Database.

The database table definition is:

    CREATE TABLE CSAX30.LOG
    (
          THREAD      VARCHAR2(255),
          LOG_LEVEL   VARCHAR2(255),
          LOGGER      VARCHAR2(255),
          MESSAGE     VARCHAR2(4000)
    )
    TABLESPACE CSAX30D LOGGING

The appender configuration is:

    <appender name="AdoNetAppender_Oracle" type="log4net.Appender.AdoNetAppender">
        <connectionType value ="System.Data.OracleClient.OracleConnection, System.Data.OracleClient, Version=1.0.5000.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" />
        <connectionString value="data source=<dsname>;User ID=<userid>;Password=<password>" />
        <commandText value="INSERT INTO Log (Log_Level,Logger,Message) VALUES (:log_level, :logger, :message)" />
        <bufferSize value="250" />
        <parameter>
            <parameterName value=":log_level" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%level" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value=":logger" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%logger" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value=":message" />
            <dbType value="String" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%message" />
            </layout>
        </parameter>
    </appender>

## IBM DB2

This example shows how to write events to an IBM DB2 8.2 Database. The following syntax should also work with older DB2 database servers.

The database table definition is:

    CREATE TABLE "myschema.LOG" (
        "ID" INTEGER NOT NULL GENERATED ALWAYS AS IDENTITY (
            START WITH +1
            INCREMENT BY +1
            MINVALUE +1
            MAXVALUE +2147483647
            NO CYCLE
            NO CACHE
            NO ORDER
        ),
        "DATE" TIMESTAMP NOT NULL,
        "THREAD" VARCHAR(255) NOT NULL,
        "LEVEL" VARCHAR(500) NOT NULL,
        "LOGGER" VARCHAR(255) NOT NULL,
        "MESSAGE" VARCHAR(4000) NOT NULL,
        "EXCEPTION" VARCHAR(2000)
    )
    IN "LRGTABLES";

The appender configuration is:

    <appender name="AdoNetAppender" type="log4net.Appender.AdoNetAppender">
        <bufferSize value="100" />
        <connectionType value="IBM.Data.DB2.DB2Connection,IBM.Data.DB2, Version=8.1.2.1" />
        <connectionString value="server=192.168.0.0;database=dbuser;user Id=username;password=password;persist security info=true" />
        <commandText value="INSERT INTO myschema.Log (Date,Thread,Level,Logger,Message,Exception) VALUES (@log_date,@thread,@log_level,@logger,@message,@exception)" />
        <parameter>
            <parameterName value="@log_date" />
            <dbType value="DateTime" />
            <layout type="log4net.Layout.RawTimeStampLayout" />
        </parameter>
        <parameter>
            <parameterName value="@thread" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%thread" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@log_level" />
            <dbType value="String" />
            <size value="500" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%level" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@logger" />
            <dbType value="String" />
            <size value="255" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%logger" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@message" />
            <dbType value="String" />
            <size value="4000" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%message" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@exception" />
            <dbType value="String" />
            <size value="2000" />
            <layout type="log4net.Layout.ExceptionLayout" />
        </parameter>
    </appender>

## SQLite

This example shows how to write events to a SQLite Database. This was tested against v0.21 of the SQLite .NET provider.

SQLite doesn't have strongly-typed columns or field lengths but its recommended you still include this information for readability. The database table definition is:

    CREATE TABLE Log (
        LogId        INTEGER PRIMARY KEY,
        Date        DATETIME NOT NULL,
        Level        VARCHAR(50) NOT NULL,
        Logger        VARCHAR(255) NOT NULL,
        Message        TEXT DEFAULT NULL
    );

The appender configuration is:

    <appender name="AdoNetAppender" type="log4net.Appender.AdoNetAppender">
        <bufferSize value="100" />
        <connectionType value="Finisar.SQLite.SQLiteConnection, SQLite.NET, Version=0.21.1869.3794, Culture=neutral, PublicKeyToken=c273bd375e695f9c" />
        <connectionString value="Data Source=c:\\inetpub\\wwwroot\\logs\\log4net.db;Version=3;" />
        <commandText value="INSERT INTO Log (Date, Level, Logger, Message) VALUES (@Date, @Level, @Logger, @Message)" />
        <parameter>
            <parameterName value="@Date" />
            <dbType value="DateTime" />
            <layout type="log4net.Layout.RawTimeStampLayout" />
        </parameter>
        <parameter>
            <parameterName value="@Level" />
            <dbType value="String" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%level" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@Logger" />
            <dbType value="String" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%logger" />
            </layout>
        </parameter>
        <parameter>
            <parameterName value="@Message" />
            <dbType value="String" />
            <layout type="log4net.Layout.PatternLayout">
                <conversionPattern value="%message" />
            </layout>
        </parameter>
    </appender>

## AspNetTraceAppender

For full details see the SDK Reference entry: log4net.Appender.AspNetTraceAppender.

The following example shows how to configure the AspNetTraceAppender to log messages to the ASP.NET TraceContext. The messages are written to the System.Web.TraceContext.Write method if they are below level WARN. If they are WARN or above they are written to the System.Web.TraceContext.Warn method.

    <appender name="AspNetTraceAppender" type="log4net.Appender.AspNetTraceAppender" >
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## BufferingForwardingAppender

For full details see the SDK Reference entry: log4net.Appender.BufferingForwardingAppender.

The following example shows how to configure the BufferingForwardingAppender to buffer 100 messages before delivering them to the ConsoleAppender.

    <appender name="BufferingForwardingAppender" type="log4net.Appender.BufferingForwardingAppender" >
        <bufferSize value="100"/>
        <appender-ref ref="ConsoleAppender" />
    </appender>

This example shows how to deliver only significant events. A LevelEvaluator is specified with a threshold of WARN. This means that the events will only be delivered when a message with level of WARN or higher level is logged. Up to 512 (BufferSize) previous messages of any level will also be delivered to provide context information. Messages not sent will be discarded.

    <appender name="BufferingForwardingAppender" type="log4net.Appender.BufferingForwardingAppender" >
        <bufferSize value="512" />
        <lossy value="true" />
        <evaluator type="log4net.Core.LevelEvaluator">
            <threshold value="WARN"/>
        </evaluator>
        <appender-ref ref="ConsoleAppender" />
    </appender>

## ColoredConsoleAppender

For full details see the SDK Reference entry: log4net.Appender.ColoredConsoleAppender.

The following example shows how to configure the ColoredConsoleAppender to log messages to the console. By default the messages are sent to the console standard output stream. This example shows how to highlight error messages.

    <appender name="ColoredConsoleAppender" type="log4net.Appender.ColoredConsoleAppender">
        <mapping>
            <level value="ERROR" />
            <foreColor value="White" />
            <backColor value="Red, HighIntensity" />
        </mapping>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example shows how to colorize multiple levels.

    <appender name="ColoredConsoleAppender" type="log4net.Appender.ColoredConsoleAppender">
        <mapping>
            <level value="ERROR" />
            <foreColor value="White" />
            <backColor value="Red, HighIntensity" />
        </mapping>
        <mapping>
            <level value="DEBUG" />
            <backColor value="Green" />
        </mapping>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## ConsoleAppender

For full details see the SDK Reference entry: log4net.Appender.ConsoleAppender.

The following example shows how to configure the ConsoleAppender to log messages to the console. By default the messages are sent to the console standard output stream.

    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example shows how to direct the log messages to the console error stream.

    <appender name="ConsoleAppender" type="log4net.Appender.ConsoleAppender">
        <target value="Console.Error" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## EventLogAppender

For full details see the SDK Reference entry: log4net.Appender.EventLogAppender.

The following example shows how to configure the EventLogAppender to log to the Application event log on the local machine using the event Source of the AppDomain.FriendlyName.

    <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender" >
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example shows how to configure the EventLogAppender to use a specific event Source.

    <appender name="EventLogAppender" type="log4net.Appender.EventLogAppender" >
        <applicationName value="MyApp" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

For more information on how to setup the event log to allow the EventLogAppender to write to it, see the FAQ: Why doesn't the EventLogAppender work?.

## FileAppender

For full details see the SDK Reference entry: log4net.Appender.FileAppender.

The following example shows how to configure the FileAppender to write messages to a file. The file specified is log-file.txt. The file will be appended to rather than overwritten each time the logging process starts.

    <appender name="FileAppender" type="log4net.Appender.FileAppender">
        <file value="log-file.txt" />
        <appendToFile value="true" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example shows how to configure the file name to write to using an environment variable TMP. The encoding to use to write to the file is also specified.

    <appender name="FileAppender" type="log4net.Appender.FileAppender">
        <file value="${TMP}\log-file.txt" />
        <appendToFile value="true" />
        <encoding value="unicodeFFFE" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example shows how to configure the appender to use the minimal locking model that allows multiple processes to write to the same file.

    <appender name="FileAppender" type="log4net.Appender.FileAppender">
        <file value="${TMP}\log-file.txt" />
        <appendToFile value="true" />
        <lockingModel type="log4net.Appender.FileAppender+MinimalLock" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example shows how to configure the appender to use the "inter process" locking model.

    <appender name="FileAppender" type="log4net.Appender.FileAppender">
        <file value="${TMP}\log-file.txt" />
        <appendToFile value="true" />
        <lockingModel type="log4net.Appender.FileAppender+InterProcessLock" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

Before you change the locking model so that multiple process may log to the same file, please read the FAQ.

## ForwardingAppender

For full details see the SDK Reference entry: log4net.Appender.ForwardingAppender.

The following example shows how to configure the ForwardingAppender. The forwarding appender allows a set of constraints to be used to decorate an appender. In this example the ConsoleAppender is decorated with a Threshold of level WARN. This means that an event directed to the ConsoleAppender directly will be logged regardless of its level, but an event directed to the ForwardingAppender will only be passed on to the ConsoleAppender if its level is WARN or higher. This appender is used only in special circumstances.

    <appender name="ForwardingAppender" type="log4net.Appender.ForwardingAppender" >
        <threshold value="WARN"/>
        <appender-ref ref="ConsoleAppender" />
    </appender>

## ManagedColoredConsoleAppender

For full details see the SDK Reference entry: log4net.Appender.ManagedColoredConsoleAppender.

The following example shows how to configure the ManagedColoredConsoleAppender to log messages to the console. By default the messages are sent to the console standard output stream. This example shows how to highlight error messages.

    <appender name="ManagedColoredConsoleAppender" type="log4net.Appender.ManagedColoredConsoleAppender">
        <mapping>
            <level value="ERROR" />
            <foreColor value="White" />
            <backColor value="Red" />
        </mapping>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example shows how to colorize multiple levels.

    <appender name="ManagedColoredConsoleAppender" type="log4net.Appender.ManagedColoredConsoleAppender">
        <mapping>
            <level value="ERROR" />
            <foreColor value="DarkRed" />
        </mapping>
        <mapping>
            <level value="WARN" />
            <foreColor value="Yellow" />
        </mapping>
        <mapping>
            <level value="INFO" />
            <foreColor value="White" />
        </mapping>
        <mapping>
            <level value="DEBUG" />
            <foreColor value="Blue" />
        </mapping>

        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date %-5level %-20.20logger: %message%newline"/>
        </layout>
    </appender>

## MemoryAppender

For full details see the SDK Reference entry: log4net.Appender.MemoryAppender.

It is unlikely that the MemoryAppender will be configured using a config file, but if you want to do it here's how.

    <appender name="MemoryAppender" type="log4net.Appender.MemoryAppender">
        <onlyFixPartialEventData value="true" />
    </appender>

## NetSendAppender

For full details see the SDK Reference entry: log4net.Appender.NetSendAppender.

The following example shows how to configure the NetSendAppender to deliver messages to a specific user's screen. As this appender is typically only used for important notifications a Threshold of level Error is specified. This example delivers the messages to the user nicko on the machine SQUARE. However things are not always straight forward using the Windows Messenger Service, one possible outcome using this configuration is that the Server will broadcast looking for a WINS server which it will then ask to deliver the message to the Recipient, the WINS server will deliver it to the first terminal that the user logged in from.

    <appender name="NetSendAppender" type="log4net.Appender.NetSendAppender">
        <threshold value="ERROR" />
        <server value="SQUARE" />
        <recipient value="nicko" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## OutputDebugStringAppender

For full details see the SDK Reference entry: log4net.Appender.OutputDebugStringAppender.

The following example shows how to configure the OutputDebugStringAppender to write logging messages to the OutputDebugString API.

    <appender name="OutputDebugStringAppender" type="log4net.Appender.OutputDebugStringAppender" >
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## RemotingAppender

For full details see the SDK Reference entry: log4net.Appender.RemotingAppender.

The following example shows how to configure the RemotingAppender to deliver logging events to a specified Sink (in this example the sink is tcp://localhost:8085/LoggingSink). In this example the events are delivered in blocks of 95 events because of the BufferSize. No events are discarded. The OnlyFixPartialEventData option allows the appender to ignore certain logging event properties that can be very slow to generate (e.g. the calling location information).

    <appender name="RemotingAppender" type="log4net.Appender.RemotingAppender" >
        <sink value="tcp://localhost:8085/LoggingSink" />
        <lossy value="false" />
        <bufferSize value="95" />
        <onlyFixPartialEventData value="true" />
    </appender>

This example configures the RemotingAppender to deliver the events only when an event with level ERROR or above is logged. When the events are delivered, up to 200 (BufferSize) previous events (regardless of level) will be delivered to provide context. Events not delivered will be discarded.

    <appender name="RemotingAppender" type="log4net.Appender.RemotingAppender" >
        <sink value="tcp://localhost:8085/LoggingSink" />
        <lossy value="true" />
        <bufferSize value="200" />
        <onlyFixPartialEventData value="true" />
        <evaluator type="log4net.Core.LevelEvaluator">
            <threshold value="ERROR"/>
        </evaluator>
    </appender>

## RollingFileAppender

For full details see the SDK Reference entry: log4net.Appender.RollingFileAppender.

The RollingFileAppender builds on the FileAppender and has the same options as that appender.

The following example shows how to configure the RollingFileAppender to write to the file log.txt. The file written to will always be called log.txt because the StaticLogFileName param is specified. The file will be rolled based on a size constraint (RollingStyle). Up to 10 (MaxSizeRollBackups) old files of 100 KB each (MaximumFileSize) will be kept. These rolled files will be named: log.txt.1, log.txt.2, log.txt.3, etc...

    <appender name="RollingFileAppender" type="log4net.Appender.RollingFileAppender">
        <file value="log.txt" />
        <appendToFile value="true" />
        <rollingStyle value="Size" />
        <maxSizeRollBackups value="10" />
        <maximumFileSize value="100KB" />
        <staticLogFileName value="true" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example show how to configure the RollingFileAppender to roll log files on a date period. This example will roll the log file every minute! To change the rolling period adjust the DatePattern value. For example, a date pattern of "yyyyMMdd" will roll every day. See System.Globalization.DateTimeFormatInfo for a list of available patterns.

    <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
        <file value="logfile" />
        <appendToFile value="true" />
        <rollingStyle value="Date" />
        <datePattern value="yyyyMMdd-HHmm" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example show how to configure the RollingFileAppender to roll log files on a date period and within a date period on file size. For each day only the last 10 files of 1MB will be kept.

    <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
        <file value="logfile" />
        <appendToFile value="true" />
        <rollingStyle value="Composite" />
        <datePattern value="yyyyMMdd" />
        <maxSizeRollBackups value="10" />
        <maximumFileSize value="1MB" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

This example show how to configure the RollingFileAppender to roll log files once per program execution. The appendToFile property is set to false to prevent the appender from overwriting the existing files. The maxSizeRollBackups is set to negative 1 to allow an infinite number of backup files. The file size does have to be limited but here it is set to 50 Gigabytes which, if a log file exceeds this size limit during a single run then it will also be rolled.

    <appender name="RollingLogFileAppender" type="log4net.Appender.RollingFileAppender">
        <file value="logfile.txt" />
        <appendToFile value="false" />
        <rollingStyle value="Size" />
        <maxSizeRollBackups value="-1" />
        <maximumFileSize value="50GB" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## SmtpAppender

For full details see the SDK Reference entry: log4net.Appender.SmtpAppender.

The following example shows how to configure the SmtpAppender to deliver log events via SMTP email. The To, From, Subject and SmtpHost are required parameters. This example shows how to deliver only significant events. A LevelEvaluator is specified with a threshold of WARN. This means that an email will be sent for each WARN or higher level message that is logged. Each email will also contain up to 512 (BufferSize) previous messages of any level to provide context. Messages not sent will be discarded.

    <appender name="SmtpAppender" type="log4net.Appender.SmtpAppender">
        <to value="to@domain.com" />
        <from value="from@domain.com" />
        <subject value="test logging message" />
        <smtpHost value="SMTPServer.domain.com" />
        <bufferSize value="512" />
        <lossy value="true" />
        <evaluator type="log4net.Core.LevelEvaluator">
            <threshold value="WARN"/>
        </evaluator>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%newline%date [%thread] %-5level %logger [%property{NDC}] - %message%newline%newline%newline" />
        </layout>
    </appender>

This example shows how to configure the SmtpAppender to deliver all messages in emails with 512 (BufferSize) messages per email.

    <appender name="SmtpAppender" type="log4net.Appender.SmtpAppender">
        <to value="to@domain.com" />
        <from value="from@domain.com" />
        <subject value="test logging message" />
        <smtpHost value="SMTPServer.domain.com" />
        <bufferSize value="512" />
        <lossy value="false" />
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%newline%date [%thread] %-5level %logger [%property{NDC}] - %message%newline%newline%newline" />
        </layout>
    </appender>

This example shows a more verbose formatting layout for the mail messages.

    <appender name="SmtpAppender" type="log4net.Appender.SmtpAppender,log4net">
        <to value="to@domain.com" />
        <from value="from@domain.com" />
        <subject value="test logging message" />
        <smtpHost value="SMTPServer.domain.com" />
        <bufferSize value="512" />
        <lossy value="false" />
        <evaluator type="log4net.Core.LevelEvaluator,log4net">
            <threshold value="WARN" />
        </evaluator>
        <layout type="log4net.Layout.PatternLayout,log4net">
            <conversionPattern value="%property{log4net:HostName} :: %level :: %message %newlineLogger: %logger%newlineThread: %thread%newlineDate: %date%newlineNDC: %property{NDC}%newline%newline" />
        </layout>
    </appender>

## SmtpPickupDirAppender

For full details see the SDK Reference entry: log4net.Appender.SmtpPickupDirAppender.

The SmtpPickupDirAppender is configured similarly to the SmtpAppender. The only difference is that rather than specify a SmtpHost parameter a PickupDir must be specified.

The PickupDir parameter is a path that must exist and the code executing the appender must have permission to create new files and write to them in this directory. The path is relative to the application's base directory (AppDomain.BaseDirectory).

The following example shows how to configure the SmtpPickupDirAppender to deliver log events via SMTP email. The To, From, Subject and PickupDir are required parameters. This example shows how to deliver only significant events. A LevelEvaluator is specified with a threshold of WARN. This means that an email will be sent for each WARN or higher level message that is logged. Each email will also contain up to 512 (BufferSize) previous messages of any level to provide context. Messages not sent will be discarded.

    <appender name="SmtpPickupDirAppender" type="log4net.Appender.SmtpPickupDirAppender">
        <to value="to@domain.com" />
        <from value="from@domain.com" />
        <subject value="test logging message" />
        <pickupDir value="C:\SmtpPickup" />
        <bufferSize value="512" />
        <lossy value="true" />
        <evaluator type="log4net.Core.LevelEvaluator">
            <threshold value="WARN"/>
        </evaluator>
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%newline%date [%thread] %-5level %logger [%property{NDC}] - %message%newline%newline%newline" />
        </layout>
    </appender>

## TraceAppender

For full details see the SDK Reference entry: log4net.Appender.TraceAppender.

The following example shows how to configure the TraceAppender to log messages to the System.Diagnostics.Trace system. This is the tracing system supplied with the .net base class libraries. See the MSDN documentation for the System.Diagnostics.Trace class for more details on how to configure the trace system.

    <appender name="TraceAppender" type="log4net.Appender.TraceAppender">
        <layout type="log4net.Layout.PatternLayout">
            <conversionPattern value="%date [%thread] %-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## UdpAppender

For full details see the SDK Reference entry: log4net.Appender.UdpAppender.

The following example shows how to configure the UdpAppender to send events to a RemoteAddress on the specified RemotePort.

    <appender name="UdpAppender" type="log4net.Appender.UdpAppender">
        <localPort value="8080" />
        <remoteAddress value="224.0.0.1" />
        <remotePort value="8080" />
        <layout type="log4net.Layout.PatternLayout, log4net">
            <conversionPattern value="%-5level %logger [%property{NDC}] - %message%newline" />
        </layout>
    </appender>

## DynamicPatternLayout

For full details see the SDK Reference entry: log4net.Layout.DynamicPatternLayout.

The DynamicPatternLayout should be used whenever the header or footer should contain information that could change over time. Compared to the static PatternLayout which does not re-evaluate on every invoke, the DynamicPatternLayout does re-evaluate the pattern on every invoke. It does, for example, allow to include the current DateTime in the header and/or the footer which was not possible with the static PatternLayout.

The following example shows how to configure the DynamicPatternLayout.

    <layout type="log4net.Layout.DynamicPatternLayout">
      <param name="Header" value="%newline**** Trace Opened Local: %date{yyyy-MM-dd HH:mm:ss.fff} UTC: %utcdate{yyyy-MM-dd HH:mm:ss.fff} ****%newline"/>
      <param name="Footer" value="**** Trace Closed %date{yyyy-MM-dd HH:mm:ss.fff} ****%newline"/>
    </layout>