Network Logging

/**
 * TCP socket appender for remote logging
 */
public class SocketAppender extends AppenderBase<ILoggingEvent> {
    static final int DEFAULT_RECONNECTION_DELAY = 30000;
    static final int DEFAULT_QUEUE_SIZE = 128;
    
    private String remoteHost;
    private int port;
    private InetAddress address;
    private int reconnectionDelay = DEFAULT_RECONNECTION_DELAY;
    private int queueSize = DEFAULT_QUEUE_SIZE;
    private boolean includeCallerData = false;
    
    /**
     * Set the remote host to connect to
     */
    public void setRemoteHost(String host);
    public String getRemoteHost();
    
    /**
     * Set the port number
     */
    public void setPort(int port);
    public int getPort();
    
    /**
     * Set reconnection delay in milliseconds
     */
    public void setReconnectionDelay(Duration delay);
    public Duration getReconnectionDelay();
    
    /**
     * Set internal queue size
     */
    public void setQueueSize(int queueSize);
    public int getQueueSize();
    
    /**
     * Enable/disable caller data inclusion (expensive)
     */
    public boolean isIncludeCallerData();
    public void setIncludeCallerData(boolean includeCallerData);
}

/**
 * SSL-secured socket appender
 */
public class SSLSocketAppender extends SocketAppender implements SSLComponent {
    private SSLConfiguration ssl;
    private SocketFactory socketFactory;
    
    /**
     * Set SSL configuration
     */
    public SSLConfiguration getSsl();
    public void setSsl(SSLConfiguration ssl);
    
    /**
     * Set custom socket factory
     */
    public void setSocketFactory(SocketFactory socketFactory);
    public SocketFactory getSocketFactory();
}

import ch.qos.logback.classic.net.SocketAppender;

// Create socket appender
SocketAppender socketAppender = new SocketAppender();
socketAppender.setContext(loggerContext);
socketAppender.setName("SOCKET");
socketAppender.setRemoteHost("log-server.example.com");
socketAppender.setPort(4560);
socketAppender.setReconnectionDelay(Duration.ofSeconds(30));
socketAppender.setIncludeCallerData(false); // For performance
socketAppender.start();

// Add to logger
Logger logger = loggerContext.getLogger("com.example.app");
logger.addAppender(socketAppender);

/**
 * TCP socket receiver for accepting remote log events
 */
public class SocketReceiver extends ReceiverBase implements Runnable {
    public static final int DEFAULT_ACCEPT_CONNECTION_DELAY = 5000;
    
    private String address;
    private int port;
    private int backlog = 50;
    private int acceptConnectionTimeout = DEFAULT_ACCEPT_CONNECTION_DELAY;
    
    /**
     * Set the local address to bind to
     */
    public String getAddress();
    public void setAddress(String address);
    
    /**
     * Set the port to listen on
     */
    public int getPort();
    public void setPort(int port);
    
    /**
     * Set the backlog for the server socket
     */
    public int getBacklog();
    public void setBacklog(int backlog);
    
    /**
     * Set accept connection timeout
     */
    public int getAcceptConnectionTimeout();
    public void setAcceptConnectionTimeout(int acceptConnectionTimeout);
}

/**
 * SSL-secured socket receiver
 */
public class SSLSocketReceiver extends SocketReceiver implements SSLComponent {
    private SSLConfiguration ssl;
    
    /**
     * Set SSL configuration
     */
    public SSLConfiguration getSsl();
    public void setSsl(SSLConfiguration ssl);
}

/**
 * Base class for all receivers
 */
public abstract class ReceiverBase extends ContextAwareBase implements LifeCycle {
    protected boolean started;
    
    public boolean isStarted();
    public void start();
    public void stop();
}

/**
 * Server socket appender that accepts client connections
 */
public class ServerSocketAppender extends AppenderBase<ILoggingEvent> {
    public static final int DEFAULT_BACKLOG = 50;
    public static final int DEFAULT_CLIENT_QUEUE_SIZE = 100;
    
