## Appenders Appenders are responsible for delivering LogEvents to their destination. Every Appender must implement the Appender interface. Most Appenders will extend AbstractAppender which adds Lifecycle and Filterable support. Lifecycle allows components to finish initialization after configuration has completed and to perform cleanup during shutdown. Filterable allows the component to have Filters attached to it which are evaluated during event processing. Appenders usually are only responsible for writing the event data to the target destination. In most cases they delegate responsibility for formatting the event to a layout. Some appenders wrap other appenders so that they can modify the LogEvent, handle a failure in an Appender, route the event to a subordinate Appender based on advanced Filter criteria or provide similar functionality that does not directly format the event for viewing. Appenders always have a name so that they can be referenced from Loggers. ### AsyncAppender The AsyncAppender accepts references to other Appenders and causes LogEvents to be written to them on a separate Thread. Note that exceptions while writing to those Appenders will be hidden from the application. The AsyncAppender should be configured after the appenders it references to allow it to shut down properly.
AsyncAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
AppenderRef | String | The name of the Appenders to invoke asynchronously. Multiple AppenderRef elements can be configured.
blocking | boolean | If true, the appender will wait until there are free slots in the queue. If false, the event will be written to the error appender if the queue is full. The default is true.
bufferSize | integer | Specifies the maximum number of events that can be queued. The default is 128.
errorRef | String | The name of the Appender to invoke if none of the appenders can be called, either due to errors in the appenders or because the queue is full. If not specified then errors will be ignored.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
name | String | The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
includeLocation | boolean | Extracting location is an expensive operation (it can make logging 5 - 20 times slower). To improve performance, location is not included by default when adding a log event to the queue. You can change this by setting includeLocation="true".
A typical AsyncAppender configuration might look like:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <File name="MyFile" fileName="logs/app.log">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
        </File>
        <Async name="Async">
          <AppenderRef ref="MyFile"/>
        </Async>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="Async"/>
        </Root>
      </Loggers>
    </Configuration>
### ConsoleAppender As one might expect, the ConsoleAppender writes its output to either System.err or System.out with System.err being the default target. A Layout must be provided to format the LogEvent.
ConsoleAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
layout | Layout | The Layout to use to format the LogEvent. If no layout is supplied the default pattern layout of "%m%n" will be used.
follow | boolean | Identifies whether the appender honors reassignments of System.out or System.err via System.setOut or System.setErr made after configuration. Note that the follow attribute cannot be used with Jansi on Windows.
name | String | The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
target | String | Either "SYSTEM_OUT" or "SYSTEM_ERR". The default is "SYSTEM_ERR".
A typical Console configuration might look like:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Console name="STDOUT" target="SYSTEM_OUT">
          <PatternLayout pattern="%m%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="STDOUT"/>
        </Root>
      </Loggers>
    </Configuration>
### FailoverAppender The FailoverAppender wraps a set of appenders. If the primary Appender fails the secondary appenders will be tried in order until one succeeds or there are no more secondaries to try.
FailoverAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
primary | String | The name of the primary Appender to use.
failovers | String[] | The names of the secondary Appenders to use.
name | String | The name of the Appender.
retryIntervalSeconds | integer | The number of seconds that should pass before retrying the primary Appender. The default is 60.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead.
target | String | Either "SYSTEM_OUT" or "SYSTEM_ERR". The default is "SYSTEM_ERR".
A Failover configuration might look like:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RollingFile name="RollingFile" fileName="logs/app.log" filePattern="logs/app-%d{MM-dd-yyyy}.log.gz"
                     ignoreExceptions="false">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
          <TimeBasedTriggeringPolicy />
        </RollingFile>
        <Console name="STDOUT" target="SYSTEM_OUT" ignoreExceptions="false">
          <PatternLayout pattern="%m%n"/>
        </Console>
        <Failover name="Failover" primary="RollingFile">
          <Failovers>
            <AppenderRef ref="Console"/>
          </Failovers>
        </Failover>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="Failover"/>
        </Root>
      </Loggers>
    </Configuration>
### FileAppender The FileAppender is an OutputStreamAppender that writes to the File named in the fileName parameter. The FileAppender uses a FileManager (which extends OutputStreamManager) to actually perform the file I/O. While FileAppenders from different Configurations cannot be shared, the FileManagers can be if the Manager is accessible. For example, two web applications in a servlet container can have their own configuration and safely write to the same file if Log4j is in a ClassLoader that is common to both of them.
FileAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
append | boolean | When true - the default, records will be appended to the end of the file. When set to false, the file will be cleared before new records are written.
bufferedIO | boolean | When true - the default, records will be written to a buffer and the data will be written to disk when the buffer is full or, if immediateFlush is set, when the record is written. File locking cannot be used with bufferedIO. Performance tests have shown that using buffered I/O significantly improves performance, even if immediateFlush is enabled.
bufferSize | int | When bufferedIO is true, this is the buffer size, the default is 8192 bytes.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
fileName | String | The name of the file to write to. If the file, or any of its parent directories, do not exist, they will be created.
immediateFlush | boolean | When set to true - the default, each write will be followed by a flush. This will guarantee the data is written to disk but could impact performance. Flushing after every write is only useful when using this appender with synchronous loggers. Asynchronous loggers and appenders will automatically flush at the end of a batch of events, even if immediateFlush is set to false. This also guarantees the data is written to disk but is more efficient.
layout | Layout | The Layout to use to format the LogEvent
locking | boolean | When set to true, I/O operations will occur only while the file lock is held allowing FileAppenders in multiple JVMs and potentially multiple hosts to write to the same file simultaneously. This will significantly impact performance so should be used carefully. Furthermore, on many systems the file lock is "advisory" meaning that other applications can perform operations on the file without acquiring a lock. The default value is false.
name | String | The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
Here is a sample File configuration:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <File name="MyFile" fileName="logs/app.log">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
        </File>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="MyFile"/>
        </Root>
      </Loggers>
    </Configuration>
### FlumeAppender This is an optional component supplied in a separate jar. Apache Flume is a distributed, reliable, and available system for efficiently collecting, aggregating, and moving large amounts of log data from many different sources to a centralized data store. The FlumeAppender takes LogEvents and sends them to a Flume agent as serialized Avro events for consumption. The Flume Appender supports three modes of operation. It can act as a remote Flume client which sends Flume events via Avro to a Flume Agent configured with an Avro Source. It can act as an embedded Flume Agent where Flume events pass directly into Flume for processing. It can persist events to a local BerkeleyDB data store and then asynchronously send the events to Flume, similar to the embedded Flume Agent but without most of the Flume dependencies. Usage as an embedded agent will cause the messages to be directly passed to the Flume Channel and then control will be immediately returned to the application. All interaction with remote agents will occur asynchronously. Setting the "type" attribute to "Embedded" will force the use of the embedded agent. In addition, configuring agent properties in the appender configuration will also cause the embedded agent to be used.
FlumeAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
agents | Agent[] | An array of Agents to which the logging events should be sent. If more than one agent is specified the first Agent will be the primary and subsequent Agents will be used in the order specified as secondaries should the primary Agent fail. Each Agent definition supplies the Agents host and port. The specification of agents and properties are mutually exclusive. If both are configured an error will result.
agentRetries | integer | The number of times the agent should be retried before failing to a secondary. This parameter is ignored when type="persistent" is specified (agents are tried once before failing to the next).
batchSize | integer | Specifies the number of events that should be sent as a batch. The default is 1. This parameter only applies to the Flume Appender.
compress | boolean | When set to true the message body will be compressed using gzip
connectTimeoutMillis | integer | The number of milliseconds Flume will wait before timing out the connection.
dataDir | String | Directory where the Flume write ahead log should be written. Valid only when embedded is set to true and Agent elements are used instead of Property elements.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
eventPrefix | String | The character string to prepend to each event attribute in order to distinguish it from MDC attributes. The default is an empty string.
flumeEventFactory | FlumeEventFactory | Factory that generates the Flume events from Log4j events. The default factory is the FlumeAvroAppender itself.
layout | Layout | The Layout to use to format the LogEvent. If no layout is specified RFC5424Layout will be used.
lockTimeoutRetries | integer | The number of times to retry if a LockConflictException occurs while writing to Berkeley DB. The default is 5.
maxDelayMillis | integer | The maximum number of milliseconds to wait for batchSize events before publishing the batch.
mdcExcludes | String | A comma separated list of mdc keys that should be excluded from the FlumeEvent. This is mutually exclusive with the mdcIncludes attribute.
mdcIncludes | String | A comma separated list of mdc keys that should be included in the FlumeEvent. Any keys in the MDC not found in the list will be excluded. This option is mutually exclusive with the mdcExcludes attribute.
mdcRequired | String | A comma separated list of mdc keys that must be present in the MDC. If a key is not present a LoggingException will be thrown.
mdcPrefix | String | A string that should be prepended to each MDC key in order to distinguish it from event attributes. The default string is "mdc:".
name | String | The name of the Appender.
properties | Property[] | One or more Property elements that are used to configure the Flume Agent. The properties must be configured without the agent name (the appender name is used for this) and no sources can be configured. Interceptors can be specified for the source using "sources.log4j-source.interceptors". All other Flume configuration properties are allowed. Specifying both Agent and Property elements will result in an error. When used to configure in Persistent mode the valid properties are: "keyProvider" to specify the name of the plugin to provide the secret key for encryption.
requestTimeoutMillis | integer | The number of milliseconds Flume will wait before timing out the request.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
type | enumeration | One of "Avro", "Embedded", or "Persistent" to indicate which variation of the Appender is desired.
A sample FlumeAppender configuration that is configured with a primary and a secondary agent, compresses the body, and formats the body using the RFC5424Layout:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Flume name="eventLogger" compress="true">
          <Agent host="192.168.10.101" port="8800"/>
          <Agent host="192.168.10.102" port="8800"/>
          <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
        </Flume>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="eventLogger"/>
        </Root>
      </Loggers>
    </Configuration>
