0
# Network Logging
1

2
Remote logging capabilities including socket appenders, receivers, email alerts, and network server components. These components enable distributed logging across multiple systems and applications.
3

4
## Capabilities
5

6
### Socket Appenders
7

8
TCP socket-based appenders for remote logging to centralized log servers.
9

10
```java { .api }
11
/**
12
 * TCP socket appender for remote logging
13
 */
14
public class SocketAppender extends AppenderBase<ILoggingEvent> {
15
    static final int DEFAULT_RECONNECTION_DELAY = 30000;
16
    static final int DEFAULT_QUEUE_SIZE = 128;
17
    
18
    private String remoteHost;
19
    private int port;
20
    private InetAddress address;
21
    private int reconnectionDelay = DEFAULT_RECONNECTION_DELAY;
22
    private int queueSize = DEFAULT_QUEUE_SIZE;
23
    private boolean includeCallerData = false;
24
    
25
    /**
26
     * Set the remote host to connect to
27
     */
28
    public void setRemoteHost(String host);
29
    public String getRemoteHost();
30
    
31
    /**
32
     * Set the port number
33
     */
34
    public void setPort(int port);
35
    public int getPort();
36
    
37
    /**
38
     * Set reconnection delay in milliseconds
39
     */
40
    public void setReconnectionDelay(Duration delay);
41
    public Duration getReconnectionDelay();
42
    
43
    /**
44
     * Set internal queue size
45
     */
46
    public void setQueueSize(int queueSize);
47
    public int getQueueSize();
48
    
49
    /**
50
     * Enable/disable caller data inclusion (expensive)
51
     */
52
    public boolean isIncludeCallerData();
53
    public void setIncludeCallerData(boolean includeCallerData);
54
}
55

56
/**
57
 * SSL-secured socket appender
58
 */
59
public class SSLSocketAppender extends SocketAppender implements SSLComponent {
60
    private SSLConfiguration ssl;
61
    private SocketFactory socketFactory;
62
    
63
    /**
64
     * Set SSL configuration
65
     */
66
    public SSLConfiguration getSsl();
67
    public void setSsl(SSLConfiguration ssl);
68
    
69
    /**
70
     * Set custom socket factory
71
     */
72
    public void setSocketFactory(SocketFactory socketFactory);
73
    public SocketFactory getSocketFactory();
74
}
75
```
76

77
**Usage Examples:**
78

79
```java
80
import ch.qos.logback.classic.net.SocketAppender;
81

82
// Create socket appender
83
SocketAppender socketAppender = new SocketAppender();
84
socketAppender.setContext(loggerContext);
85
socketAppender.setName("SOCKET");
86
socketAppender.setRemoteHost("log-server.example.com");
87
socketAppender.setPort(4560);
88
socketAppender.setReconnectionDelay(Duration.ofSeconds(30));
89
socketAppender.setIncludeCallerData(false); // For performance
90
socketAppender.start();
91

92
// Add to logger
93
Logger logger = loggerContext.getLogger("com.example.app");
94
logger.addAppender(socketAppender);
95
```
96

97
### Socket Receivers
98

99
TCP socket receivers for accepting log events from remote appenders.
100

