Java / Gradle

Collect Metrics with Micronaut

Learn how to collect standard and custom metrics with the Micronaut framework.

Burt Beckwith
On this guide
In this section

Getting Started

In this guide, we will create a Micronaut application written in Java.

We’ll use Micronaut Micrometer to expose application metric data with Micrometer.

What you will need

To complete this guide, you will need the following:

Solution

We recommend that you follow the instructions in the next sections and create the application step by step. However, you can go right to the completed example.

Writing the Application

Create an application using the Micronaut Command Line Interface or with Micronaut Launch.

mn create-app example.micronaut.micronautguide \
    --features=micrometer-annotation,data-jdbc,flyway,validation,http-client,graalvm \
    --build=gradle \
    --lang=java \
    --test=junit
Note
 If you don’t specify the --build argument, Gradle with the Kotlin DSL is used as the build tool.
If you don’t specify the --lang argument, Java is used as the language.
If you don’t specify the --test argument, JUnit is used for Java and Kotlin, and Spock is used for Groovy.

The previous command creates a Micronaut application with the default package example.micronaut in a directory named micronautguide.

If you use Micronaut Launch, select Micronaut Application as application type and add micrometer-annotation, data-jdbc, flyway, validation, http-client, and graalvm features.

Note
 If you have an existing Micronaut application and want to add the functionality described here, you can view the dependency and configuration changes from the specified features, and apply those changes to your application.

Diff

Setup IntelliJ IDEA to develop Micronaut Applications.

Metrics Configuration

Several groups of metrics are enabled by default. These include system metrics (JVM info, uptime, etc.), as well as metrics tracking web requests, DataSource activity, and others. Overall metrics can be enabled or disabled, and groups can be individually enabled or disabled in configuration.

Add the following to application.properties:

src/main/resources/application.properties
micronaut.metrics.enabled=true 
micronaut.metrics.binders.files.enabled=true 
micronaut.metrics.binders.jdbc.enabled=true
micronaut.metrics.binders.jvm.enabled=true
micronaut.metrics.binders.logback.enabled=true
micronaut.metrics.binders.processor.enabled=true
micronaut.metrics.binders.uptime.enabled=true
micronaut.metrics.binders.web.enabled=true
1 Change to false to disable all metrics, for example, per environment.
2 These default to true and are only here for convenience, to be able to disable a subset of metrics.

Custom Metrics

If the built-in metrics aren’t enough, you can easily add custom metrics with the following annotations.

@Timed

Creates a Timer metric that contains the total time, max time, and count.

@Counted

Creates a Counter metric that only contains a count.

If you want to create your own gauge, you can inject io.micrometer.core.instrument.MeterRegistry to your bean.

Data Source Metrics

DataSource metrics are enabled by default if you use HikariCP (the default), Tomcat JDBC, or the Commons DBCP connection pool.

Database Migration with Flyway

We need a way to create the database schema. For that, we use Micronaut integration with Flyway.

Flyway automates schema changes, significantly simplifying schema management tasks, such as migrating, rolling back, and reproducing in multiple environments.

Add the following snippet to include the necessary dependencies:

build.gradle
implementation("io.micronaut.flyway:micronaut-flyway")

We will enable Flyway in the Micronaut configuration file and configure it to perform migrations on one of the defined data sources.

src/main/resources/application.properties
flyway.datasources.default.enabled=true
1 Enable Flyway for the default datasource.
Note
 Configuring multiple data sources is as simple as enabling Flyway for each one. You can also specify directories that will be used for migrating each data source. Review the Micronaut Flyway documentation for additional details.

Flyway migration will be automatically triggered before your Micronaut application starts. Flyway will read migration commands in the resources/db/migration/ directory, execute them if necessary, and verify that the configured data source is consistent with them.

Create the following migration files with the database schema creation:

src/main/resources/db/migration/V1__schema.sql
DROP TABLE IF EXISTS book;

CREATE TABLE book (
    id    BIGINT GENERATED BY DEFAULT AS IDENTITY,
    name  VARCHAR(255) NOT NULL,
    isbn  VARCHAR(255) NOT NULL UNIQUE
);

