Your code can create, look up, and update metrics programmatically using the Micrometer MeterRegistry API. The Micrometer concepts document provides a good starting point for learning how to use Micrometer’s interfaces and classes.

Your application can easily have Helidon create a REST endpoint which clients can access to retrieve Micrometer metrics, by default at the /micrometer endpoint.

Within Helidon, each type of meter registry is paired with some code that examines the incoming HTTP request to /micrometer and decides whether the request matches up with the associated meter registry. The first pairing that accepts the request returns the response. You will need to take advantage of this if your application uses additional meter registries beyond what Helidon automatically provides and you want those meter registries reflected in the output from the /micrometer REST endpoint.

Helidon provides no special API for dealing with Micrometer meters and meter registries beyond what Micrometer offers itself.

Helidon does give you an easy way to expose a REST endpoint to report the meters stored in the Micrometer meter registry. The MicrometerSupport interface exposes static methods to directly create an instance of MicrometerSupport and to return a Builder instance so your code can fine-tune how the REST service behaves.

By default, Helidon Micrometer integration exposes the /micrometer endpoint. You can override the path using the Builder or the micrometer.web-context configuration key.

micrometer:
  web-context: my-micrometer

MicrometerFeature micrometerFeature = MicrometerFeature.create(); 

HttpRouting.builder()
        .addFeature(micrometerFeature) 
        .register("/myapp", new MyService(micrometerFeature.registry())) 
        .build();

• Create the MicrometerSupport instance, using the default built-in Prometheus meter registry.
• Register the MicrometerSupport instance as a service; by default, MicrometerSupport exposes the endpoint as /micrometer.
• Pass the MicrometerSupport object’s meter registry to your service for use in creating and updating meters.

class MyService implements HttpService {

    final Counter requestCounter;

    MyService(MeterRegistry registry) {
        requestCounter = registry.counter("allRequests"); 
    }

    @Override
    public void routing(HttpRules rules) {
        rules
                .any(this::countRequests) 
                .get("/", this::myGet);
    }

    void countRequests(ServerRequest request, ServerResponse response) {
        requestCounter.increment(); 
        response.next();
    }

    void myGet(ServerRequest request, ServerResponse response) {
        response.send("OK");
    }

}

• Use the Micrometer meter registry to create the request counter.
• Add routing for any request to invoke the method which counts requests by updating the counter.
• Update the counter and then delegate the rest of the request processing to the next handler in the chain.

The example above enrolls the built-in Prometheus meter registry with the default Prometheus registry configuration. You can change the default setup for built-in registries, and you can enroll other meter registries your application creates itself.

Overriding Defaults for Built-in Meter Registry Types

Using MicrometerSupport.Builder

MeterRegistryFactory meterRegistryFactory = MeterRegistryFactory.builder()
        .enrollBuiltInRegistry(BuiltInRegistryType.PROMETHEUS, myPrometheusConfig) 
        .build();
MicrometerFeature micrometerFeature = MicrometerFeature.builder()
        .meterRegistryFactorySupplier(meterRegistryFactory)
        .build();

Using Configuration

micrometer:
  builtin-registries:
    - type: prometheus

micrometer:
  builtin-registries:
    - type: prometheus
      prefix: myPrefix

To create additional types of registries and enroll them with MicrometerSupport, you need to:

1. Write a Handler
   

   Each meter registry has its own way of producing output. Write your handler so that it has a reference to the meter registry it should use and so that its accept method sets the payload in the HTTP response using the registry’s mechanism for creating output.

2. Write a Function which accepts a ServerRequest and returns an Optional<Handler>
   

   Typically, the function examines the request—​the Content-Type, query parameters, etc.--to decide whether the corresponding handler should respond to the request. If so, your function should instantiate your Handler and return an Optional.of(theHandlerInstance); otherwise, your function should return Optional.empty().
   

   When MicrometerSupport receives a request, it invokes the functions of all the enrolled registries, stopping as soon as one function provides a handler. MicrometerSupport then delegates to that handler to create and send the response.

3. Pass the Handler and Function to the MicrometerSupport.enrollRegistry method to enroll them
   
   Creating and enrolling your own Micrometer meter registry

   PrometheusMeterRegistry myRegistry = new PrometheusMeterRegistry(myPrometheusConfig); 
   MeterRegistryFactory meterRegistryFactory = MeterRegistryFactory.builder()
           .enrollRegistry(myRegistry, request -> {
               return request 
                       .headers()
                       .bestAccepted(MediaTypes.TEXT_PLAIN)
                       .map(mt -> (req, resp) -> resp.send(myRegistry.scrape())); 
           })
           .build();
   MicrometerFeature micrometerFeature = MicrometerFeature.builder()
           .meterRegistryFactorySupplier(meterRegistryFactory)
           .build();

   content_copy Copied
   • Create the meter registry. This example uses a Prometheus registry, but it can be any extension of MeterRegistry.
   • Provide the function that checks if the ServerRequest
   • A very simple in-line Handler that sets the response entity from the Prometheus registry’s scrape() method.

Your application can easily have Helidon create a REST endpoint which clients can access to retrieve Micrometer metrics, by default at the /micrometer endpoint.

Within Helidon, each type of meter registry is paired with some code that examines the incoming HTTP request to /micrometer and decides whether the request matches up with the associated meter registry. The first pairing that accepts the request returns the response. You will need to take advantage of this if your application uses additional meter registries beyond what Helidon automatically provides and you want those meter registries reflected in the output from the /micrometer REST endpoint.

When MicrometerSupport receives a request at the endpoint, it looks for the first enrolled meter registry for which the corresponding Function<ServerRequest, Optional<Handler>> returns a non-empty Handler. Helidon invokes that Handler which must retrieve the metrics output from its meter registry and set and send the response. Note that the Handler which your function returns typically has a reference to the meter registry it will use in preparing the response.