101
```java { .api }
102
/**
103
 * TCP socket receiver for accepting remote log events
104
 */
105
public class SocketReceiver extends ReceiverBase implements Runnable {
106
    public static final int DEFAULT_ACCEPT_CONNECTION_DELAY = 5000;
107
    
108
    private String address;
109
    private int port;
110
    private int backlog = 50;
111
    private int acceptConnectionTimeout = DEFAULT_ACCEPT_CONNECTION_DELAY;
112
    
113
    /**
114
     * Set the local address to bind to
115
     */
116
    public String getAddress();
117
    public void setAddress(String address);
118
    
119
    /**
120
     * Set the port to listen on
121
     */
122
    public int getPort();
123
    public void setPort(int port);
124
    
125
    /**
126
     * Set the backlog for the server socket
127
     */
128
    public int getBacklog();
129
    public void setBacklog(int backlog);
130
    
131
    /**
132
     * Set accept connection timeout
133
     */
134
    public int getAcceptConnectionTimeout();
135
    public void setAcceptConnectionTimeout(int acceptConnectionTimeout);
136
}
137

138
/**
139
 * SSL-secured socket receiver
140
 */
141
public class SSLSocketReceiver extends SocketReceiver implements SSLComponent {
142
    private SSLConfiguration ssl;
143
    
144
    /**
145
     * Set SSL configuration
146
     */
147
    public SSLConfiguration getSsl();
148
    public void setSsl(SSLConfiguration ssl);
149
}
150

151
/**
152
 * Base class for all receivers
153
 */
154
public abstract class ReceiverBase extends ContextAwareBase implements LifeCycle {
155
    protected boolean started;
156
    
157
    public boolean isStarted();
158
    public void start();
159
    public void stop();
160
}
161
```
162

163
### Server Socket Appenders
164

165
Server-side components that accept connections from client applications.
166

167
```java { .api }
168
/**
169
 * Server socket appender that accepts client connections
170
 */
171
public class ServerSocketAppender extends AppenderBase<ILoggingEvent> {
172
    public static final int DEFAULT_BACKLOG = 50;
173
    public static final int DEFAULT_CLIENT_QUEUE_SIZE = 100;
174
    
175
    private int port;
176
    private int backlog = DEFAULT_BACKLOG;
177
    private int clientQueueSize = DEFAULT_CLIENT_QUEUE_SIZE;
178
    private String address;
179
    private boolean includeCallerData;
180
    
181
    /**
182
     * Set the port to listen on
183
     */
184
    public int getPort();
185
    public void setPort(int port);
186
    
187
    /**
188
     * Set the address to bind to
189
     */
190
    public String getAddress();
191
    public void setAddress(String address);
192
    
193
    /**
194
     * Set the server socket backlog
195
     */
196
    public int getBacklog();
197
    public void setBacklog(int backlog);
198
    
199
    /**
200
     * Set queue size for each client connection
201
     */
202
    public int getClientQueueSize();
203
    public void setClientQueueSize(int clientQueueSize);
204
    
205
    /**
206
     * Enable/disable caller data inclusion
207
     */
208
    public boolean isIncludeCallerData();
209
    public void setIncludeCallerData(boolean includeCallerData);
210
}
211

212
/**
213
 * SSL-secured server socket appender
214
 */
215
public class SSLServerSocketAppender extends ServerSocketAppender implements SSLComponent {
216
    private SSLConfiguration ssl;
217
    
218
    /**
219
     * Set SSL configuration
220
     */
221
    public SSLConfiguration getSsl();
222
    public void setSsl(SSLConfiguration ssl);
223
}
224
```
225

226
### SMTP Appender
227

228
Email-based appender for critical alerts and notifications.
229

