Create a Micronaut Application to Collect Metrics and Monitor Them on Google Cloud Monitoring

micronaut.metrics.enabled=true
flyway.datasources.default.enabled=true
datasources.default.dialect=MYSQL
datasources.default.driverClassName=com.mysql.cj.jdbc.Driver
datasources.default.db-type=mysql
customMetrics.initialDelay=10h
micronaut.metrics.export.stackdriver.enabled=false

package com.example;

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Tags;
import io.micrometer.core.instrument.Timer;
import io.micronaut.core.type.Argument;
import io.micronaut.http.HttpRequest;
import io.micronaut.http.client.HttpClient;
import io.micronaut.http.client.annotation.Client;
import io.micronaut.logging.LoggingSystem;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.stream.Collectors;
import java.util.concurrent.TimeUnit;

import static io.micronaut.logging.LogLevel.ALL;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertFalse;
import static org.junit.jupiter.api.Assertions.assertTrue;

@MicronautTest
class BookControllerMetricsTest {

    @Inject
    MeterRegistry meterRegistry;

    @Inject
    LoggingSystem loggingSystem;

    @Inject
    @Client("/")
    HttpClient httpClient;

    @Test
    void testExpectedMeters() {

        Set<String> names = meterRegistry.getMeters().stream()
                .map(meter -> meter.getId().getName())
                .collect(Collectors.toSet());

        // check that a subset of expected meters exist
        assertTrue(names.contains("jvm.memory.max"));
        assertTrue(names.contains("process.uptime"));
        assertTrue(names.contains("system.cpu.usage"));
        assertTrue(names.contains("logback.events"));
        assertTrue(names.contains("hikaricp.connections.max"));

        // these will be lazily created
        assertFalse(names.contains("http.client.requests"));
        assertFalse(names.contains("http.server.requests"));
    }

    @Test
    void testHttp() {

        Timer timer = meterRegistry.timer("http.server.requests", Tags.of(
                "exception", "none",
                "method", "GET",
                "status", "200",
                "uri", "/books"));
        assertEquals(0, timer.count());

        Timer bookIndexTimer = meterRegistry.timer("books.index",
                Tags.of("exception", "none"));
        assertEquals(0, bookIndexTimer.count());

        httpClient.toBlocking().retrieve(
                HttpRequest.GET("/books"),
                Argument.listOf(Book.class));

        assertEquals(1, timer.count());
        assertEquals(1, bookIndexTimer.count());
        assertTrue(0.0 < bookIndexTimer.totalTime(TimeUnit.MILLISECONDS));
        assertTrue(0.0 < bookIndexTimer.max(TimeUnit.MILLISECONDS));

        Counter bookFindCounter = meterRegistry.counter("books.find",
                Tags.of("result", "success",
                        "exception", "none"));
        assertEquals(0, bookFindCounter.count());

        httpClient.toBlocking().retrieve(
                HttpRequest.GET("/books/9781491950357"),
                Argument.of(Book.class));

        assertEquals(1, bookFindCounter.count());
    }

    @Test
    void testLogback() {

        Counter counter = meterRegistry.counter("logback.events", Tags.of("level", "info"));
        double initial = counter.count();

        Logger logger = LoggerFactory.getLogger("testing.testing");
        loggingSystem.setLogLevel("testing.testing", ALL);

        logger.trace("trace");
        logger.debug("debug");
        logger.info("info");
        logger.warn("warn");
        logger.error("error");

        assertEquals(initial + 1, counter.count(), 0.000001);
    }

    @Test
    void testMetricsEndpoint() {

        Map<String, Object> response = httpClient.toBlocking().retrieve(
                HttpRequest.GET("/metrics"),
                Argument.mapOf(String.class, Object.class));

        assertTrue(response.containsKey("names"));
        assertTrue(response.get("names") instanceof List);

        List<String> names = (List<String>) response.get("names");

        // check that a subset of expected meters exist
        assertTrue(names.contains("jvm.memory.max"));
        assertTrue(names.contains("process.uptime"));
        assertTrue(names.contains("system.cpu.usage"));
        assertTrue(names.contains("logback.events"));
        assertTrue(names.contains("hikaricp.connections.max"));
    }

