faheemsohail.com

import javax.jms.DeliveryMode;
import javax.jms.Destination;
import javax.jms.MessageProducer;
import javax.jms.ObjectMessage;
import javax.jms.Session;
 
import org.apache.activemq.ActiveMQConnectionFactory;
import org.apache.log4j.Appender;
import org.apache.log4j.AppenderSkeleton;
import org.apache.log4j.Logger;
import org.apache.log4j.PatternLayout;
import org.apache.log4j.spi.LoggingEvent;
 
/**
 * JMSQueue appender is a log4j appender that writes LoggingEvent to a queue.
 * @author faheem
 *
 */
public class JMSQueueAppender extends AppenderSkeleton implements Appender{
 
private static Logger logger = Logger.getLogger("JMSQueueAppender");
 
private String brokerUri;
private String queueName;
 
@Override
public void close() {
 
}
 
@Override
public boolean requiresLayout() {
	return false;
}
 
@Override
protected synchronized void append(LoggingEvent event) {
 
   try {
 
     ActiveMQConnectionFactory connectionFactory = new ActiveMQConnectionFactory(
					this.brokerUri);
 
     // Create a Connection
     javax.jms.Connection connection = connectionFactory.createConnection();
     connection.start();
 
     // Create a Session
     Session session = connection.createSession(false,Session.AUTO_ACKNOWLEDGE);
 
     // Create the destination (Topic or Queue)
     Destination destination = session.createQueue(this.queueName);
 
     // Create a MessageProducer from the Session to the Topic or Queue
     MessageProducer producer = session.createProducer(destination);
     producer.setDeliveryMode(DeliveryMode.NON_PERSISTENT);
 
     ObjectMessage message = session.createObjectMessage(new LoggingEventWrapper(event));
 
     // Tell the producer to send the message
     producer.send(message);
 
     // Clean up
     session.close();
     connection.close();
  } catch (Exception e) {
     e.printStackTrace();
  }
}
 
public void setBrokerUri(String brokerUri) {
	this.brokerUri = brokerUri;
}
 
public String getBrokerUri() {
	return brokerUri;
}
 
public void setQueueName(String queueName) {
	this.queueName = queueName;
}
 
public String getQueueName() {
	return queueName;
}
}

import java.io.Serializable;
import java.net.InetAddress;
import java.net.UnknownHostException;
 
import org.apache.log4j.EnhancedPatternLayout;
import org.apache.log4j.spi.LoggingEvent;
 
/**
 * Logging Event Wraps a log4j LoggingEvent object. Wrapping is required by some information is lost
 * when the LoggingEvent is serialized. The idea is to extract all information required from the LoggingEvent
 * object, place it in the wrapper and then serialize the LoggingEventWrapper. This way all required data remains
 * available to us.
 * @author faheem
 *
 */
 
public class LoggingEventWrapper implements Serializable{
 
	private static final String ENHANCED_PATTERN_LAYOUT = "%throwable";
	private static final long serialVersionUID = 3281981073249085474L;
	private LoggingEvent loggingEvent;
 
	private Long timeStamp;
	private String level;
	private String logger;
	private String message;
	private String detail;
	private String ipAddress;
	private String hostName;
 
	public LoggingEventWrapper(LoggingEvent loggingEvent){
		this.loggingEvent = loggingEvent;
 
		//Format event and set detail field
	    EnhancedPatternLayout layout = new EnhancedPatternLayout();
	    layout.setConversionPattern(ENHANCED_PATTERN_LAYOUT);
	    this.detail = layout.format(this.loggingEvent);
	}
 
	public Long getTimeStamp() {
		return this.loggingEvent.timeStamp;
	}
 
	public String getLevel() {
		return this.loggingEvent.getLevel().toString();
	}
 
	public String getLogger() {
		return this.loggingEvent.getLoggerName();
	}
 
	public String getMessage() {
		return this.loggingEvent.getRenderedMessage();
	}
 
	public String getDetail() {
	    return this.detail;
	}
 
	public LoggingEvent getLoggingEvent() {
		return loggingEvent;
	}
 
	public String getIpAddress() {
		try {
			return InetAddress.getLocalHost().getHostAddress();
		} catch (UnknownHostException e) {
			return "Could not determine IP";
		}
	}
 
	public String getHostName() {
		try {
			return InetAddress.getLocalHost().getHostName();
		} catch (UnknownHostException e) {
			return "Could not determine Host Name";
		}
	}
}

import javax.jms.JMSException;
import javax.jms.Message;
import javax.jms.MessageListener;
import javax.jms.ObjectMessage;
 
import org.apache.log4j.Logger;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
 
@Component
public class LogQueueListener implements MessageListener
{
	public static Logger logger = Logger.getLogger(LogQueueListener.class);
 
	@Autowired
	private ILoggingService loggingService;
 
    public void onMessage( final Message message )
    {
        if ( message instanceof ObjectMessage )
        {
            try{
        	    final LoggingEventWrapper loggingEventWrapper = (LoggingEventWrapper)((ObjectMessage) message).getObject();
        	    loggingService.saveLog(loggingEventWrapper);
            }
            catch (final JMSException e)
            {
                logger.error(e.getMessage(), e);
            } catch (Exception e) {
		logger.error(e.getMessage(),e);
	    }
        }
    }
}

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:p="http://www.springframework.org/schema/p"
	xmlns:context="http://www.springframework.org/schema/context"
	xmlns:jms="http://www.springframework.org/schema/jms"
    xmlns:amq="http://activemq.apache.org/schema/core"
	xmlns:aop="http://www.springframework.org/schema/aop"
	xsi:schemaLocation="http://www.springframework.org/schema/beans
		http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
		http://www.springframework.org/schema/context
		http://www.springframework.org/schema/context/spring-context-3.0.xsd
		http://www.springframework.org/schema/aop
		http://www.springframework.org/schema/aop/spring-aop-3.0.xsd
		http://www.springframework.org/schema/jms
		http://www.springframework.org/schema/jms/spring-jms-3.0.xsd
		http://activemq.apache.org/schema/core
		http://activemq.apache.org/schema/core/activemq-core-5.5.0.xsd"
	>
 
	<!-- lets create an embedded ActiveMQ Broker -->
	<!-- uncomment the tag below only if you need to create an embedded broker -->
 
	<!-- amq:broker useJmx="false" persistent="false">
		<amq:transportConnectors>
			<amq:transportConnector uri="tcp://localhost:61616" />
		</amq:transportConnectors>
	</amq:broker-->
 
	<!-- ActiveMQ destinations to use -->
	<amq:queue id="destination" physicalName="logQueue" />
 
	<!-- JMS ConnectionFactory to use, configuring the embedded broker using XML -->
	<amq:connectionFactory id="jmsFactory" brokerURL="tcp://localhost:61616" />
 
	<bean id="connectionFactory"
		class="org.springframework.jms.connection.CachingConnectionFactory">
		<constructor-arg ref="jmsFactory" />
		<property name="exceptionListener" ref="JMSExceptionListener" />
		<property name="sessionCacheSize" value="100" />
	</bean>
 
	<!-- Spring JMS Template -->
	<bean id="jmsTemplate" class="org.springframework.jms.core.JmsTemplate">
		<constructor-arg ref="connectionFactory" />
	</bean>
 
	<!-- listener container definition using the jms namespace, concurrency
		is the max number of concurrent listeners that can be started -->
	<jms:listener-container concurrency="10">
		<jms:listener id="QueueListener" destination="logQueue" ref="logQueueListener" />
	</jms:listener-container>
 
</beans>