--- /dev/null
+/*
+ * 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.
+ */
+
+// Contributors: Dan MacDonald <dan@redknee.com>
+
+package org.apache.log4j.net;
+
+import java.io.IOException;
+import java.io.ObjectOutputStream;
+import java.io.InterruptedIOException;
+import java.net.InetAddress;
+import java.net.Socket;
+
+import org.apache.log4j.AppenderSkeleton;
+import org.apache.log4j.helpers.LogLog;
+import org.apache.log4j.spi.ErrorCode;
+import org.apache.log4j.spi.LoggingEvent;
+
+/**
+ Sends {@link LoggingEvent} objects to a remote a log server,
+ usually a {@link SocketNode}.
+
+ <p>The SocketAppender has the following properties:
+
+ <ul>
+
+ <p><li>If sent to a {@link SocketNode}, remote logging is
+ non-intrusive as far as the log event is concerned. In other
+ words, the event will be logged with the same time stamp, {@link
+ org.apache.log4j.NDC}, location info as if it were logged locally by
+ the client.
+
+ <p><li>SocketAppenders do not use a layout. They ship a
+ serialized {@link LoggingEvent} object to the server side.
+
+ <p><li>Remote logging uses the TCP protocol. Consequently, if
+ the server is reachable, then log events will eventually arrive
+ at the server.
+
+ <p><li>If the remote server is down, the logging requests are
+ simply dropped. However, if and when the server comes back up,
+ then event transmission is resumed transparently. This
+ transparent reconneciton is performed by a <em>connector</em>
+ thread which periodically attempts to connect to the server.
+
+ <p><li>Logging events are automatically <em>buffered</em> by the
+ native TCP implementation. This means that if the link to server
+ is slow but still faster than the rate of (log) event production
+ by the client, the client will not be affected by the slow
+ network connection. However, if the network connection is slower
+ then the rate of event production, then the client can only
+ progress at the network rate. In particular, if the network link
+ to the the server is down, the client will be blocked.
+
+ <p>On the other hand, if the network link is up, but the server
+ is down, the client will not be blocked when making log requests
+ but the log events will be lost due to server unavailability.
+
+ <p><li>Even if a <code>SocketAppender</code> is no longer
+ attached to any category, it will not be garbage collected in
+ the presence of a connector thread. A connector thread exists
+ only if the connection to the server is down. To avoid this
+ garbage collection problem, you should {@link #close} the the
+ <code>SocketAppender</code> explicitly. See also next item.
+
+ <p>Long lived applications which create/destroy many
+ <code>SocketAppender</code> instances should be aware of this
+ garbage collection problem. Most other applications can safely
+ ignore it.
+
+ <p><li>If the JVM hosting the <code>SocketAppender</code> exits
+ before the <code>SocketAppender</code> is closed either
+ explicitly or subsequent to garbage collection, then there might
+ be untransmitted data in the pipe which might be lost. This is a
+ common problem on Windows based systems.
+
+ <p>To avoid lost data, it is usually sufficient to {@link
+ #close} the <code>SocketAppender</code> either explicitly or by
+ calling the {@link org.apache.log4j.LogManager#shutdown} method
+ before exiting the application.
+
+
+ </ul>
+
+ @author Ceki Gülcü
+ @since 0.8.4 */
+
+public class SocketAppender extends AppenderSkeleton {
+
+ /**
+ The default port number of remote logging server (4560).
+ @since 1.2.15
+ */
+ static public final int DEFAULT_PORT = 4560;
+
+ /**
+ The default reconnection delay (30000 milliseconds or 30 seconds).
+ */
+ static final int DEFAULT_RECONNECTION_DELAY = 30000;
+
+ /**
+ We remember host name as String in addition to the resolved
+ InetAddress so that it can be returned via getOption().
+ */
+ String remoteHost;
+
+ /**
+ * The MulticastDNS zone advertised by a SocketAppender
+ */
+ public static final String ZONE = "_log4j_obj_tcpconnect_appender.local.";
+
+ InetAddress address;
+ int port = DEFAULT_PORT;
+ ObjectOutputStream oos;
+ int reconnectionDelay = DEFAULT_RECONNECTION_DELAY;
+ boolean locationInfo = false;
+ private String application;
+
+ private Connector connector;
+
+ int counter = 0;
+
+ // reset the ObjectOutputStream every 70 calls
+ //private static final int RESET_FREQUENCY = 70;
+ private static final int RESET_FREQUENCY = 1;
+ private boolean advertiseViaMulticastDNS;
+ private ZeroConfSupport zeroConf;
+
+ public SocketAppender() {
+ }
+
+ /**
+ Connects to remote server at <code>address</code> and <code>port</code>.
+ */
+ public SocketAppender(InetAddress address, int port) {
+ this.address = address;
+ this.remoteHost = address.getHostName();
+ this.port = port;
+ connect(address, port);
+ }
+
+ /**
+ Connects to remote server at <code>host</code> and <code>port</code>.
+ */
+ public SocketAppender(String host, int port) {
+ this.port = port;
+ this.address = getAddressByName(host);
+ this.remoteHost = host;
+ connect(address, port);
+ }
+
+ /**
+ Connect to the specified <b>RemoteHost</b> and <b>Port</b>.
+ */
+ public void activateOptions() {
+ if (advertiseViaMulticastDNS) {
+ zeroConf = new ZeroConfSupport(ZONE, port, getName());
+ zeroConf.advertise();
+ }
+ connect(address, port);
+ }
+
+ /**
+ * Close this appender.
+ *
+ * <p>This will mark the appender as closed and call then {@link
+ * #cleanUp} method.
+ * */
+ synchronized public void close() {
+ if(closed) {
+ return;
+ }
+
+ this.closed = true;
+ if (advertiseViaMulticastDNS) {
+ zeroConf.unadvertise();
+ }
+
+ cleanUp();
+ }
+
+ /**
+ * Drop the connection to the remote host and release the underlying
+ * connector thread if it has been created
+ * */
+ public void cleanUp() {
+ if(oos != null) {
+ try {
+ oos.close();
+ } catch(IOException e) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ LogLog.error("Could not close oos.", e);
+ }
+ oos = null;
+ }
+ if(connector != null) {
+ //LogLog.debug("Interrupting the connector.");
+ connector.interrupted = true;
+ connector = null; // allow gc
+ }
+ }
+
+ void connect(InetAddress address, int port) {
+ if(this.address == null) {
+ return;
+ }
+ try {
+ // First, close the previous connection if any.
+ cleanUp();
+ oos = new ObjectOutputStream(new Socket(address, port).getOutputStream());
+ } catch(IOException e) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ String msg = "Could not connect to remote log4j server at ["
+ +address.getHostName()+"].";
+ if(reconnectionDelay > 0) {
+ msg += " We will try again later.";
+ fireConnector(); // fire the connector thread
+ } else {
+ msg += " We are not retrying.";
+ errorHandler.error(msg, e, ErrorCode.GENERIC_FAILURE);
+ }
+ LogLog.error(msg);
+ }
+ }
+
+
+ public void append(LoggingEvent event) {
+ if(event == null) {
+ return;
+ }
+
+ if(address==null) {
+ errorHandler.error("No remote host is set for SocketAppender named \""+
+ this.name+"\".");
+ return;
+ }
+
+ if(oos != null) {
+ try {
+
+ if(locationInfo) {
+ event.getLocationInformation();
+ }
+ if (application != null) {
+ event.setProperty("application", application);
+ }
+ event.getNDC();
+ event.getThreadName();
+ event.getMDCCopy();
+ event.getRenderedMessage();
+ event.getThrowableStrRep();
+
+ oos.writeObject(event);
+ //LogLog.debug("=========Flushing.");
+ oos.flush();
+ if(++counter >= RESET_FREQUENCY) {
+ counter = 0;
+ // Failing to reset the object output stream every now and
+ // then creates a serious memory leak.
+ //System.err.println("Doing oos.reset()");
+ oos.reset();
+ }
+ } catch(IOException e) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ oos = null;
+ LogLog.warn("Detected problem with connection: "+e);
+ if(reconnectionDelay > 0) {
+ fireConnector();
+ } else {
+ errorHandler.error("Detected problem with connection, not reconnecting.", e,
+ ErrorCode.GENERIC_FAILURE);
+ }
+ }
+ }
+ }
+
+ public void setAdvertiseViaMulticastDNS(boolean advertiseViaMulticastDNS) {
+ this.advertiseViaMulticastDNS = advertiseViaMulticastDNS;
+ }
+
+ public boolean isAdvertiseViaMulticastDNS() {
+ return advertiseViaMulticastDNS;
+ }
+
+ void fireConnector() {
+ if(connector == null) {
+ LogLog.debug("Starting a new connector thread.");
+ connector = new Connector();
+ connector.setDaemon(true);
+ connector.setPriority(Thread.MIN_PRIORITY);
+ connector.start();
+ }
+ }
+
+ static
+ InetAddress getAddressByName(String host) {
+ try {
+ return InetAddress.getByName(host);
+ } catch(Exception e) {
+ if (e instanceof InterruptedIOException || e instanceof InterruptedException) {
+ Thread.currentThread().interrupt();
+ }
+ LogLog.error("Could not find address of ["+host+"].", e);
+ return null;
+ }
+ }
+
+ /**
+ * The SocketAppender does not use a layout. Hence, this method
+ * returns <code>false</code>.
+ * */
+ public boolean requiresLayout() {
+ return false;
+ }
+
+ /**
+ * The <b>RemoteHost</b> option takes a string value which should be
+ * the host name of the server where a {@link SocketNode} is
+ * running.
+ * */
+ public void setRemoteHost(String host) {
+ address = getAddressByName(host);
+ remoteHost = host;
+ }
+
+ /**
+ Returns value of the <b>RemoteHost</b> option.
+ */
+ public String getRemoteHost() {
+ return remoteHost;
+ }
+
+ /**
+ The <b>Port</b> option takes a positive integer representing
+ the port where the server is waiting for connections.
+ */
+ public void setPort(int port) {
+ this.port = port;
+ }
+
+ /**
+ Returns value of the <b>Port</b> option.
+ */
+ public int getPort() {
+ return port;
+ }
+
+ /**
+ The <b>LocationInfo</b> option takes a boolean value. If true,
+ the information sent to the remote host will include location
+ information. By default no location information is sent to the server.
+ */
+ public void setLocationInfo(boolean locationInfo) {
+ this.locationInfo = locationInfo;
+ }
+
+ /**
+ Returns value of the <b>LocationInfo</b> option.
+ */
+ public boolean getLocationInfo() {
+ return locationInfo;
+ }
+
+ /**
+ * The <b>App</b> option takes a string value which should be the name of the
+ * application getting logged.
+ * If property was already set (via system property), don't set here.
+ * @since 1.2.15
+ */
+ public void setApplication(String lapp) {
+ this.application = lapp;
+ }
+
+ /**
+ * Returns value of the <b>Application</b> option.
+ * @since 1.2.15
+ */
+ public String getApplication() {
+ return application;
+ }
+
+ /**
+ The <b>ReconnectionDelay</b> option takes a positive integer
+ representing the number of milliseconds to wait between each
+ failed connection attempt to the server. The default value of
+ this option is 30000 which corresponds to 30 seconds.
+
+ <p>Setting this option to zero turns off reconnection
+ capability.
+ */
+ public void setReconnectionDelay(int delay) {
+ this.reconnectionDelay = delay;
+ }
+
+ /**
+ Returns value of the <b>ReconnectionDelay</b> option.
+ */
+ public int getReconnectionDelay() {
+ return reconnectionDelay;
+ }
+
+ /**
+ The Connector will reconnect when the server becomes available
+ again. It does this by attempting to open a new connection every
+ <code>reconnectionDelay</code> milliseconds.
+
+ <p>It stops trying whenever a connection is established. It will
+ restart to try reconnect to the server when previously open
+ connection is droppped.
+
+ @author Ceki Gülcü
+ @since 0.8.4
+ */
+ class Connector extends Thread {
+
+ boolean interrupted = false;
+
+ public
+ void run() {
+ Socket socket;
+ while(!interrupted) {
+ try {
+ sleep(reconnectionDelay);
+ LogLog.debug("Attempting connection to "+address.getHostName());
+ socket = new Socket(address, port);
+ synchronized(this) {
+ oos = new ObjectOutputStream(socket.getOutputStream());
+ connector = null;
+ LogLog.debug("Connection established. Exiting connector thread.");
+ break;
+ }
+ } catch(InterruptedException e) {
+ LogLog.debug("Connector interrupted. Leaving loop.");
+ return;
+ } catch(java.net.ConnectException e) {
+ LogLog.debug("Remote host "+address.getHostName()
+ +" refused connection.");
+ } catch(IOException e) {
+ if (e instanceof InterruptedIOException) {
+ Thread.currentThread().interrupt();
+ }
+ LogLog.debug("Could not connect to " + address.getHostName()+
+ ". Exception is " + e);
+ }
+ }
+ //LogLog.debug("Exiting Connector.run() method.");
+ }
+
+ /**
+ public
+ void finalize() {
+ LogLog.debug("Connector finalize() has been called.");
+ }
+ */
+ }
+
+}
git://source.jalview.org / jalview.git / blobdiff