# logstash-logback-encoder
**Repository Path**: pilgrimS/logstash-logback-encoder
## Basic Information
- **Project Name**: logstash-logback-encoder
- **Description**: No description available
- **Primary Language**: Unknown
- **License**: Apache-2.0
- **Default Branch**: master
- **Homepage**: None
- **GVP Project**: No
## Statistics
- **Stars**: 0
- **Forks**: 0
- **Created**: 2020-12-04
- **Last Updated**: 2024-05-29
## Categories & Tags
**Categories**: Uncategorized
**Tags**: None
## README
> !! This document applies to the next version under development.
>
> See [here for documentation on the latest released version](https://github.com/logstash/logstash-logback-encoder/tree/logstash-logback-encoder-6.5).
# Logstash Logback Encoder
[](https://github.com/logstash/logstash-logback-encoder/actions)
[](http://www.javadoc.io/doc/net.logstash.logback/logstash-logback-encoder)
[](https://search.maven.org/artifact/net.logstash.logback/logstash-logback-encoder)
[](https://github.com/logstash/logstash-logback-encoder/releases/latest)
Provides [logback](http://logback.qos.ch/) encoders, layouts, and appenders to log in JSON and [other formats supported by Jackson](#data-format).
Supports both regular _LoggingEvents_ (logged through a `Logger`) and _AccessEvents_ (logged via [logback-access](http://logback.qos.ch/access.html)).
Originally written to support output in [logstash](http://logstash.net/)'s JSON format, but has evolved into a highly-configurable, general-purpose, structured logging mechanism for JSON and other Jackson dataformats.
The structure of the output, and the data it contains, is fully configurable.
#### Contents:
* [Including it in your project](#including-it-in-your-project)
* [Java Version Requirements](#java-version-requirements)
* [Usage](#usage)
* [UDP Appender](#udp-appender)
* [TCP Appenders](#tcp-appenders)
* [Keep-alive](#keep-alive)
* [Multiple Destinations](#multiple-destinations)
* [Reconnection Delay](#reconnection-delay)
* [Write buffer size](#write-buffer-size)
* [Write timeouts](#write-timeouts)
* [SSL](#ssl)
* [Async Appenders](#async-appenders)
* [Appender Listeners](#appender-listeners)
* [Encoders / Layouts](#encoders--layouts)
* [LoggingEvent Fields](#loggingevent-fields)
* [Standard Fields](#standard-fields)
* [MDC fields](#mdc-fields)
* [Context fields](#context-fields)
* [Caller Info Fields](#caller-info-fields)
* [Custom Fields](#custom-fields)
* [Global Custom Fields](#global-custom-fields)
* [Event-specific Custom Fields](#event-specific-custom-fields)
* [AccessEvent Fields](#accessevent-fields)
* [Standard Fields](#standard-fields-1)
* [Header Fields](#header-fields)
* [Customizing Jackson](#customizing-jackson)
* [Data Format](#data-format)
* [Customizing JSON Factory and Generator](#customizing-json-factory-and-generator)
* [Registering Jackson Modules](#registering-jackson-modules)
* [Customizing Character Escapes](#customizing-character-escapes)
* [Masking](#masking)
* [Customizing Standard Field Names](#customizing-standard-field-names)
* [Customizing Version](#customizing-version)
* [Customizing Timestamp](#customizing-timestamp)
* [Customizing Message](#customizing-message)
* [Customizing Logger Name Length](#customizing-logger-name-length)
* [Customizing Stack Traces](#customizing-stack-traces)
* [Prefix/Suffix/Separator](#prefixsuffixseparator)
* [Composite Encoder/Layout](#composite-encoderlayout)
* [Providers for LoggingEvents](#providers-for-loggingevents)
* [Providers for AccessEvents](#providers-for-accessevents)
* [Nested JSON Provider](#nested-json-provider)
* [Pattern JSON Provider](#pattern-json-provider)
* [LoggingEvent patterns](#loggingevent-patterns)
* [AccessEvent patterns](#accessevent-patterns)
* [Custom JSON Provider](#custom-json-provider)
* [Status Listeners](#status-listeners)
## Including it in your project
Maven style:
```xml
net.logstash.logback
logstash-logback-encoder
6.5
ch.qos.logback
logback-classic
1.2.3
```
If you get `ClassNotFoundException`/`NoClassDefFoundError`/`NoSuchMethodError` at runtime, then ensure the required dependencies (and appropriate versions) as specified in the pom file from the maven repository exist on the runtime classpath. Specifically, the following need to be available on the runtime classpath:
* jackson-databind / jackson-core / jackson-annotations
* logback-core
* logback-classic (required for logging _LoggingEvents_)
* logback-access (required for logging _AccessEvents_)
* slf4j-api
Older versions than the ones specified in the pom file _might_ work, but the versions in the pom file are what testing has been performed against.
If you are using logstash-logback-encoder in a project (such as spring-boot) that also declares dependencies on any of the above libraries, you might need to tell maven explicitly which versions to use to avoid conflicts.
You can do so using maven's [dependencyManagement](https://maven.apache.org/guides/introduction/introduction-to-dependency-mechanism.html#Dependency_Management) feature.
For example, to ensure that maven doesn't pick different versions of logback-core, logback-classic, and logback-access, add this to your project's pom.xml
```xml
1.2.3
ch.qos.logback
logback-core
${ch.qos.logback.version}
ch.qos.logback
logback-classic
${ch.qos.logback.version}
ch.qos.logback
logback-access
${ch.qos.logback.version}
```
## Java Version Requirements
| logstash-logback-encoder | Minimum Java Version supported |
| ------------------------ | -------------------------------|
| >= 6.0 | 1.8 |
| 5.x | 1.7 |
| <= 4.x | 1.6 |
## Usage
To log using JSON format, you must configure logback to use either:
* an appender provided by the logstash-logback-encoder library, OR
* an appender provided by logback (or another library) with an encoder or layout provided by the logstash-logback-encoder library
The appenders, encoders, and layouts provided by the logstash-logback-encoder library are as follows:
| Format | Protocol | Function | LoggingEvent | AccessEvent
|---------------|------------|----------| ------------ | -----------
| Logstash JSON | Syslog/UDP | Appender | [`LogstashUdpSocketAppender`](/src/main/java/net/logstash/logback/appender/LogstashUdpSocketAppender.java) | [`LogstashAccessUdpSocketAppender`](/src/main/java/net/logstash/logback/appender/LogstashAccessUdpSocketAppender.java)
| Logstash JSON | TCP | Appender | [`LogstashTcpSocketAppender`](/src/main/java/net/logstash/logback/appender/LogstashTcpSocketAppender.java) | [`LogstashAccessTcpSocketAppender`](/src/main/java/net/logstash/logback/appender/LogstashAccessTcpSocketAppender.java)
| any | any | Appender | [`LoggingEventAsyncDisruptorAppender`](/src/main/java/net/logstash/logback/appender/LoggingEventAsyncDisruptorAppender.java) | [`AccessEventAsyncDisruptorAppender`](/src/main/java/net/logstash/logback/appender/AccessEventAsyncDisruptorAppender.java)
| Logstash JSON | any | Encoder | [`LogstashEncoder`](/src/main/java/net/logstash/logback/encoder/LogstashEncoder.java) | [`LogstashAccessEncoder`](/src/main/java/net/logstash/logback/encoder/LogstashAccessEncoder.java)
| Logstash JSON | any | Layout | [`LogstashLayout`](/src/main/java/net/logstash/logback/layout/LogstashLayout.java) | [`LogstashAccessLayout`](/src/main/java/net/logstash/logback/layout/LogstashAccessLayout.java)
| General JSON | any | Encoder | [`LoggingEventCompositeJsonEncoder`](/src/main/java/net/logstash/logback/encoder/LoggingEventCompositeJsonEncoder.java) | [`AccessEventCompositeJsonEncoder`](/src/main/java/net/logstash/logback/encoder/AccessEventCompositeJsonEncoder.java)
| General JSON | any | Layout | [`LoggingEventCompositeJsonLayout`](/src/main/java/net/logstash/logback/layout/LoggingEventCompositeJsonLayout.java) | [`AccessEventCompositeJsonLayout`](/src/main/java/net/logstash/logback/encoder/AccessEventCompositeJsonLayout.java)
These encoders/layouts can generally be used by any logback appender (such as `RollingFileAppender`).
The general _composite_ JSON encoders/layouts can be used to
output any JSON format/data by configuring them with various JSON _providers_.
The Logstash encoders/layouts are really just extensions of the general
composite JSON encoders/layouts with a pre-defined set of providers.
The logstash encoders/layouts are easier to configure if you want to use the standard logstash version 1 output format.
Use the [composite encoders/layouts](#composite-encoderlayout) if you want to heavily customize the output,
or if you need to use logstash version 0 output.
The `*AsyncDisruptorAppender` appenders are similar to logback's `AsyncAppender`,
except that a [LMAX Disruptor RingBuffer](https://lmax-exchange.github.io/disruptor/)
is used as the queuing mechanism, as opposed to a `BlockingQueue`.
These async appenders can delegate to any other underlying logback appender.
### UDP Appender
To output JSON for LoggingEvents to a syslog/UDP channel,
use the `LogstashUdpSocketAppender` with a `LogstashLayout` or `LoggingEventCompositeJsonLayout`
in your `logback.xml`, like this:
```xml
MyAwesomeSyslogServer
514
```
You can further customize the JSON output by customizing the layout as described in later sections.
For example, to configure [global custom fields](#global-custom-fields), you can specify
```xml
MyAwesomeSyslogServer
514
{"appname":"myWebservice"}
```
To output JSON for AccessEvents over UDP, use a `LogstashAccessUdpSocketAppender`
with a `LogstashAccessLayout` or `AccessEventCompositeJsonLayout`
in your `logback-access.xml`, like this:
```xml
MyAwesomeSyslogServer
514
{"appname":"myWebservice"}
```
To receive syslog/UDP input in logstash, configure a [`syslog`](http://www.logstash.net/docs/latest/inputs/syslog) or [`udp`](http://www.logstash.net/docs/latest/inputs/udp) input with the [`json`](http://www.logstash.net/docs/latest/codecs/json) codec in logstash's configuration like this:
```
input {
syslog {
codec => "json"
}
}
```
### TCP Appenders
To output JSON for LoggingEvents over TCP, use a `LogstashTcpSocketAppender`
with a `LogstashEncoder` or `LoggingEventCompositeJsonEncoder`
in your `logback.xml`, like this:
```xml
127.0.0.1:4560
```
To output JSON for AccessEvents over TCP, use a `LogstashAccessTcpSocketAppender`
with a `LogstashAccessEncoder` or `AccessEventCompositeJsonEncoder`
in your `logback-access.xml`, like this:
```xml
127.0.0.1:4560
```
The TCP appenders use an encoder, rather than a layout as the [UDP appenders](#udp) .
You can use a `Logstash*Encoder`, `*EventCompositeJsonEncoder`, or any other logback encoder.
All of the output formatting options are configured at the encoder level.
Internally, the TCP appenders are asynchronous (using the [LMAX Disruptor RingBuffer](https://lmax-exchange.github.io/disruptor/)).
All the encoding and TCP communication is delegated to a single writer thread.
There is no need to wrap the TCP appenders with another asynchronous appender
(such as `AsyncAppender` or `LoggingEventAsyncDisruptorAppender`).
All the configuration parameters (except for sub-appender) of the [async appenders](#async)
are valid for TCP appenders. For example, `waitStrategyType` and `ringBufferSize`.
The TCP appenders will never block the logging thread.
If the RingBuffer is full (e.g. due to slow network, etc), then events will be dropped.
The TCP appenders will automatically reconnect if the connection breaks.
However, events may be lost before Java's socket realizes the connection has broken.
To receive TCP input in logstash, configure a [`tcp`](http://www.logstash.net/docs/latest/inputs/tcp)
input with the [`json_lines`](http://www.logstash.net/docs/latest/codecs/json_lines) codec in logstash's configuration like this:
```
input {
tcp {
port => 4560
codec => json_lines
}
}
```
In order to guarantee that logged messages have had a chance to be processed by the TCP appender, you'll need to [cleanly shut down logback](http://logback.qos.ch/manual/configuration.html#stopContext) when your application exits.
#### Keep-alive
If events occur infrequently, and the connection breaks consistently due to a server-side idle timeout,
then you can enable keep alive functionality by configuring a `keepAliveDuration` like this:
```xml
...
5 minutes
```
When the `keepAliveDuration` is set, then a keep alive message will be sent
if an event has not occurred for the length of the duration.
The keep alive message defaults to the system's line separator,
but can be changed by setting the `keepAliveMessage` property.
#### Multiple Destinations
The TCP appenders can be configured to try to connect to one of several destinations like this:
```xml
destination1.domain.com:4560
destination2.domain.com:4560
destination3.domain.com:4560
...
```
or this:
```xml
destination1.domain.com:4560,
destination2.domain.com:4560,
destination3.domain.com:4560
...
```
The appender uses a `connectionStrategy` to determine:
* the order in which destination connections are attempted, and
* when an established connection should be reestablished (to the next destination selected by the connection strategy).
Logs are only sent to one destination at a time (i.e. not all destinations).
By default, the appender will stay connected to the connected destination
until it breaks, or until the application is shut down.
Some connection strategies can force a reconnect (see below).
If a connection breaks, then the appender will attempt to connect
to the next destination selected by the connection strategy.
The available connection strategies are as follows:
Strategy |
Description |
preferPrimary |
(default)
The first destination is considered the primary destination.
Each additional destination is considered a secondary destination.
This strategy prefers the primary destination, unless it is down.
The appender will attempt to connect to each destination in the order in which they are configured.
If a connection attempt fails, thes the appender will attempt to connect to the next destination.
If a connection succeeds, and then closes before the minConnectionTimeBeforePrimary
has elapsed, then the appender will attempt to connect to the next destination.
If a connection succeeds, and then closes after the minConnectionTimeBeforePrimary
has elapsed, then the appender will attempt to connect
to the destinations in the order in which they are configured,
starting at the first/primary destination.
The secondaryConnectionTTL can be set to gracefully close connections to secondary
destinations after a specific duration. This will force the
the appender to reattempt to connect to the destinations in order again.
The secondaryConnectionTTL value does not affect connections to the
primary destination.
The minConnectionTimeBeforePrimary (10 seconds by default) specifies
the minimum amount of time that a sucessfully established connection
must remain open before the next connection attempt will try the primary.
i.e. If a connection stays open less than this amount of time,
then the next connection attempt will attempt the next destination (instead of the primary).
This is used to prevent a connection storm to the primary in the case the
primary accepts a connection, and then immediately closes it.
Example:
<appender name="stash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
<destination>destination1.domain.com:4560</destination>
<destination>destination2.domain.com:4560</destination>
<destination>destination3.domain.com:4560</destination>
<connectionStrategy>
<preferPrimary>
<secondaryConnectionTTL>5 minutes</secondaryConnectionTTL>
</preferPrimary>
</connectionStrategy>
</appender>
|
roundRobin |
This strategy attempts connections to the destination in round robin order.
If a connection fails, the next destination is attempted.
The connectionTTL can be set to gracefully close connections after a specific duration.
This will force the the appender to reattempt to connect to the next destination.
Example:
<appender name="stash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
<destination>destination1.domain.com:4560</destination>
<destination>destination2.domain.com:4560</destination>
<destination>destination3.domain.com:4560</destination>
<connectionStrategy>
<roundRobin>
<connectionTTL>5 minutes</connectionTTL>
</roundRobin>
</connectionStrategy>
</appender>
|
random |
This strategy attempts connections to the destination in a random order.
If a connection fails, the next random destination is attempted.
The connectionTTL can be set to gracefully close connections after a specific duration.
This will force the the appender to reattempt to connect to the next random destination.
Example:
<appender name="stash" class="net.logstash.logback.appender.LogstashTcpSocketAppender">
<destination>destination1.domain.com:4560</destination>
<destination>destination2.domain.com:4560</destination>
<destination>destination3.domain.com:4560</destination>
<connectionStrategy>
<random>
<connectionTTL>5 minutes</connectionTTL>
</random>
</connectionStrategy>
</appender>
|
You can also use your own custom connection strategy by implementing the `DestinationConnectionStrategy` interface,
and configuring the appender to use it like this:
```xml
destination1.domain.com:4560
destination2.domain.com:4560
destination3.domain.com:4560
```
#### Reconnection Delay
By default, the TCP appender will wait 30 seconds between connection attempts to a single destination.
The time between connection attempts to each destination is tracked separately.
This amount of time to delay can be changed by setting the `reconnectionDelay` field.
```xml
...
1 second
```
#### Write buffer size
By default, a buffer size of 8192 is used to buffer socket output stream writes.
You can adjust this by setting the appender's `writeBufferSize`.
```xml
...
16384
```
Buffering can be disabled by setting the `writeBufferSize` to `0`.
Consider disabling the write buffer if you are concerned about losing data from the buffer for flaky connections.
Disabling the buffer can potentially slow down the writer thread due to increased system calls,
but in some environments, this does not seem to affect overall performance.
See [this discussion](https://github.com/logstash/logstash-logback-encoder/issues/342).
#### Write timeouts
If a destination stops reading from its socket input, but does not close the connection,
then writes from the TCP appender will eventually backup,
causing the ring buffer to backup, causing events to be dropped.
To detect this situation, you can enable a write timeout, so that "stuck" writes will
eventually timeout, at which point the connection will be re-established.
When the [write buffer](#write-buffer-size) is enabled, any buffered data will be lost
when the connection is reestablished.
By default there is no write timeout. To enable a write timeout, do the following:
```xml
...
1 minute
```
Note that since the blocking java socket output stream used to send events does not have a concept of a write timeout,
write timeouts are detected using a task scheduled periodically with the same frequency as the write timeout.
For example, if the write timeout is set to 30 seconds, then a task will execute every 30 seconds
to see if 30 seconds has elapsed since the start of the current write operation.
Therefore, it is recommended to use longer write timeouts (e.g. > 30s, or minutes),
rather than short write timeouts, so that this task does not execute too frequently.
Also, this approach means that it could take up to two times the write timeout
before a write timeout is detected.
#### SSL
To use SSL, add an `` sub-element within the `` element for the `LogstashTcpSocketAppender`
or `LogstashAccessTcpSocketAppender`.
See the [logback manual](http://logback.qos.ch/manual/usingSSL.html) for how to configure SSL.
SSL for the `Logstash*TcpSocketAppender`s are configured the same way as logback's `SSLSocketAppender`.
For example, to enable SSL using the JVM's default keystore/truststore, do the following:
```xml
...
```
To use a different truststore, do the following:
```xml
...
classpath:server.truststore
${server.truststore.password}
```
All the customizations that [logback](http://logback.qos.ch/manual/usingSSL.html) offers
(such as configuring cipher specs, protocols, algorithms, providers, etc.)
are supported by the `Logback*TcpSocketAppender`s.
See the logstash documentation for the [`tcp`](http://www.logstash.net/docs/latest/inputs/tcp) input
for how to configure it to use SSL.
### Async Appenders
The `*AsyncDisruptorAppender` appenders are similar to logback's `AsyncAppender`,
except that a [LMAX Disruptor RingBuffer](https://lmax-exchange.github.io/disruptor/)
is used as the queuing mechanism, as opposed to a `BlockingQueue`.
These async appenders can delegate to any other underlying logback appender.
For example:
```xml
...
```
The async appenders will never block the logging thread.
If the RingBuffer is full (e.g. due to slow network, etc), then events will be dropped.
By default, the [`BlockingWaitStrategy`](https://lmax-exchange.github.io/disruptor/docs/com/lmax/disruptor/BlockingWaitStrategy.html)
is used by the worker thread spawned by this appender.
The `BlockingWaitStrategy` minimizes CPU utilization, but results in slower latency and throughput.
If you need faster latency and throughput (at the expense of higher CPU utilization), consider
a different [wait strategy](https://lmax-exchange.github.io/disruptor/docs/com/lmax/disruptor/WaitStrategy.html) offered by the disruptor.
> !! Whichever wait strategy you choose, be sure to test and monitor CPU utilization, latency, and throughput to ensure it meets your needs.
> For example, in some configurations, `SleepingWaitStrategy` can consume 90% CPU utilization at rest.
The wait strategy can be configured on the async appender using the `waitStrategyType` parameter, like this:
```xml
sleeping
...
```
The supported wait strategies are as follows:
Wait Strategy |
Parameters |
Implementation |
blocking |
none |
BlockingWaitStrategy |
busySpin |
none |
BusySpinWaitStrategy |
liteBlocking |
none |
LiteBlockingWaitStrategy |
yielding |
none |
YieldingWaitStrategy |
sleeping{
retries,
sleepTimeNs
}
e.g. sleeping or sleeping{500,1000} |
- retries - Number of times (integer) to spin before sleeping. (default = 200)
- sleepTimeNs - Time in nanoseconds to sleep each iteration after spinning (default = 100)
|
SleepingWaitStrategy |
phasedBackoff{
spinTime,
yieldTime,
timeUnit,
fallbackStrategy
}
e.g. phasedBackoff{10,60,seconds,blocking} |
- spinTime - Time to spin before yielding
- yieldTime - Time to yield before falling back to the fallbackStrategy
- timeUnit - Units of time for spin and yield timeouts. String name of a TimeUnit value (e.g. seconds)
- fallbackStrategy - String name of the wait strategy to fallback to after the timeouts have elapsed
|
PhasedBackoffWaitStrategy |
timeoutBlocking{
timeout,
timeUnit
}
e.g. timeoutBlocking{1,minutes} |
- timeout - Time to block before throwing an exception
- timeUnit - Units of time for timeout. String name of a TimeUnit value (e.g. seconds)
|
TimeoutBlockingWaitStrategy |
liteTimeoutBlocking{
timeout,
timeUnit
}
e.g. liteTimeoutBlocking{1,minutes} |
- timeout - Time to block before throwing an exception
- timeUnit - Units of time for timeout. String name of a TimeUnit value (e.g. seconds)
|
LiteTimeoutBlockingWaitStrategy |
See [AsyncDisruptorAppender](/src/main/java/net/logstash/logback/appender/AsyncDisruptorAppender.java)
for other configuration parameters (such as `ringBufferSize`, `producerType`, `threadNamePrefix`, `daemon`, and `droppedWarnFrequency`)
In order to guarantees that logged messages have had a chance to be processed by asynchronous appenders (including the TCP appender) and ensure background threads have been stopped, you'll need to [cleanly shut down logback](http://logback.qos.ch/manual/configuration.html#stopContext) when your application exits.
### Appender Listeners
Listeners can be registered to an appender to receive notifications for the appender lifecycle and event processing.
See the two listener interfaces for the types of notifications that can be received:
* [`AppenderListener`](/src/main/java/net/logstash/logback/appender/listener/AppenderListener.java) - basic notifications for the [async appenders](#async-appenders) and [udp appender](#udp-appender).
* [`TcpAppenderListener`](/src/main/java/net/logstash/logback/appender/listener/TcpAppenderListener.java) - extension of `AppenderListener` with additional TCP-specific notifications. Only works with the [TCP appenders](#tcp-appenders).
Some example use cases for a listener are:
* Monitoring metrics for events per second, event processing durations, dropped events, connections successes / failures, etc.
* Logging event processing errors to a different appender (that perhaps appends to a different destination).
A [`FailureSummaryLoggingAppenderListener`](src/main/java/net/logstash/logback/appender/listener/FailureSummaryLoggingAppenderListener.java)
is provided that will log a warning on the first success after a series of consecutive append/send/connect failures.
The message includes summary details of the failures that occurred (such as the number of failures, duration of the failures, etc).
To register it:
```xml
```
To create your own listener, create a new class that extends one of the `*ListenerImpl` classes or directly implements the `*Listener` interface.
Then register your listener class to an appender using the `listener` xml element like this:
```xml
...
propertyValue
```
Multiple listeners can be registered by supplying multiple `listener` xml elements.
### Encoders / Layouts
You can use any of the encoders/layouts provided by the logstash-logback-encoder library with other logback appenders.
For example, to output LoggingEvents to a file, use the `LogstashEncoder`
with the `RollingFileAppender` in your `logback.xml` like this:
```xml
info
/some/path/to/your/file.log
/some/path/to/your/file.log.%d{yyyy-MM-dd}
30
```
To log AccessEvents to a file, configure your `logback-access.xml` like this:
```xml
/some/path/to/your/file.log
```
The `LogstashLayout` and `LogstashAccessLayout` can be configured the same way as
the `LogstashEncoder` and `LogstashAccessEncoder`. All the other examples
in this document use encoders, but the same options apply to the layouts as well.
To receive file input in logstash, configure a [`file`](http://www.logstash.net/docs/latest/inputs/file) input in logstash's configuration like this:
```
input {
file {
path => "/some/path/to/your/file.log"
codec => "json"
}
}
```
## LoggingEvent Fields
The following sections describe the fields included in the JSON output by default for LoggingEvents written by the
* `LogstashEncoder`
* `LogstashLayout`, and
* the logstash appenders
If you are using the [composite encoders/layouts](#composite-encoderlayout), then the fields written will
vary by the providers you configure.
### Standard Fields
These fields will appear in every LoggingEvent unless otherwise noted.
The field names listed here are the default field names.
The field names can be customized (see [Customizing Standard Field Names](#customizing-standard-field-names)).
| Field | Description
|---------------|------------
| `@timestamp` | Time of the log event (`yyyy-MM-dd'T'HH:mm:ss.SSSZZ`) - see [Customizing Timestamp](#customizing-timestamp)
| `@version` | Logstash format version (e.g. `1`) - see [Customizing Version](#customizing-version)
| `message` | Formatted log message of the event - see [Customizing Message](#customizing-message)
| `logger_name` | Name of the logger that logged the event
| `thread_name` | Name of the thread that logged the event
| `level` | String name of the level of the event
| `level_value` | Integer value of the level of the event
| `stack_trace` | (Only if a throwable was logged) The stacktrace of the throwable. Stackframes are separated by line endings.
| `tags` | (Only if tags are found) The names of any markers not explicitly handled. (e.g. markers from `MarkerFactory.getMarker` will be included as tags, but the markers from [`Markers`](/src/main/java/net/logstash/logback/marker/Markers.java) will not.) This can be fully disabled by specifying `false`, in the encoder/layout/appender configuration.
### MDC fields
By default, each entry in the Mapped Diagnostic Context (MDC) (`org.slf4j.MDC`)
will appear as a field in the LoggingEvent.
This can be fully disabled by specifying `false`,
in the encoder/layout/appender configuration.
You can also configure specific entries in the MDC to be included or excluded as follows:
```xml
key1ToInclude
key2ToInclude
```
or
```xml
key1ToExclude
key2ToExclude
```
When key names are specified for inclusion, then all other fields will be excluded.
When key names are specified for exclusion, then all other fields will be included.
It is a configuration error to specify both included and excluded key names.
By default, the MDC key is used as the field name in the output.
To use an alternative field name in the output for an MDC entry,
specify`mdcKeyName=fieldName`:
```xml
key1=alternateFieldNameForKey1
```
### Context fields
By default, each property of Logback's Context (`ch.qos.logback.core.Context`)
will appear as a field in the LoggingEvent.
This can be disabled by specifying `false`
in the encoder/layout/appender configuration.
Note that logback versions prior to 1.1.10 included a `HOSTNAME` property by default in the context.
As of logback 1.1.10, the `HOSTNAME` property is lazily calculated (see [LOGBACK-1221](https://jira.qos.ch/browse/LOGBACK-1221)), and will no longer be included by default.
### Caller Info Fields
The encoder/layout/appender do not contain caller info by default.
This can be costly to calculate and should be switched off for busy production environments.
To switch it on, add the `includeCallerData` property to the configuration.
```xml
true
```
If the encoder is included inside an asynchronous appender, such as
`AsyncAppender`, `LoggingEventAsyncDisruptorAppender`, or `LogstashTcpSocketAppender`, then
`includeCallerData` must be set to true on the appender as well.
When switched on, the following fields will be included in the log event:
| Field | Description
|----------------------|------------
| `caller_class_name` | Fully qualified class name of the class that logged the event
| `caller_method_name` | Name of the method that logged the event
| `caller_file_name` | Name of the file that logged the event
| `caller_line_number` | Line number of the file where the event was logged
### Custom Fields
In addition to the fields above, you can add other fields to the LoggingEvent either globally, or on an event-by-event basis.
#### Global Custom Fields
Add custom fields that will appear in every LoggingEvent like this :
```xml
{"appname":"myWebservice","roles":["customerorder","auth"],"buildinfo":{"version":"Version 0.1.0-SNAPSHOT","lastcommit":"75473700d5befa953c45f630c6d9105413c16fe1"}}
```
or in an AccessEvent like this :
```xml
{"appname":"myWebservice","roles":["customerorder","auth"],"buildinfo":{"version":"Version 0.1.0-SNAPSHOT","lastcommit":"75473700d5befa953c45f630c6d9105413c16fe1"}}
```
#### Event-specific Custom Fields
When logging a message, you can add additional fields to the JSON output by using
* _structured arguments_ provided by
[`StructuredArguments`](/src/main/java/net/logstash/logback/argument/StructuredArguments.java), OR
* _markers_ provided by
[`Markers`](/src/main/java/net/logstash/logback/marker/Markers.java)
The difference between the two is that
* `StructuredArguments` are included in a the log event's formatted message
(when the message has a parameter for the argument) _AND_ in the JSON output.
* `StructuredArguments` will be included in the JSON output if using `LogstashEncoder/Layout`
or if using [composite encoders/layouts](#composite-encoderlayout) with the `arguments` provider.
* `Markers` are only written to the JSON output, and _NEVER_ to the log event's formatted message.
* `Markers` will be included in the JSON output if using `LogstashEncoder/Layout`
or if using [composite encoders/layouts](#composite-encoderlayout) with the `logstashMarkers` provider.
You can use `StructuredArguments` even if the message does not contain a parameter
for the argument. However, in this case, the argument will only be written to the JSON output
and not the formatted message (which is effectively the same behavior that the Markers provide).
In general, you should use `StructuredArguments`, unless you have a static analyzer
that flags parameter count / argument count mismatches.
Both `StructuredArguments` and `Markers` require constructing additional objects.
Therefore, it is best practice to surround the log lines with `logger.isXXXEnabled()`,
to avoid the object construction if the log level is disabled.
Examples using `StructuredArguments`:
```java
import static net.logstash.logback.argument.StructuredArguments.*;
/*
* Add "name":"value" to the JSON output,
* but only add the value to the formatted message.
*
* The formatted message will be `log message value`
*/
logger.info("log message {}", value("name", "value"));
/*
* Add "name":"value" to the JSON output,
* and add name=value to the formatted message.
*
* The formatted message will be `log message name=value`
*/
logger.info("log message {}", keyValue("name", "value"));
/*
* Add "name":"value" ONLY to the JSON output.
*
* Since there is no parameter for the argument,
* the formatted message will NOT contain the key/value.
*
* If this looks funny to you or to static analyzers,
* consider using Markers instead.
*/
logger.info("log message", keyValue("name", "value"));
/*
* Add multiple key value pairs to both JSON and formatted message
*/
logger.info("log message {} {}", keyValue("name1", "value1"), keyValue("name2", "value2")));
/*
* Add "name":"value" to the JSON output and
* add name=[value] to the formatted message using a custom format.
*/
logger.info("log message {}", keyValue("name", "value", "{0}=[{1}]"));
/*
* In the JSON output, values will be serialized by Jackson's ObjectMapper.
* In the formatted message, values will follow the same behavior as logback
* (formatting of an array or if not an array `toString()` is called).
*
* Add "foo":{...} to the JSON output and add `foo.toString()` to the formatted message:
*
* The formatted message will be `log message `
*/
Foo foo = new Foo();
logger.info("log message {}", value("foo", foo));
/*
* Add "name1":"value1","name2":"value2" to the JSON output by using a Map,
* and add `myMap.toString()` to the formatted message.
*
* Note the values can be any object that can be serialized by Jackson's ObjectMapper
* (e.g. other Maps, JsonNodes, numbers, arrays, etc)
*/
Map myMap = new HashMap();
myMap.put("name1", "value1");
myMap.put("name2", "value2");
logger.info("log message {}", entries(myMap));
/*
* Add "array":[1,2,3] to the JSON output,
* and array=[1,2,3] to the formatted message.
*/
logger.info("log message {}", array("array", 1, 2, 3));
/*
* Add fields of any object that can be unwrapped by Jackson's UnwrappableBeanSerializer to the JSON output.
* i.e. The fields of an object can be written directly into the JSON output.
* This is similar to the @JsonUnwrapped annotation.
*
* The formatted message will contain `myobject.toString()`
*/
logger.info("log message {}", fields(myobject));
/*
* In order to normalize a field object name, static helper methods can be created.
* For example:
* public static StructuredArgument foo(Foo foo) {
* return StructuredArguments.value("foo", foo);
* }
*/
logger.info("log message {}", foo(foo));
```
Abbreviated convenience methods are available for all the structured argument types.
For example, instead of `keyValue(key, value)`, you can use `kv(key, value)`.
Examples using `Markers`:
```java
import static net.logstash.logback.marker.Markers.*;
/*
* Add "name":"value" to the JSON output.
*/
logger.info(append("name", "value"), "log message");
/*
* Add "name1":"value1","name2":"value2" to the JSON output by using multiple markers.
*/
logger.info(append("name1", "value1").and(append("name2", "value2")), "log message");
/*
* Add "name1":"value1","name2":"value2" to the JSON output by using a map.
*
* Note the values can be any object that can be serialized by Jackson's ObjectMapper
* (e.g. other Maps, JsonNodes, numbers, arrays, etc)
*/
Map myMap = new HashMap();
myMap.put("name1", "value1");
myMap.put("name2", "value2");
logger.info(appendEntries(myMap), "log message");
/*
* Add "array":[1,2,3] to the JSON output
*/
logger.info(appendArray("array", 1, 2, 3), "log message");
/*
* Add "array":[1,2,3] to the JSON output by using raw json.
* This allows you to use your own json seralization routine to construct the json output
*/
logger.info(appendRaw("array", "[1,2,3]"), "log message");
/*
* Add any object that can be serialized by Jackson's ObjectMapper
* (e.g. Maps, JsonNodes, numbers, arrays, etc)
*/
logger.info(append("object", myobject), "log message");
/*
* Add fields of any object that can be unwrapped by Jackson's UnwrappableBeanSerializer.
* i.e. The fields of an object can be written directly into the json output.
* This is similar to the @JsonUnwrapped annotation.
*/
logger.info(appendFields(myobject), "log message");
```
See [DEPRECATED.md](DEPRECATED.md) for other deprecated ways of adding json to the output.
## AccessEvent Fields
The following sections describe the fields included in the JSON output by default for AccessEvents written by the
* `LogstashAccessEncoder`,
* `LogstashAccessLayout`, and
* the logstash access appenders.
If you are using the [composite encoders/layouts](#composite-encoderlayout), then the fields written will
vary by the providers you configure.
### Standard Fields
These fields will appear in every AccessEvent unless otherwise noted.
The field names listed here are the default field names.
The field names can be customized (see [Customizing Standard Field Names](#customizing-standard-field-names)).
| Field | Description
|---------------|------------
| `@timestamp` | Time of the log event. (`yyyy-MM-dd'T'HH:mm:ss.SSSZZ`) See [customizing timestamp](#customizing-timestamp).
| `@version` | Logstash format version (e.g. `1`) See [customizing version](#customizing-version).
| `message` | Message in the form `${remoteHost} - ${remoteUser} [${timestamp}] "${requestUrl}" ${statusCode} ${contentLength}`
| `method` | HTTP method
| `protocol` | HTTP protocol
| `status_code` | HTTP status code
| `requested_url` | Request URL
| `requested_uri` | Request URI
| `remote_host` | Remote host
| `remote_user` | Remote user
| `content_length` | Content length
| `elapsed_time` | Elapsed time in millis
### Header Fields
Request and response headers are not logged by default, but can be enabled by specifying a field name for them, like this:
```xml
request_headers
response_headers
```
See [Customizing Standard Field Names](#customizing-standard-field-names)) for more details.
To write the header names in lowercase (so that header names that only differ by case are treated the same),
set `lowerCaseFieldNames` to true, like this:
```xml
request_headers
response_headers
true
```
Headers can be filtered via configuring the `requestHeaderFilter` and/or the `responseHeaderFilter`
with a [`HeaderFilter`](/src/main/java/net/logstash/logback/composite/accessevent/HeaderFilter.java), such as the
[`IncludeExcludeHeaderFilter`](/src/main/java/net/logstash/logback/composite/accessevent/IncludeExcludeHeaderFilter.java).
The `IncludeExcludeHeaderFilter` can be configured like this:
```xml
request_headers
Content-Type
```
Custom filters implementing [`HeaderFilter`](/src/main/java/net/logstash/logback/composite/accessevent/HeaderFilter.java)
can be used by specifying the filter class like this:
```xml
```
## Customizing Jackson
Logstash-logback-encoder uses [Jackson](https://github.com/FasterXML/jackson) to encode log and access events.
Logstash-logback-encoder provides sensible defaults for Jackson, but gives you full control over the Jackson configuration.
For example, you can:
* specify the [data format](#data-format)
* customize the [`JsonFactory` and `JsonGenerator`](#customizing-json-factory-and-generator)
* register [jackson modules](#registering-jackson-modules)
* configure [character escapes](#customizing-character-escapes)
### Data Format
JSON is used by default, but other data formats supported by Jackson can be used.
* [text data formats](https://github.com/FasterXML/jackson-dataformats-text)
* [binary data formats](https://github.com/FasterXML/jackson-dataformats-binary)
> :warning: When using non-JSON data formats, you must include the appropriate jackson dataformat library on the runtime classpath,
> typically via a maven/gradle dependency (e.g. for Smile, include `jackson-dataformat-smile`).
[Decorators](#customizing-json-factory-and-generator) are provided for the following data formats:
* `cbor` - [`CborJsonFactoryDecorator`](src/main/java/net/logstash/logback/decorate/cbor/CborJsonFactoryDecorator.java)
* `smile` - [`SmileJsonFactoryDecorator`](src/main/java/net/logstash/logback/decorate/smile/SmileJsonFactoryDecorator.java)
* `yaml` - [`YamlJsonFactoryDecorator`](src/main/java/net/logstash/logback/decorate/yaml/YamlJsonFactoryDecorator.java)
To use one these formats, specify the `` like this:
```xml
```
Other data formats can be used by implementing a custom
[`net.logstash.logback.decorate.JsonFactoryDecorator`](src/main/java/net/logstash/logback/decorate/JsonFactoryDecorator.java).
The following [decorators](#customizing-json-factory-and-generator)
can be used to configure data-format-specific generator features:
* [`SmileFeatureJsonGeneratorDecorator`](src/main/java/net/logstash/logback/decorate/smile/SmileFeatureJsonGeneratorDecorator.java)
* [`CborFeatureJsonGeneratorDecorator`](src/main/java/net/logstash/logback/decorate/cbor/CborFeatureJsonGeneratorDecorator.java)
* [`YamlFeatureJsonGeneratorDecorator`](src/main/java/net/logstash/logback/decorate/yaml/YamlFeatureJsonGeneratorDecorator.java)
For example:
```xml
WRITE_HEADER
```
### Customizing JSON Factory and Generator
The `JsonFactory` and `JsonGenerator` used to write output can be customized by instances of:
* [`JsonFactoryDecorator`](/src/main/java/net/logstash/logback/decorate/JsonFactoryDecorator.java)
* [`JsonGeneratorDecorator`](/src/main/java/net/logstash/logback/decorate/JsonGeneratorDecorator.java)
For example, you could enable pretty printing by using the
[PrettyPrintingJsonGeneratorDecorator](/src/main/java/net/logstash/logback/decorate/PrettyPrintingJsonGeneratorDecorator.java)
Or customize object mapping like this:
```java
public class ISO8601DateDecorator implements JsonFactoryDecorator {
@Override
public JsonFactory decorate(JsonFactory factory) {
ObjectMapper codec = (ObjectMapper) factory.getCodec();
codec.setDateFormat(new ISO8601DateFormat());
return factory;
}
}
```
and then specify the decorators in the logback.xml file like this:
```xml
```
`JsonFactory` and `JsonGenerator` features can be enabled/disabled by using the
`FeatureJsonFactoryDecorator` and `FeatureJsonGeneratorDecorator`, respectively.
For example:
```xml
USE_THREAD_LOCAL_FOR_BUFFER_RECYCLING
WRITE_NUMBERS_AS_STRINGS
```
See the [net.logstash.logback.decorate](/src/main/java/net/logstash/logback/decorate) package
and sub-packages for other decorators.
### Registering Jackson Modules
By default, Jackson modules are dynamically registered via
[`ObjectMapper.findAndRegisterModules()`](https://fasterxml.github.io/jackson-databind/javadoc/2.9/com/fasterxml/jackson/databind/ObjectMapper.html#findAndRegisterModules--).
Therefore, you just need to add jackson modules (e.g. jackson-datatype-jdk8) to the classpath,
and they will be dynamically registered.
To disable automatic discovery, set `false` on the encoder/layout.
If you have a module that Jackson is not able to dynamically discover,
you can register it manually via a [`JsonFactoryDecorator`](#customizing-json-factory-and-generator).
### Customizing Character Escapes
By default, when a string is written as a JSON string value, any character not allowed in a JSON string will be escaped.
For example, the newline character (ASCII 10) will be escaped as `\n`.
To customize these escape sequences, use the `net.logstash.logback.decorate.CharacterEscapesJsonFactoryDecorator`.
For example, if you want to use something other than `\n` as the escape sequence for the newline character, you can do the following:
```xml
10
\u2028
```
You can also disable all the default escape sequences by specifying `false` on the `CharacterEscapesJsonFactoryDecorator`.
If you do this, then you will need to register custom escapes for each character that is illegal in JSON string values. Otherwise, invalid JSON could be written.
## Masking
The [`MaskingJsonGeneratorDecorator`](src/main/java/net/logstash/logback/mask/MaskingJsonGeneratorDecorator.java)
can be used to mask sensitive values (e.g. personally identifiable information (PII) or financial data).
Data to be masked can be identified by [path](#identifying-field-values-to-mask-by-path)
and/or by [value](#identifying-field-values-to-mask-by-value).
### Identifying field values to mask by path
Paths of fields to mask can be specified in several ways, as shown in the following example:
```xml
****
singleFieldName
/absolute/path/to/mask
partial/path/to/mask
partial/path/with/*/wildcard
tilde~0slash~1escapedPath
path1,path2,path3
some/path
some/other/path
[masked]
anotherFieldName,anotherFieldName2
**anotherCustomMask**
```
See [`PathBasedFieldMasker`](src/main/java/net/logstash/logback/mask/PathBasedFieldMasker.java)
for the path string format and more examples. But in general:
* Paths follow a format similar to (but not _exactly_ same as) a [JSON Pointer](http://tools.ietf.org/html/draft-ietf-appsawg-json-pointer-03).
* Absolute paths start with `/` and are absolute to the root of the JSON output event (e.g. `/@timestamp` would mask the default timestamp field)
* Partial paths do not start with `/` and match anywhere that path sequence is seen in the output.
* A path with a single token (i.e. no `/` characters) will match all occurrences of a field with the given name
* A wildcard token (`*`) will match anything at that location within the path
* Use `~1` to escape `/` within a token
* Use `~0` to escape `~` within a token
### Identifying field values to mask by value
Specific values to be masked can be specified in several ways, as seen in the following example:
```xml
****
^foo$
^bar$
^baz$,^blah$
^(foo)-.*$
^(bar)-.*$
$1****
```
Identifying data to mask by value is much more expensive than identifying data to mask by [path](#identifying-field-values-to-mask-by-path).
Therefore, prefer identifying data to mask by path.
## Customizing Standard Field Names
The standard field names above for LoggingEvents and AccessEvents can be customized by using the `fieldNames`configuration element in the encoder or appender configuration.
For example:
```xml
time
msg
stacktrace
...
```
Prevent a field from being output by setting the field name to `[ignore]`.
For LoggingEvents, see [`LogstashFieldNames`](/src/main/java/net/logstash/logback/fieldnames/LogstashFieldNames.java)
for all the field names that can be customized. Each java field name in that class is the name of the xml element that you would use to specify the field name (e.g. `logger`, `levelValue`). Additionally, a separate set of [shortened field names](/src/main/java/net/logstash/logback/fieldnames/ShortenedFieldNames.java) can be configured like this:
```xml
```
For LoggingEvents, log the caller info, MDC properties, and context properties
in sub-objects within the JSON event by specifying field
names for `caller`, `mdc`, and `context`, respectively.
For AccessEvents, see [`LogstashAccessFieldNames`](/src/main/java/net/logstash/logback/fieldnames/LogstashAccessFieldNames.java)
for all the field names that can be customized. Each java field name in that class is the name of the xml element that you would use to specify the field name (e.g. `fieldsMethod`, `fieldsProtocol`).
## Customizing Version
The version field value by default is the string value `1`.
The value can be changed like this:
```xml
2
```
The value can be written as a number (instead of a string) like this:
```xml
true
```
## Customizing Timestamp
By default, timestamps are written as string values in the format `yyyy-MM-dd'T'HH:mm:ss.SSSZZ` (e.g. `2018-04-28T22:23:59.164-07:00`), in the default TimeZone of the host Java platform.
You can change the timezone like this:
```xml
UTC
```
The value of the `timeZone` element can be any string accepted by java's `TimeZone.getTimeZone(String id)` method.
You can change the pattern used like this:
```xml
yyyy-MM-dd'T'HH:mm:ss.SSS
```
Use these timestamp pattern values to output the timestamp as a unix timestamp (number of milliseconds since unix epoch).
* `[UNIX_TIMESTAMP_AS_NUMBER]` - write the timestamp value as a numeric unix timestamp
* `[UNIX_TIMESTAMP_AS_STRING]` - write the timestamp value as a string verion of the numeric unix timestamp
For example:
```xml
[UNIX_TIMESTAMP_AS_NUMBER]
```
## Customizing Message
By default, messages are written as JSON strings. Any characters not allowed in a JSON string, such as newlines, are escaped.
See the [Customizing Character Escapes](#customizing-character-escapes) section for details.
You can also write messages as JSON arrays instead of strings, by specifying a `messageSplitRegex` to split the message text.
This configuration element can take the following values:
* any valid regex pattern
* `SYSTEM` (uses the system-default line separator)
* `UNIX` (uses `\n`)
* `WINDOWS` (uses `\r\n`)
If you split the log message by the origin system's line separator, the written message does not contain any embedded line separators.
The target system can unambiguously parse the message without any knowledge of the origin system's line separators.
For example:
```xml
SYSTEM
```
```xml
\r?\n
```
```xml
#+
```
## Customizing Logger Name Length
For LoggingEvents, you can shorten the logger name field length similar to the normal pattern style of `%logger{36}`.
Examples of how it is shortened can be found [here](http://logback.qos.ch/manual/layouts.html#conversionWord)
```xml
36
```
## Customizing Stack Traces
When [logging exceptions](https://www.baeldung.com/slf4j-log-exceptions),
stack traces are formatted using logback's `ExtendedThrowableProxyConverter` by default.
However, you can configure the encoder to use any `ThrowableHandlingConverter`
to format stacktraces.
Note that the `ThrowableHandlingConverter` only applies to the
[exception passed as an extra argument](https://www.baeldung.com/slf4j-log-exceptions)
to the log method, the way you normally log an exception in slf4j.
Do NOT use [structured arguments or markers](#event-specific-custom-fields) for exceptions.
A powerful [`ShortenedThrowableConverter`](/src/main/java/net/logstash/logback/stacktrace/ShortenedThrowableConverter.java)
is included in the logstash-logback-encoder library to format stacktraces by:
* Limiting the number of stackTraceElements per throwable (applies to each individual throwable. e.g. caused-bys and suppressed)
* Limiting the total length in characters of the trace
* Abbreviating class names
* Filtering out consecutive unwanted stackTraceElements based on regular expressions.
* Using evaluators to determine if the stacktrace should be logged.
* Outputing in either 'normal' order (root-cause-last), or root-cause-first.
* Computing and inlining hexadecimal hashes for each exception stack ([more info](stack-hash.md)).
For example:
```xml
30
2048
20
sun\.reflect\..*\.invoke.*
net\.sf\.cglib\.proxy\.MethodProxy\.invoke
true
true
```
[`ShortenedThrowableConverter`](/src/main/java/net/logstash/logback/stacktrace/ShortenedThrowableConverter.java)
can even be used within a `PatternLayout` to format stacktraces in any non-JSON logs you may have.
## Prefix/Suffix/Separator
You can specify a prefix (written before the JSON object),
suffix (written after the JSON object),
and/or line separator (written after suffix),
which may be required for the log pipeline you are using, such as:
* If you are using the Common Event Expression (CEE) format for syslog, you need to add the `@cee:` prefix.
* If you are using other syslog destinations, you might need to add the standard syslog headers.
* If you are using Loggly, you might need to add your customer token.
For example, to add standard syslog headers for syslog over UDP, configure the following:
```xml
MyAwesomeSyslogServer
514
%syslogStart{USER}
...
```
When using the `LogstashEncoder`, `LogstashAccessEncoder` or a composite encoder, the prefix is an `Encoder`, not a `Layout`, so you will need to wrap the prefix `PatternLayout` in a `LayoutWrappingEncoder` like this:
```xml
...
...
@cee:
```
Note that logback's xml configuration reader will [trim whitespace from xml element values](https://github.com/qos-ch/logback/blob/c2dcbfcfb4048d11d7e81cd9220efbaaccf931fa/logback-core/src/main/java/ch/qos/logback/core/joran/event/BodyEvent.java#L27-L37). Therefore, if you want to end the prefix or suffix pattern with whitespace, first add the whitespace, and then add something like `%mdc{keyThatDoesNotExist}` after it. For example `your pattern %mdc{keyThatDoesNotExist}`. This will cause logback to output the whitespace as desired, and then a blank string for the MDC key that does not exist.
> :warning: If you encounter the following warning: `A "net.logstash.logback.encoder.LogstashEncoder" object is not assignable to a "ch.qos.logback.core.Appender" variable.`, you are encountering a backwards incompatibilility introduced in logback 1.2.1. Please vote for [LOGBACK-1326](https://jira.qos.ch/browse/LOGBACK-1326) and add a thumbs up to [PR#383](https://github.com/qos-ch/logback/pull/383) to try to get this addressed in logback. In the meantime, the only solution is to downgrade logback-classic and logback-core to 1.2.0
The line separator, which is written after the suffix, can be specified as:
* `SYSTEM` (uses the system default)
* `UNIX` (uses `\n`)
* `WINDOWS` (uses `\r\n`), or
* any other string.
For example:
```xml
...
...
UNIX
```
## Composite Encoder/Layout
If you want greater flexibility in the JSON format and data included in LoggingEvents and AccessEvents, use the [`LoggingEventCompositeJsonEncoder`](/src/main/java/net/logstash/logback/encoder/LoggingEventCompositeJsonEncoder.java) and [`AccessEventCompositeJsonEncoder`](/src/main/java/net/logstash/logback/encoder/AccessEventCompositeJsonEncoder.java) (or the corresponding layouts).
These encoders/layouts are composed of one or more JSON _providers_ that contribute to the JSON output. No providers are configured by default in the composite encoders/layouts. You must add the ones you want.
For example:
```xml
{
"timestamp": "%date{ISO8601}",
"myCustomField": "fieldValue",
"relative": "#asLong{%relative}"
}
30
2048
20
^sun\.reflect\..*\.invoke
^net\.sf\.cglib\.proxy\.MethodProxy\.invoke
true
```
The logstash-logback-encoder library contains many providers out-of-the-box,
and you can even plug-in your own by extending `JsonProvider`.
Each provider has its own configuration options to further customize it.
#### Providers for LoggingEvents
For LoggingEvents, the available providers and their configuration properties (defaults in parenthesis) are as follows:
Provider |
Description/Properties |
timestamp |
Event timestamp
- fieldName - Output field name (@timestamp)
- pattern - Output format (yyyy-MM-dd'T'HH:mm:ss.SSSZZ)
- If set to [UNIX_TIMESTAMP_AS_NUMBER], then the timestamp will be written as a numeric unix timestamp value
- If set to [UNIX_TIMESTAMP_AS_STRING], then the timestamp will be written as a string unix timestamp value
- timeZone - Timezone (local timezone)
|
version |
Logstash JSON format version
- fieldName - Output field name (@version)
- version - Output value (1)
- writeAsInteger - Write the version as a integer value (false = write as a string value)
|
message |
Formatted log event message
- fieldName - Output field name (message)
- messageSplitRegex - If null or empty, write the message text as is (the default behavior).
Otherwise, split the message text using the specified regex and write it as an array.
See the Customizing Message section for details.
|
rawMessage |
Raw log event message, as opposed to formatted log where parameters are resolved
- fieldName - Output field name (raw_message)
|
loggerName |
Name of the logger that logged the message
- fieldName - Output field name (logger_name)
- shortenedLoggerNameLength - Length to which the name will be attempted to be abbreviated (no abbreviation)
|
threadName |
Name of the thread from which the event was logged
- fieldName - Output field name (thread_name)
|
logLevel |
Logger level text (INFO, WARN, etc)
- fieldName - Output field name (level)
|
logLevelValue |
Logger level numerical value
- fieldName - Output field name (level_value)
|
callerData |
Outputs data about from where the logger was called (class/method/file/line)
- fieldName - Sub-object field name (no sub-object)
- classFieldName - Field name for class name (caller_class_name)
- methodFieldName - Field name for method name (caller_method_name)
- fileFieldName - Field name for file name (caller_file_name)
- lineFieldName - Field name for line number (caller_line_number)
|
stackTrace |
Stacktrace of any throwable logged with the event. Stackframes are separated by newline chars.
- fieldName - Output field name (stack_trace)
- throwableConverter - The ThrowableHandlingConverter to use to format the stacktrace (stack_trace)
|
rootStackTraceElement |
(Only if a throwable was logged) Outputs a JSON Object containing the class and method name from which the outer-most exception was thrown.
- fieldName - Output field name (root_stack_trace_element)
- classFieldName - Field name containing the class name from which the outermost exception was thrown (class_name)
- methodFieldName - Field name containing the method name from which the outermost exception was thrown (method_name)
|
stackHash |
(Only if a throwable was logged) Computes and outputs a hexadecimal hash of the throwable stack.
This helps identifying several occurrences of the same error (more info).
- fieldName - Output field name (stack_hash)
- exclude - Regular expression pattern matching stack trace elements to exclude when computing the error hash
- exclusions - Coma separated list of regular expression patterns matching stack trace elements to exclude when computing the error hash
|
throwableClassName |
(Only if a throwable was logged) Outputs a field that contains the class name of the thrown Throwable.
- fieldName - Output field name (throwable_class)
- useSimpleClassName - When true, the throwable's simple class name will be used. When false, the fully qualified class name will be used. (true)
|
throwableRootCauseClassName |
(Only if a throwable was logged) Outputs a field that contains the class name of the root cause of the thrown Throwable.
- fieldName - Output field name (throwable_root_cause_class)
- useSimpleClassName - When true, the throwable's simple class name will be used. When false, the fully qualified class name will be used. (true)
|
context |
Outputs entries from logback's context
- fieldName - Sub-object field name (no sub-object)
|
contextName |
Outputs the name of logback's context
- fieldName - Output field name (context)
|
mdc |
Outputs entries from the Mapped Diagnostic Context (MDC).
Will include all entries by default.
When key names are specified for inclusion, then all other fields will be excluded.
When key names are specified for exclusion, then all other fields will be included.
It is a configuration error to specify both included and excluded key names.
- fieldName - Sub-object field name (no sub-object)
- includeMdcKeyName - Name of keys to include (all)
- excludeMdcKeyName - Name of keys to exclude (none)
- mdcKeyFieldName - Strings in the form mdcKeyName=fieldName
that specify an alternate field name to output for specific MDC key (none)
|
tags |
Outputs logback markers as a comma separated list
- fieldName - Output field name (tags)
|
logstashMarkers |
Used to output Logstash Markers as specified in Event-specific Custom Fields
|
nestedField |
Nests a JSON object under the configured fieldName.
The nested object is populated by other providers added to this provider.
See Nested JSON provider
- fieldName - Output field name
- providers - The providers that should populate the nested object.
|
pattern |
Outputs fields from a configured JSON Object string,
while substituting patterns supported by logback's PatternLayout.
See Pattern JSON Provider
- pattern - JSON object string (no default)
- omitEmptyFields - whether to omit fields with empty values (false)
|
arguments |
Outputs fields from the event arguments array.
See Event-specific Custom Fields
- fieldName - Sub-object field name (no sub-object)
- includeNonStructuredArguments - Include arguments that are not an instance
of StructuredArgument.
(default=false)
Object field name will be nonStructuredArgumentsFieldPrefix prepend to the argument index
- nonStructuredArgumentsFieldPrefix - Object field name prefix (default=arg)
|
uuid |
Outputs random UUID as field value. Handy when you want to provide unique identifier
for log lines
- fieldName - Output field name (uuid)
- strategy - UUID generation strategy (random). Supported options:
- random - for Type 4 UUID
- time - for Type 1 time based UUID
- ethernet - Only for 'time' strategy. When defined - MAC address to use for location part of UUID. Set it to interface value to use real underlying network interface or to specific values like 00:C0:F0:3D:5B:7C
|
sequence |
Outputs an incrementing sequence number for every log event.
Useful for tracking pottential message loss during transport (eg. UDP)
- fieldName - Output field name (sequence)
|
#### Providers for AccessEvents
For AccessEvents, the available providers and their configuration properties (defaults in parenthesis) are as follows:
Provider |
Description/Properties |
timestamp |
Event timestamp
- fieldName - Output field name (@timestamp)
- pattern - Output format (yyyy-MM-dd'T'HH:mm:ss.SSSZZ)
- If set to [UNIX_TIMESTAMP_AS_NUMBER], then the timestamp will be written as a numeric unix timestamp value
- If set to [UNIX_TIMESTAMP_AS_STRING], then the timestamp will be written as a string unix timestamp value
- timeZone - Timezone (local timezone)
|
version |
Logstash JSON format version
- fieldName - Output field name (@version)
- version - Output value (1)
- writeAsInteger - Write the version as a integer value (false = write as a string value)
|
message |
Message in the form `${remoteHost} - ${remoteUser} [${timestamp}] "${requestUrl}" ${statusCode} ${contentLength}`
- fieldName - Output field name (message)
|
method |
HTTP method
- fieldName - Output field name (method)
|
protocol |
HTTP protocol
- fieldName - Output field name (protocol)
|
statusCode |
HTTP status code
- fieldName - Output field name (status_code)
|
requestedUrl |
Requested URL
- fieldName - Output field name (requested_url)
|
requestedUri |
Requested URI
- fieldName - Output field name (requested_uri)
|
remoteHost |
Remote Host
- fieldName - Output field name (remote_host)
|
remoteUser |
Remote User
- fieldName - Output field name (remote_user)
|
contentLength |
Content length
- fieldName - Output field name (content_length)
|
elapsedTime |
Elapsed time in milliseconds
- fieldName - Output field name (elapsed_time)
|
requestHeaders |
Include the request headers
- fieldName - Output field name (no default, must be provided)
- lowerCaseHeaderNames - Write header names in lower case (false)
- filter - A filter to determine which headers to include/exclude.
See HeaderFilter
and IncludeExcludeHeaderFilter
|
responseHeaders |
Include the response headers
- fieldName - Output field name (no default, must be provided)
- lowerCaseHeaderNames - Write header names in lower case (false)
- filter - A filter to determine which headers to include/exclude.
See HeaderFilter
and IncludeExcludeHeaderFilter
|
nestedField |
Nests a JSON object under the configured fieldName.
The nested object is populated by other providers added to this provider.
See Nested JSON provider
- fieldName - Output field name
- providers - The providers that should populate the nested object.
|
pattern |
Outputs fields from a configured JSON Object string,
while substituting patterns supported by logback access's PatternLayout.
See Pattern JSON Provider
- pattern - JSON object string (no default)
- omitEmptyFields - whether to omit fields with empty values (false)
|
### Nested JSON Provider
Use the `nestedField` provider to create a sub-object in the JSON event output.
For example...
```
fields
```
...will produce something like...
```
{
"@timestamp":"...",
"fields":{
"level": "DEBUG"
}
}
```
### Pattern JSON Provider
When used with a composite JSON encoder/layout, the `pattern` JSON provider can be used to
define a template for a portion of the logged JSON output.
The encoder/layout will populate values within the template.
Every value in the template is treated as a pattern for logback's standard `PatternLayout` so it can be a combination
of literal strings (for some constants) and various conversion specifiers (like `%d` for date).
The pattern string (configured within the pattern provider) must be a JSON Object.
The contents of the JSON object are included within the logged JSON output.
This example...
```xml
{ "level": "%level" }
```
... will produce something like...
```
{
"@timestamp":"...",
"@version": "1",
"level": "DEBUG"
}
```
The real power comes from the fact that there are lots of standard conversion specifiers so you
can customise what is logged and how. For example, you could log a single specific value from MDC with `%mdc{mykey}`.
Or, for access logs, you could log a single request header with `%i{User-Agent}`.
You can use nested objects and arrays in your pattern.
If you use a null, number, or a boolean constant in a pattern, it will keep its type in the
resulting JSON. However, only the text values are searched for conversion patterns.
And, as these patterns are sent through `PatternLayout`, the result is always a string
even for something which you may feel should be a number - like for `%b` (bytes sent, in access logs).
You can either deal with the type conversion on the logstash side or you may use special operations provided by this encoder.
The operations are:
* `#asLong{...}` - evaluates the pattern in curly braces and then converts resulting string to a long (or a null if conversion fails).
* `#asDouble{...}` - evaluates the pattern in curly braces and then converts resulting string to a double (or a null if conversion fails).
* `#asJson{...}` - evaluates the pattern in curly braces and then converts resulting string to json (or a null if conversion fails).
* `#tryJson{...}` - evaluates the pattern in curly braces and then converts resulting string to json (or just the string if conversion fails).
So this example...
```xml
{
"line_str": "%line",
"line_long": "#asLong{%line}",
"has_message": "#asJson{%mdc{hasMessage}}",
"json_message": "#asJson{%message}"
}
```
... And this logging code...
```java
MDC.put("hasMessage", "true");
LOGGER.info("{\"type\":\"example\",\"msg\":\"example of json message with type\"}");
```
...will produce something like...
```
{
"line_str":"97",
"line_long":97,
"has_message":true,
"json_message":{"type":"example","msg":"example of json message with type"}
}
```
Note that the value that is sent for `line_long` is a number even though in your pattern it is a quoted text.
And the json_message field value is a json object, not a string.
#### Omitting fields with empty values
The pattern provider can be configured to omit fields with the following _empty_ values:
* `null`
* empty string (`""`)
* empty array (`[]`)
* empty object (`{}`)
* objects containing only fields with empty values
* arrays containing only empty values
To omit fields with empty values, configure `omitEmptyFields` to `true` (default is `false`), like this:
```xml
true
{
"logger": "%logger",
"level": "%level",
"thread": "%thread",
"message": "%message",
"traceId": "%mdc{traceId}"
}
```
If the MDC did not contain a `traceId` entry, then a JSON log event from the above pattern would not contain the `traceId` field...
```
{
"logger": "com.example...",
"level": "DEBUG",
"thread": "exec-1",
"message": "Hello World!"
}
```
#### LoggingEvent patterns
For LoggingEvents, patterns from logback-classic's
[`PatternLayout`](http://logback.qos.ch/manual/layouts.html#conversionWord) are supported.
For example:
```xml
{
"custom_constant": "123",
"tags": ["one", "two"],
"logger": "%logger",
"level": "%level",
"thread": "%thread",
"message": "%message",
...
}
```
#### AccessEvent patterns
For AccessEvents, patterns from logback-access's
[`PatternLayout`](http://logback.qos.ch/xref/ch/qos/logback/access/PatternLayout.html) are supported.
For example:
```xml
{
"custom_constant": "123",
"tags": ["one", "two"],
"remote_ip": "%a",
"status_code": "%s",
"elapsed_time": "%D",
"user_agent": "%i{User-Agent}",
"accept": "%i{Accept}",
"referer": "%i{Referer}",
"session": "%requestCookie{JSESSIONID}",
...
}
```
There is also a special operation that can be used with this AccessEvents:
* `#nullNA{...}` - if the pattern in curly braces evaluates to a dash ("-"), it will be replaced with a null value.
You may want to use it because many of the `PatternLayout` conversion specifiers from logback-access will evaluate to "-"
for non-existent value (for example for a cookie, header or a request attribute).
So the following pattern...
```xml
{
"default_cookie": "%requestCookie{MISSING}",
"filtered_cookie": "#nullNA{%requestCookie{MISSING}}"
}
```
...will produce...
```
{
"default_cookie": "-",
"filtered_cookie": null
}
```
### Custom JSON Provider
You can create your own JSON provider by implementing the [`JsonProvider`](src/main/java/net/logstash/logback/composite/JsonProvider.java) interface (or extending one of the existing classes that implements the `JsonProvider` interface).
Then, add the provider to a `LoggingEventCompositeJsonEncoder` like this:
```xml
...
...
```
or a `LogstashEncoder` like this:
```xml
...
...
```
You can do something similar for `AccessEventCompositeJsonEncoder` and `LogstashAccessEncoder` as well, if your `JsonProvider` handles `IAccessEvent`s.
## Status Listeners
During execution, the encoders/appenders/layouts provided in logstash-logback-encoder
will add logback status messages to the logback [`StatusManager`](https://logback.qos.ch/apidocs/ch/qos/logback/core/status/StatusManager.html).
These status messages are typically reported via a logback [`StatusListener`](https://logback.qos.ch/apidocs/ch/qos/logback/core/status/StatusListener.html).
Since the [async appenders](#async-appenders) (especially the [tcp appenders](#tcp-appenders))
report warnings and errors via the status manager, a default status listener that
outputs WARN and ERROR level status messages to standard out
will be registered on startup if a status listener has not already been registered.
To disable the automatic registering of the default status listener by an appender, do one of the following:
* register a different logback [status listener](https://logback.qos.ch/manual/configuration.html#dumpingStatusData), or
* set `false
Memory usage and performance of logstash-logback-encoder have been improved
by addressing issues discovered with the help of the
[YourKit Java Profiler](http://www.yourkit.com/java/profiler/index.jsp).
YourKit, LLC has graciously donated a free license of the
[YourKit Java Profiler](http://www.yourkit.com/java/profiler/index.jsp)
to this open source project.