    private int port;
    private int backlog = DEFAULT_BACKLOG;
    private int clientQueueSize = DEFAULT_CLIENT_QUEUE_SIZE;
    private String address;
    private boolean includeCallerData;
    
    /**
     * Set the port to listen on
     */
    public int getPort();
    public void setPort(int port);
    
    /**
     * Set the address to bind to
     */
    public String getAddress();
    public void setAddress(String address);
    
    /**
     * Set the server socket backlog
     */
    public int getBacklog();
    public void setBacklog(int backlog);
    
    /**
     * Set queue size for each client connection
     */
    public int getClientQueueSize();
    public void setClientQueueSize(int clientQueueSize);
    
    /**
     * Enable/disable caller data inclusion
     */
    public boolean isIncludeCallerData();
    public void setIncludeCallerData(boolean includeCallerData);
}

/**
 * SSL-secured server socket appender
 */
public class SSLServerSocketAppender extends ServerSocketAppender implements SSLComponent {
    private SSLConfiguration ssl;
    
    /**
     * Set SSL configuration
     */
    public SSLConfiguration getSsl();
    public void setSsl(SSLConfiguration ssl);
}

/**
 * SMTP appender for sending log events via email
 */
public class SMTPAppender extends SMTPAppenderBase<ILoggingEvent> {
    static final String DEFAULT_SUBJECT_PATTERN = "%logger{20} - %m";
    
    private IEvaluator<ILoggingEvent> eventEvaluator;
    private String subjectStr = null;
    private boolean includeCallerData = false;
    
    /**
     * Set the event evaluator for triggering emails
     */
    public IEvaluator<ILoggingEvent> getEvaluator();
    public void setEvaluator(IEvaluator<ILoggingEvent> eventEvaluator);
    
    /**
     * Set the email subject pattern
     */
    public String getSubject();
    public void setSubject(String subject);
    
    /**
     * Enable/disable caller data in emails
     */
    public boolean isIncludeCallerData();
    public void setIncludeCallerData(boolean includeCallerData);
}

/**
 * Base class for SMTP appenders
 */
public abstract class SMTPAppenderBase<E> extends AppenderBase<E> {
    static final int DEFAULT_SMTP_PORT = 25;
    static final int DEFAULT_BUFFER_SIZE = 512;
    
    protected Layout subjectLayout;
    protected String from;
    protected String subjectStr;
    protected String smtpHost;
    protected int smtpPort = DEFAULT_SMTP_PORT;
    protected boolean starttls = false;
    protected boolean ssl = false;
    protected String username;
    protected String password;
    protected String charsetEncoding = "UTF-8";
    protected boolean asynchronousSending = true;
    protected boolean includeCallerData = false;
    protected int bufferSize = DEFAULT_BUFFER_SIZE;
    
    private List<String> toList = new ArrayList<String>();
    
    /**
     * Set SMTP server configuration
     */
    public String getSmtpHost();
    public void setSmtpHost(String smtpHost);
    public int getSmtpPort();
    public void setSmtpPort(int smtpPort);
    
    /**
     * Set authentication
     */
    public String getUsername();
    public void setUsername(String username);
    public String getPassword();
    public void setPassword(String password);
    
    /**
     * Set security options
     */
    public boolean isSTARTTLS();
    public void setSTARTTLS(boolean starttls);
    public boolean isSSL();
    public void setSSL(boolean ssl);
    
    /**
     * Set email addresses
     */
    public void addTo(String to);
    public List<String> getToList();
    public String getFrom();
    public void setFrom(String from);
    
    /**
     * Set message configuration
     */
    public String getSubject();
    public void setSubject(String subject);
    public void setCharsetEncoding(String charsetEncoding);
    public String getCharsetEncoding();
    
    /**
     * Set buffer size (number of events to buffer before sending)
     */
    public int getBufferSize();
    public void setBufferSize(int bufferSize);
    
    /**
     * Enable/disable asynchronous sending
     */
    public boolean isAsynchronousSending();
    public void setAsynchronousSending(boolean asynchronousSending);
}

