AbstractLogWriter (Log-Writers and Shared Components 3.1.2 API)

java.lang.Object
- com.kdgregory.logging.aws.internal.AbstractLogWriter<ConfigType,StatsType>

All Implemented Interfaces:: LogWriter, Runnable

Direct Known Subclasses:: CloudWatchLogWriter, KinesisLogWriter, SNSLogWriter

public abstract class AbstractLogWriter<ConfigType extends AbstractWriterConfig<ConfigType>,StatsType extends AbstractWriterStatistics>
extends Object
implements LogWriter

Manages common LogWriter activities.

Field Summary

Fields
Modifier and Type Field and Description

protected ConfigType config

protected InternalLogger logger

protected StatsType stats

Fields
Modifier and Type	Field and Description
`protected ConfigType`	`config`
`protected InternalLogger`	`logger`
`protected StatsType`	`stats`

Constructor Summary

Constructors
Constructor and Description

AbstractLogWriter(ConfigType config, StatsType appenderStats, InternalLogger logger)

Constructors
Constructor and Description
`AbstractLogWriter(ConfigType config, StatsType appenderStats, InternalLogger logger)`

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addMessage(LogMessage message)` Adds a message to the writer's message queue.
`protected List<LogMessage>`	`buildBatch(long waitUntil)` Attempts to read a list of messages from the queue.
`protected abstract int`	`effectiveSize(LogMessage message)` Calculates the effective size of the message.
`protected abstract boolean`	`ensureDestinationAvailable()` Verifies that the logging destination is available (which may involve creating it).
`int`	`getBatchCount()` Returns the number of batches processed.
`long`	`getBatchDelay()` Returns the current batch delay.
`protected boolean`	`initialize()` Called before the main loop, to ensure that the writer is able to perform its job.
`boolean`	`isRunning()` Returns whether or not the writer is currently running.
`boolean`	`isSynchronous()` Returns a flag to indicate whether the writer is operating in synchrnous mode.
`protected boolean`	`keepRunning()` A check for whether we should keep running: either we haven't been shut down or there's still messages to process
`protected void`	`processBatch(long waitUntil)` Called from the main loop to build a batch of messages and send them.
`protected void`	`reportError(String message, Throwable exception)` Reports an operational error to both the internal logger and the stats bean.
`void`	`run()`
`protected abstract List<LogMessage>`	`sendBatch(List<LogMessage> currentBatch)` Sends a batch of messages.
`void`	`setBatchDelay(long value)` Sets the batch delay for the writer.
`void`	`setDiscardAction(MessageQueue.DiscardAction value)` Updates the writer's discard action: how it discards messages once the threshold has been reached.
`void`	`setDiscardThreshold(int value)` Updates the writer's discard threshold: the maximum number of message stored in its queue.
`void`	`stop()` Signals the writer that it will no longer receive batches.
`protected abstract void`	`stopAWSClient()` This is called when the logwriter is stopped, to explicitly close the AWS service client.
`boolean`	`waitUntilInitialized(long millisToWait)` Waits up to the specified amount of time for the writer to initialize.
`void`	`waitUntilStopped(long millisToWait)` Waits until the writer thread has stopped, the timeout has expired, or the calling thread is interrupted.
`protected abstract boolean`	`withinServiceLimits(int batchBytes, int numMessages)` Determines whether the provided batch size or number of messages would exceed the service's limits.

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

Methods inherited from interface com.kdgregory.logging.common.LogWriter
maxMessageSize

- Field Detail
  - config
```
protected ConfigType extends AbstractWriterConfig<ConfigType> config
```
  - stats
```
protected StatsType extends AbstractWriterStatistics stats
```
  - logger
```
protected InternalLogger logger
```
- Constructor Detail
  - AbstractLogWriter
```
public AbstractLogWriter(ConfigType config,
                         StatsType appenderStats,
                         InternalLogger logger)