During application startup, Flyway will execute the SQL file and create the schema needed for the application.

Domain

Create a Book domain class that uses Micronaut Data JDBC:

java/src/main/java/example/micronaut/Book.java
package example.micronaut;

import io.micronaut.data.annotation.GeneratedValue;
import io.micronaut.data.annotation.Id;
import io.micronaut.data.annotation.MappedEntity;
import io.micronaut.serde.annotation.Serdeable;

import static io.micronaut.data.annotation.GeneratedValue.Type.AUTO;

@Serdeable
@MappedEntity // 
public class Book {

    @Id // 
    @GeneratedValue(AUTO) // 
    private Long id;

    private String name;
    private String isbn;

    public Book(String isbn, String name) {
        this.isbn = isbn;
        this.name = name;
    }

    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getIsbn() {
        return isbn;
    }

    public void setIsbn(String isbn) {
        this.isbn = isbn;
    }
}
1 Annotate the class with @MappedEntity to map the class to the table defined in the schema.
2 Specifies the ID of an entity
3 Specifies that the property value is generated by the database and not included in inserts

BookRepository

Next, create the BookRepository interface to define database operations. Micronaut Data will implement the interface at compilation time:

java/src/main/java/example/micronaut/BookRepository.java
package example.micronaut;

import io.micronaut.core.annotation.NonNull;
import io.micronaut.data.jdbc.annotation.JdbcRepository;
import io.micronaut.data.repository.CrudRepository;

import jakarta.validation.constraints.NotBlank;
import java.util.Optional;

import static io.micronaut.data.model.query.builder.sql.Dialect.H2;

@JdbcRepository(dialect = H2) // 
public interface BookRepository extends CrudRepository<Book, Long> { // 

    @NonNull
    Optional<Book> findByIsbn(@NotBlank String isbn);
}
1 @JdbcRepository with a specific dialect.
2 Specifies that Book is the root entity, and the primary key type is Long.

Data populator class

Create a DataPopulator class to create some example database entries when the application starts:

java/src/main/java/example/micronaut/DataPopulator.java
package example.micronaut;

import io.micronaut.context.annotation.Requires;
import io.micronaut.context.event.StartupEvent;
import io.micronaut.runtime.event.annotation.EventListener;
import jakarta.inject.Singleton;

import jakarta.transaction.Transactional;

import static io.micronaut.context.env.Environment.TEST;

@Singleton // 
class DataPopulator {

    private final BookRepository bookRepository;

    DataPopulator(BookRepository bookRepository) { // 
        this.bookRepository = bookRepository;
    }

    @EventListener // 
    @Transactional // 
    void init(StartupEvent event) {
        if (bookRepository.count() == 0) {
            bookRepository.save(new Book("1491950358", "Building Microservices"));
            bookRepository.save(new Book("1680502395", "Release It!"));
            bookRepository.save(new Book("0321601912", "Continuous Delivery"));
        }
    }
}
1 Use jakarta.inject.Singleton to designate a class as a singleton.
2 Use constructor injection to inject a bean of type BookRepository.
3 Annotate a method with @EventListener to subscribe to an event you define as the method parameter.
4 You can declare a method or class as transactional with the jakarta.transaction.Transactional annotation.

BookController

Create BookController to access Book instances (and trigger JDBC metric data):

java/src/main/java/example/micronaut/BookController.java
package example.micronaut;

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.scheduling.TaskExecutors;
import io.micronaut.scheduling.annotation.ExecuteOn;
import io.micrometer.core.annotation.Timed;
import io.micrometer.core.annotation.Counted;

import java.util.Optional;

@Controller("/books") // 
@ExecuteOn(TaskExecutors.BLOCKING) // 
class BookController {

    private final BookRepository bookRepository;

    BookController(BookRepository bookRepository) { // 
        this.bookRepository = bookRepository;
    }

    @Get// 
    @Timed("books.index") // 
    Iterable<Book> index() {
        return bookRepository.findAll();
    }