A sample FlumeAppender configuration that is configured with a primary and a secondary agent, compresses the body, formats the body using the RFC5424Layout, and persists encrypted events to disk:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Flume name="eventLogger" compress="true" type="persistent" dataDir="./logData">
          <Agent host="192.168.10.101" port="8800"/>
          <Agent host="192.168.10.102" port="8800"/>
          <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
          <Property name="keyProvider">MySecretProvider</Property>
        </Flume>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="eventLogger"/>
        </Root>
      </Loggers>
    </Configuration>
A sample FlumeAppender configuration that is configured with a primary and a secondary agent, compresses the body, formats the body using RFC5424Layout and passes the events to an embedded Flume Agent.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Flume name="eventLogger" compress="true" type="Embedded">
          <Agent host="192.168.10.101" port="8800"/>
          <Agent host="192.168.10.102" port="8800"/>
          <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
        </Flume>
        <Console name="STDOUT">
          <PatternLayout pattern="%d [%p] %c %m%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Logger name="EventLogger" level="info">
          <AppenderRef ref="eventLogger"/>
        </Logger>
        <Root level="warn">
          <AppenderRef ref="STDOUT"/>
        </Root>
      </Loggers>
    </Configuration>
A sample FlumeAppender configuration that is configured with a primary and a secondary agent using Flume configuration properties, compresses the body, formats the body using RFC5424Layout and passes the events to an embedded Flume Agent.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="error" name="MyApp" packages="">
      <Appenders>
        <Flume name="eventLogger" compress="true" type="Embedded">
          <Property name="channels">file</Property>
          <Property name="channels.file.type">file</Property>
          <Property name="channels.file.checkpointDir">target/file-channel/checkpoint</Property>
          <Property name="channels.file.dataDirs">target/file-channel/data</Property>
          <Property name="sinks">agent1 agent2</Property>
          <Property name="sinks.agent1.channel">file</Property>
          <Property name="sinks.agent1.type">avro</Property>
          <Property name="sinks.agent1.hostname">192.168.10.101</Property>
          <Property name="sinks.agent1.port">8800</Property>
          <Property name="sinks.agent1.batch-size">100</Property>
          <Property name="sinks.agent2.channel">file</Property>
          <Property name="sinks.agent2.type">avro</Property>
          <Property name="sinks.agent2.hostname">192.168.10.102</Property>
          <Property name="sinks.agent2.port">8800</Property>
          <Property name="sinks.agent2.batch-size">100</Property>
          <Property name="sinkgroups">group1</Property>
          <Property name="sinkgroups.group1.sinks">agent1 agent2</Property>
          <Property name="sinkgroups.group1.processor.type">failover</Property>
          <Property name="sinkgroups.group1.processor.priority.agent1">10</Property>
          <Property name="sinkgroups.group1.processor.priority.agent2">5</Property>
          <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
        </Flume>
        <Console name="STDOUT">
          <PatternLayout pattern="%d [%p] %c %m%n"/>
        </Console>
      </Appenders>
      <Loggers>
        <Logger name="EventLogger" level="info">
          <AppenderRef ref="eventLogger"/>
        </Logger>
        <Root level="warn">
          <AppenderRef ref="STDOUT"/>
        </Root>
      </Loggers>
    </Configuration>
### JDBCAppender The JDBCAppender writes log events to a relational database table using standard JDBC. It can be configured to obtain JDBC connections using a JNDI `DataSource` or a custom factory method. Whichever approach you take, it must be backed by a connection pool. Otherwise, logging performance will suffer greatly.
JDBCAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
name | String | Required. The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
bufferSize | int | If an integer greater than 0, this causes the appender to buffer log events and flush whenever the buffer reaches this size.
connectionSource | ConnectionSource | Required. The connections source from which database connections should be retrieved.
tableName | String | Required. The name of the database table to insert log events into.
columnConfigs | ColumnConfig[] | Required. Information about the columns that log event data should be inserted into and how to insert that data. This is represented with multiple `<Column>` elements.
When configuring the JDBCAppender, you must specify a `ConnectionSource` implementation from which the Appender gets JDBC connections. You must use exactly one of the `<DataSource>` or `<ConnectionFactory>` nested elements.
DataSource Parameters
Parameter Name | Type | Description
--- | --- | ---
jndiName | String | Required. The full, prefixed JNDI name that the `javax.sql.DataSource` is bound to, such as `java:/comp/env/jdbc/LoggingDatabase`. The `DataSource` must be backed by a connection pool; otherwise, logging will be very slow.
ConnectionFactory Parameters
Parameter Name | Type | Description
--- | --- | ---
class | Class | Required. The fully qualified name of a class containing a static factory method for obtaining JDBC connections.
method | Method | Required. The name of a static factory method for obtaining JDBC connections. This method must have no parameters and its return type must be either `java.sql.Connection` or `DataSource`. If the method returns `Connection`s, it must obtain them from a connection pool (and they will be returned to the pool when Log4j is done with them); otherwise, logging will be very slow. If the method returns a `DataSource`, the `DataSource` will only be retrieved once, and it must be backed by a connection pool for the same reasons.
When configuring the JDBCAppender, use the nested `<Column>` elements to specify which columns in the table should be written to and how to write to them. The JDBCAppender uses this information to formulate a `PreparedStatement` to insert records without SQL injection vulnerability.
Column Parameters
Parameter Name | Type | Description
--- | --- | ---
name | String | Required. The name of the database column.
pattern | String | Use this attribute to insert a value or values from the log event in this column using a `PatternLayout` pattern. Simply specify any legal pattern in this attribute. Either this attribute, `literal`, or `isEventTimestamp="true"` must be specified, but not more than one of these.
literal | String | Use this attribute to insert a literal value in this column. The value will be included directly in the insert SQL, without any quoting (which means that if you want this to be a string, your value should contain single quotes around it like this: `literal="'Literal String'"`). This is especially useful for databases that don't support identity columns. For example, if you are using Oracle you could specify `literal="NAME_OF_YOUR_SEQUENCE.NEXTVAL"` to insert a unique ID in an ID column. Either this attribute, `pattern`, or `isEventTimestamp="true"` must be specified, but not more than one of these.
isEventTimestamp | boolean | Use this attribute to insert the event timestamp in this column, which should be a SQL datetime. The value will be inserted as a `java.sql.Types.TIMESTAMP`. Either this attribute (equal to `true`), `pattern`, or `isEventTimestamp` must be specified, but not more than one of these.
isUnicode | boolean | This attribute is ignored unless `pattern` is specified. If `true` or omitted (default), the value will be inserted as unicode (`setNString` or `setNClob`). Otherwise, the value will be inserted non-unicode (`setString` or `setClob`).
isClob | boolean | This attribute is ignored unless `pattern` is specified. Use this attribute to indicate that the column stores Character Large Objects (CLOBs). If `true`, the value will be inserted as a CLOB (`setClob` or `setNClob`). If `false` or omitted (default), the value will be inserted as a VARCHAR or NVARCHAR (`setString` or `setNString`).
Here are a couple sample configurations for the JDBCAppender, as well as a sample factory implementation that uses Commons Pooling and Commons DBCP to pool database connections:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="error">
      <Appenders>
        <JDBC name="databaseAppender" tableName="dbo.application_log">
          <DataSource jndiName="java:/comp/env/jdbc/LoggingDataSource" />
          <Column name="eventDate" isEventTimestamp="true" />
          <Column name="level" pattern="%level" />
          <Column name="logger" pattern="%logger" />
          <Column name="message" pattern="%message" />
          <Column name="exception" pattern="%ex{full}" />
        </JDBC>
      </Appenders>
      <Loggers>
        <Root level="warn">
          <AppenderRef ref="databaseAppender"/>
        </Root>
      </Loggers>
    </Configuration>
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="error">
      <Appenders>
        <JDBC name="databaseAppender" tableName="LOGGING.APPLICATION_LOG">
          <ConnectionFactory class="net.example.db.ConnectionFactory" method="getDatabaseConnection" />
          <Column name="EVENT_ID" literal="LOGGING.APPLICATION_LOG_SEQUENCE.NEXTVAL" />
          <Column name="EVENT_DATE" isEventTimestamp="true" />
          <Column name="LEVEL" pattern="%level" />
          <Column name="LOGGER" pattern="%logger" />
          <Column name="MESSAGE" pattern="%message" />
          <Column name="THROWABLE" pattern="%ex{full}" />
        </JDBC>
      </Appenders>
      <Loggers>
        <Root level="warn">
          <AppenderRef ref="databaseAppender"/>
        </Root>
      </Loggers>
    </Configuration>
    package net.example.db;

    import java.sql.Connection;
    import java.sql.SQLException;
    import java.util.Properties;

    import javax.sql.DataSource;

    import org.apache.commons.dbcp.DriverManagerConnectionFactory;
    import org.apache.commons.dbcp.PoolableConnection;
    import org.apache.commons.dbcp.PoolableConnectionFactory;
    import org.apache.commons.dbcp.PoolingDataSource;
    import org.apache.commons.pool.impl.GenericObjectPool;

    public class ConnectionFactory {
        private static interface Singleton {
            final ConnectionFactory INSTANCE = new ConnectionFactory();
        }

        private final DataSource dataSource;

        private ConnectionFactory() {
            Properties properties = new Properties();
            properties.setProperty("user", "logging");
            properties.setProperty("password", "abc123"); // or get properties from some configuration file

            GenericObjectPool<PoolableConnection> pool = new GenericObjectPool<PoolableConnection>();
            DriverManagerConnectionFactory connectionFactory = new DriverManagerConnectionFactory(
                    "jdbc:mysql://example.org:3306/exampleDb", properties
            );
            new PoolableConnectionFactory(
                    connectionFactory, pool, null, "SELECT 1", 3, false, false, Connection.TRANSACTION_READ_COMMITTED
            );

            this.dataSource = new PoolingDataSource(pool);
        }

        public static Connection getDatabaseConnection() throws SQLException {
            return Singleton.INSTANCE.dataSource.getConnection();
        }
    }
