AbstractLogWriter (AWS Log4J Appenders 1.3.0 API)

java.lang.Object
- com.kdgregory.log4j.aws.internal.shared.AbstractLogWriter

All Implemented Interfaces:

LogWriter, Runnable

Direct Known Subclasses:

CloudWatchLogWriter, KinesisLogWriter, SNSLogWriter
```
public abstract class AbstractLogWriter
extends Object
implements LogWriter
```
Manages common LogWriter activities.

Constructor Summary

Constructors
Constructor and Description
`AbstractLogWriter(AbstractAppenderStatistics appenderStats, long batchDelay, int discardThreshold, MessageQueue.DiscardAction discardAction)`

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 waiting for batch.
`protected List<LogMessage>`	`buildBatch()` Attempts to read a list of messages from the queue.
`protected abstract void`	`createAWSClient()` Creates the appropriate AWS client.
`protected abstract int`	`effectiveSize(LogMessage message)` Calculates the effective size of the message.
`protected abstract boolean`	`ensureDestinationAvailable()` Verifies that the logging destination is available, including creating it if not.
`int`	`getBatchCount()` Returns the number of batches processed.
`long`	`getBatchDelay()` Returns the current batch delay.
`String`	`getClientFactoryUsed()` Returns the factory method used to create the client, if any.
`protected boolean`	`initializationFailure(String message, Exception exception)` Records an initialization failure in the appender stats.
`boolean`	`isInitializationComplete()` Returns a flag indicating that initialization has completed (whether or not successful).
`protected abstract List<LogMessage>`	`processBatch(List<LogMessage> currentBatch)` Processes a batch of messages.
`void`	`run()`
`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 <T> T`	`tryClientFactory(String clientFactoryName, Class<T> expectedClientClass, boolean rethrow)` Attempts to use a factory method to create the service client.
`protected <T extends com.amazonaws.AmazonWebServiceClient> T`	`tryConfigureEndpointOrRegion(T client, String endpoint)` Common support code: attempts to configure client endpoint and/or region.
`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

- Constructor Detail
  - AbstractLogWriter
```
public AbstractLogWriter(AbstractAppenderStatistics appenderStats,
                         long batchDelay,
                         int discardThreshold,
                         MessageQueue.DiscardAction discardAction)
```
- Method Detail
  - 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
  - isInitializationComplete
```
public boolean isInitializationComplete()
```
    Returns a flag indicating that initialization has completed (whether or not successful).
  - getClientFactoryUsed
```
public String getClientFactoryUsed()
```
    Returns the factory method used to create the client, if any. Null if the client was created via constructor.
  - addMessage
```
public void addMessage(LogMessage message)
```
    Description copied from interface: LogWriter
    
    Adds a message to the writer waiting for batch.
    Implementations should assume that they are invoked within a synchronized block, and therefore should not perform excessive amounts of work.
    
    Specified by:
    
    addMessage in interface LogWriter
  - 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.
    If the writer doesn't support batching, this will be a no-op.
    
    Specified by:
    
    setBatchDelay 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
  - 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
  - run
```
public void run()
```
    Specified by:
    
    run in interface Runnable
  - createAWSClient
```
protected abstract void createAWSClient()
```
    Creates the appropriate AWS client. This is called as the first thing in the run() method (because, for some reason calling it in the ctor was failing).
  - ensureDestinationAvailable
```
protected abstract boolean ensureDestinationAvailable()
```
    Verifies that the logging destination is available, including creating it if not. Return true if successful, false if not (which will cause the appender to stop running).
  - processBatch
```
protected abstract List<LogMessage> processBatch(List<LogMessage> currentBatch)
```
    Processes 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.
  - 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.
  - initializationFailure
```
protected boolean initializationFailure(String message,
                                        Exception exception)
```
    Records an initialization failure in the appender stats. This method returns false so that the failure handler can return its result to the caller.
  - buildBatch
```
protected List<LogMessage> buildBatch()
```
    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.
  - tryClientFactory
```
protected <T> T tryClientFactory(String clientFactoryName,
                                 Class<T> expectedClientClass,
                                 boolean rethrow)
```
    Attempts to use a factory method to create the service client.
    
    Parameters:
    
    clientFactoryName - Fully qualified name of a static factory method. If empty or null, this function returns null (used to handle optionally-configured factories).
    
    expectedClientClass - The interface fullfilled by this client.
    
    rethrow - If true, any reflection exceptions will be wrapped and rethrown; if false, exceptions return null
  - tryConfigureEndpointOrRegion
```
protected <T extends com.amazonaws.AmazonWebServiceClient> T tryConfigureEndpointOrRegion(T client,
                                                                                          String endpoint)
```
    Common support code: attempts to configure client endpoint and/or region.
    
    Parameters:
    
    client - A constructed writer-specific service client.
    
    endpoint - A possibly-null endpoint specification.

Class AbstractLogWriter

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

AbstractLogWriter

Method Detail

getBatchDelay

getBatchCount

isInitializationComplete

getClientFactoryUsed

addMessage

setBatchDelay

stop

setDiscardThreshold

setDiscardAction

run

createAWSClient

ensureDestinationAvailable

processBatch

effectiveSize

withinServiceLimits

initializationFailure

buildBatch

tryClientFactory

tryConfigureEndpointOrRegion