    @Get("/{isbn}") // 
    @Counted("books.find") // 
    Optional<Book> findBook(String isbn) {
        return bookRepository.findByIsbn(isbn);
    }
}
1 The class is defined as a controller with the @Controller annotation mapped to the path /books.
2 It is critical that any blocking I/O operations (such as fetching the data from the database) are offloaded to a separate thread pool that does not block the Event loop.
3 Use constructor injection to inject a bean of type BookRepository.
4 Maps a GET request to /books, which returns a list of Book
5 Creates a Timer metric with the given name. If the name is omitted, defaults to method.timed.
6 Maps a GET request to /books/{isbn}, which attempts to show a Book. This illustrates the use of a URL path variable.
7 Creates a Counter metric with the given name. If the name is omitted, defaults to the method.counted.

Custom Metrics

To see custom metrics in action, create a service that periodically retrieves the current Bitcoin price in USD using REST.

Model

We’ll need a data class to represent the REST response. Create the BitcoinPrice class:

java/src/main/java/example/micronaut/crypto/BitcoinPrice.java
package example.micronaut.crypto;

import io.micronaut.serde.annotation.Serdeable;

@Serdeable // 
public class BitcoinPrice {

    private final Data data;

    public BitcoinPrice(Data data) {
        this.data = data;
    }

    public float getPrice() {
        return data.getPrice();
    }

    @Serdeable // 
    public static class Data {

        private final float price;

        public Data(float price) {
            this.price = price;
        }

        public float getPrice() {
            return price;
        }
    }
}
1 Annotate the class with @Introspected to generate BeanIntrospection metadata at compilation time. This information can be used, for example, to render the POJO as JSON using Jackson without using reflection.

Kucoin Declarative HTTP Client

Create a declarative Micronaut HTTP Client interface that will be implemented at compile time:

java/src/main/java/example/micronaut/crypto/PriceClient.java
package example.micronaut.crypto;

import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.QueryValue;
import io.micronaut.http.client.annotation.Client;

@Client(id = "kucoin") // 
public interface PriceClient {
    @Get("/api/v1/market/orderbook/level1")
    BitcoinPrice latest(@QueryValue String symbol);

    default BitcoinPrice latestInUSD() {
        return latest("BTC-USDT");
    }
}
1 Use @Client to use declarative HTTP Clients. You can annotate interfaces or abstract classes. You can use the id member to provide a service identifier or specify the URL directly as the annotation’s value.

HTTP Service Configuration

Modify application.properties to configure the URL for the kucoin Service ID:

src/main/resources/application.properties
# 
micronaut.http.services.kucoin.url=https://api.kucoin.com
1 The ID we used with @Client and the URL for the kucoin service

Service

Create a CryptoService class that uses PriceClient and updates three custom meters:

java/src/main/java/example/micronaut/crypto/CryptoService.java
package example.micronaut.crypto;

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;

@Singleton // 
public class CryptoService {

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

    private final PriceClient priceClient;
    private final Counter checks;
    private final Timer time;
    private final AtomicInteger latestPriceUsd = new AtomicInteger(0);

    CryptoService(PriceClient priceClient, // 
                  MeterRegistry meterRegistry) {
        this.priceClient = priceClient;

        checks = meterRegistry.counter("bitcoin.price.checks"); // 
        time = meterRegistry.timer("bitcoin.price.time"); // 
        meterRegistry.gauge("bitcoin.price.latest", latestPriceUsd); // 
    }

    @Scheduled(fixedRate = "${crypto.update-frequency:1h}",
            initialDelay = "${crypto.initial-delay:0s}") // 
    public void updatePrice() {
        time.record(() -> { // 
            try {
                checks.increment(); // 
                latestPriceUsd.set((int) priceClient.latestInUSD().getPrice()); // 
            } catch (Exception e) {
                log.error("Problem checking price", e);
            }
        });
    }
}
1 Use jakarta.inject.Singleton to designate a class as a singleton.
2 Use constructor injection to inject PriceClient, MeterRegistry, and ObjectMapper beans
3 Create a Counter to track the total number of updates
4 Create a Timer to track the total time performing updates
5 Create a Gauge to track the most recent update
6 Use the Scheduled annotation to configure regular updates
7 Update the Timer
8 Increment the Counter
9 Update the Gauge with the latest price

