Intelligent microservice metrics with Spring Boot and Statsd

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:

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 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: '')

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:

@EnableMetrics(proxyTargetClass = true)
class BlogApplication extends MetricsConfigurerAdapter {
    MetricsConfigurerAdapter metricsConfigurerAdapter() {
        new BaseMetricsConfigurerAdapter()
    static void main(String[] args) { BlogApplication, args

Install and Configure statsd

See 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:

@RequestMapping(value = '/hello')
class BlogMetricsController {
  @Timed(absolute = true, name = 'sayhello')
  @RequestMapping(value = '/{name}', method = RequestMethod.GET, produces = MediaType.APPLICATION_JSON_VALUE)
  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.


public class MetricWriterJava {
    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 {
        return result;


class MetricWriterGroovy {
    MetricRegistry metricRegistry
    def time(String name, Closure c) {
        Timer timer = metricRegistry.timer(name)
        final Timer.Context context = timer.time()
        def result = null
        try {
            result =
        finally {

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) }
//random groovy metric
int x = metricWriterGroovy.time('groovy.metric', {
    (1..1000).each { sleep(1) }

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!

About the Author

Object Partners profile.

One thought on “Intelligent microservice metrics with Spring Boot and Statsd

Leave a Reply

Your email address will not be published. Required fields are marked *

Related Blog Posts
Feature Flags in Terraform
Feature flagging any code can be useful to developers but many don’t know how to or even that you can do it in Terraform. Some benefits of Feature Flagging your code You can enable different […]
Infrastructure as Code – The Wrong Way
You are probably familiar with the term “infrastructure as code”. It’s a great concept, and it’s gaining steam in the industry. Unfortunately, just as we had a lot to learn about how to write clean […]
Snowflake CI/CD using Jenkins and Schemachange
CI/CD and Management of Data Warehouses can be a serious challenge. In this blog you will learn how to setup CI/CD for Snowflake using Schemachange, Github, and Jenkins. For access to the code check out […]
How to get your pull requests approved more quickly
TL;DR The fewer reviews necessary, the quicker your PR gets approved. Code reviews serve an essential function on any software codebase. Done right, they help ensure correctness, reliability, and maintainability of code. On many teams, […]