AsyncDisruptorAppender (Logstash Logback Encoder 7.0.1 API)

java.lang.Object
- ch.qos.logback.core.spi.ContextAwareBase
- - ch.qos.logback.core.UnsynchronizedAppenderBase<Event>
  - - net.logstash.logback.appender.AsyncDisruptorAppender<Event,Listener>

Type Parameters:

Event - type of event (ILoggingEvent or IAccessEvent).

All Implemented Interfaces:

Appender<Event>, ContextAware, FilterAttachable<Event>, LifeCycle

Direct Known Subclasses:

AbstractLogstashTcpSocketAppender, DelegatingAsyncDisruptorAppender
```
public abstract class AsyncDisruptorAppender<Event extends DeferredProcessingAware,Listener extends AppenderListener<Event>>
extends UnsynchronizedAppenderBase<Event>
```
An asynchronous appender that uses an LMAX Disruptor RingBuffer as the interthread data exchange mechanism (as opposed to a BlockingQueue used by logback's AsyncAppender).
See the LMAX Disruptor documentation for more information about the advantages of using a RingBuffer over a BlockingQueue.
The behavior of the appender when the RingBuffer is full and the event cannot be published is controlled by the appendTimeout configuration parameter. By default the appender drops the event immediately, and emits a warning message every droppedWarnFrequency consecutive dropped events. It can also be configured to wait until some space is available, with or without timeout.
A single handler thread will be used to handle the actual handling of the event.
Subclasses must implement createEventHandler() to provide a EventHandler to define the logic that executes in the handler thread. For example, DelegatingAsyncDisruptorAppender will delegate appending of the event to another appender in the handler thread.
By default, child threads created by this appender will be daemon threads, and therefore allow the JVM to exit gracefully without needing to explicitly shut down the appender. Note that in this case, it is possible for appended log events to not be handled (if the child thread has not had a chance to process them yet). By setting setDaemon(boolean) to false, you can change this behavior. When false, child threads created by this appender will not be daemon threads, and therefore will prevent the JVM from shutting down until the appender is explicitly shut down. Set this to false if you want to ensure that every log event prior to shutdown is handled.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`protected static class`	`AsyncDisruptorAppender.LogEvent<Event>` Event wrapper object used for each element of the `RingBuffer`.
`protected static class`	`AsyncDisruptorAppender.LogEventFactory<Event>` Factory for creating the initial `AsyncDisruptorAppender.LogEvent`s to populate the `RingBuffer`.
`protected static class`	`AsyncDisruptorAppender.LogEventTranslator<Event>` Sets the `AsyncDisruptorAppender.LogEvent.event` to the logback Event.

Field Summary

Fields
Modifier and Type	Field and Description
`protected static String`	`APPENDER_NAME_FORMAT`
`static int`	`DEFAULT_DROPPED_WARN_FREQUENCY`
`static com.lmax.disruptor.dsl.ProducerType`	`DEFAULT_PRODUCER_TYPE`
`static int`	`DEFAULT_RING_BUFFER_SIZE`
`static String`	`DEFAULT_THREAD_NAME_FORMAT`
`static com.lmax.disruptor.WaitStrategy`	`DEFAULT_WAIT_STRATEGY`
`protected List<Listener>`	`listeners` These listeners will be notified when certain events occur on this appender.
`protected static String`	`THREAD_INDEX_FORMAT`

Fields inherited from class ch.qos.logback.core.UnsynchronizedAppenderBase
name, started

Fields inherited from class ch.qos.logback.core.spi.ContextAwareBase
context

Constructor Summary

Constructors
Constructor and Description

AsyncDisruptorAppender()

Constructors
Constructor and Description
`AsyncDisruptorAppender()`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`void`	`addListener(Listener listener)`
`protected void`	`append(Event event)`
`protected String`	`calculateThreadName()`
`protected abstract com.lmax.disruptor.EventHandler<AsyncDisruptorAppender.LogEvent<Event>>`	`createEventHandler()` Create the `EventHandler` to process events as they become available from the RingBuffer.
`protected void`	`fireAppenderStarted()`
`protected void`	`fireAppenderStopped()`
`protected void`	`fireEventAppended(Event event, long durationInNanos)`
`protected void`	`fireEventAppendFailed(Event event, Throwable reason)`
`Duration`	`getAppendRetryFrequency()`
`Duration`	`getAppendTimeout()`
`protected com.lmax.disruptor.dsl.Disruptor<AsyncDisruptorAppender.LogEvent<Event>>`	`getDisruptor()`
`int`	`getDroppedWarnFrequency()`
`protected com.lmax.disruptor.EventTranslatorOneArg<AsyncDisruptorAppender.LogEvent<Event>,Event>`	`getEventTranslator()`
`com.lmax.disruptor.dsl.ProducerType`	`getProducerType()` Get the `ProducerType` configured for the Disruptor.
`int`	`getRingBufferSize()` Returns the maximum number of events allowed in the queue.
`Duration`	`getShutdownGracePeriod()`
`ThreadFactory`	`getThreadFactory()`
`String`	`getThreadNameFormat()`
`protected List<Object>`	`getThreadNameFormatParams()`
`com.lmax.disruptor.WaitStrategy`	`getWaitStrategy()`
`boolean`	`isAddDefaultStatusListener()`
`boolean`	`isDaemon()`
`protected boolean`	`isRingBufferEmpty()` Test whether the ring buffer is empty or not
`protected void`	`prepareForDeferredProcessing(Event event)`
`void`	`removeListener(Listener listener)`
`protected void`	`safelyFireEvent(Consumer<Listener> callback)`
`void`	`setAddDefaultStatusListener(boolean addDefaultStatusListener)`
`void`	`setAppendRetryFrequency(Duration appendRetryFrequency)`
`void`	`setAppendTimeout(Duration appendTimeout)`
`void`	`setDaemon(boolean useDaemonThread)`
`void`	`setDroppedWarnFrequency(int droppedWarnFrequency)`
`protected void`	`setEventFactory(AsyncDisruptorAppender.LogEventFactory<Event> eventFactory)`
`protected void`	`setEventTranslator(com.lmax.disruptor.EventTranslatorOneArg<AsyncDisruptorAppender.LogEvent<Event>,Event> eventTranslator)`
`void`	`setProducerType(com.lmax.disruptor.dsl.ProducerType producerType)` Deprecated. ProducerType will be fixed to MULTI in future release and this method removed without any replacement.
`void`	`setRingBufferSize(int ringBufferSize)` Sets the size of the `RingBuffer`.
`void`	`setShutdownGracePeriod(Duration shutdownGracePeriod)`
`void`	`setThreadFactory(ThreadFactory threadFactory)`
`void`	`setThreadNameFormat(String threadNameFormat)` Pattern used by the to set the handler thread names.
`void`	`setWaitStrategy(com.lmax.disruptor.WaitStrategy waitStrategy)`
`void`	`setWaitStrategyType(String waitStrategyType)`
`void`	`start()`
`void`	`stop()`

Methods inherited from class ch.qos.logback.core.UnsynchronizedAppenderBase
addFilter, clearAllFilters, doAppend, getCopyOfAttachedFiltersList, getFilterChainDecision, getName, isStarted, setName, toString

Methods inherited from class ch.qos.logback.core.spi.ContextAwareBase
addError, addError, addInfo, addInfo, addStatus, addWarn, addWarn, getContext, getDeclaredOrigin, getStatusManager, setContext

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface ch.qos.logback.core.spi.ContextAware
addError, addError, addInfo, addInfo, addStatus, addWarn, addWarn, getContext, setContext

- Field Detail
  - APPENDER_NAME_FORMAT
```
protected static final String APPENDER_NAME_FORMAT
```
    See Also:
    
    Constant Field Values
  - THREAD_INDEX_FORMAT
```
protected static final String THREAD_INDEX_FORMAT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_THREAD_NAME_FORMAT
```
public static final String DEFAULT_THREAD_NAME_FORMAT
```
    See Also:
    
    Constant Field Values
  - DEFAULT_RING_BUFFER_SIZE
```
public static final int DEFAULT_RING_BUFFER_SIZE
```
    See Also:
    
    Constant Field Values
  - DEFAULT_PRODUCER_TYPE
```
public static final com.lmax.disruptor.dsl.ProducerType DEFAULT_PRODUCER_TYPE
```
  - DEFAULT_WAIT_STRATEGY
```
public static final com.lmax.disruptor.WaitStrategy DEFAULT_WAIT_STRATEGY
```
  - DEFAULT_DROPPED_WARN_FREQUENCY
```
public static final int DEFAULT_DROPPED_WARN_FREQUENCY
```
    See Also:
    
    Constant Field Values
  - listeners
```
protected final List<Listener extends AppenderListener<Event>> listeners
```
    These listeners will be notified when certain events occur on this appender.
- Constructor Detail
  - AsyncDisruptorAppender
```
public AsyncDisruptorAppender()
```
- Method Detail
  - start
```
public void start()
```
    Specified by:
    
    start in interface LifeCycle
    
    Overrides:
    
    start in class UnsynchronizedAppenderBase<Event extends DeferredProcessingAware>
  - stop
```
public void stop()
```
    Specified by:
    
    stop in interface LifeCycle
    
    Overrides:
    
    stop in class UnsynchronizedAppenderBase<Event extends DeferredProcessingAware>
  - createEventHandler
```
protected abstract com.lmax.disruptor.EventHandler<AsyncDisruptorAppender.LogEvent<Event>> createEventHandler()
```
    Create the EventHandler to process events as they become available from the RingBuffer. This method is invoked when the appender is started by start() and a new Disruptor is initialized.
    
    Returns:
    
    a EventHandler instance.
  - isRingBufferEmpty
```
protected boolean isRingBufferEmpty()
```
    Test whether the ring buffer is empty or not
    
    Returns:
    
    true if the ring buffer is empty, false otherwise
  - append
```
protected void append(Event event)
```
    Specified by:
    
    append in class UnsynchronizedAppenderBase<Event extends DeferredProcessingAware>
  - prepareForDeferredProcessing
```
protected void prepareForDeferredProcessing(Event event)
```
  - calculateThreadName
```
protected String calculateThreadName()
```
  - getThreadNameFormatParams
```
protected List<Object> getThreadNameFormatParams()
```
  - fireAppenderStarted
```
protected void fireAppenderStarted()
```
  - fireAppenderStopped
```
protected void fireAppenderStopped()
```
  - fireEventAppended
```
protected void fireEventAppended(Event event,
                                 long durationInNanos)
```
  - fireEventAppendFailed
```
protected void fireEventAppendFailed(Event event,
                                     Throwable reason)
```
  - safelyFireEvent
```
protected void safelyFireEvent(Consumer<Listener> callback)
```
  - setEventFactory
```
protected void setEventFactory(AsyncDisruptorAppender.LogEventFactory<Event> eventFactory)
```
  - getEventTranslator
```
protected com.lmax.disruptor.EventTranslatorOneArg<AsyncDisruptorAppender.LogEvent<Event>,Event> getEventTranslator()
```
  - setEventTranslator
```
protected void setEventTranslator(com.lmax.disruptor.EventTranslatorOneArg<AsyncDisruptorAppender.LogEvent<Event>,Event> eventTranslator)
```
  - getDisruptor
```
protected com.lmax.disruptor.dsl.Disruptor<AsyncDisruptorAppender.LogEvent<Event>> getDisruptor()
```
  - getThreadNameFormat
```
public String getThreadNameFormat()
```
  - setThreadNameFormat
```
public void setThreadNameFormat(String threadNameFormat)
```
    Pattern used by the to set the handler thread names. Defaults to "logback-appender-%1$s-%2$d".
    If you change the threadFactory, then this value may not be honored.
    The string is a format pattern understood by Formatter.format(String, Object...). Formatter.format(String, Object...) is used to construct the actual thread name prefix. The first argument (%1$s) is the string appender name. The second argument (%2$d) is the numerical thread index. Other arguments can be made available by subclasses.
    
    Parameters:
    
    threadNameFormat - the thread name format pattern
  - getRingBufferSize
```
public int getRingBufferSize()
```
    Returns the maximum number of events allowed in the queue.
    
    Returns:
    
    the size of the ring buffer
  - setRingBufferSize
```
public void setRingBufferSize(int ringBufferSize)
```
    Sets the size of the RingBuffer. Must be a positive power of 2. Defaults to 8192.
    If the handler thread is not as fast as the producing threads, then the RingBuffer will eventually fill up, at which point events will be dropped or producing threads blocked depending on appendTimeout.
    
    Parameters:
    
    ringBufferSize - the maximum number of entries in the queue.
  - getProducerType
```
public com.lmax.disruptor.dsl.ProducerType getProducerType()
```
    Get the ProducerType configured for the Disruptor.
    
    Returns:
    
    the ProducerType.
  - setProducerType
```
@Deprecated
public void setProducerType(com.lmax.disruptor.dsl.ProducerType producerType)
```
    Deprecated. ProducerType will be fixed to MULTI in future release and this method removed without any replacement.
    
    The ProducerType to use to configure the Disruptor. By default this is ProducerType.MULTI. Can be set to ProducerType.SINGLE for increase performance if (and only if) only one thread will ever be appending to this appender.
    WARNING: unexpected behavior may occur if this parameter is set to ProducerType.SINGLE and multiple threads are appending to this appender.
    
    Parameters:
    
    producerType - the type of producer
  - getWaitStrategy
```
public com.lmax.disruptor.WaitStrategy getWaitStrategy()
```
  - setWaitStrategy
```
public void setWaitStrategy(com.lmax.disruptor.WaitStrategy waitStrategy)
```
  - setWaitStrategyType
```
public void setWaitStrategyType(String waitStrategyType)
```
  - getAppendRetryFrequency
```
public Duration getAppendRetryFrequency()
```
  - setAppendRetryFrequency
```
public void setAppendRetryFrequency(Duration appendRetryFrequency)
```
  - getAppendTimeout
```
public Duration getAppendTimeout()
```
  - setAppendTimeout
```
public void setAppendTimeout(Duration appendTimeout)
```
  - setShutdownGracePeriod
```
public void setShutdownGracePeriod(Duration shutdownGracePeriod)
```
  - getShutdownGracePeriod
```
public Duration getShutdownGracePeriod()
```
  - getThreadFactory
```
public ThreadFactory getThreadFactory()
```
  - setThreadFactory
```
public void setThreadFactory(ThreadFactory threadFactory)
```
  - getDroppedWarnFrequency
```
public int getDroppedWarnFrequency()
```
  - setDroppedWarnFrequency
```
public void setDroppedWarnFrequency(int droppedWarnFrequency)
```
  - isDaemon
```
public boolean isDaemon()
```
  - setDaemon
```
public void setDaemon(boolean useDaemonThread)
```
  - addListener
```
public void addListener(Listener listener)
```
  - removeListener
```
public void removeListener(Listener listener)
```
  - isAddDefaultStatusListener
```
public boolean isAddDefaultStatusListener()
```
  - setAddDefaultStatusListener
```
public void setAddDefaultStatusListener(boolean addDefaultStatusListener)
```

Class AsyncDisruptorAppender<Event extends DeferredProcessingAware,Listener extends AppenderListener<Event>>

Nested Class Summary

Field Summary

Fields inherited from class ch.qos.logback.core.UnsynchronizedAppenderBase

Fields inherited from class ch.qos.logback.core.spi.ContextAwareBase

Constructor Summary

Method Summary

Methods inherited from class ch.qos.logback.core.UnsynchronizedAppenderBase

Methods inherited from class ch.qos.logback.core.spi.ContextAwareBase

Methods inherited from class java.lang.Object

Methods inherited from interface ch.qos.logback.core.spi.ContextAware

Field Detail

APPENDER_NAME_FORMAT

THREAD_INDEX_FORMAT

DEFAULT_THREAD_NAME_FORMAT

DEFAULT_RING_BUFFER_SIZE

DEFAULT_PRODUCER_TYPE

DEFAULT_WAIT_STRATEGY

DEFAULT_DROPPED_WARN_FREQUENCY

listeners

Constructor Detail

AsyncDisruptorAppender

Method Detail

start

stop

createEventHandler

isRingBufferEmpty

append

prepareForDeferredProcessing

calculateThreadName

getThreadNameFormatParams

fireAppenderStarted

fireAppenderStopped

fireEventAppended

fireEventAppendFailed

safelyFireEvent

setEventFactory

getEventTranslator

setEventTranslator

getDisruptor

getThreadNameFormat

setThreadNameFormat

getRingBufferSize

setRingBufferSize

getProducerType

setProducerType

getWaitStrategy

setWaitStrategy

setWaitStrategyType

getAppendRetryFrequency

setAppendRetryFrequency

getAppendTimeout

setAppendTimeout

setShutdownGracePeriod

getShutdownGracePeriod

getThreadFactory

setThreadFactory

getDroppedWarnFrequency

setDroppedWarnFrequency

isDaemon

setDaemon

addListener

removeListener

isAddDefaultStatusListener

setAddDefaultStatusListener