In this blog post I go step-to-step through a solution that analyzes the xml file and plots the results in a chart generated with jfreechart.

Introduction

In one of my previous posts I have discussed a nice framework for easy performance measurement called Beet. You can find this post here: Using beet to monitor your (springframework) application. The result of a monitor session with beet can be an xml file. Nice, but how do you analyze this file? By hand? No way, you need a tool. Excel or Numbers can be fine, but it can be a lot faster. Therefore I decided to create a small groovy application.

The first requirement for me was very easy, read the events in the xml file and calculate the average of all events of a certain type. I asked a few of my collegues about their estimated effort when having to do it in java. They varied from 1 hour (pretty optimistic) to half a day. Curious how much time it took me?

First iteration

The first iteration was to calculate the overall average, an optimist of 2 hour java work. First you locate the file, than you slurp the xml out of the file. With the xml file in your hand, you obtain all events with a child element type with the value method. The following code block shows these three lines of code, yes for real, three lines.

def file = new File("beet-integration-web-perf.xml")
def xml = new XmlSlurper().parse(file)
def methodEvents = xml.event.findAll {it.type == "method"}

The next step is to take all durations from the found events. Using these durations, calculating the average is very easy.

def file = new File("beet-integration-web-perf.xml")
def xml = new XmlSlurper().parse(file)
def methodEvents = xml.event.findAll {it.type == "method"}
def durations = methodEvents*."duration-ms"
println "Average duration is ${durations.sum {it.toBigDecimal()} / durations.size()}"

That is it, this took me 10 minutes. And yes for 5 lines of code that is still a lot, but cut me some slag man, I am still learning groovy . What I forgot to mention is that I use the groovyConsole to create and run the application.

Second iteration

The total average is nice, but with hundreds of measurements, not very useful. Of course we want more information on the data. To stretch myself a little bit, I had the idea to take the average of each minute and print that on screen. The next code block does just that, it calculates the averages of all measurements in the same minute and prints the result on the screen. When reading the code, take this tip. We create an array with all durations for each minute and put the result in a map with the minute as a key and the array with durations as a value.

def averages = [:]
def start = methodEvents[0].start.text()[0..16]
def minuteItems = []
methodEvents.each {
    def duration = it."duration-ms".toBigDecimal()
    def currentStart = it.start.text()[0..16]

    if (start == currentStart) {
        minuteItems.add duration
    } else {
        averages.put ((start),minuteItems)
        minuteItems = [duration]
        start = currentStart
    }
}

averages.each {key,value ->
    println "Minute : ${key} has average duration of ${value.sum {it.toBigDecimal()} / value.size()}"
}

Third and final iteration

Having this data written to the screen is oke, but a nice graph would be even better. For this I used a sample I found via google. Since the code is pretty straightforward, I just copy it in here.

def dataset = new DefaultCategoryDataset()
dataset.with{
    avarages.each {key,values ->
    def value = (values.sum {it.toInteger()} / values.size())
        addValue value , "average", key[-3..-1]
    }
}

def labels = ["Registered events total ${methodEvents.size()}", "Minute", "Average"]
def options = [true, true, true]
def chart = ChartFactory.createLineChart(*labels, dataset,Orientation.VERTICAL, *options)
def swing = new SwingBuilder()
def frame = swing.frame(title:'Groovy LineChart',
        defaultCloseOperation:WC.EXIT_ON_CLOSE) {
    panel(id:'canvas') { widget(new ChartPanel(chart)) }
}
frame.pack()
frame.show()

For those java people, check the way you can work with arrays in line 5. Counting from the end of the array, nice.

The result is shown in the next image.

That is about it, just two last things. First you need to add two jars to the classpath of groovy: jcommon-1.0.16.jar, jfreechart-1.0.13.jar. These are in the jfreechart download package. I used the mechanism to create a folder .groovy/lib in your root and add the jars to that folder.

The other thing I wanted to mention is the option to create a shell script from groovy. Just add the following line at the top and make your file executable and you are good to go.

#!/usr/bin/env groovy

That is it, in total 2 hours of work, not bad I think for a beginner in groovy with access to google. If you are good at groovy and you spot improvements, please let me know, I am eager to learn more.

Why this introduction, when I promised to write about performance and monitoring? For performance I see the same relationship. A tester creates the test plan, including the performance test. If you are lucky requirements for monitoring are available as well. Ok, I do not want to combine the role of tester and developer. Still they should both have a very good idea about what the other one does and how you can help each other. Real performance testing is hard and should not be taken to light. Monitoring however can be done on a low level during development. How often have you written log statements like: This method X is executed. Sometimes with a start and end time. Some of you might have used there own aspects to be non intrusive and other might have used a framework.

This blog post is about using a framework to do basic performance measurement and monitoring. The framework I am going to discuss is the Beet framework.

Beet records user behavior and performance data for your Spring-based Java application. It can thus help you to analyze usage patterns and research production performance issues.

Read on to learn about my experiences with the framework and why I like it to do some basic monitoring.

What does it do?

I am not going to enlist all features, go to the website to find out what it can do for you. Here are some of the features that I like:

• Very nice integration with spring framework including namespace support.
• Manager that does logging of events using a memory and flush mechanism.
• Easy configuration to write the logs to disk or database.
• Use a binary format for events that is very condensed together with utilities to generate readable xml, csv or database inserts.
• Easy http-request monitoring
• JMX integration, switching monitoring on and off
• Good user manual and well written and documented code.

What does it look like?

