Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * 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;
 
 

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.

Here is a list of the available configuration options:

NameRequirementDescriptionSample Value
PortoptionalThis parameter determines the port to use for announcing log events. The default port is 23 (telnet).5875

Author(s):
Jay Funnell
 
 
 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 {
        = new SocketHandler();
       .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 ;
   }
 
   public
   void setPort(int port) {
     this. = port;
   }


  
shuts down the appender.
  public void close() {
    if ( != null) {
        .close();
        try {
            .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( != null) {
        .send(.format(event));
        if(.ignoresThrowable()) {
            String[] s = event.getThrowableStrRep();
            if (s != null) {
                StringBuffer buf = new StringBuffer();
                for(int i = 0; i < s.lengthi++) {
                    buf.append(s[i]);
                    buf.append("\r\n");
                }
                .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 = .elements();e.hasMoreElements();) {
            try {
                ((Socket)e.nextElement()).close();
            } catch(InterruptedIOException ex) {
                Thread.currentThread().interrupt();
            } catch(IOException ex) {
            } catch(RuntimeException ex) {
            }
        }
      }
      try {
        .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 = .iterator();
      for(Iterator e = .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(!.isClosed()) {
        try {
          Socket newClient = .accept();
          PrintWriter pw = new PrintWriter(newClient.getOutputStream());
          if(.size() < ) {
            synchronized(this) {
                .addElement(newClient);
                .addElement(pw);
                pw.print("TelnetAppender v1.0 (" + .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 (!.isClosed()) {
            LogLog.error("Encountered error while in SocketHandler loop."e);
          }
          break;
        }
      }
      try {
          .close();
      } catch(InterruptedIOException ex) {
          Thread.currentThread().interrupt();
      } catch(IOException ex) {
      }
    }
    public SocketHandler(int portthrows IOException {
       = new ServerSocket(port);
      setName("TelnetAppender-" + getName() + "-" + port);
    }
  }
New to GrepCode? Check out our FAQ X