1. Overview
In this tutorial, we’ll integrate basic Metrics into a Spring REST API.
We’ll build out the metric functionality first using simple Servlet Filters, then using the Spring Boot Actuator module.
2. The web.xml
Let’s start by registering a filter – “MetricFilter” – into the web.xml of our app:
<filter>
<filter-name>metricFilter</filter-name>
<filter-class>org.baeldung.metrics.filter.MetricFilter</filter-class>
</filter>
<filter-mapping>
<filter-name>metricFilter</filter-name>
<url-pattern>/*</url-pattern>
</filter-mapping>
Note how we’re mapping the filter to cover all requests coming in – “/*” – which is of course fully configurable.
3. The Servlet Filter
Now – let’s create our custom filter:
public class MetricFilter implements Filter {
private MetricService metricService;
@Override
public void init(FilterConfig config) throws ServletException {
metricService = (MetricService) WebApplicationContextUtils
.getRequiredWebApplicationContext(config.getServletContext())
.getBean("metricService");
}
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws java.io.IOException, ServletException {
HttpServletRequest httpRequest = ((HttpServletRequest) request);
String req = httpRequest.getMethod() + " " + httpRequest.getRequestURI();
chain.doFilter(request, response);
int status = ((HttpServletResponse) response).getStatus();
metricService.increaseCount(req, status);
}
}
Since the filter isn’t a standard bean, we’re not going to inject the metricService but instead retrieve it manually – via the ServletContext.
Also note that we’re continuing the execution of the filter chain by calling the doFilter API here.
4. Metric – Status Code Counts
Next – let’s take a look at our simple InMemoryMetricService:
@Service
public class MetricService {
private Map<Integer, Integer> statusMetric;
public MetricService() {
statusMetric = new ConcurrentHashMap<>();
}
public void increaseCount(String request, int status) {
Integer statusCount = statusMetric.get(status);
if (statusCount == null) {
statusMetric.put(status, 1);
} else {
statusMetric.put(status, statusCount + 1);
}
}
public Map getStatusMetric() {
return statusMetric;
}
}
We’re using an in-memory ConcurrentMap to hold the counts for each type of HTTP status code.
Now – to display this basic metric – we’re going to map it to a Controller method:
@GetMapping(value = "/status-metric")
@ResponseBody
public Map getStatusMetric() {
return metricService.getStatusMetric();
}
And here is a sample response:
{
"404":1,
"200":6,
"409":1
}
5. Metric – Status Codes by Request
Next – let’s record metrics for Counts by Request:
@Service
public class MetricService {
private Map<String, Map<Integer, Integer>> metricMap;
public void increaseCount(String request, int status) {
Map<Integer, Integer> statusMap = metricMap.get(request);
if (statusMap == null) {
statusMap = new ConcurrentHashMap<>();
}
Integer count = statusMap.get(status);
if (count == null) {
count = 1;
} else {
count++;
}
statusMap.put(status, count);
metricMap.put(request, statusMap);
}
public Map getFullMetric() {
return metricMap;
}
}
We’ll display the metric results via the API:
@GetMapping(value = "/metric")
@ResponseBody
public Map getMetric() {
return metricService.getFullMetric();
}
Here’s how these metrics look like:
{
"GET /users":
{
"200":6,
"409":1
},
"GET /users/1":
{
"404":1
}
}
According to the above example, the API had the following activity:
- “7” requests to “GET /users“
- “6” of them resulted in “200” status code responses and only one in a “409”
6. Metric – Time Series Data
Overall counts are somewhat useful in an application, but if the system has been running for a significant amount of time – it’s hard to tell what these metrics actually mean.
You need the context of the time in order for the data to make sense and be easily interpreted.
Let’s now build a simple time-based metric; we’ll keep a record of status code counts per minute – as follows:
@Service
public class MetricService {
private static final SimpleDateFormat DATE_FORMAT =
new SimpleDateFormat("yyyy-MM-dd HH:mm");
private Map<String, Map<Integer, Integer>> timeMap;
public void increaseCount(String request, int status) {
String time = DATE_FORMAT.format(new Date());
Map<Integer, Integer> statusMap = timeMap.get(time);
if (statusMap == null) {
statusMap = new ConcurrentHashMap<>();
}
Integer count = statusMap.get(status);
if (count == null) {
count = 1;
} else {
count++;
}
statusMap.put(status, count);
timeMap.put(time, statusMap);
}
}
And the getGraphData():
public Object[][] getGraphData() {
int colCount = statusMetric.keySet().size() + 1;
Set<Integer> allStatus = statusMetric.keySet();
int rowCount = timeMap.keySet().size() + 1;
Object[][] result = new Object[rowCount][colCount];
result[0][0] = "Time";
int j = 1;
for (int status : allStatus) {
result[0][j] = status;
j++;
}
int i = 1;
Map<Integer, Integer> tempMap;
for (Entry<String, Map<Integer, Integer>> entry : timeMap.entrySet()) {
result[i][0] = entry.getKey();
tempMap = entry.getValue();
for (j = 1; j < colCount; j++) {
result[i][j] = tempMap.get(result[0][j]);
if (result[i][j] == null) {
result[i][j] = 0;
}
}
i++;
}
for (int k = 1; k < result\[0\].length; k++) {
result\[0\]\[k\] = result\[0\]\[k\].toString();
}
return result;
}
We’re now going to map this to the API:
@GetMapping(value = "/metric-graph-data")
@ResponseBody
public Object[][] getMetricData() {
return metricService.getGraphData();
}
And finally – we’re going to render it out using Google Charts:
<html>
<head>
<title>Metric Graph</title>
<script src="http://ajax.googleapis.com/ajax/libs/jquery/1.11.2/jquery.min.js"></script>
<script type="text/javascript" src="https://www.google.com/jsapi"></script>
<script type="text/javascript">
google.load("visualization", "1", {packages : [ "corechart" ]});
function drawChart() {
$.get("/metric-graph-data",function(mydata) {
var data = google.visualization.arrayToDataTable(mydata);
var options = {title : 'Website Metric',
hAxis : {title : 'Time',titleTextStyle : {color : '#333'}},
vAxis : {minValue : 0}};
var chart = new google.visualization.AreaChart(document.getElementById('chart_div'));
chart.draw(data, options);
});
}
</script>
</head>
<body onload="drawChart()">
<div id="chart_div" style="width: 900px; height: 500px;"></div>
</body>
</html>
7. Using Spring Boot 1.x Actuator
In the next few sections, we’re going to hook into the Actuator functionality in Spring Boot to present our metrics.
First – we’ll need to add the actuator dependency to our pom.xml:
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
7.1. The MetricFilter
Next – we can turn the MetricFilter – into an actual Spring bean:
@Component
public class MetricFilter implements Filter {
@Autowired
private MetricService metricService;
@Override
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)
throws java.io.IOException, ServletException {
chain.doFilter(request, response);
int status = ((HttpServletResponse) response).getStatus();
metricService.increaseCount(status);
}
}
This is, of course, a minor simplification – but one that’s worth doing to get rid of the previously manual wiring of dependencies.
7.2. Using CounterService
Let’s now use the CounterService to count occurrences for each Status Code:
@Service
public class MetricService {
@Autowired
private CounterService counter;
private List<String> statusList;
public void increaseCount(int status) {
counter.increment("status." + status);
if (!statusList.contains("counter.status." + status)) {
statusList.add("counter.status." + status);
}
}
}
7.3. Export Metrics Using MetricRepository
Next – we need to export the metrics – using the MetricRepository:
@Service
public class MetricService {
@Autowired
private MetricRepository repo;
private List<List<Integer>> statusMetric;
private List<String> statusList;
@Scheduled(fixedDelay = 60000)
private void exportMetrics() {
Metric<?> metric;
List<Integer> statusCount = new ArrayList<>();
for (String status : statusList) {
metric = repo.findOne(status);
if (metric != null) {
statusCount.add(metric.getValue().intValue());
repo.reset(status);
} else {
statusCount.add(0);
}
}
statusMetric.add(statusCount);
}
}
Note that we’re storing counts of status codes per minute.
7.4. Spring Boot PublicMetrics
We can also use Spring Boot PublicMetrics to export metrics instead of using our own filters – as follows:
First, we have our scheduled task to export metrics per minute:
@Autowired
private MetricReaderPublicMetrics publicMetrics;
private List<List<Integer>> statusMetricsByMinute;
private List<String> statusList;
private static final SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd HH:mm");
@Scheduled(fixedDelay = 60000)
private void exportMetrics() {
List<Integer> lastMinuteStatuses = initializeStatuses(statusList.size());
for (Metric<?> counterMetric : publicMetrics.metrics()) {
updateMetrics(counterMetric, lastMinuteStatuses);
}
statusMetricsByMinute.add(lastMinuteStatuses);
}
We, of course, need to initialize the list of HTTP status codes:
private List<Integer> initializeStatuses(int size) {
List<Integer> counterList = new ArrayList<>();
for (int i = 0; i < size; i++) {
counterList.add(0);
}
return counterList;
}
And then we’re going to actually update the metrics with status code count:
private void updateMetrics(Metric<?> counterMetric, List<Integer> statusCount) {
if (counterMetric.getName().contains("counter.status.")) {
String status = counterMetric.getName().substring(15, 18); // example 404, 200
appendStatusIfNotExist(status, statusCount);
int index = statusList.indexOf(status);
int oldCount = statusCount.get(index) == null ? 0 : statusCount.get(index);
statusCount.set(index, counterMetric.getValue().intValue() + oldCount);
}
}
private void appendStatusIfNotExist(String status, List<Integer> statusCount) {
if (!statusList.contains(status)) {
statusList.add(status);
statusCount.add(0);
}
}
Note that:
- PublicMetics status counter name start with “counter.status” for example “counter.status.200.root“
- We keep a record of status count per minute in our list statusMetricsByMinute
We can export our collected data to draw it in a graph – as follows:
public Object[][] getGraphData() {
Date current = new Date();
int colCount = statusList.size() + 1;
int rowCount = statusMetricsByMinute.size() + 1;
Object[][] result = new Object[rowCount][colCount];
result[0][0] = "Time";
int j = 1;
for (String status : statusList) {
result[0][j] = status;
j++;
}
for (int i = 1; i < rowCount; i++) {
result[i][0] = dateFormat.format(
new Date(current.getTime() - (60000L * (rowCount - i))));
}
List<Integer> minuteOfStatuses;
List<Integer> last = new ArrayList<Integer>();
for (int i = 1; i < rowCount; i++) {
minuteOfStatuses = statusMetricsByMinute.get(i - 1);
for (j = 1; j <= minuteOfStatuses.size(); j++) {
result[i][j] =
minuteOfStatuses.get(j - 1) - (last.size() >= j ? last.get(j - 1) : 0);
}
while (j < colCount) {
result[i][j] = 0;
j++;
}
last = minuteOfStatuses;
}
return result;
}
7.5. Draw Graph Using Metrics
Finally – let’s represent these metrics via a 2 dimension array – so that we can then graph them:
public Object[][] getGraphData() {
Date current = new Date();
int colCount = statusList.size() + 1;
int rowCount = statusMetric.size() + 1;
Object[][] result = new Object[rowCount][colCount];
result[0][0] = "Time";
int j = 1;
for (String status : statusList) {
result[0][j] = status;
j++;
}
ArrayList<Integer> temp;
for (int i = 1; i < rowCount; i++) {
temp = statusMetric.get(i - 1);
result[i][0] = dateFormat.format
(new Date(current.getTime() - (60000L * (rowCount - i))));
for (j = 1; j <= temp.size(); j++) {
result[i][j] = temp.get(j - 1);
}
while (j < colCount) {
result[i][j] = 0;
j++;
}
}
return result;
}
And here is our Controller method getMetricData():
@GetMapping(value = "/metric-graph-data")
@ResponseBody
public Object[][] getMetricData() {
return metricService.getGraphData();
}
And here is a sample response:
[
["Time","counter.status.302","counter.status.200","counter.status.304"],
["2015-03-26 19:59",3,12,7],
["2015-03-26 20:00",0,4,1]
]
8. Using Spring Boot 2.x Actuator
In Spring Boot 2, Spring Actuator’s APIs witnessed a major change. Spring’s own metrics have been replaced with Micrometer. So let’s write the same metrics example above with Micrometer.
8.1. Replacing CounterService With MeterRegistry
As our Spring Boot application already depends on the Actuator starter, Micrometer is already auto-configured. We can inject MeterRegistry instead of CounterService. We can use different types of Meter to capture metrics. The Counter is one of the Meters:
@Autowired
private MeterRegistry registry;
private List<String> statusList;
@Override
public void increaseCount(int status) {
String counterName = "counter.status." + status;
registry.counter(counterName).increment(1);
if (!statusList.contains(counterName)) {
statusList.add(counterName);
}
}
8.2. Viewing Custom Metrics
As our metrics are now registered with Micrometer, first, let’s enable them in the application configuration. Now we can view them by navigating to the Actuator endpoint at /actuator/metrics:
{
"names": [
"application.ready.time",
"application.started.time",
"counter.status.200",
"disk.free",
"disk.total",
.....
]
}
Here we can see our counter.status.200 metric is listed amongst the standard Actuator metrics. In addition, we can also get the latest value of this metric by providing the selector in the URI as /actuator/metrics/counter.status.200:
{
"name": "counter.status.200",
"description": null,
"baseUnit": null,
"measurements": [
{
"statistic": "COUNT",
"value": 2
}
],
"availableTags": []
}
8.3. Exporting Counts Using MeterRegistry
In Micrometer, we can export the Counter values using MeterRegistry:
@Scheduled(fixedDelay = 60000)
private void exportMetrics() {
List<Integer> statusCount = new ArrayList<>();
for (String status : statusList) {
Search search = registry.find(status);
Counter counter = search.counter();
if (counter == null) {
statusCount.add(0);
} else {
statusCount.add(counter != null ? ((int) counter.count()) : 0);
registry.remove(counter);
}
}
statusMetricsByMinute.add(statusCount);
}
8.3. Publishing Metrics Using Meters
Now we can also publish Metrics using MeterRegistry’s Meters:
@Scheduled(fixedDelay = 60000)
private void exportMetrics() {
List<Integer> lastMinuteStatuses = initializeStatuses(statusList.size());
for (Meter counterMetric : publicMetrics.getMeters()) {
updateMetrics(counterMetric, lastMinuteStatuses);
}
statusMetricsByMinute.add(lastMinuteStatuses);
}
private void updateMetrics(Meter counterMetric, List<Integer> statusCount) {
String metricName = counterMetric.getId().getName();
if (metricName.contains("counter.status.")) {
String status = metricName.substring(15, 18); // example 404, 200
appendStatusIfNotExist(status, statusCount);
int index = statusList.indexOf(status);
int oldCount = statusCount.get(index) == null ? 0 : statusCount.get(index);
statusCount.set(index, (int)((Counter) counterMetric).count() + oldCount);
}
}
9. Conclusion
In this article, we explored a few simple ways to build out some basic metrics capabilities into a Spring web application.
Note that the counters aren’t thread-safe – so they might not be exact without using something like atomic numbers. This was deliberate just because the delta should be small and 100% accuracy isn’t the goal – rather, spotting trends early is.
There are of course more mature ways to record HTTP metrics in an application, but this is a simple, lightweight, and super-useful way to do it without the extra complexity of a full-fledged tool.
The full implementation of this article can be found in the GitHub project.