/**
 * Syslog appender implementing RFC 3164 and RFC 5424
 */
public class SyslogAppender extends AppenderBase<ILoggingEvent> {
    final static String DEFAULT_SUFFIX_PATTERN = "[%thread] %logger %msg";
    final static String DEFAULT_STACKTRACE_PATTERN = "" + CoreConstants.TAB;
    
    Facility facility = Facility.USER;
    String facilityStr; // for configuration via string
    String syslogHost;
    int port = SyslogConstants.SYSLOG_PORT;
    String suffixPattern = DEFAULT_SUFFIX_PATTERN;
    SyslogOutputStream sos;
    int maxMessageSize = SyslogConstants.MAX_MESSAGE_SIZE;
    
    /**
     * Set syslog facility
     */
    public Facility getFacility();
    public void setFacility(Facility facility);
    public String getFacilityAsStr();
    public void setFacilityAsStr(String facilityStr);
    
    /**
     * Set syslog server
     */
    public String getSyslogHost();
    public void setSyslogHost(String syslogHost);
    public int getPort();
    public void setPort(int port);
    
    /**
     * Set message formatting
     */
    public String getSuffixPattern();
    public void setSuffixPattern(String suffixPattern);
    public int getMaxMessageSize();
    public void setMaxMessageSize(int maxMessageSize);
}

/**
 * Syslog facility enumeration
 */
public enum Facility {
    KERN(0), USER(1), MAIL(2), DAEMON(3), AUTH(4), SYSLOG(5),
    LPR(6), NEWS(7), UUCP(8), CRON(9), AUTHPRIV(10), FTP(11),
    NTP(12), AUDIT(13), ALERT(14), CLOCK(15),
    LOCAL0(16), LOCAL1(17), LOCAL2(18), LOCAL3(19),
    LOCAL4(20), LOCAL5(21), LOCAL6(22), LOCAL7(23);
    
    private int code;
    
    public int getCode();
    public static Facility fromCode(int code);
}

/**
 * Simple socket server for testing and development
 */
public class SimpleSocketServer extends ServerSocketReceiver<ILoggingEvent> {
    public static void main(String[] argv) throws Exception;
}

/**
 * SSL socket server
 */
public class SimpleSSLSocketServer {
    public static void main(String[] argv) throws Exception;
}

/**
 * Event pre-serialization transformer for network transport
 */
public class LoggingEventPreSerializationTransformer implements PreSerializationTransformer<ILoggingEvent> {
    public Serializable transform(ILoggingEvent event);
}

/**
 * Socket node for handling individual client connections
 */
public class SocketNode implements Runnable {
    public SocketNode(Socket socket, LoggerContext context);
    public void run();
}

/**
 * Socket acceptor for managing client connections
 */
public class SocketAcceptor extends Thread {
    public SocketAcceptor(ServerSocket serverSocket);
    public void run();
}

import ch.qos.logback.classic.net.*;

// Client-side: Send logs to central server
SocketAppender socketAppender = new SocketAppender();
socketAppender.setContext(loggerContext);
socketAppender.setName("CENTRAL_LOG");
socketAppender.setRemoteHost("log-server.company.com");
socketAppender.setPort(4560);
socketAppender.setReconnectionDelay(Duration.ofSeconds(30));
socketAppender.setIncludeCallerData(false);
socketAppender.start();

// Add to root logger
Logger rootLogger = loggerContext.getLogger(Logger.ROOT_LOGGER_NAME);
rootLogger.addAppender(socketAppender);

// Server-side: Receive logs from clients
SocketReceiver receiver = new SocketReceiver();
receiver.setContext(loggerContext);
receiver.setPort(4560);
receiver.start();

import ch.qos.logback.core.net.ssl.*;

// SSL configuration
SSLConfiguration sslConfig = new SSLConfiguration();
sslConfig.setKeyStore("keystore.jks");
sslConfig.setKeyStorePassword("keystorepass");
sslConfig.setTrustStore("truststore.jks");
sslConfig.setTrustStorePassword("truststorepass");