230
```java { .api }
231
/**
232
 * SMTP appender for sending log events via email
233
 */
234
public class SMTPAppender extends SMTPAppenderBase<ILoggingEvent> {
235
    static final String DEFAULT_SUBJECT_PATTERN = "%logger{20} - %m";
236
    
237
    private IEvaluator<ILoggingEvent> eventEvaluator;
238
    private String subjectStr = null;
239
    private boolean includeCallerData = false;
240
    
241
    /**
242
     * Set the event evaluator for triggering emails
243
     */
244
    public IEvaluator<ILoggingEvent> getEvaluator();
245
    public void setEvaluator(IEvaluator<ILoggingEvent> eventEvaluator);
246
    
247
    /**
248
     * Set the email subject pattern
249
     */
250
    public String getSubject();
251
    public void setSubject(String subject);
252
    
253
    /**
254
     * Enable/disable caller data in emails
255
     */
256
    public boolean isIncludeCallerData();
257
    public void setIncludeCallerData(boolean includeCallerData);
258
}
259

260
/**
261
 * Base class for SMTP appenders
262
 */
263
public abstract class SMTPAppenderBase<E> extends AppenderBase<E> {
264
    static final int DEFAULT_SMTP_PORT = 25;
265
    static final int DEFAULT_BUFFER_SIZE = 512;
266
    
267
    protected Layout subjectLayout;
268
    protected String from;
269
    protected String subjectStr;
270
    protected String smtpHost;
271
    protected int smtpPort = DEFAULT_SMTP_PORT;
272
    protected boolean starttls = false;
273
    protected boolean ssl = false;
274
    protected String username;
275
    protected String password;
276
    protected String charsetEncoding = "UTF-8";
277
    protected boolean asynchronousSending = true;
278
    protected boolean includeCallerData = false;
279
    protected int bufferSize = DEFAULT_BUFFER_SIZE;
280
    
281
    private List<String> toList = new ArrayList<String>();
282
    
283
    /**
284
     * Set SMTP server configuration
285
     */
286
    public String getSmtpHost();
287
    public void setSmtpHost(String smtpHost);
288
    public int getSmtpPort();
289
    public void setSmtpPort(int smtpPort);
290
    
291
    /**
292
     * Set authentication
293
     */
294
    public String getUsername();
295
    public void setUsername(String username);
296
    public String getPassword();
297
    public void setPassword(String password);
298
    
299
    /**
300
     * Set security options
301
     */
302
    public boolean isSTARTTLS();
303
    public void setSTARTTLS(boolean starttls);
304
    public boolean isSSL();
305
    public void setSSL(boolean ssl);
306
    
307
    /**
308
     * Set email addresses
309
     */
310
    public void addTo(String to);
311
    public List<String> getToList();
312
    public String getFrom();
313
    public void setFrom(String from);
314
    
315
    /**
316
     * Set message configuration
317
     */
318
    public String getSubject();
319
    public void setSubject(String subject);
320
    public void setCharsetEncoding(String charsetEncoding);
321
    public String getCharsetEncoding();
322
    
323
    /**
324
     * Set buffer size (number of events to buffer before sending)
325
     */
326
    public int getBufferSize();
327
    public void setBufferSize(int bufferSize);
328
    
329
    /**
330
     * Enable/disable asynchronous sending
331
     */
332
    public boolean isAsynchronousSending();
333
    public void setAsynchronousSending(boolean asynchronousSending);
334
}
335
```
336

337
### Syslog Appender
338

339
Syslog protocol support for integration with system logging infrastructure.
340

341
```java { .api }
342
/**
343
 * Syslog appender implementing RFC 3164 and RFC 5424
344
 */
345
public class SyslogAppender extends AppenderBase<ILoggingEvent> {
346
    final static String DEFAULT_SUFFIX_PATTERN = "[%thread] %logger %msg";
347
    final static String DEFAULT_STACKTRACE_PATTERN = "" + CoreConstants.TAB;
348
    
349
    Facility facility = Facility.USER;
350
    String facilityStr; // for configuration via string
351
    String syslogHost;
352
    int port = SyslogConstants.SYSLOG_PORT;
353
    String suffixPattern = DEFAULT_SUFFIX_PATTERN;
354
    SyslogOutputStream sos;
355
    int maxMessageSize = SyslogConstants.MAX_MESSAGE_SIZE;
356
    
357
    /**
358
     * Set syslog facility
359
     */
360
    public Facility getFacility();
361
    public void setFacility(Facility facility);
362
    public String getFacilityAsStr();
363
    public void setFacilityAsStr(String facilityStr);
364
    
365
    /**
366
     * Set syslog server
367
     */
368
    public String getSyslogHost();
369
    public void setSyslogHost(String syslogHost);
370
    public int getPort();
371
    public void setPort(int port);
372
    
373
    /**
374
     * Set message formatting
375
     */
376
    public String getSuffixPattern();
377
    public void setSuffixPattern(String suffixPattern);
378
    public int getMaxMessageSize();
379
    public void setMaxMessageSize(int maxMessageSize);
380
}
381

382
/**
383
 * Syslog facility enumeration
384
 */
385
public enum Facility {
386
    KERN(0), USER(1), MAIL(2), DAEMON(3), AUTH(4), SYSLOG(5),
387
    LPR(6), NEWS(7), UUCP(8), CRON(9), AUTHPRIV(10), FTP(11),
388
    NTP(12), AUDIT(13), ALERT(14), CLOCK(15),
389
    LOCAL0(16), LOCAL1(17), LOCAL2(18), LOCAL3(19),
390
    LOCAL4(20), LOCAL5(21), LOCAL6(22), LOCAL7(23);
391
    
392
    private int code;
393
    
394
    public int getCode();
395
    public static Facility fromCode(int code);
396
}
397
```
398

