Suivi d’une application Spring avec Actuator

management:
  endpoint:
    health:
      show-components: always

~$ curl http://localhost:9999/actuator/health

{
  "status":"UP",
  "components": {
    "db":{
      "status":"UP",
    },
    "diskSpace": {
      "status":"UP",
    },
    "ping":{
      "status":"UP"
    }
  }
}

~$ curl http://localhost:9999/actuator/health/db

{
  "status":"UP",
}

management:
  endpoint:
    health:
      show-details: always

~$ curl http://localhost:9999/actuator/health

{
  "status":"UP",
  "components": {
    "db":{
      "status":"UP",
      "details":{
        "database":"PostgreSQL",
        "validationQuery":"isValid()"
      }
    },
    "diskSpace": {
      "status":"UP",
      "details": {
        "total":502392610816,
        "free":381957959680,
        "threshold":10485760,
        "exists":true
      }
    },
    "ping":{
      "status":"UP"
    }
  }
}

management:
  endpoint:
    health:
      probes:
        enabled: true

~$ curl http://localhost:9999/actuator/health/liveness

{
    "status": "UP"
}

~$ curl http://localhost:9999/actuator/health/readiness

{
    "status": "UP"
}

management:
  metrics:
    web:
      server:
        request:
          autotime:
            enabled: false

~$ curl http://localhost:9999/actuator/metrics/http.server.requests

{
  "name": "http.server.requests",
  "baseUnit": "seconds",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 754
    },
    {
      "statistic": "TOTAL_TIME",
      "value": 134.09375702
    },
    {
      "statistic": "MAX",
      "value": 0.76434196
    }
  ]
}

~$ curl http://localhost:9999/actuator/metrics/http.server.requests?tag=uri:/secured/roles&tag=method:GET

{
  "name": "http.server.requests",
  "description": null,
  "baseUnit": "seconds",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 56
    },
    {
      "statistic": "TOTAL_TIME",
      "value": 5.121863713
    },
    {
      "statistic": "MAX",
      "value": 0.143918815
    }
  ]
}

management.metrics.data.repository.autotime.enabled=false

~$ curl http://localhost:9999/actuator/metrics/spring.data.repository.invocations

{
  "name": "spring.data.repository.invocations",
  "description": null,
  "baseUnit": "seconds",
  "measurements": [
    {
      "statistic": "COUNT",
      "value": 293
    },
    {
      "statistic": "TOTAL_TIME",
      "value": 2.293597305
    },
    {
      "statistic": "MAX",
      "value": 0
    }
  ]
}

~$ curl http://localhost:9999/actuator/metrics/spring.data.repository.invocations?tag=repository:ClientRepository'&'method=findAll

spring:
  jpa:
    properties:
      hibernate:
        generate_statistics: true

    <dependency>
        <groupId>org.hibernate</groupId>
        <artifactId>hibernate-micrometer</artifactId>
        <version>${hibernate.version}</version>
    </dependency>

  private final Counter createClientCallCounter;

  public ClientService(MeterRegistry meterRegistry) {
      Counter createClientCallCounter = Counter.builder("jtips.client.create")
                                              .description("Nombre de création de Client")
                                              .register(meterRegistry);
  }

  public Client create(Client client) {
    createClientCallCounter.increment();
    ...
  }

  <dependency>
    <groupId>io.micrometer</groupId>
    <artifactId>micrometer-registry-jmx</artifactId>
    <version>${micrometer.version}</version>
  </dependency>

management:
  jmx:
    metrics:
      export:
        domain: info.jtips

@Component
@Endpoint(id = "echo")
public class EchoEndpoint {
    @ReadOperation
    public String echo(@Selector String input) {
        return "Hello " + input;
    }
}

@Component
@Endpoint(id = "echo")
public class EchoEndpoint {
    @ReadOperation(produces = "text/plain")
    public WebEndpointResponse<String> echoSimple(@Selector String input) {
        return new WebEndpointResponse<>("Hello " + input);
    }

    @ReadOperation(produces = "application/json")
    public WebEndpointResponse<Message> echoJson(@Selector String input) {
        return new WebEndpointResponse<>(new Message("Hello", input));
    }
    public record Message(String hi, String dest) {}
}

/
 * An @Endpoint for exposing aggregated metrics from Prometheus registry.
 * 

 * Can be requested in JSON format (default), in CSV (text/csv) or in Prometheus format ("text/plain").
 */
@Component
@Endpoint(id = "metrix")
public class MetrixEndpoint {

  private final PrometheusScrapeEndpoint prometheusScrapeEndpoint;
  private final CollectorRegistry collectorRegistry;

  public MetrixEndpoint(PrometheusScrapeEndpoint prometheusScrapeEndpoint, CollectorRegistry collectorRegistry) {
    this.prometheusScrapeEndpoint = prometheusScrapeEndpoint;
    this.collectorRegistry = collectorRegistry;
  }

  /
    * JSON format, default
    */
  @ReadOperation()
  public List json(@Nullable Set includedNames) {
    Enumeration samples = (includedNames != null)
            ? this.collectorRegistry.filteredMetricFamilySamples(includedNames)
            : this.collectorRegistry.metricFamilySamples();
    return Collections.list(samples);
  }

  /
    * Prometheus format ("text/plain")
    */
  @ReadOperation(producesFrom = TextOutputFormat.class)
  public WebEndpointResponse prometheus(TextOutputFormat format, @Nullable Set includedNames) {
    return prometheusScrapeEndpoint.scrape(format, includedNames);
  }

  /
    * CSV format ("text/csv")
    */
  @ReadOperation(produces = "text/csv")
  public String csv(@Nullable Set includedNames) {
    return json(includedNames).stream()
            .flatMap(metric -> metric.samples.stream().map(sample -> new MetricSample(metric, sample)))
            .map(MetricSample::toCsv)
            .collect(Collectors.joining());
  }

  @ReadOperation
  public Collector.MetricFamilySamples single(@Selector String requiredMetricName) {
    return this.collectorRegistry.filteredMetricFamilySamples(Set.of(requiredMetricName)).nextElement();
  }

  private record MetricSample(Collector.MetricFamilySamples metric, Collector.MetricFamilySamples.Sample sample) {
    String toCsv() {
      Stream labels = StreamUtils.zip(
              sample.labelNames.stream(),
              sample.labelValues.stream(),
              (name, value) -> String.format("%s=\"%s\"", name, value));
      return "%s;%s;%s;%s%n"
              .formatted(sample.name, labels.collect(Collectors.joining(",")), sample.value, metric.unit);
    }
  }

}