// SSL socket appender
SSLSocketAppender sslAppender = new SSLSocketAppender();
sslAppender.setContext(loggerContext);
sslAppender.setName("SSL_LOG");
sslAppender.setRemoteHost("secure-log-server.company.com");
sslAppender.setPort(4561);
sslAppender.setSsl(sslConfig);
sslAppender.start();

import ch.qos.logback.classic.boolex.OnErrorEvaluator;

// SMTP appender for critical alerts
SMTPAppender smtpAppender = new SMTPAppender();
smtpAppender.setContext(loggerContext);
smtpAppender.setName("EMAIL_ALERTS");

// SMTP server configuration
smtpAppender.setSmtpHost("smtp.company.com");
smtpAppender.setSmtpPort(587);
smtpAppender.setSTARTTLS(true);
smtpAppender.setUsername("alerts@company.com");
smtpAppender.setPassword("password");

// Email configuration
smtpAppender.setFrom("noreply@company.com");
smtpAppender.addTo("ops-team@company.com");
smtpAppender.addTo("dev-team@company.com");
smtpAppender.setSubject("ALERT: %logger{20} - %m");

// Only send emails for ERROR events
OnErrorEvaluator errorEvaluator = new OnErrorEvaluator();
errorEvaluator.setContext(loggerContext);
errorEvaluator.setName("ErrorEvaluator");
errorEvaluator.start();
smtpAppender.setEvaluator(errorEvaluator);

// HTML layout for better email formatting
HTMLLayout htmlLayout = new HTMLLayout();
htmlLayout.setContext(loggerContext);
htmlLayout.setTitle("Application Error Alert");
htmlLayout.start();
smtpAppender.setLayout(htmlLayout);

smtpAppender.start();

// Add to root logger
rootLogger.addAppender(smtpAppender);

// Syslog appender for Unix/Linux systems
SyslogAppender syslogAppender = new SyslogAppender();
syslogAppender.setContext(loggerContext);
syslogAppender.setName("SYSLOG");
syslogAppender.setSyslogHost("syslog.company.com");
syslogAppender.setPort(514);
syslogAppender.setFacility(Facility.LOCAL0);
syslogAppender.setSuffixPattern("[%thread] %logger{36} %msg");
syslogAppender.start();

// Add threshold filter for syslog
ThresholdFilter syslogFilter = new ThresholdFilter();
syslogFilter.setContext(loggerContext);
syslogFilter.setLevel(Level.INFO);
syslogFilter.start();
syslogAppender.addFilter(syslogFilter);

rootLogger.addAppender(syslogAppender);

// Multiple socket appenders for redundancy
SocketAppender primary = new SocketAppender();
primary.setContext(loggerContext);
primary.setName("PRIMARY_LOG");
primary.setRemoteHost("log1.company.com");
primary.setPort(4560);
primary.start();

SocketAppender secondary = new SocketAppender();
secondary.setContext(loggerContext);
secondary.setName("SECONDARY_LOG");
secondary.setRemoteHost("log2.company.com");
secondary.setPort(4560);
secondary.start();

// Async wrapper for performance
AsyncAppender asyncPrimary = new AsyncAppender();
asyncPrimary.setContext(loggerContext);
asyncPrimary.setName("ASYNC_PRIMARY");
asyncPrimary.setQueueSize(1024);
asyncPrimary.setDiscardingThreshold(20);
asyncPrimary.addAppender(primary);
asyncPrimary.start();

AsyncAppender asyncSecondary = new AsyncAppender();
asyncSecondary.setContext(loggerContext);
asyncSecondary.setName("ASYNC_SECONDARY");
asyncSecondary.setQueueSize(1024);
asyncSecondary.setDiscardingThreshold(20);
asyncSecondary.addAppender(secondary);
asyncSecondary.start();

rootLogger.addAppender(asyncPrimary);
rootLogger.addAppender(asyncSecondary);