Testing the Application

Create the src/test/resources/application-test.properties configuration file for tests.

src/test/resources/application-test.properties
crypto.initial-delay=10h
1 Disable crypto price lookups with a long initial delay

Create a test class to verify metrics functionality:

java/src/test/java/example/micronaut/MetricsTest.java
package example.micronaut;

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 MetricsTest {

    @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("process.files.open"));
        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/1491950358"),
                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("process.files.open"));
        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);
    }
}
1 Annotate the class with @MicronautTest so the Micronaut framework will initialize the application context and the embedded server. More info.
2 Inject the MeterRegistry bean
3 Inject the LoggingSystem bean
4 Inject the HttpClient bean and point it to the embedded server.

Create an additional test class to verify the custom metrics:

java/src/test/java/example/micronaut/CryptoUpdatesTest.java
package example.micronaut;

import example.micronaut.crypto.CryptoService;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.MeterRegistry;
import io.micrometer.core.instrument.Timer;
import io.micronaut.context.ApplicationContext;
import io.micronaut.context.annotation.Requires;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.annotation.QueryValue;
import io.micronaut.runtime.server.EmbeddedServer;
import org.junit.jupiter.api.AfterAll;
import org.junit.jupiter.api.BeforeAll;
import org.junit.jupiter.api.Test;
import org.junit.jupiter.api.TestInstance;

import java.util.Collections;

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

@TestInstance(PER_CLASS)
public class CryptoUpdatesTest {

    EmbeddedServer embeddedServer;
    EmbeddedServer kucoinEmbeddedServer;

    @BeforeAll
    void beforeAll() {

        kucoinEmbeddedServer = ApplicationContext.run(EmbeddedServer.class,
                Collections.singletonMap("spec.name", "MetricsTestKucoin"));

        embeddedServer = ApplicationContext.run(EmbeddedServer.class,
                Collections.singletonMap("micronaut.http.services.kucoin.url", "http://localhost:" + kucoinEmbeddedServer.getPort()));
    }

    @AfterAll
    void afterAll() {
        embeddedServer.close();
        kucoinEmbeddedServer.close();
    }

    @Test
    void testCryptoUpdates() {
        CryptoService cryptoService = embeddedServer.getApplicationContext().getBean(CryptoService.class);
        MeterRegistry meterRegistry = embeddedServer.getApplicationContext().getBean(MeterRegistry.class);

        Counter counter = meterRegistry.counter("bitcoin.price.checks");
        Timer timer = meterRegistry.timer("bitcoin.price.time");

        assertEquals(0, counter.count(), 0.000001);
        assertEquals(0, timer.totalTime(MILLISECONDS));

        int checks = 3;

        for (int i = 0; i < checks; i++) {
            cryptoService.updatePrice();
        }

        assertEquals(checks, counter.count(), 0.000001);
        assertTrue(timer.totalTime(MILLISECONDS) > 0);
    }

    @Requires(property = "spec.name", value = "MetricsTestKucoin")
    @Controller
    static class MockKucoinController {
        private static final String RESPONSE = """
                {
                "code":"200000",
                   "data":{
                      "time":1654865889872,
                      "sequence":"1630823934334",
                      "price":"29670.4",
                      "size":"0.00008436",
                      "bestBid":"29666.4",
                      "bestBidSize":"0.16848947",
                      "bestAsk":"29666.5",
                      "bestAskSize":"2.37840044"
                   }
                }""";

        @Get("/api/v1/market/orderbook/level1")
        String latest(@QueryValue String symbol) {
            return RESPONSE;
        }
    }
}

The previous test creates two Micronaut embedded servers. One mocks the kucoin API, the other is our application. The test uses @Requires to conditionally load a controller only for the kucoin bean context. We used an identifier with @Client, which makes it easy to point our HTTP client to the mock server.