### JMSAppender The JMSAppender sends the formatted log event to a JMS Destination. Note that in Log4j 2.0, this appender was split into a JMSQueueAppender and a JMSTopicAppender. Starting in Log4j 2.1, these appenders were combined into the JMSAppender which makes no distinction between queues and topics. However, configurations written for 2.0 which use the `<JMSQueue/>` or `<JMSTopic/>` elements will continue to work with the new `<JMS/>` configuration element.
JMSAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
factoryBindingName | String | The name to locate in the Context that provides the ConnectionFactory. This can be any subinterface of `ConnectionFactory` as well. This attribute is required.
factoryName | String | The fully qualified class name that should be used to define the Initial Context Factory as defined in INITIAL_CONTEXT_FACTORY. If no value is provided the default InitialContextFactory will be used. If a factoryName is specified without a providerURL a warning message will be logged as this is likely to cause problems.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
layout | Layout | The Layout to use to format the LogEvent. If you do not specify a layout, this appender will use a SerializedLayout.
name | String | The name of the Appender. Required.
password | String | The password to use to create the JMS connection.
providerURL | String | The URL of the provider to use as defined by PROVIDER_URL. If this value is null the default system provider will be used.
destinationBindingName | String | The name to use to locate the Destination. This can be a `Queue` or `Topic`, and as such, the attribute names `queueBindingName` and `topicBindingName` are aliases to maintain compatibility with the Log4j 2.0 JMS appenders.
securityPrincipalName | String | The name of the identity of the Principal as specified by SECURITY_PRINCIPAL. If a securityPrincipalName is specified without securityCredentials a warning message will be logged as this is likely to cause problems.
securityCredentials | String | The security credentials for the principal as specified by SECURITY_CREDENTIALS.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
urlPkgPrefixes | String | A colon-separated list of package prefixes for the class name of the factory class that will create a URL context factory as defined by URL_PKG_PREFIXES.
userName | String | The user id used to create the JMS connection.
Here is a sample JMSAppender configuration:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp">
      <Appenders>
        <JMS name="jmsQueue" destinationBindingName="MyQueue"
             factoryBindingName="MyQueueConnectionFactory"/>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="jmsQueue"/>
        </Root>
      </Loggers>
    </Configuration>
### JPAAppender The JPAAppender writes log events to a relational database table using the Java Persistence API 2.1. It requires the API and a provider implementation be on the classpath. It also requires a decorated entity configured to persist to the table desired. The entity should either extend `org.apache.logging.log4j.core.appender.db.jpa.BasicLogEventEntity` (if you mostly want to use the default mappings) and provide at least an `@Id` property, or `org.apache.logging.log4j.core.appender.db.jpa.AbstractLogEventWrapperEntity` (if you want to significantly customize the mappings). See the Javadoc for these two classes for more information. You can also consult the source code of these two classes as an example of how to implement the entity.
JPAAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
name | String | Required. The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
bufferSize | int | If an integer greater than 0, this causes the appender to buffer log events and flush whenever the buffer reaches this size.
entityClassName | String | Required. The fully qualified name of the concrete LogEventWrapperEntity implementation that has JPA annotations mapping it to a database table.
persistenceUnitName | String | Required. The name of the JPA persistence unit that should be used for persisting log events.
Here is a sample configuration for the JPAAppender. The first XML sample is the Log4j configuration file, the second is the `persistence.xml` file. EclipseLink is assumed here, but any JPA 2.1 or higher provider will do. You should always create a separate persistence unit for logging, for two reasons. First, `<shared-cache-mode>` must be set to "NONE," which is usually not desired in normal JPA usage. Also, for performance reasons the logging entity should be isolated in its own persistence unit away from all other entities and you should use a non-JTA data source. Note that your persistence unit must also contain `<class>` elements for all of the `org.apache.logging.log4j.core.appender.db.jpa.converter` converter classes.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="error">
      <Appenders>
        <JPA name="databaseAppender" persistenceUnitName="loggingPersistenceUnit"
             entityClassName="com.example.logging.JpaLogEntity" />
      </Appenders>
      <Loggers>
        <Root level="warn">
          <AppenderRef ref="databaseAppender"/>
        </Root>
      </Loggers>
    </Configuration>
    <?xml version="1.0" encoding="UTF-8"?>
    <persistence xmlns="http://xmlns.jcp.org/xml/ns/persistence"
                 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
                 xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
                                     http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd"
                 version="2.1">

      <persistence-unit name="loggingPersistenceUnit" transaction-type="RESOURCE_LOCAL">
        <provider>org.eclipse.persistence.jpa.PersistenceProvider</provider>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextMapAttributeConverter</class>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextMapJsonAttributeConverter</class>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextStackAttributeConverter</class>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ContextStackJsonAttributeConverter</class>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.MarkerAttributeConverter</class>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.MessageAttributeConverter</class>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.StackTraceElementAttributeConverter</class>
        <class>org.apache.logging.log4j.core.appender.db.jpa.converter.ThrowableAttributeConverter</class>
        <class>com.example.logging.JpaLogEntity</class>
        <non-jta-data-source>jdbc/LoggingDataSource</non-jta-data-source>
        <shared-cache-mode>NONE</shared-cache-mode>
      </persistence-unit>

    </persistence>
    package com.example.logging;
    ...
    @Entity
    @Table(name="application_log", schema="dbo")
    public class JpaLogEntity extends BasicLogEventEntity {
        private static final long serialVersionUID = 1L;
        private long id = 0L;

        public TestEntity() {
            super(null);
        }
        public TestEntity(LogEvent wrappedEvent) {
            super(wrappedEvent);
        }

        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "id")
        public long getId() {
            return this.id;
        }

        public void setId(long id) {
            this.id = id;
        }

        // If you want to override the mapping of any properties mapped in BasicLogEventEntity,
        // just override the getters and re-specify the annotations.
    }
    package com.example.logging;
    ...
    @Entity
    @Table(name="application_log", schema="dbo")
    public class JpaLogEntity extends AbstractLogEventWrapperEntity {
        private static final long serialVersionUID = 1L;
        private long id = 0L;

        public TestEntity() {
            super(null);
        }
        public TestEntity(LogEvent wrappedEvent) {
            super(wrappedEvent);
        }

        @Id
        @GeneratedValue(strategy = GenerationType.IDENTITY)
        @Column(name = "logEventId")
        public long getId() {
            return this.id;
        }

        public void setId(long id) {
            this.id = id;
        }

        @Override
        @Enumerated(EnumType.STRING)
        @Column(name = "level")
        public Level getLevel() {
            return this.getWrappedEvent().getLevel();
        }

        @Override
        @Column(name = "logger")
        public String getLoggerName() {
            return this.getWrappedEvent().getLoggerName();
        }

        @Override
        @Column(name = "message")
        @Convert(converter = MyMessageConverter.class)
        public Message getMessage() {
            return this.getWrappedEvent().getMessage();
        }
        ...
    }