399
### Network Utilities
400

401
Utility classes for network logging operations.
402

403
```java { .api }
404
/**
405
 * Simple socket server for testing and development
406
 */
407
public class SimpleSocketServer extends ServerSocketReceiver<ILoggingEvent> {
408
    public static void main(String[] argv) throws Exception;
409
}
410

411
/**
412
 * SSL socket server
413
 */
414
public class SimpleSSLSocketServer {
415
    public static void main(String[] argv) throws Exception;
416
}
417

418
/**
419
 * Event pre-serialization transformer for network transport
420
 */
421
public class LoggingEventPreSerializationTransformer implements PreSerializationTransformer<ILoggingEvent> {
422
    public Serializable transform(ILoggingEvent event);
423
}
424

425
/**
426
 * Socket node for handling individual client connections
427
 */
428
public class SocketNode implements Runnable {
429
    public SocketNode(Socket socket, LoggerContext context);
430
    public void run();
431
}
432

433
/**
434
 * Socket acceptor for managing client connections
435
 */
436
public class SocketAcceptor extends Thread {
437
    public SocketAcceptor(ServerSocket serverSocket);
438
    public void run();
439
}
440
```
441

442
## Usage Examples
443

444
### Centralized Logging Setup
445

446
```java
447
import ch.qos.logback.classic.net.*;
448

449
// Client-side: Send logs to central server
450
SocketAppender socketAppender = new SocketAppender();
451
socketAppender.setContext(loggerContext);
452
socketAppender.setName("CENTRAL_LOG");
453
socketAppender.setRemoteHost("log-server.company.com");
454
socketAppender.setPort(4560);
455
socketAppender.setReconnectionDelay(Duration.ofSeconds(30));
456
socketAppender.setIncludeCallerData(false);
457
socketAppender.start();
458

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

463
// Server-side: Receive logs from clients
464
SocketReceiver receiver = new SocketReceiver();
465
receiver.setContext(loggerContext);
466
receiver.setPort(4560);
467
receiver.start();
468
```
469

470
### SSL Secure Logging
471

472
```java
473
import ch.qos.logback.core.net.ssl.*;
474

475
// SSL configuration
476
SSLConfiguration sslConfig = new SSLConfiguration();
477
sslConfig.setKeyStore("keystore.jks");
478
sslConfig.setKeyStorePassword("keystorepass");
479
sslConfig.setTrustStore("truststore.jks");
480
sslConfig.setTrustStorePassword("truststorepass");
481

482
// SSL socket appender
483
SSLSocketAppender sslAppender = new SSLSocketAppender();
484
sslAppender.setContext(loggerContext);
485
sslAppender.setName("SSL_LOG");
486
sslAppender.setRemoteHost("secure-log-server.company.com");
487
sslAppender.setPort(4561);
488
sslAppender.setSsl(sslConfig);
489
sslAppender.start();
490
```
491