Running the tests

To run the tests:

./gradlew test

Then open build/reports/tests/test/index.html in a browser to see the results.

Running the Application

To run the application, use the ./gradlew run command, which starts the application on port 8080.

Alternatively, to make the Bitcoin price update occur more frequently to see the effects on metrics, start the application with a config override to update every five seconds:

./gradlew run --args="-crypto.updateFrequency=5s"

You can retrieve a list of known metrics using cURL:

curl localhost:8080/metrics

The response should look like this:

{
  "names": [
    "bitcoin.price.checks",
    "bitcoin.price.latest",
    "bitcoin.price.time",
    "executor",
    "executor.active",
    "executor.completed",
    "executor.pool.core",
    "executor.pool.max",
    "executor.pool.size",
    "executor.queue.remaining",
    "executor.queued",
    "hikaricp.connections",
    "hikaricp.connections.acquire",
    "hikaricp.connections.active",
    ...
    "jvm.threads.peak",
    "jvm.threads.states",
    "logback.events",
    "process.cpu.usage",
    "process.files.max",
    "process.files.open",
    "process.start.time",
    "process.uptime",
    "system.cpu.count",
    "system.cpu.usage",
    "system.load.average.1m"
  ]
}

After the application has been running for a bit and has made a few Bitcoin price checks, we can view the related metric values:

curl localhost:8080/metrics/bitcoin.price.latest
{
  "measurements": [{ "statistic": "VALUE", "value": 29659.0 } ],
  "name": "bitcoin.price.latest"
}
curl localhost:8080/metrics/bitcoin.price.checks
{
  "measurements": [{ "statistic": "COUNT", "value": 5.0 } ],
  "name": "bitcoin.price.checks"
}
curl localhost:8080/metrics/bitcoin.price.time
{
  "baseUnit": "seconds",
  "measurements": [
    { "statistic": "COUNT",      "value": 5.0 },
    { "statistic": "TOTAL_TIME", "value": 2.525546791 },
    { "statistic": "MAX",        "value": 0.851958216 }
  ],
  "name": "bitcoin.price.time"
}

Generate a Micronaut Application Native Executable with GraalVM

We will use GraalVM, an advanced JDK with ahead-of-time Native Image compilation, to generate a native executable of this Micronaut application.

Compiling Micronaut applications ahead of time with GraalVM significantly improves startup time and reduces the memory footprint of JVM-based applications.

Note
 Only Java and Kotlin projects support using GraalVM’s native-image tool. Groovy relies heavily on reflection, which is only partially supported by GraalVM.

GraalVM Installation

The easiest way to install GraalVM on Linux or Mac is to use SDKMan.io.

Java 25
sdk install java 25.0.2-graal

For installation on Windows, or for a manual installation on Linux or Mac, see the GraalVM Getting Started documentation.

The previous command installs Oracle GraalVM, which is free to use in production and free to redistribute, at no cost, under the GraalVM Free Terms and Conditions.

Alternatively, you can use the GraalVM Community Edition:

Java 25
sdk install java 25.0.2-graalce

Native Executable Generation

To generate a native executable using Gradle, run:

./gradlew nativeCompile

The native executable is created in build/native/nativeCompile directory and can be run with build/native/nativeCompile/micronautguide.

It is possible to customize the name of the native executable or pass additional parameters to GraalVM:

build.gradle
graalvmNative {
    binaries {
        main {
            imageName.set('mn-graalvm-application') // 
            buildArgs.add('-Ob') // 
        }
    }
}
1 The native executable name will now be mn-graalvm-application
2 It is possible to pass extra build arguments to native-image. For example, -Ob enables the quick build mode.

Start the native image and run the cURL commands above to see that the application works the same way as before, with faster startup and response times.

Next Steps

In combination with the /metrics endpoint, you often want to register a specific type of reporter. See the Micronaut Micrometer documentation to learn about the supported libraries for reporting metrics.

License

Note
 All guides are released with an Apache License 2.0 for the code and a Creative Commons Attribution 4.0 license for the writing and media (images).