### MemoryMappedFileAppender New since 2.1. Be aware that this is a new addition, and although it has been tested on several platforms, it does not have as much track record as the other file appenders. The MemoryMappedFileAppender maps a part of the specified file into memory and writes log events to this memory, relying on the operating system's virtual memory manager to synchronize the changes to the storage device. The main benefit of using memory mapped files is I/O performance. Instead of making system calls to write to disk, this appender can simply change the program's local memory, which is orders of magnitude faster. Also, in most operating systems the memory region mapped actually is the kernel's page cache (file cache), meaning that no copies need to be created in user space. (TODO: performance tests that compare performance of this appender to RandomAccessFileAppender and FileAppender.) There is some overhead with mapping a file region into memory, especially very large regions (half a gigabyte or more). The default region size is 32 MB, which should strike a reasonable balance between the frequency and the duration of remap operations. (TODO: performance test remapping various sizes.) Similar to the FileAppender and the RandomAccessFileAppender, MemoryMappedFileAppender uses a MemoryMappedFileManager to actually perform the file I/O. While MemoryMappedFileAppender from different Configurations cannot be shared, the MemoryMappedFileManagers can be if the Manager is accessible. For example, two web applications in a servlet container can have their own configuration and safely write to the same file if Log4j is in a ClassLoader that is common to both of them.
MemoryMappedFileAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
append | boolean | When true - the default, records will be appended to the end of the file. When set to false, the file will be cleared before new records are written.
fileName | String | The name of the file to write to. If the file, or any of its parent directories, do not exist, they will be created.
filters | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
immediateFlush | boolean | When set to true, each write will be followed by a call to MappedByteBuffer.force(). This will guarantee the data is written to the storage device. The default for this parameter is `false`. This means that the data is written to the storage device even if the Java process crashes, but there may be data loss if the operating system crashes. Note that manually forcing a sync on every log event loses most of the performance benefits of using a memory mapped file. Flushing after every write is only useful when using this appender with synchronous loggers. Asynchronous loggers and appenders will automatically flush at the end of a batch of events, even if immediateFlush is set to false. This also guarantees the data is written to disk but is more efficient.
regionLength | int | The length of the mapped region, defaults to 32 MB (32 * 1024 * 1024 bytes). This parameter must be a value between 256 and 1,073,741,824 (1 GB or 2^30); values outside this range will be adjusted to the closest valid value. Log4j will round the specified value up to the nearest power of two.
layout | Layout | The Layout to use to format the LogEvent
name | String | The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
Here is a sample MemoryMappedFile configuration:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <MemoryMappedFile name="MyFile" fileName="logs/app.log">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
        </MemoryMappedFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="MyFile"/>
        </Root>
      </Loggers>
    </Configuration>
### NoSQLAppender The NoSQLAppender writes log events to a NoSQL database using an internal lightweight provider interface. Provider implementations currently exist for MongoDB and Apache CouchDB, and writing a custom provider is quite simple.
NoSQLAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
name | String | Required. The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
bufferSize | int | If an integer greater than 0, this causes the appender to buffer log events and flush whenever the buffer reaches this size.
NoSqlProvider | NoSQLProvider<C extends NoSQLConnection<W, T extends NoSQLObject<W>>> | Required. The NoSQL provider that provides connections to the chosen NoSQL database.
You specify which NoSQL provider to use by specifying the appropriate configuration element within the `<NoSql>` element. The types currently supported are `<MongoDb>` and `<CouchDb>`. To create your own custom provider, read the JavaDoc for the `NoSQLProvider`, `NoSQLConnection`, and `NoSQLObject` classes and the documentation about creating Log4j plugins. We recommend you review the source code for the MongoDB and CouchDB providers as a guide for creating your own provider.
MongoDB Provider Parameters
Parameter Name | Type | Description
--- | --- | ---
collectionName | String | Required. The name of the MongoDB collection to insert the events into.
writeConcernConstant | Field | By default, the MongoDB provider inserts records with the instructions `com.mongodb.WriteConcern.ACKNOWLEDGED`. Use this optional attribute to specify the name of a constant other than `ACKNOWLEDGED`.
writeConcernConstantClass | Class | If you specify `writeConcernConstant`, you can use this attribute to specify a class other than `com.mongodb.WriteConcern` to find the constant on (to create your own custom instructions).
factoryClassName | Class | To provide a connection to the MongoDB database, you can use this attribute and `factoryMethodName` to specify a class and static method to get the connection from. The method must return a `com.mongodb.DB` or a `com.mongodb.MongoClient`. If the `DB` is not authenticated, you must also specify a `username` and `password`. If you use the factory method for providing a connection, you must not specify the `databaseName`, `server`, or `port` attributes.
factoryMethodName | Method | See the documentation for attribute `factoryClassName`.
databaseName | String | If you do not specify a `factoryClassName` and `factoryMethodName` for providing a MongoDB connection, you must specify a MongoDB database name using this attribute. You must also specify a `username` and `password`. You can optionally also specify a `server` (defaults to localhost), and a `port` (defaults to the default MongoDB port).
server | String | See the documentation for attribute `databaseName`.
port | int | See the documentation for attribute `databaseName`.
username | String | See the documentation for attributes `databaseName` and `factoryClassName`.
password | String | See the documentation for attributes `databaseName` and `factoryClassName`.
CouchDB Provider Parameters
Parameter Name | Type | Description
--- | --- | ---
factoryClassName | Class | To provide a connection to the CouchDB database, you can use this attribute and `factoryMethodName` to specify a class and static method to get the connection from. The method must return a `org.lightcouch.CouchDbClient` or a `org.lightcouch.CouchDbProperties`. If you use the factory method for providing a connection, you must not specify the `databaseName`, `protocol`, `server`, `port`, `username`, or `password` attributes.
factoryMethodName | Method | See the documentation for attribute `factoryClassName`.
databaseName | String | If you do not specify a `factoryClassName` and `factoryMethodName` for providing a CouchDB connection, you must specify a CouchDB database name using this attribute. You must also specify a `username` and `password`. You can optionally also specify a `protocol` (defaults to http), `server` (defaults to localhost), and a `port` (defaults to 80 for http and 443 for https).
protocol | String | Must either be "http" or "https." See the documentation for attribute `databaseName`.
server | String | See the documentation for attribute `databaseName`.
port | int | See the documentation for attribute `databaseName`.
username | String | See the documentation for attributes `databaseName`.
password | String | See the documentation for attributes `databaseName`.
Here are a few sample configurations for the NoSQLAppender:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="error">
      <Appenders>
        <NoSql name="databaseAppender">
          <MongoDb databaseName="applicationDb" collectionName="applicationLog" server="mongo.example.org"
                   username="loggingUser" password="abc123" />
        </NoSql>
      </Appenders>
      <Loggers>
        <Root level="warn">
          <AppenderRef ref="databaseAppender"/>
        </Root>
      </Loggers>
    </Configuration>
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="error">
      <Appenders>
        <NoSql name="databaseAppender">
          <MongoDb collectionName="applicationLog" factoryClassName="org.example.db.ConnectionFactory"
                   factoryMethodName="getNewMongoClient" />
        </NoSql>
      </Appenders>
      <Loggers>
        <Root level="warn">
          <AppenderRef ref="databaseAppender"/>
        </Root>
      </Loggers>
    </Configuration>
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="error">
      <Appenders>
        <NoSql name="databaseAppender">
          <CouchDb databaseName="applicationDb" protocol="https" server="couch.example.org"
                   username="loggingUser" password="abc123" />
        </NoSql>
      </Appenders>
      <Loggers>
        <Root level="warn">
          <AppenderRef ref="databaseAppender"/>
        </Root>
      </Loggers>
    </Configuration>