492
### Email Alerts for Critical Errors
493

494
```java
495
import ch.qos.logback.classic.boolex.OnErrorEvaluator;
496

497
// SMTP appender for critical alerts
498
SMTPAppender smtpAppender = new SMTPAppender();
499
smtpAppender.setContext(loggerContext);
500
smtpAppender.setName("EMAIL_ALERTS");
501

502
// SMTP server configuration
503
smtpAppender.setSmtpHost("smtp.company.com");
504
smtpAppender.setSmtpPort(587);
505
smtpAppender.setSTARTTLS(true);
506
smtpAppender.setUsername("alerts@company.com");
507
smtpAppender.setPassword("password");
508

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

515
// Only send emails for ERROR events
516
OnErrorEvaluator errorEvaluator = new OnErrorEvaluator();
517
errorEvaluator.setContext(loggerContext);
518
errorEvaluator.setName("ErrorEvaluator");
519
errorEvaluator.start();
520
smtpAppender.setEvaluator(errorEvaluator);
521

522
// HTML layout for better email formatting
523
HTMLLayout htmlLayout = new HTMLLayout();
524
htmlLayout.setContext(loggerContext);
525
htmlLayout.setTitle("Application Error Alert");
526
htmlLayout.start();
527
smtpAppender.setLayout(htmlLayout);
528

529
smtpAppender.start();
530

531
// Add to root logger
532
rootLogger.addAppender(smtpAppender);
533
```
534

535
### Syslog Integration
536

537
```java
538
// Syslog appender for Unix/Linux systems
539
SyslogAppender syslogAppender = new SyslogAppender();
540
syslogAppender.setContext(loggerContext);
541
syslogAppender.setName("SYSLOG");
542
syslogAppender.setSyslogHost("syslog.company.com");
543
syslogAppender.setPort(514);
544
syslogAppender.setFacility(Facility.LOCAL0);
545
syslogAppender.setSuffixPattern("[%thread] %logger{36} %msg");
546
syslogAppender.start();
547

548
// Add threshold filter for syslog
549
ThresholdFilter syslogFilter = new ThresholdFilter();
550
syslogFilter.setContext(loggerContext);
551
syslogFilter.setLevel(Level.INFO);
552
syslogFilter.start();
553
syslogAppender.addFilter(syslogFilter);
554

555
rootLogger.addAppender(syslogAppender);
556
```
557

558
### High-Availability Logging
559

560
```java
561
// Multiple socket appenders for redundancy
562
SocketAppender primary = new SocketAppender();
563
primary.setContext(loggerContext);
564
primary.setName("PRIMARY_LOG");
565
primary.setRemoteHost("log1.company.com");
566
primary.setPort(4560);
567
primary.start();
568

569
SocketAppender secondary = new SocketAppender();
570
secondary.setContext(loggerContext);
571
secondary.setName("SECONDARY_LOG");
572
secondary.setRemoteHost("log2.company.com");
573
secondary.setPort(4560);
574
secondary.start();
575

576
// Async wrapper for performance
577
AsyncAppender asyncPrimary = new AsyncAppender();
578
asyncPrimary.setContext(loggerContext);
579
asyncPrimary.setName("ASYNC_PRIMARY");
580
asyncPrimary.setQueueSize(1024);
581
asyncPrimary.setDiscardingThreshold(20);
582
asyncPrimary.addAppender(primary);
583
asyncPrimary.start();
584

585
AsyncAppender asyncSecondary = new AsyncAppender();
586
asyncSecondary.setContext(loggerContext);
587
asyncSecondary.setName("ASYNC_SECONDARY");
588
asyncSecondary.setQueueSize(1024);
589
asyncSecondary.setDiscardingThreshold(20);
590
asyncSecondary.addAppender(secondary);
591
asyncSecondary.start();
592

593
rootLogger.addAppender(asyncPrimary);
594
rootLogger.addAppender(asyncSecondary);
595
```