```
- Method Detail
  - isRunning
```
public boolean isRunning()
```
    Returns whether or not the writer is currently running. This is intended for testing.
  - getBatchDelay
```
public long getBatchDelay()
```
    Returns the current batch delay. This is intended for testing.
  - getBatchCount
```
public int getBatchCount()
```
    Returns the number of batches processed. This is intended for testing
  - run
```
public void run()
```
    Specified by:
    
    run in interface Runnable
  - setBatchDelay
```
public void setBatchDelay(long value)
```
    Description copied from interface: LogWriter
    
    Sets the batch delay for the writer. The appender is assumed to expose a delay parameter, and this method allows it to change the writer's delay at runtime. Changes may or may not take place immediately.
    This is a no-op if the writer doesn't support batching or is in synchronous mode.
    
    Specified by:
    
    setBatchDelay in interface LogWriter
  - setDiscardThreshold
```
public void setDiscardThreshold(int value)
```
    Description copied from interface: LogWriter
    
    Updates the writer's discard threshold: the maximum number of message stored in its queue.
    
    Specified by:
    
    setDiscardThreshold in interface LogWriter
  - setDiscardAction
```
public void setDiscardAction(MessageQueue.DiscardAction value)
```
    Description copied from interface: LogWriter
    
    Updates the writer's discard action: how it discards messages once the threshold has been reached.
    
    Specified by:
    
    setDiscardAction in interface LogWriter
  - isSynchronous
```
public boolean isSynchronous()
```
    Description copied from interface: LogWriter
    
    Returns a flag to indicate whether the writer is operating in synchrnous mode.
    
    Specified by:
    
    isSynchronous in interface LogWriter
  - waitUntilInitialized
```
public boolean waitUntilInitialized(long millisToWait)
```
    Description copied from interface: LogWriter
    
    Waits up to the specified amount of time for the writer to initialize.
    
    Specified by:
    
    waitUntilInitialized in interface LogWriter
    
    Returns:
    
    true if it initialized successfully, false if writer failed to initialize, the timeout expired, or the calling thread was interrupted.
  - addMessage
```
public void addMessage(LogMessage message)
```
    Description copied from interface: LogWriter
    
    Adds a message to the writer's message queue. If in synchronous mode, this also triggers batch processing.
    Implementations should assume that they are invoked within a synchronized block, and therefore should not perform excessive amounts work (synchronous mode being an exception).
    
    Specified by:
    
    addMessage in interface LogWriter
  - stop
```
public void stop()
```
    Description copied from interface: LogWriter
    
    Signals the writer that it will no longer receive batches. It should, however, make a best effort to send any batches that it already has before exiting its run() method.
    
    Specified by:
    
    stop in interface LogWriter
  - waitUntilStopped
```
public void waitUntilStopped(long millisToWait)
```
    Description copied from interface: LogWriter
    
    Waits until the writer thread has stopped, the timeout has expired, or the calling thread is interrupted.
    
    Specified by:
    
    waitUntilStopped in interface LogWriter
  - keepRunning
```
protected boolean keepRunning()
```
    A check for whether we should keep running: either we haven't been shut down or there's still messages to process
  - initialize
```
protected boolean initialize()
```
    Called before the main loop, to ensure that the writer is able to perform its job. If unable, reconfigures the writer to discard all message.
  - processBatch
```
protected void processBatch(long waitUntil)
```
    Called from the main loop to build a batch of messages and send them. Waits until the specified timestamp for the first message, then waits for the batch delay before passing the messages to sendBatch(java.util.List<com.kdgregory.logging.common.LogMessage>).
    It's necessary to synchronize this method to support synchronous mode. In normal threaded mode it the lock will always be uncontended.
  - buildBatch
```
protected List<LogMessage> buildBatch(long waitUntil)
```
    Attempts to read a list of messages from the queue. Will wait "forever" (or until shutdown) for the first message, then read as many messages as possible within the batch delay.
    For each message, the subclass is called to determine the effective size of the message, and whether the aggregate batch size is within the range accepted by the service.
  - ensureDestinationAvailable
```
protected abstract boolean ensureDestinationAvailable()
```
    Verifies that the logging destination is available (which may involve creating it). Return true if successful, false if not (which will cause the appender to stop running).
  - sendBatch
```
protected abstract List<LogMessage> sendBatch(List<LogMessage> currentBatch)
```
    Sends a batch of messages. The subclass is responsible for returning any messages that weren't sent, in order, so that they can be requeued.
  - effectiveSize
```
protected abstract int effectiveSize(LogMessage message)
```
    Calculates the effective size of the message. This includes the message bytes plus any overhead. It is used to calculate the number of bytes the message will add to a batch.
  - withinServiceLimits
```
protected abstract boolean withinServiceLimits(int batchBytes,
                                               int numMessages)
```
    Determines whether the provided batch size or number of messages would exceed the service's limits.
  - stopAWSClient
```
protected abstract void stopAWSClient()
```
    This is called when the logwriter is stopped, to explicitly close the AWS service client. It must be implemented by the subclass because we don't know the actual type and there's no abstract super-interface.
  - reportError
```
protected void reportError(String message,
                           Throwable exception)
```
    Reports an operational error to both the internal logger and the stats bean.

Class AbstractLogWriter<ConfigType extends AbstractWriterConfig<ConfigType>,StatsType extends AbstractWriterStatistics>

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.kdgregory.logging.common.LogWriter

Field Detail

config

stats

logger

Constructor Detail

AbstractLogWriter

Method Detail

isRunning

getBatchDelay

getBatchCount

run

setBatchDelay

setDiscardThreshold

setDiscardAction

isSynchronous

waitUntilInitialized

addMessage

stop

waitUntilStopped

keepRunning

initialize

processBatch

buildBatch

ensureDestinationAvailable

sendBatch

effectiveSize

withinServiceLimits

stopAWSClient

reportError