The following example demonstrates how log events are persisted in NoSQL databases if represented in a JSON format:
    {
        "level": "WARN",
        "loggerName": "com.example.application.MyClass",
        "message": "Something happened that you might want to know about.",
        "source": {
            "className": "com.example.application.MyClass",
            "methodName": "exampleMethod",
            "fileName": "MyClass.java",
            "lineNumber": 81
        },
        "marker": {
            "name": "SomeMarker",
            "parent" {
                "name": "SomeParentMarker"
            }
        },
        "threadName": "Thread-1",
        "millis": 1368844166761,
        "date": "2013-05-18T02:29:26.761Z",
        "thrown": {
            "type": "java.sql.SQLException",
            "message": "Could not insert record. Connection lost.",
            "stackTrace": [
                    { "className": "org.example.sql.driver.PreparedStatement$1", "methodName": "responder", "fileName": "PreparedStatement.java", "lineNumber": 1049 },
                    { "className": "org.example.sql.driver.PreparedStatement", "methodName": "executeUpdate", "fileName": "PreparedStatement.java", "lineNumber": 738 },
                    { "className": "com.example.application.MyClass", "methodName": "exampleMethod", "fileName": "MyClass.java", "lineNumber": 81 },
                    { "className": "com.example.application.MainClass", "methodName": "main", "fileName": "MainClass.java", "lineNumber": 52 }
            ],
            "cause": {
                "type": "java.io.IOException",
                "message": "Connection lost.",
                "stackTrace": [
                    { "className": "java.nio.channels.SocketChannel", "methodName": "write", "fileName": null, "lineNumber": -1 },
                    { "className": "org.example.sql.driver.PreparedStatement$1", "methodName": "responder", "fileName": "PreparedStatement.java", "lineNumber": 1032 },
                    { "className": "org.example.sql.driver.PreparedStatement", "methodName": "executeUpdate", "fileName": "PreparedStatement.java", "lineNumber": 738 },
                    { "className": "com.example.application.MyClass", "methodName": "exampleMethod", "fileName": "MyClass.java", "lineNumber": 81 },
                    { "className": "com.example.application.MainClass", "methodName": "main", "fileName": "MainClass.java", "lineNumber": 52 }
                ]
            }
        },
        "contextMap": {
            "ID": "86c3a497-4e67-4eed-9d6a-2e5797324d7b",
            "username": "JohnDoe"
        },
        "contextStack": [
            "topItem",
            "anotherItem",
            "bottomItem"
        ]
    }
### OutputStreamAppender The OutputStreamAppender provides the base for many of the other Appenders such as the File and Socket appenders that write the event to an Output Stream. It cannot be directly configured. Support for immediateFlush and buffering is provided by the OutputStreamAppender. The OutputStreamAppender uses an OutputStreamManager to handle the actual I/O, allowing the stream to be shared by Appenders in multiple configurations. ### RandomAccessFileAppender As of beta-9, the name of this appender has been changed from FastFile to RandomAccessFile. Configurations using the `FastFile` element no longer work and should be modified to use the `RandomAccessFile` element. The RandomAccessFileAppender is similar to the standard FileAppender except it is always buffered (this cannot be switched off) and internally it uses a `ByteBuffer + RandomAccessFile` instead of a `BufferedOutputStream`. We saw a 20-200% performance improvement compared to FileAppender with "bufferedIO=true" in our measurements. Similar to the FileAppender, RandomAccessFileAppender uses a RandomAccessFileManager to actually perform the file I/O. While RandomAccessFileAppender from different Configurations cannot be shared, the RandomAccessFileManagers can be if the Manager is accessible. For example, two web applications in a servlet container can have their own configuration and safely write to the same file if Log4j is in a ClassLoader that is common to both of them.
RandomAccessFileAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
append | boolean | When true - the default, records will be appended to the end of the file. When set to false, the file will be cleared before new records are written.
fileName | String | The name of the file to write to. If the file, or any of its parent directories, do not exist, they will be created.
filters | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
immediateFlush | boolean | When set to true - the default, each write will be followed by a flush. This will guarantee the data is written to disk but could impact performance. Flushing after every write is only useful when using this appender with synchronous loggers. Asynchronous loggers and appenders will automatically flush at the end of a batch of events, even if immediateFlush is set to false. This also guarantees the data is written to disk but is more efficient.
bufferSize | int | The buffer size, defaults to 262,144 bytes (256 * 1024).
layout | Layout | The Layout to use to format the LogEvent
name | String | The name of the Appender.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
Here is a sample RandomAccessFile configuration:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RandomAccessFile name="MyFile" fileName="logs/app.log">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
        </RandomAccessFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="MyFile"/>
        </Root>
      </Loggers>
    </Configuration>
### RewriteAppender The RewriteAppender allows the LogEvent to manipulated before it is processed by another Appender. This can be used to mask sensitive information such as passwords or to inject information into each event. The RewriteAppender must be configured with a RewritePolicy. The RewriteAppender should be configured after any Appenders it references to allow it to shut down properly.
RewriteAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
AppenderRef | String | The name of the Appenders to call after the LogEvent has been manipulated. Multiple AppenderRef elements can be configured.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
name | String | The name of the Appender.
rewritePolicy | RewritePolicy | The RewritePolicy that will manipulate the LogEvent.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
#### RewritePolicy RewritePolicy is an interface that allows implementations to inspect and possibly modify LogEvents before they are passed to Appender. RewritePolicy declares a single method named rewrite that must be implemented. The method is passed the LogEvent and can return the same event or create a new one. ##### MapRewritePolicy MapRewritePolicy will evaluate LogEvents that contain a MapMessage and will add or update elements of the Map.
Parameter Name | Type | Description
--- | --- | ---
mode | String | "Add" or "Update"
keyValuePair | KeyValuePair[] | An array of keys and their values.
The following configuration shows a RewriteAppender configured to add a product key and its value to the MapMessage.:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Console name="STDOUT" target="SYSTEM_OUT">
          <PatternLayout pattern="%m%n"/>
        </Console>
        <Rewrite name="rewrite">
          <AppenderRef ref="STDOUT"/>
          <MapRewritePolicy mode="Add">
            <KeyValuePair key="product" value="TestProduct"/>
          </MapRewritePolicy>
        </Rewrite>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="Rewrite"/>
        </Root>
      </Loggers>
    </Configuration>
##### PropertiesRewritePolicy PropertiesRewritePolicy will add properties configured on the policy to the ThreadContext Map being logged. The properties will not be added to the actual ThreadContext Map. The property values may contain variables that will be evaluated when the configuration is processed as well as when the event is logged.
Parameter Name | Type | Description
--- | --- | ---
properties | Property[] | One of more Property elements to define the keys and values to be added to the ThreadContext Map.
The following configuration shows a RewriteAppender configured to add a product key and its value to the MapMessage.:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Console name="STDOUT" target="SYSTEM_OUT">
          <PatternLayout pattern="%m%n"/>
        </Console>
        <Rewrite name="rewrite">
          <AppenderRef ref="STDOUT"/>
          <PropertiesRewritePolicy>
            <Property name="user">${sys:user.name}</Property>
            <Property name="env">${sys:environment}</Property>
          </PropertiesRewritePolicy>
        </Rewrite>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="Rewrite"/>
        </Root>
      </Loggers>
    </Configuration>
