Class AbstractSocketAppender<E>

All Implemented Interfaces:
Appender<E>, SocketConnector.ExceptionHandler, ContextAware, FilterAttachable<E>, LifeCycle
Direct Known Subclasses:
AbstractSSLSocketAppender, SocketAppender, SocketAppender

public abstract class AbstractSocketAppender<E> extends AppenderBase<E> implements SocketConnector.ExceptionHandler
An abstract base for module specific SocketAppender implementations in other logback modules.
  • Field Details

    • DEFAULT_PORT

      public static final int DEFAULT_PORT
      The default port number of remote logging server (4560).
      See Also:
    • DEFAULT_RECONNECTION_DELAY

      public static final int DEFAULT_RECONNECTION_DELAY
      The default reconnection delay (30000 milliseconds or 30 seconds).
      See Also:
    • DEFAULT_QUEUE_SIZE

      public static final int DEFAULT_QUEUE_SIZE
      Default size of the deque used to hold logging events that are destined for the remote peer.
      See Also:
    • DEFAULT_ACCEPT_CONNECTION_DELAY

      private static final int DEFAULT_ACCEPT_CONNECTION_DELAY
      Default timeout when waiting for the remote server to accept our connection.
      See Also:
    • DEFAULT_EVENT_DELAY_TIMEOUT

      private static final int DEFAULT_EVENT_DELAY_TIMEOUT
      Default timeout for how long to wait when inserting an event into the BlockingQueue.
      See Also:
    • objectWriterFactory

      private final ObjectWriterFactory objectWriterFactory
    • queueFactory

      private final QueueFactory queueFactory
    • remoteHost

      private String remoteHost
    • port

      private int port
    • address

      private InetAddress address
    • reconnectionDelay

      private Duration reconnectionDelay
    • queueSize

      private int queueSize
    • acceptConnectionTimeout

      private int acceptConnectionTimeout
    • eventDelayLimit

      private Duration eventDelayLimit
    • deque

      private BlockingDeque<E> deque
    • peerId

      private String peerId
    • connector

      private SocketConnector connector
    • task

      private Future<?> task
    • socket

      private volatile Socket socket
  • Constructor Details

  • Method Details

    • start

      public void start()
      Specified by:
      start in interface LifeCycle
      Overrides:
      start in class AppenderBase<E>
    • stop

      public void stop()
      Specified by:
      stop in interface LifeCycle
      Overrides:
      stop in class AppenderBase<E>
    • append

      protected void append(E event)
      Specified by:
      append in class AppenderBase<E>
    • connectSocketAndDispatchEvents

      private void connectSocketAndDispatchEvents()
    • socketConnectionCouldBeEstablished

      private boolean socketConnectionCouldBeEstablished() throws InterruptedException
      Throws:
      InterruptedException
    • createObjectWriterForSocket

      private ObjectWriter createObjectWriterForSocket() throws IOException
      Throws:
      IOException
    • createConnector

      private SocketConnector createConnector(InetAddress address, int port, int initialDelay, long retryDelay)
    • dispatchEvents

      private void dispatchEvents(ObjectWriter objectWriter) throws InterruptedException, IOException
      Throws:
      InterruptedException
      IOException
    • tryReAddingEventToFrontOfQueue

      private void tryReAddingEventToFrontOfQueue(E event)
    • connectionFailed

      public void connectionFailed(SocketConnector connector, Exception ex)
      Specified by:
      connectionFailed in interface SocketConnector.ExceptionHandler
    • newConnector

      protected SocketConnector newConnector(InetAddress address, int port, long initialDelay, long retryDelay)
      Creates a new SocketConnector.

      The default implementation creates an instance of DefaultSocketConnector. A subclass may override to provide a different SocketConnector implementation.

      Parameters:
      address - target remote address
      port - target remote port
      initialDelay - delay before the first connection attempt
      retryDelay - delay before a reconnection attempt
      Returns:
      socket connector
    • getSocketFactory

      protected SocketFactory getSocketFactory()
      Gets the default SocketFactory for the platform.

      Subclasses may override to provide a custom socket factory.

    • postProcessEvent

      protected abstract void postProcessEvent(E event)
      Post-processes an event before it is serialized for delivery to the remote receiver.
      Parameters:
      event - the event to post-process
    • getPST

      protected abstract PreSerializationTransformer<E> getPST()
      Get the pre-serialization transformer that will be used to transform each event into a Serializable object before delivery to the remote receiver.
      Returns:
      transformer object
    • setRemoteHost

      public void setRemoteHost(String host)
      The RemoteHost property takes the name of of the host where a corresponding server is running.
    • getRemoteHost

      public String getRemoteHost()
      Returns value of the RemoteHost property.
    • setPort

      public void setPort(int port)
      The Port property takes a positive integer representing the port where the server is waiting for connections.
    • getPort

      public int getPort()
      Returns value of the Port property.
    • setReconnectionDelay

      public void setReconnectionDelay(Duration delay)
      The reconnectionDelay property takes a positive Duration value representing the time to wait between each failed connection attempt to the server. The default value of this option is to 30 seconds.

      Setting this option to zero turns off reconnection capability.

    • getReconnectionDelay

      public Duration getReconnectionDelay()
      Returns value of the reconnectionDelay property.
    • setQueueSize

      public void setQueueSize(int queueSize)
      The queueSize property takes a non-negative integer representing the number of logging events to retain for delivery to the remote receiver. When the deque size is zero, event delivery to the remote receiver is synchronous. When the deque size is greater than zero, the append(Object) method returns immediately after enqueing the event, assuming that there is space available in the deque. Using a non-zero deque length can improve performance by eliminating delays caused by transient network delays.
      Parameters:
      queueSize - the deque size to set.
    • getQueueSize

      public int getQueueSize()
      Returns the value of the queueSize property.
    • setEventDelayLimit

      public void setEventDelayLimit(Duration eventDelayLimit)
      The eventDelayLimit takes a non-negative integer representing the number of milliseconds to allow the appender to block if the underlying BlockingQueue is full. Once this limit is reached, the event is dropped.
      Parameters:
      eventDelayLimit - the event delay limit
    • getEventDelayLimit

      public Duration getEventDelayLimit()
      Returns the value of the eventDelayLimit property.
    • setAcceptConnectionTimeout

      void setAcceptConnectionTimeout(int acceptConnectionTimeout)
      Sets the timeout that controls how long we'll wait for the remote peer to accept our connection attempt.

      This property is configurable primarily to support instrumentation for unit testing.

      Parameters:
      acceptConnectionTimeout - timeout value in milliseconds