    @Test
    void testOneMetricEndpoint() {

        Map<String, Object> response = httpClient.toBlocking().retrieve(
                HttpRequest.GET("/metrics/jvm.memory.used"),
                Argument.mapOf(String.class, Object.class));

        String name = (String) response.get("name");
        assertEquals("jvm.memory.used", name);

        List<Map<String, Object>> measurements = (List<Map<String, Object>>) response.get("measurements");
        assertEquals(1, measurements.size());

        double value = (double) measurements.get(0).get("value");
        assertTrue(value > 0);
    }
}

package com.example;

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import io.micronaut.scheduling.annotation.Scheduled;
import jakarta.inject.Singleton;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import java.util.concurrent.atomic.AtomicInteger;
import java.util.stream.StreamSupport;

@Singleton
public class MicroserviceBooksNumberService {

    private final Logger log = LoggerFactory.getLogger(getClass().getName());

    private final BookRepository bookRepository;
    private final Counter checks;
    private final Timer time;
    private final AtomicInteger microserviceBooksNumber = new AtomicInteger(0);

    private static final String SEARCH_KEY = "microservice";

    MicroserviceBooksNumberService(BookRepository bookRepository,
                                   MeterRegistry meterRegistry) {  (1)
        this.bookRepository = bookRepository;
        checks = meterRegistry.counter("microserviceBooksNumber.checks");
        time = meterRegistry.timer("microserviceBooksNumber.time");
        meterRegistry.gauge("microserviceBooksNumber.latest", microserviceBooksNumber);
    }

    @Scheduled(fixedRate = "${customMetrics.updateFrequency:1h}",
               initialDelay = "${customMetrics.initialDelay:0s}")  (2)
    public void updateNumber() {
        time.record(() -> {
            try {
                Iterable<Book> allBooks = bookRepository.findAll();
                long booksNumber = StreamSupport.stream(allBooks.spliterator(), false)
                        .filter(b -> b.getName().toLowerCase().contains(SEARCH_KEY))
                        .count();

                checks.increment();
                microserviceBooksNumber.set((int) booksNumber);
            } catch (Exception e) {
                log.error("Problem setting the number of microservice books", e);
            }
        });
    }
}

package com.example;

import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.Gauge;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import io.micronaut.test.extensions.junit5.annotation.MicronautTest;
import jakarta.inject.Inject;
import org.junit.jupiter.api.Test;

import static java.util.concurrent.TimeUnit.MILLISECONDS;
import static org.junit.jupiter.api.Assertions.assertEquals;
import static org.junit.jupiter.api.Assertions.assertTrue;

@MicronautTest
class MicroserviceBooksNumberTest {

    @Inject
    MeterRegistry meterRegistry;

    @Inject
    MicroserviceBooksNumberService service;

    @Test
    void testMicroserviceBooksNumberUpdates() {
        Counter counter = meterRegistry.counter("microserviceBooksNumber.checks");
        Timer timer = meterRegistry.timer("microserviceBooksNumber.time");
        Gauge gauge = meterRegistry.get("microserviceBooksNumber.latest").gauge();

        assertEquals(0.0, counter.count());
        assertEquals(0.0, timer.totalTime(MILLISECONDS));
        assertEquals(0.0, gauge.value());

        int checks = 3;
        for (int i = 0; i < checks; i++) {
            service.updateNumber();
        }

        assertEquals((double) checks, counter.count());
        assertTrue(timer.totalTime(MILLISECONDS) > 0);
        assertEquals(2.0, gauge.value());
    }
}

customMetrics.initialDelay=10h