I’ve often heard the phrase “you can’t improve what you can’t measure.” When developing high-performance systems, this is especially true. Such systems typically have strict non functional requirements, such as requests/second and response time. When we collect metrics about the various layers of a system, we can then take action to improve the performance of wayward components.

The technology stack introduced in the article includes the following:

• Spring boot for microservices (http://projects.spring.io/spring-boot/)
• Dropwizard metrics for collecting application metrics (https://dropwizard.github.io/metrics/3.1.0/). Dropwizard contains a lot of modules for instrumenting existing libraries like ehcache and httpclient as well.
• Metrics-spring for recording metrics with field and method annotations (https://github.com/ryantenney/metrics-spring)
• Metrics-statsd for sending dropwizard metrics collected in the spring boot application to the statsd daemon (https://github.com/ReadyTalk/metrics-statsd)
• Statsd for aggregating application metrics from various sources, and sending the information on to end consumers like influxdb, graphite, ganglia, etc. (https://github.com/etsy/statsd). Statsd collects data over UDP. UDP accepts data, but does not send responses. As such it does not block your application’s execution.

This article assumes knowledge of how to create restful services with spring boot and gradle. It will give examples on how to start collecting various application metrics and send those to statsd. It does not talk about how to consume metrics with influxdb, graphite, ganglia, etc. – this is left as an exercise for the reader.

Dropwizard metrics defines a rich collection of metric types:

• Gauges – record raw values
• Counters – record event counts
• Timers – record execution time metrics
• Meters – record execution rates
• Histograms – record value distributions

See https://dropwizard.github.io/metrics/3.1.0/manual/core/ for more information about each of these types.

To start, let’s get our application setup to record metrics, and install statsd.

Gradle Setup

Add the readytalk bintray repository to your build.grade.

repositories {
  mavenRepo(url: 'http://dl.bintray.com/readytalk/maven')
}

Now add dropwizard-metrics, metrics-spring, and metrics-statsd to your dependencies.

compile 'com.readytalk:metrics3-statsd:4.1.0'
compile ('com.ryantenney.metrics:metrics-spring:3.0.4') {
 exclude group: 'com.codahale.metrics'
 exclude group: 'org.springframework'
}
compile 'io.dropwizard.metrics:metrics-core:3.1.1'
compile 'io.dropwizard.metrics:metrics-annotation:3.1.1'
compile 'io.dropwizard.metrics:metrics-healthchecks:3.1.1'
compile 'org.springframework.boot:spring-boot-starter-web:1.2.3.RELEASE'
compile 'org.springframework:spring-aspects:4.1.6.RELEASE'
compile 'org.springframework:spring-context-support:4.1.6.RELEASE'

Application Configuration Setup

Add the following to an @Configuration or @SpringBootApplication annotated class, for example:

@SpringBootApplication
@EnableMetrics(proxyTargetClass = true)
class BlogApplication extends MetricsConfigurerAdapter {
 
    @Bean
    MetricsConfigurerAdapter metricsConfigurerAdapter() {
        new BaseMetricsConfigurerAdapter()
    }
 
    static void main(String[] args) {
        SpringApplication.run BlogApplication, args
    }
}

Install and Configure statsd

See https://github.com/etsy/statsd#installation-and-configuration for installation and configuration instructions. Don’t forget to change the port to 8125. Here is my example config file:

{
debug: true,
port: 8125,
backends: [ "./backends/console" ]
}

Now run statsd.

node stats.js localConfig.js

Add controller timed annotation

Now, let’s say I want to record timing statistics for a rest endpoint. Add something like this:

@RestController
@RequestMapping(value = '/hello')
class BlogMetricsController {
 
  @Timed(absolute = true, name = 'sayhello')
  @RequestMapping(value = '/{name}', method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
  @ResponseStatus(HttpStatus.OK)
  String sayHello(@PathVariable(value = 'name') String name) {
    "Hello $name"
  }
 
}

Run the application and  you can view statistics in the console.

gradle bootRun

You can hit the url and see the statistics change in the application log. You can also see the same metrics in the statsd console output.

Other Use Cases

One other interesting way to record metrics on arbitrary code blocks is to use Java8 lambdas or Groovy closures.

Java8

@Component
public class MetricWriterJava {
 
    @Autowired
    private MetricRegistry metricRegistry;
 
    public <T> T time(String name, Supplier<T> s) {
        Timer timer = metricRegistry.timer(name);
        final Timer.Context context = timer.time();
        T result = null;
        try {
            result = s.get();
        }
        finally {
            context.stop();
        }
        return result;
    }
}

Groovy

@Component
class MetricWriterGroovy {
 
    @Autowired
    MetricRegistry metricRegistry
 
    def time(String name, Closure c) {
        Timer timer = metricRegistry.timer(name)
        final Timer.Context context = timer.time()
        def result = null
        try {
            result = c.call()
        }
        finally {
            context.stop();
        }
        result
    }
}

Then you can create metrics like this and see them immediately in the output.

//random java metric
int t = metricWriterJava.time('java.metric', {
    (1..1000).each { sleep(1) }
    42
})
 
//random groovy metric
int x = metricWriterGroovy.time('groovy.metric', {
    (1..1000).each { sleep(1) }
    99
})

The examples above can be applied to all metrics types. The links at the top of the article provide excellent in depth documentation on how to configure and use the individual components of this stack.

Full source code available here

Happy metrics!