TelnetAppender.java
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.log4j.net;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.helpers.LogLog;
import org.apache.log4j.spi.LoggingEvent;
import java.io.IOException;
import java.io.PrintWriter;
import java.io.InterruptedIOException;
import java.net.ServerSocket;
import java.net.Socket;
import java.util.Enumeration;
import java.util.Iterator;
import java.util.Vector;
/**
* <p>
* The TelnetAppender is a log4j appender that specializes in writing to a read-only socket. The output is provided in a
* telnet-friendly way so that a log can be monitored over TCP/IP. Clients using telnet connect to the socket and
* receive log data. This is handy for remote monitoring, especially when monitoring a servlet.
*
* <p>
* Here is a list of the available configuration options:
*
* <table border=1>
* <tr>
* <th>Name</th>
* <th>Requirement</th>
* <th>Description</th>
* <th>Sample Value</th>
* </tr>
*
* <tr>
* <td>Port</td>
* <td>optional</td>
* <td>This parameter determines the port to use for announcing log events. The
* default port is 23 (telnet).</td>
* <td>5875</td>
* </table>
*
* @author <a HREF="mailto:jay@v-wave.com">Jay Funnell</a>
*/
public class TelnetAppender extends AppenderSkeleton {
private SocketHandler sh;
private int port = 23;
/**
* This appender requires a layout to format the text to the attached client(s).
*/
public boolean requiresLayout() {
return true;
}
/**
* all of the options have been set, create the socket handler and wait for connections.
*/
public void activateOptions() {
try {
sh = new SocketHandler(port);
sh.start();
} catch (InterruptedIOException e) {
Thread.currentThread().interrupt();
e.printStackTrace();
} catch (IOException e) {
e.printStackTrace();
} catch (RuntimeException e) {
e.printStackTrace();
}
super.activateOptions();
}
public int getPort() {
return port;
}
public void setPort(int port) {
this.port = port;
}
/**
* shuts down the appender.
*/
public void close() {
if (sh != null) {
sh.close();
try {
sh.join();
} catch (InterruptedException ex) {
Thread.currentThread().interrupt();
}
}
}
/**
* Handles a log event. For this appender, that means writing the message to each connected client.
*/
protected void append(LoggingEvent event) {
if (sh != null) {
sh.send(layout.format(event));
if (layout.ignoresThrowable()) {
String[] s = event.getThrowableStrRep();
if (s != null) {
StringBuilder buf = new StringBuilder();
for (int i = 0; i < s.length; i++) {
buf.append(s[i]);
buf.append("\r\n");
}
sh.send(buf.toString());
}
}
}
}
// ---------------------------------------------------------- SocketHandler:
/**
* The SocketHandler class is used to accept connections from clients. It is threaded so that clients can
* connect/disconnect asynchronously.
*/
protected class SocketHandler extends Thread {
private Vector writers = new Vector();
private Vector connections = new Vector();
private ServerSocket serverSocket;
private int MAX_CONNECTIONS = 20;
public void finalize() {
close();
}
/**
* make sure we close all network connections when this handler is destroyed.
*
* @since 1.2.15
*/
public void close() {
synchronized (this) {
for (Enumeration e = connections.elements(); e.hasMoreElements(); ) {
try {
((Socket) e.nextElement()).close();
} catch (InterruptedIOException ex) {
Thread.currentThread().interrupt();
} catch (IOException ex) {
} catch (RuntimeException ex) {
}
}
}
try {
serverSocket.close();
} catch (InterruptedIOException ex) {
Thread.currentThread().interrupt();
} catch (IOException ex) {
} catch (RuntimeException ex) {
}
}
/**
* sends a message to each of the clients in telnet-friendly output.
*/
public synchronized void send(final String message) {
Iterator ce = connections.iterator();
for (Iterator e = writers.iterator(); e.hasNext(); ) {
ce.next();
PrintWriter writer = (PrintWriter) e.next();
writer.print(message);
if (writer.checkError()) {
ce.remove();
e.remove();
}
}
}
/**
* Continually accepts client connections. Client connections are refused when MAX_CONNECTIONS is reached.
*/
public void run() {
while (!serverSocket.isClosed()) {
try {
Socket newClient = serverSocket.accept();
PrintWriter pw = new PrintWriter(newClient.getOutputStream());
if (connections.size() < MAX_CONNECTIONS) {
synchronized (this) {
connections.addElement(newClient);
writers.addElement(pw);
pw.print("TelnetAppender v1.0 (" + connections.size() + " active connections)\r\n\r\n");
pw.flush();
}
} else {
pw.print("Too many connections.\r\n");
pw.flush();
newClient.close();
}
} catch (Exception e) {
if (e instanceof InterruptedIOException || e instanceof InterruptedException) {
Thread.currentThread().interrupt();
}
if (!serverSocket.isClosed()) {
LogLog.error("Encountered error while in SocketHandler loop.", e);
}
break;
}
}
try {
serverSocket.close();
} catch (InterruptedIOException ex) {
Thread.currentThread().interrupt();
} catch (IOException ex) {
}
}
public SocketHandler(int port) throws IOException {
serverSocket = new ServerSocket(port);
setName("TelnetAppender-" + getName() + "-" + port);
}
}
}