### RollingFileAppender The RollingFileAppender is an OutputStreamAppender that writes to the File named in the fileName parameter and rolls the file over according the TriggeringPolicy and the RolloverPolicy. The RollingFileAppender uses a RollingFileManager (which extends OutputStreamManager) to actually perform the file I/O and perform the rollover. While RolloverFileAppenders from different Configurations cannot be shared, the RollingFileManagers can be if the Manager is accessible. For example, two web applications in a servlet container can have their own configuration and safely write to the same file if Log4j is in a ClassLoader that is common to both of them. A RollingFileAppender requires a TriggeringPolicy and a RolloverStrategy. The triggering policy determines if a rollover should be performed while the RolloverStrategy defines how the rollover should be done. If no RolloverStrategy is configured, RollingFileAppender will use the DefaultRolloverStrategy. File locking is not supported by the RollingFileAppender.
RollingFileAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
append | boolean | When true - the default, records will be appended to the end of the file. When set to false, the file will be cleared before new records are written.
bufferedIO | boolean | When true - the default, records will be written to a buffer and the data will be written to disk when the buffer is full or, if immediateFlush is set, when the record is written. File locking cannot be used with bufferedIO. Performance tests have shown that using buffered I/O significantly improves performance, even if immediateFlush is enabled.
bufferSize | int | When bufferedIO is true, this is the buffer size, the default is 8192 bytes.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
fileName | String | The name of the file to write to. If the file, or any of its parent directories, do not exist, they will be created.
filePattern | String | The pattern of the file name of the archived log file. The format of the pattern should is dependent on the RolloverPolicy that is used. The DefaultRolloverPolicy will accept both a date/time pattern compatible with SimpleDateFormat and and/or a %i which represents an integer counter. The pattern also supports interpolation at runtime so any of the Lookups (such as the DateLookup can be included in the pattern.
immediateFlush | boolean | When set to true - the default, each write will be followed by a flush. This will guarantee the data is written to disk but could impact performance. Flushing after every write is only useful when using this appender with synchronous loggers. Asynchronous loggers and appenders will automatically flush at the end of a batch of events, even if immediateFlush is set to false. This also guarantees the data is written to disk but is more efficient.
layout | Layout | The Layout to use to format the LogEvent
name | String | The name of the Appender.
policy | TriggeringPolicy | The policy to use to determine if a rollover should occur.
strategy | RolloverStrategy | The strategy to use to determine the name and location of the archive file.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
#### Triggering Policies ##### Composite Triggering Policy The `CompositeTriggeringPolicy` combines multiple triggering policies and returns true if any of the configured policies return true. The `CompositeTriggeringPolicy` is configured simply by wrapping other policies in a `Policies` element. For example, the following XML fragment defines policies that rollover the log when the JVM starts, when the log size reaches twenty megabytes, and when the current date no longer matches the log’s start date.
    <Policies>
      <OnStartupTriggeringPolicy />
      <SizeBasedTriggeringPolicy size="20 MB" />
      <TimeBasedTriggeringPolicy />
    </Policies>
##### OnStartup Triggering Policy The `OnStartupTriggeringPolicy` policy takes no parameters and causes a rollover if the log file is older than the current JVM's start time. Google App Engine note: When running in Google App Engine, the OnStartup policy causes a rollover if the log file is older than the time when Log4J initialized. (Google App Engine restricts access to certain classes so Log4J cannot determine JVM start time with `java.lang.management.ManagementFactory.getRuntimeMXBean().getStartTime()` and falls back to Log4J initialization time instead.) ##### SizeBased Triggering Policy The `SizeBasedTriggeringPolicy` causes a rollover once the file has reached the specified size. The size can be specified in bytes, with the suffix KB, MB or GB, for example `20MB`. ##### TimeBased Triggering Policy The `TimeBasedTriggeringPolicy` causes a rollover once the date/time pattern no longer applies to the active file. This policy accepts an `increment` attribute which indicates how frequently the rollover should occur based on the time pattern and a `modulate` boolean attribute.
TimeBasedTriggeringPolicy Parameters
Parameter Name | Type | Description
--- | --- | ---
interval | integer | How often a rollover should occur based on the most specific time unit in the date pattern. For example, with a date pattern with hours as the most specific item and and increment of 4 rollovers would occur every 4 hours. The default value is 1.
modulate | boolean | Indicates whether the interval should be adjusted to cause the next rollover to occur on the interval boundary. For example, if the item is hours, the current hour is 3 am and the interval is 4 then then the first rollover will occur at 4 am and then next ones will occur at 8 am, noon, 4pm, etc.
#### Rollover Strategies ##### Default Rollover Strategy The default rollover strategy accepts both a date/time pattern and an integer from the filePattern attribute specified on the RollingFileAppender itself. If the date/time pattern is present it will be replaced with the current date and time values. If the pattern contains an integer it will be incremented on each rollover. If the pattern contains both a date/time and integer in the pattern the integer will be incremented until the result of the date/time pattern changes. If the file pattern ends with ".gz" or ".zip" the resulting archive will be compressed using the compression scheme that matches the suffix. The pattern may also contain lookup references that can be resolved at runtime such as is shown in the example below. The default rollover strategy supports two variations for incrementing the counter. The first is the "fixed window" strategy. To illustrate how it works, suppose that the min attribute is set to 1, the max attribute is set to 3, the file name is "foo.log", and the file name pattern is "foo-%i.log".
Number of rollovers | Active output target | Archived log files | Description
--- | --- | --- | ---
0 | foo.log | - | All logging is going to the initial file.
1 | foo.log | foo-1.log | During the first rollover foo.log is renamed to foo-1.log. A new foo.log file is created and starts being written to.
2 | foo.log | foo-1.log, foo-2.log | During the second rollover foo-1.log is renamed to foo-2.log and foo.log is renamed to foo-1.log. A new foo.log file is created and starts being written to.
3 | foo.log | foo-1.log, foo-2.log, foo-3.log | During the third rollover foo-2.log is renamed to foo-3.log, foo-1.log is renamed to foo-2.log and foo.log is renamed to foo-1.log. A new foo.log file is created and starts being written to.
4 | foo.log | foo-1.log, foo-2.log, foo-3.log | In the fourth and subsequent rollovers, foo-3.log is deleted, foo-2.log is renamed to foo-3.log, foo-1.log is renamed to foo-2.log and foo.log is renamed to foo-1.log. A new foo.log file is created and starts being written to.
By way of contrast, when the the fileIndex attribute is set to "max" but all the other settings are the same the following actions will be performed.
Number of rollovers | Active output target | Archived log files | Description
--- | --- | --- | ---
0 | foo.log | - | All logging is going to the initial file.
1 | foo.log | foo-1.log | During the first rollover foo.log is renamed to foo-1.log. A new foo.log file is created and starts being written to.
2 | foo.log | foo-1.log, foo-2.log | During the second rollover foo.log is renamed to foo-2.log. A new foo.log file is created and starts being written to.
3 | foo.log | foo-1.log, foo-2.log, foo-3.log | During the third rollover foo.log is renamed to foo-3.log. A new foo.log file is created and starts being written to.
4 | foo.log | foo-1.log, foo-2.log, foo-3.log | In the fourth and subsequent rollovers, foo-1.log is deleted, foo-2.log is renamed to foo-1.log, foo-3.log is renamed to foo-2.log and foo.log is renamed to foo-3.log. A new foo.log file is created and starts being written to.
DefaultRolloverStrategy Parameters
Parameter Name | Type | Description
--- | --- | ---
fileIndex | String | If set to "max" (the default), files with a higher index will be newer than files with a smaller index. If set to "min", file renaming and the counter will follow the Fixed Window strategy described above.
min | integer | The minimum value of the counter. The default value is 1.
max | integer | The maximum value of the counter. Once this values is reached older archives will be deleted on subsequent rollovers.
compressionLevel | integer | Sets the compression level, 0-9, where 0 = none, 1 = best speed, through 9 = best compression. Only implemented for ZIP files.
Below is a sample configuration that uses a RollingFileAppender with both the time and size based triggering policies, will create up to 7 archives on the same day (1-7) that are stored in a directory based on the current year and month, and will compress each archive using gzip:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
          <Policies>
            <TimeBasedTriggeringPolicy />
            <SizeBasedTriggeringPolicy size="250 MB"/>
          </Policies>
        </RollingFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="RollingFile"/>
        </Root>
      </Loggers>
    </Configuration>
This second example shows a rollover strategy that will keep up to 20 files before removing them.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
          <Policies>
            <TimeBasedTriggeringPolicy />
            <SizeBasedTriggeringPolicy size="250 MB"/>
          </Policies>
          <DefaultRolloverStrategy max="20"/>
        </RollingFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="RollingFile"/>
        </Root>
      </Loggers>
    </Configuration>
Below is a sample configuration that uses a RollingFileAppender with both the time and size based triggering policies, will create up to 7 archives on the same day (1-7) that are stored in a directory based on the current year and month, and will compress each archive using gzip and will roll every 6 hours when the hour is divisible by 6:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RollingFile name="RollingFile" fileName="logs/app.log"
                     filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
          <Policies>
            <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
            <SizeBasedTriggeringPolicy size="250 MB"/>
          </Policies>
        </RollingFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="RollingFile"/>
        </Root>
      </Loggers>
    </Configuration>
### RollingRandomAccessFileAppender As of beta-9, the name of this appender has been changed from FastRollingFile to RollingRandomAccessFile. Configurations using the `FastRollingFile` element no longer work and should be modified to use the `RollingRandomAccessFile` element. The RollingRandomAccessFileAppender is similar to the standard RollingFileAppender except it is always buffered (this cannot be switched off) and internally it uses a `ByteBuffer + RandomAccessFile` instead of a `BufferedOutputStream`. We saw a 20-200% performance improvement compared to RollingFileAppender with "bufferedIO=true" in our measurements. The RollingRandomAccessFileAppender writes to the File named in the fileName parameter and rolls the file over according the TriggeringPolicy and the RolloverPolicy. Similar to the RollingFileAppender, RollingRandomAccessFileAppender uses a RollingRandomAccessFileManager to actually perform the file I/O and perform the rollover. While RollingRandomAccessFileAppender from different Configurations cannot be shared, the RollingRandomAccessFileManagers can be if the Manager is accessible. For example, two web applications in a servlet container can have their own configuration and safely write to the same file if Log4j is in a ClassLoader that is common to both of them. A RollingRandomAccessFileAppender requires a TriggeringPolicy and a RolloverStrategy. The triggering policy determines if a rollover should be performed while the RolloverStrategy defines how the rollover should be done. If no RolloverStrategy is configured, RollingRandomAccessFileAppender will use the DefaultRolloverStrategy. File locking is not supported by the RollingRandomAccessFileAppender.
RollingRandomAccessFileAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
append | boolean | When true - the default, records will be appended to the end of the file. When set to false, the file will be cleared before new records are written.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
fileName | String | The name of the file to write to. If the file, or any of its parent directories, do not exist, they will be created.
filePattern | String | The pattern of the file name of the archived log file. The format of the pattern should is dependent on the RolloverPolicy that is used. The DefaultRolloverPolicy will accept both a date/time pattern compatible with SimpleDateFormat and/or a %i which represents an integer counter. The pattern also supports interpolation at runtime so any of the Lookups (such as the DateLookup can be included in the pattern.
immediateFlush | boolean | When set to true - the default, each write will be followed by a flush. This will guarantee the data is written to disk but could impact performance. Flushing after every write is only useful when using this appender with synchronous loggers. Asynchronous loggers and appenders will automatically flush at the end of a batch of events, even if immediateFlush is set to false. This also guarantees the data is written to disk but is more efficient.
bufferSize | int | The buffer size, defaults to 262,144 bytes (256 * 1024).
layout | Layout | The Layout to use to format the LogEvent
name | String | The name of the Appender.
policy | TriggeringPolicy | The policy to use to determine if a rollover should occur.
strategy | RolloverStrategy | The strategy to use to determine the name and location of the archive file.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
#### Triggering Policies See RollingFileAppender Triggering Policies. #### Rollover Strategies See RollingFileAppender Rollover Strategies. Below is a sample configuration that uses a RollingRandomAccessFileAppender with both the time and size based triggering policies, will create up to 7 archives on the same day (1-7) that are stored in a directory based on the current year and month, and will compress each archive using gzip:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RollingRandomAccessFile name="RollingRandomAccessFile" fileName="logs/app.log"
                     filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
          <Policies>
            <TimeBasedTriggeringPolicy />
            <SizeBasedTriggeringPolicy size="250 MB"/>
          </Policies>
        </RollingRandomAccessFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="RollingRandomAccessFile"/>
        </Root>
      </Loggers>
    </Configuration>
This second example shows a rollover strategy that will keep up to 20 files before removing them.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RollingRandomAccessFile name="RollingRandomAccessFile" fileName="logs/app.log"
                     filePattern="logs/$${date:yyyy-MM}/app-%d{MM-dd-yyyy}-%i.log.gz">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
          <Policies>
            <TimeBasedTriggeringPolicy />
            <SizeBasedTriggeringPolicy size="250 MB"/>
          </Policies>
          <DefaultRolloverStrategy max="20"/>
        </RollingRandomAccessFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="RollingRandomAccessFile"/>
        </Root>
      </Loggers>
    </Configuration>
Below is a sample configuration that uses a RollingRandomAccessFileAppender with both the time and size based triggering policies, will create up to 7 archives on the same day (1-7) that are stored in a directory based on the current year and month, and will compress each archive using gzip and will roll every 6 hours when the hour is divisible by 6:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <RollingRandomAccessFile name="RollingRandomAccessFile" fileName="logs/app.log"
                     filePattern="logs/$${date:yyyy-MM}/app-%d{yyyy-MM-dd-HH}-%i.log.gz">
          <PatternLayout>
            <Pattern>%d %p %c{1.} [%t] %m%n</Pattern>
          </PatternLayout>
          <Policies>
            <TimeBasedTriggeringPolicy interval="6" modulate="true"/>
            <SizeBasedTriggeringPolicy size="250 MB"/>
          </Policies>
        </RollingRandomAccessFile>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="RollingRandomAccessFile"/>
        </Root>
      </Loggers>
    </Configuration>
### RoutingAppender The RoutingAppender evaluates LogEvents and then routes them to a subordinate Appender. The target Appender may be an appender previously configured and may be referenced by its name or the Appender can be dynamically created as needed. The RoutingAppender should be configured after any Appenders it references to allow it to shut down properly.
RoutingAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
name | String | The name of the Appender.
rewritePolicy | RewritePolicy | The RewritePolicy that will manipulate the LogEvent.
routes | Routes | Contains one or more Route declarations to identify the criteria for choosing Appenders.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
#### Routes The Routes element accepts a single, required attribute named "pattern". The pattern is evaluated against all the registered Lookups and the result is used to select a Route. Each Route may be configured with a key. If the key matches the result of evaluating the pattern then that Route will be selected. If no key is specified on a Route then that Route is the default. Only one Route can be configured as the default. Each Route must reference an Appender. If the Route contains a ref attribute then the Route will reference an Appender that was defined in the configuration. If the Route contains an Appender definition then an Appender will be created within the context of the RoutingAppender and will be reused each time a matching Appender name is referenced through a Route. Below is a sample configuration that uses a RoutingAppender to route all Audit events to a FlumeAppender and all other events will be routed to a RollingFileAppender that captures only the specific event type. Note that the AuditAppender was predefined while the RollingFileAppenders are created as needed.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Flume name="AuditLogger" compress="true">
          <Agent host="192.168.10.101" port="8800"/>
          <Agent host="192.168.10.102" port="8800"/>
          <RFC5424Layout enterpriseNumber="18060" includeMDC="true" appName="MyApp"/>
        </Flume>
        <Routing name="Routing">
          <Routes pattern="$${sd:type}">
            <Route>
              <RollingFile name="Rolling-${sd:type}" fileName="${sd:type}.log"
                           filePattern="${sd:type}.%i.log.gz">
                <PatternLayout>
                  <pattern>%d %p %c{1.} [%t] %m%n</pattern>
                </PatternLayout>
                <SizeBasedTriggeringPolicy size="500" />
              </RollingFile>
            </Route>
            <Route ref="AuditLogger" key="Audit"/>
          </Routes>
        </Routing>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="Routing"/>
        </Root>
      </Loggers>
    </Configuration>
### SMTPAppender Sends an e-mail when a specific logging event occurs, typically on errors or fatal errors. The number of logging events delivered in this e-mail depend on the value of BufferSize option. The `SMTPAppender` keeps only the last `BufferSize` logging events in its cyclic buffer. This keeps memory requirements at a reasonable level while still delivering useful application context. All events in the buffer are included in the email. The buffer will contain the most recent events of level TRACE to WARN preceding the event that triggered the email. The default behavior is to trigger sending an email whenever an ERROR or higher severity event is logged and to format it as HTML. The circumstances on when the email is sent can be controlled by setting one or more filters on the Appender. As with other Appenders, the formatting can be controlled by specifying a Layout for the Appender.
SMTPAppender Parameters
Parameter Name | Type | Description
--- | --- | ---
bcc | String | The comma-separated list of BCC email addresses.
cc | String | The comma-separated list of CC email addresses.
bufferSize | integer | The maximum number of log events to be buffered for inclusion in the message. Defaults to 512.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
from | String | The email address of the sender.
layout | Layout | The Layout to use to format the LogEvent. The default is SerializedLayout.
name | String | The name of the Appender.
replyTo | String | The comma-separated list of reply-to email addresses.
smtpDebug | boolean | When set to true enables session debugging on STDOUT. Defaults to false.
smtpHost | String | The SMTP hostname to send to. This parameter is required.
smtpPassword | String | The password required to authenticate against the SMTP server.
smtpPort | integer | The SMTP port to send to.
smtpProtocol | String | The SMTP transport protocol (such as "smtps", defaults to "smtp").
smtpUsername | String | The username required to authenticate against the SMTP server.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
to | String | The comma-separated list of recipient email addresses.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <SMTP name="Mail" subject="Error Log" to="errors@logging.apache.org" from="test@logging.apache.org"
              smtpHost="localhost" smtpPort="25" bufferSize="50">
        </SMTP>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="Mail"/>
        </Root>
      </Loggers>
    </Configuration>
### SocketAppender The `SocketAppender` is an OutputStreamAppender that writes its output to a remote destination specified by a host and port. The data can be sent over either TCP or UDP and can be sent in any format. The default format is to send a Serialized LogEvent. Log4j 2 contains a SocketServer which is capable of receiving serialized LogEvents and routing them through the logging system on the server. You can optionally secure communication with SSL.
`SocketAppender` Parameters
Parameter Name | Type | Description
--- | --- | ---
name | String | The name of the Appender.
host | String | The name or address of the system that is listening for log events. This parameter is required.
port | integer | The port on the host that is listening for log events. This parameter must be specified.
protocol | String | "TCP" (default), "SSL" or "UDP".
SSL | SslConfiguration | Contains the configuration for the KeyStore and TrustStore.
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
immediateFail | boolean | When set to true, log events will not wait to try to reconnect and will fail immediately if the socket is not available.
immediateFlush | boolean | When set to true - the default, each write will be followed by a flush. This will guarantee the data is written to disk but could impact performance.
layout | Layout | The Layout to use to format the LogEvent. The default is SerializedLayout.
reconnectionDelayMillis | integer | If set to a value greater than 0, after an error the SocketManager will attempt to reconnect to the server after waiting the specified number of milliseconds. If the reconnect fails then an exception will be thrown (which can be caught by the application if `ignoreExceptions` is set to `false`).
connectTimeoutMillis | integer | The connect timeout in milliseconds. The default is 0 (infinite timeout, like Socket.connect() methods).
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
This is an unsecured TCP configuration:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Socket name="socket" host="localhost" port="9500">
          <SerializedLayout />
        </Socket>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="socket"/>
        </Root>
      </Loggers>
    </Configuration>
This is a secured SSL configuration:
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Socket name="socket" host="localhost" port="9500">
          <SerializedLayout />
          <SSL>
            <KeyStore location="log4j2-keystore.jks" password="changeme"/>
            <TrustStore location="truststore.jks" password="changeme"/>
          </SSL>
        </Socket>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="socket"/>
        </Root>
      </Loggers>
    </Configuration>
### SyslogAppender The `SyslogAppender` is a `SocketAppender` that writes its output to a remote destination specified by a host and port in a format that conforms with either the BSD Syslog format or the RFC 5424 format. The data can be sent over either TCP or UDP.
`SyslogAppender` Parameters
Parameter Name | Type | Description
--- | --- | ---
advertise | boolean | Indicates whether the appender should be advertised.
appName | String | The value to use as the APP-NAME in the RFC 5424 syslog record.
charset | String | The character set to use when converting the syslog String to a byte array. The String must be a valid Charset. If not specified, the default system Charset will be used.
connectTimeoutMillis | integer | The connect timeout in milliseconds. The default is 0 (infinite timeout, like Socket.connect() methods).
enterpriseNumber | integer | The IANA enterprise number as described in RFC 5424
filter | Filter | A Filter to determine if the event should be handled by this Appender. More than one Filter may be used by using a CompositeFilter.
facility | String | The facility is used to try to classify the message. The facility option must be set to one of "KERN", "USER", "MAIL", "DAEMON", "AUTH", "SYSLOG", "LPR", "NEWS", "UUCP", "CRON", "AUTHPRIV", "FTP", "NTP", "AUDIT", "ALERT", "CLOCK", "LOCAL0", "LOCAL1", "LOCAL2", "LOCAL3", "LOCAL4", "LOCAL5", "LOCAL6", or "LOCAL7". These values may be specified as upper or lower case characters.
format | String | If set to "RFC5424" the data will be formatted in accordance with RFC 5424. Otherwise, it will be formatted as a BSD Syslog record. Note that although BSD Syslog records are required to be 1024 bytes or shorter the SyslogLayout does not truncate them. The RFC5424Layout also does not truncate records since the receiver must accept records of up to 2048 bytes and may accept records that are longer.
host | String | The name or address of the system that is listening for log events. This parameter is required.
id | String | The default structured data id to use when formatting according to RFC 5424. If the LogEvent contains a StructuredDataMessage the id from the Message will be used instead of this value.
ignoreExceptions | boolean | The default is `true`, causing exceptions encountered while appending events to be internally logged and then ignored. When set to `false` exceptions will be propagated to the caller, instead. You must set this to `false` when wrapping this Appender in a FailoverAppender.
immediateFail | boolean | When set to true, log events will not wait to try to reconnect and will fail immediately if the socket is not available.
immediateFlush | boolean | When set to true - the default, each write will be followed by a flush. This will guarantee the data is written to disk but could impact performance.
includeMDC | boolean | Indicates whether data from the ThreadContextMap will be included in the RFC 5424 Syslog record. Defaults to true.
loggerFields | List of KeyValuePairs | Allows arbitrary PatternLayout patterns to be included as specified ThreadContext fields; no default specified. To use, include a >LoggerFields< nested element, containing one or more >KeyValuePair< elements. Each >KeyValuePair< must have a key attribute, which specifies the key name which will be used to identify the field within the MDC Structured Data element, and a value attribute, which specifies the PatternLayout pattern to use as the value.
mdcExcludes | String | A comma separated list of mdc keys that should be excluded from the LogEvent. This is mutually exclusive with the mdcIncludes attribute. This attribute only applies to RFC 5424 syslog records.
mdcIncludes | String | A comma separated list of mdc keys that should be included in the FlumeEvent. Any keys in the MDC not found in the list will be excluded. This option is mutually exclusive with the mdcExcludes attribute. This attribute only applies to RFC 5424 syslog records.
mdcRequired | String | A comma separated list of mdc keys that must be present in the MDC. If a key is not present a LoggingException will be thrown. This attribute only applies to RFC 5424 syslog records.
mdcPrefix | String | A string that should be prepended to each MDC key in order to distinguish it from event attributes. The default string is "mdc:". This attribute only applies to RFC 5424 syslog records.
messageId | String | The default value to be used in the MSGID field of RFC 5424 syslog records.
name | String | The name of the Appender.
newLine | boolean | If true, a newline will be appended to the end of the syslog record. The default is false.
port | integer | The port on the host that is listening for log events. This parameter must be specified.
protocol | String | "TCP" or "UDP". This parameter is required.
SSL | SslConfiguration | Contains the configuration for the KeyStore and TrustStore.
reconnectionDelayMillis | integer | If set to a value greater than 0, after an error the SocketManager will attempt to reconnect to the server after waiting the specified number of milliseconds. If the reconnect fails then an exception will be thrown (which can be caught by the application if `ignoreExceptions` is set to `false`).
A sample syslogAppender configuration that is configured with two `SyslogAppender`s, one using the BSD format and one using RFC 5424.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <Syslog name="bsd" host="localhost" port="514" protocol="TCP"/>
        <Syslog name="RFC5424" format="RFC5424" host="localhost" port="8514"
                protocol="TCP" appName="MyApp" includeMDC="true"
                facility="LOCAL0" enterpriseNumber="18060" newLine="true"
                messageId="Audit" id="App"/>
      </Appenders>
      <Loggers>
        <Logger name="com.mycorp" level="error">
          <AppenderRef ref="RFC5424"/>
        </Logger>
        <Root level="error">
          <AppenderRef ref="bsd"/>
        </Root>
      </Loggers>
    </Configuration>
For SSL this appender writes its output to a remote destination specified by a host and port over SSL in a format that conforms with either the BSD Syslog format or the RFC 5424 format.
    <?xml version="1.0" encoding="UTF-8"?>
    <Configuration status="warn" name="MyApp" packages="">
      <Appenders>
        <TLSSyslog name="bsd" host="localhost" port="6514">
          <SSL>
            <KeyStore location="log4j2-keystore.jks" password="changeme"/>
            <TrustStore location="truststore.jks" password="changeme"/>
          </SSL>
        </TLSSyslog>
      </Appenders>
      <Loggers>
        <Root level="error">
          <AppenderRef ref="bsd"/>
        </Root>
      </Loggers>
    </Configuration>