Mule ESB comes with a number of JMX Agents: http://www.mulesoft.org/documentation/display/MULE3USER/JMX+Management. These give some great insight in the system. At our client this info is already being used to display statistics in Zabbix, not only from Mule but also from HornetQ JMS. Zabbix is used to monitor the Average service execution times, JMS Queue depth, memory usage, CPU usage and so on.
These agents however do not expose the information that we want so we we need to write our own.
But first we need to collect the statistics For this we created a statistics object that will keep track of the number of calls, minimum, maximum and average duration and also the average of the last 500 calls. This last metric allows us to have an average which does show peaks over time. To capture the call and add the call info to our statistics object we used AOP:
@Around("execThirdPartyCall")
public Object execute(ProceedingJoinPoint pjp) throws Throwable{
long timeBefore = System.currentTimeMillis();
Object result = pjp.proceed();
try{
getStatistics(pjp).addMuleCallInfo(
System.currentTimeMillis() - timeBefore);
}catch(Exception e){
LOGGER.error("Error adding MuleCallInfo to Statistics Object.",e);
}
return result;
}So now we come to the main part of this post: how to create an MBean and register it to the Mule MBeanServer. I've worked with Spring and MBeans before and I do like the annotation driven mechanisms that Spring offers for auto registrating your MBeans.
Mule however does not use annotations but a method that is more reflection based. The main class in Mule that provides this logic is org.mule.module.management.agent.ClassloaderSwitchingMBeanWrapper. This class needs an interface for introspection and a concrete class in order to create an MBean instance.
The first thing you do is create an interface that will define the MBean attributes and methods. In the example there are 4 read-only attributes. The JMX_PREFIX will be used later on to define the JMX objectName:
public interface StatisticsMBean {
String DEFAULT_JMX_PREFIX = "type=Thirdparty.Statistics,name=";
long getHttpCallLast500Average();
long getHttpCallLast500Minimum();
long getHttpCallLast500Maximum();
int getTotalNumberOfCalls();
}public final class StatisticsService implements StatisticsMBean {
private Statistics Statistics;
public StatisticsService(Statistics statistics) {
this.statistics = statistics;
}
@Override
public long getHttpCallLast500Average() {
return statistics.getAvgLast500HttpCall();
}
@Override
public long getHttpCallLast500Minimum() {
return statistics.getMinLast500HttpCall();
}
@Override
public long getHttpCallLast500Maximum() {
return statistics.getMaxLast500HttpCall();
}
@Override
public int getTotalNumberOfCalls() {
return statistics.getTotalCallsMuleCall();
}
}
- the fields are missing and also some methods that are left empty anyway
- only the registerMbean part is in here, if you have some fancy hot deploy setup, you'll need to provide an unregisterMBean part
- a MuleContextListener is used to make sure that Spring has finished initializing before doing any work
- the Statistics object below is an Enum, because we keep statistics for multiple third parties
public final class StatisticsAgent extends AbstractAgent {
@Override
public void initialise() throws InitialisationException {
if (initialized.get()) {
return;
}
//get mbeanserver
if (mBeanServer == null) {
mBeanServer = ManagementFactory.getPlatformMBeanServer();
}
if (mBeanServer == null) {
throw new InitialisationException(
ManagementMessages.cannotLocateOrCreateServer(), this);
}
try {
// We need to register all the services once the server has initialised
muleContext.registerListener(new MuleContextStartedListener());
} catch (NotificationException e) {
throw new InitialisationException(e, this);
}
initialized.compareAndSet(false, true);
}
protected class MuleContextStartedListener implements
MuleContextNotificationListener {
public void onNotification(MuleContextNotification notification) {
if (notification.getAction() == MuleContextNotification.CONTEXT_STARTED) {
try {
registerMBeans();
} catch (Exception e) {
throw new MuleRuntimeException(
CoreMessages.objectFailedToInitialise("MBeans"), e);
}
}
}
}
private void registerMBeans() throws MalformedObjectNameException,
NotCompliantMBeanException, InstanceAlreadyExistsException, MBeanRegistrationException {
Statistics[] statisticsAr = Statistics.values();
for (Statistics statistics : statisticsAr) {
ObjectName on = jmxSupport.getObjectName(
String.format("%s:%s",
jmxSupport.getDomainName(muleContext, false),
StatisticsMBean.DEFAULT_JMX_PREFIX + statistics.name())
);
StatisticsService statisticsService = new StatisticsService(statistics);
ClassloaderSwitchingMBeanWrapper mBean = new ClassloaderSwitchingMBeanWrapper(
statisticsService,
StatisticsMBean.class,
muleContext.getExecutionClassLoader()
);
logger.debug("Registering StatisticsAgent with name: " + on);
mBeanServer.registerMBean(mBean, on);
}
}
}
<mule>
<custom-agent class="management.StatisticsAgent" name="statistics-agent"/>
</mule>
And that's it, once you start up Mule, you will see your custom agent appearing and your MBeans are available via JMX.
That is how our operations guys can now provide a nice screen with the call durations over time:
Author: Jeroen Verellen