I am using the code of yourscrum to experiment with Beet. Check out the code if you want to follow a long.

Before you can use Beet, you have to download it. Luckily it is available in a maven repository. More information about the repository and the dependency can be found on the beet download page. For my sample I only included the beet artifact. I downloaded the utils (more on those later) as a tar file. You can find the downloads here: http://sourceforge.net/projects/beet/files/.

Now we have Beet available, we should add the namespace defintion to the spring configuration and the first very basic tracking manager to track all http-requests.

<?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:context="http://www.springframework.org/schema/context"
       xmlns:bt="http://www.mantis-tgi.com/schema/bt/1.1"
       xmlns:aop="http://www.springframework.org/schema/aop"
       xsi:schemaLocation="
            http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-2.5.xsd
            http://www.springframework.org/schema/context http://www.springframework.org/schema/context/spring-context-2.5.xsd
            http://www.mantis-tgi.com/schema/bt/1.1 http://www.mantis-tgi.com/schema/bt/mtgi-bt-1.1.xsd
            http://www.springframework.org/schema/aop http://www.springframework.org/schema/aop/spring-aop-2.5.xsd">

    <bean class="org.springframework.beans.factory.config.PropertyPlaceholderConfigurer"/>
	...
    <bt:manager id="defaultTrackingManager"
                application="yourscrum"
                register-mbeans="false"
                flush-schedule="0/30 * * * * ?">
        <bt:xml-persister binary="true" compress="true" file="${log.dir}/beet-yourscrum-perf.xml"/>
        <bt:http-requests parameters="dispatch"/>
    </bt:manager>
	...
</beans

There are a few things to learn from this confguration. First that we are logging in a binary format and compressed. This is not handy when you are trying to read the logs at runtime. Therefore you have the option to change this. The result is a nice readable XML formatted file. Other interesting things are the http_request configuration and the flush schedule. The flush schedule is used to cache logs and send them to the file only every 30 seconds in our case.

If you choose for the binary format, you need to use the beet-utils to extract the data into a csv file, readable xml or database calls. There is a basic command that you can use to uncompress and transform the data.

gzcat ./beet-yourscrum-perf.bxml.gz  | java -jar /path/to/beet-utils.jar -tool csv > result.csv

The *.bxml.gz is the binary data file. Beware that the original documentation explains the use of zcat. For me on the mac I had to use the older gzcat tool. But the commands are the same. The following image shows the results in csv format.

Next up is to configure method access.

Can we monitor method calls?

Of course we can track method calls. Actually Beet makes it very easy for you. The manager namespace has an attribute called track-method-expression. You can provided it with any pointcut expression and you are done.

There are two buts when using pointcuts. But 1, you want to use one tracking manager but multiple pointcuts. One to monitor services and one to monitor controllers. Beet provides a mechanism to create separate advisors and pointcuts. There is a small bug in the 1.4.0-b3 release that prevents your from using this though. But 2, think about the way spring treats multiple configuration files. One loaded by the web context (servlet) and the other by the application context (listener). Pointcuts can not overcome these context boundaries, therefore we need multiple tracking managers at the moment.

The code looks like this, check thetrack-method-expression

<bt:manager id="webTrackingManager"
            application="yourscrum"
            register-mbeans="false"
            track-method-expression="execution(* org.yourscrum.web.story.*Controller.*(..))"
            flush-schedule="0/30 * * * * ?">
    <bt:xml-persister binary="true" compress="true" file="${log.dir}/beet-yourscrum-web-perf.xml"/>
    <bt:http-requests parameters="dispatch"/>
</bt:manager>

Are there other things to monitor?

Beet does provided some other helpful beans to monitor your application. A nice one is the datasource monitor. Very easy to configure. Just add an attribute to the datasource configuration. You can look at the following code block for an example. After that there is again an image with some sample csv data.

    <bean id="dataSource" class="org.springframework.jdbc.datasource.DriverManagerDataSource"
          bt:tracking-manager="serviceTrackingManager">

        <property name="driverClassName" value="${jdbc.driverclass}"/>
        <property name="url" value="${jdbc.url}"/>
        <property name="username" value="${jdbc.username}"/>
        <property name="password" value="${jdbc.password}"/>
    </bean>

What could be improved?

Before I sound to negative I do like to mention that Jason responded fast to the issues I found. Still others can find them as well, let’s help Jason to fix the issues and improve the project. I think it is worth it.

• Problem configuring pointcuts and separate advise. The manager accepts an pointcut expression for tracking method calls. It is also possible to create you own pointcuts and combine them with existing pointcuts. That way you can combine it with transaction creation for instance. The fix does not look very hard, the issue is logged.
• Problems logging to one file with one manager when the spring configuration is split up into multiple files and multiple contexts loaded by the servlet and the listener. To create a solution for this problem we need the pointcut option as mentioned in the previous point and preferably a separate bean for the http-request listener that is connected to the tracking manager at the moment. The issues are mentioned and a solution will be created.
• The last point depends on your taste, to me it is a big problem. The project uses GIT for source control. I had never worked with it and needed to configure it on my machine to extract the sources from the repository. But the bigger problem is ant and ivy. Man I do not like this. I just love the maven integration in my IDE and the project setup. This project is not easy to open in a real IDE like intellij. But again, that is a matter of taste.

Conclusion

I can say I am going to experiment more with this framework. It looks very promising. A few small issues need to be fixed. I am planning on using it for a bit bigger project to see how it holds up.

I am curious to learn from you about the frameworks that you use for performance testing and monitoring. Drop me a line or a comment.