Prérequis

Avant de commencer, assurez-vous d’avoir :

• Java Development Kit (JDK) installé.
• Apache Maven installé et configuré.
• Une connaissance de base des concepts Java et Maven.

Étape 1 : Configurer le Projet du Plugin

Pour créer un plugin Maven, commencez par configurer un nouveau projet Maven :

1. Ouvrez un terminal ou un IDE et exécutez la commande suivante pour créer une structure de projet :

mvn archetype:generate -DgroupId=com.exemple -DartifactId=my-plugin -DarchetypeArtifactId=maven-archetype-plugin -DinteractiveMode=false

Cette commande utilise l’archétype de plugin Maven pour générer une structure de base pour votre plugin.

2. Accédez au répertoire du projet généré

cd my-plugin

Étape 2 : Implémenter la Logique du Plugin

1. Localisez la classe principale du plugin sous src/main/java/com/example/MyMojo.java. Cette classe est annotée avec @Mojo et sert de point d’entrée pour votre plugin.

2. Modifiez la classe MyMojo pour implémenter la fonctionnalité souhaitée. Par exemple :

package com.example;

import org.apache.maven.plugin.AbstractMojo;
import org.apache.maven.plugin.MojoExecutionException;
import org.apache.maven.plugins.annotations.Mojo;
import org.apache.maven.plugins.annotations.Parameter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;

@Mojo(name = "generatefile")
public class MyMojo extends AbstractMojo {

    @Parameter(property = "outputDir", defaultValue = "${project.build.directory}")
    private File outputDir;

    @Parameter(property = "filename", defaultValue = "output.txt")
    private String filename;

    @Parameter(property = "content", defaultValue = "Hello, Maven Plugin!")
    private String content;

    public void execute() throws MojoExecutionException {
        File outputFile = new File(outputDir, filename);
        try {
            if (!outputDir.exists()) {
                outputDir.mkdirs();
            }
            try (FileWriter writer = new FileWriter(outputFile)) {
                writer.write(content);
            }
            getLog().info("Fichier généré à : " + outputFile.getAbsolutePath());
        } catch (IOException e) {
            throw new MojoExecutionException("Erreur lors de la génération du fichier", e);
        }
    }
}

Dans cet exemple, le plugin définit une tâche nommée generatefile qui génère un fichier texte avec le contenu spécifié. Les utilisateurs peuvent personnaliser le répertoire de sortie, le nom du fichier et le contenu à l’aide des paramètres du plugin.

Étape 3 : Construire et Tester le Plugin

1. Construisez le projet du plugin en exécutant

mvn clean install

Cette commande compile le plugin et l’installe dans votre dépôt Maven local.

2. Pour tester le plugin, créez un projet Maven simple et ajoutez la configuration suivante à son fichier pom.xml :

<build>
    <plugins>
        <plugin>
            <groupId>com.example</groupId>
            <artifactId>my-plugin</artifactId>
            <version>1.0-SNAPSHOT</version>
            <configuration>
                <outputDir>${project.build.directory}/custom-dir</outputDir>
                <filename>custom-file.txt</filename>
                <content>Ceci est un fichier généré sur mesure.</content>
            </configuration>
        </plugin>
    </plugins>
</build>

3. Exécutez le plugin avec la commande :

mvn com.example:my-plugin:1.0-SNAPSHOT:generatefile

Vous devriez voir un message indiquant l’emplacement du fichier. Vérifiez que le fichier est créé avec le contenu spécifié.

Étape 4 : Personnaliser et Étendre

Vous pouvez améliorer votre plugin en ajoutant plus de tâches, de paramètres et de dépendances. Voici quelques conseils :

• Ajouter Plusieurs Tâches : Définissez plusieurs classes annotées avec @Mojo, chacune implémentant une tâche différente.
• Accéder aux Détails du Projet : Utilisez l’annotation @Parameter pour injecter les détails du projet Maven, tels que les dépendances et les répertoires de construction.
• Inclure des Dépendances : Ajoutez des dépendances dans le fichier pom.xml de votre plugin pour réutiliser des bibliothèques existantes.

Étape 5 : Publier le Plugin (Optionnel)

Pour rendre votre plugin disponible à d’autres développeurs, envisagez de le publier dans un dépôt Maven. Mettez à jour le fichier pom.xml avec les paramètres de gestion de distribution et déployez le plugin en exécutant :

mvn deploy

Conclusion

Créer un plugin Maven personnalisé peut considérablement simplifier vos processus de construction et ajouter des fonctionnalités précieuses à vos projets. En suivant ce guide, vous pouvez construire, tester et étendre votre plugin facilement. Explorez la documentation Maven pour découvrir des fonctionnalités avancées et des meilleures pratiques.

Code source

L’exemple complet de ce tutorial est disponible sur GitHub

L’article Développer un Plugin Maven est apparu en premier sur ji-ka.

1. Spring, c’est quoi

Sorti en 2003, Spring est un Framework de développement d’application Java qui fournit une infrastructure complète pour le développement d’applications

Spring s’appuie principalement sur l’intégration de 3 concepts clés :

• L’inversion de contrôle : La recherche de dépendance et l’injection de dépendances
• La programmation orientée aspect.
• Une couche d’abstraction qui permet d’intégrer d’autres Framework et bibliothèques.

2. Bean, c’est quoi

Un Bean est une instance d’une classe qui est crée, assemblé et géré par le conteneur Spring offrant ainsi un moyen souple de gérer les composants d’une application.

2.1. Caractéristiques des Beans

• Gestion du cycle de vie : Spring gère le cycle de vie des Beans, depuis leur création jusqu’à leur destruction.
• Injection de dépendances : Les dépendances d’un Bean peuvent être injectées par le conteneur Spring, ce qui facilite le développement et la maintenance de l’application.
• Configuration déclarative : Les Beans peuvent être configurés à l’aide de fichiers de configuration XML, d’annotations Java ou de configurations basées sur Java.
• Réutilisation et modularité : Les beans peuvent être réutilisés et assemblés pour former des applications modulaires.

2.2. Cycle de vie d’un Bean

Le cycle de vie des beans dans Spring se compose de plusieurs étapes distinctes, chacune jouant un rôle crucial dans le bon fonctionnement de l’application. :

Un Bean suit un cycle de vie bien défini, composé des phases clés suivantes :

• Instanciation : Cette phase correspond à la création d’une instance de bean. Spring prend en charge plusieurs mécanismes d’instanciation, tels que la création par un constructeur, la création par une méthode statique de la classe, ou la récupération depuis un pool de beans déjà créés.
• Injection des Dépendances : Une fois que le bean est créé, Spring injecte les dépendances nécessaires. Cela peut être réalisé par le biais de méthodes de configuration (setter) ou de la configuration du constructeur.
• Initialisation : Après l’injection des dépendances, le conteneur Spring appelle des méthodes d’initialisation spécifiées par le développeur. Ces méthodes permettent d’effectuer des opérations personnalisées avant que le bean ne soit pleinement opérationnel.
• Utilisation : À ce stade, le bean est prêt à être utilisé dans l’application. Les autres composants de l’application peuvent maintenant interagir avec le bean pour effectuer leurs tâches.
• Destruction : Lorsque l’application se termine ou lorsque le bean n’est plus nécessaire, le conteneur Spring peut appeler des méthodes de destruction spécifiées par le développeur. Ces méthodes permettent d’effectuer des opérations de nettoyage ou de libération de ressources.

3. Plus de d’étails

Carl Azoury nous montre, ici, comment fonctionne le cycle de vie des Beans via cette conférences  qui a eu lieu lors de l’événement DEVOXX France 2023

4. Conclusion

Comprendre le cycle de vie des beans dans Spring est essentiel pour un développement efficace et une gestion appropriée des ressources. En utilisant les différentes annotations et interfaces fournies par Spring, vous pouvez contrôler le comportement de vos beans à chaque étape de leur cycle de vie, garantissant ainsi une application bien gérée et performante

L’article Cycle de Vie des Beans dans Spring Framework est apparu en premier sur ji-ka.

1 API ChatGPT

l’API qu’on va utiliser dans ce tutorial s’appelle chat completation. Commençant par jeter un coup d’œil à cette API pour comprendre son modèle.

1.1 Accès à l’API

Pour utiliser l’API chat completation, vous devez obtenir un accès auprès d’OpenAI

1.2 Utilisation de l’API

Utilisez la clé API pour faire des requêtes à l’API « completions » en utilisant des appels HTTP. Il faut fournir un message qui est le texte d’entrée ou la question que vous souhaitez poser et l’API renvoie une réponse générée par le moteur GPT.

curl -X POST -s https://api.openai.com/v1/chat/completions \
-H "Content-Type: application/json" \
-H "Authorization: Bearer ${CLE_API}" \
-d '{
    "model": "gpt-3.5-turbo",
    "messages": [
        {
            "role": "user",
            "content": "Hello!"
        }
    ]
}'

Assurez vous de remplacer « ${CLE_API} » par votre clé API réelle et de personnaliser les autres paramètres de la requête en fonction de vos besoins.

• model : ID / version du modèle à utiliser. Pour cet exemple, on va utilisée le denier model de la version publique (gpt-3.5-turbo), ceci dit, il existe d’autres models aussi, voir ici.
• messages : Une liste de messages comprenant la conversation. Chaque message nécessite deux champs:
  • role : spécifie l’expéditeur du message
  • content: le message réel à envoyer

1.3 Réponse de l’API

La réponse de l’API sera au format JSON avec des métadonnées et un  champ « choices« . Ce champ est une liste qui contient un index et une liste de messages.

{
  "id": "chatcmpl-123",
  "object": "chat.completion",
  "created": 1589478378,
  "model": "gpt-3.5-turbo",
  "choices": [{
    "index": 0,
    "message": {
      "role": "assistant",
      "content": "\n\nHello there, how may I assist you today?",
    },
    "finish_reason": "stop"
  }],
  "usage": {
    "prompt_tokens": 5,
    "completion_tokens": 7,
    "total_tokens": 12
  }
}

2 Spring et ChatGPT

Nous allons créer une application Spring Boot contenant une API Rest qui accepte un message dans les paramètres de la requête, le transmet à l’API ChatGPT et renvoie le message de retour.

2.1 Dépendances

Créer un projet du starter Spring boot et ajouter la dépendance « spring-boot-starter-web« 

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

Aussi, on a besoin de Lombok pour faciliter la génération du getter et setter.

		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>

2.2 Configuration

Dans cette article on va faire simple du coup on va utiliser ResTemplate pour s’interfacer avec OpenAI. On doit ajouter un intercepteur pour ajouter la clé.

@Configuration
public class OpenAIConfig {

    @Value("${application.openai.key}")
    private String openaiApiKey;

    @Bean
    @Qualifier("openaiRestTemplate")
    public RestTemplate openaiRestTemplate() {
        RestTemplate restTemplate = new RestTemplate();
        restTemplate.getInterceptors().add((request, body, execution) -> {
            request.getHeaders().add("Authorization", "Bearer " + openaiApiKey);
            return execution.execute(request, body);
        });
        return restTemplate;
    }
}

2.3 Modèle

Créons maintenant le modèle correspondant au modèle de l’api ChatGPT.

• Classe Message :

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Message {

		private String role;
		private String content;

}

• Classe Choice :

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Choice {

    private int index;
    private Message message;
}

Ensuite, créons note model request et response.

• Classe ChatRequest :

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChatRequest {

	private String model;
	private List<Message> messages;

	@Builder
	public ChatRequest(String model, String message) {
		this.model = model;
		this.messages = new ArrayList<>();
		this.messages.add(new Message("user", message));
	}

}

• Classe de réponse :

@Data
@AllArgsConstructor
@NoArgsConstructor
public class ChatResponse {

	private String id;
	private List<Choice> choices;
	@JsonProperty("finish_reason")
	private String finishReason;
}

2.4 Service

La classe service permet d’appeler notre client OpenAI :

@Service
@RequiredArgsConstructor
public class ChatService {

	@Qualifier("openaiRestTemplate")
	private final RestTemplate restTemplate;

	@Value("${application.openai.model}")
	private String model;

	@Value("${application.openai.url}")
	private String apiUrl;

	public String sendMessage(String message) {
		ChatRequest request = ChatRequest.builder()
				.model(model)
				.message(message)
				.build();
				
		ChatResponse response = restTemplate.postForObject(apiUrl, request, ChatResponse.class);
		if (response == null || CollectionUtils.isEmpty(response.getChoices())) {
			return "No response";
		}
		return response.getChoices().get(0).getMessage().getContent();
	}

}

2.5 Api d’entré

Exposant maintenant notre Api :

@RestController
@RequiredArgsConstructor
public class ChatController {

	private final ChatService chatService;

	@GetMapping("/chat")
	public String chat(@RequestParam String message) {
		return chatService.sendMessage(message);
	}

}

2.6 Propriétés

Ajoutons dans le fichier « application.yml » les paramètres qu’on a déclaré.

application:
  openai:
    model: gpt-3.5-turbo
    url: https://api.openai.com/v1/chat/completions
    key: ${your_api_key}

3 Exécution

Désormé, on peut lancer l’application et appeler notre api via http://localhost:8080/chat?message=Hello!

4 Code source

L’exemple complet de ce tutorial est disponible sur GitHub

5. Référence

https://platform.openai.com/docs/models/model-endpoint-compatibility

https://platform.openai.com/docs/api-reference/completions

L’article Premier pas avec Spring et ChatGPT est apparu en premier sur ji-ka.

1 Application

Spring Boot is a very popular microservice framework that significantly simplifies web application development by providing Java developers with a platform to get started with an auto-configurable, production-grade Spring application.

1.1 Actuator

Actuator endpoints let you monitor and interact with your Spring Boot application.
Read this article for more details : spring boot actuator

1.2 Setup

• Prometheus dependency

To expose prometeus enndpoint we nedd to add this dependency

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-actuator</artifactId>
        </dependency>

        <dependency>
            <groupId>io.micrometer</groupId>
            <artifactId>micrometer-registry-prometheus</artifactId>
            <scope>runtime</scope>
        </dependency>

• Spring Boot properties

Next, we need to expose an actuator endpoint through which Prometheus will collect metrics data in the format that Prometheus understands. For this, we need to add the following properties.

# -- actuator global configuration -- #
management: 
  endpoints: 
    web: 
      exposure: 
        include: "health,info,prometheus"
  endpoint:
    health:
      show-details: always
    metrics:
      enabled: true
    prometheus:
      enabled: true 

management.metrics:
  tags:
    application: ${spring.application.name}
    env: ${spring.profiles.active}
  distribution:
    percentiles-histogram:
      http:
        server:
          requests: 'true'

You can reach the info actuator on your local machine : http://localhost:8080/actuator/prometheus once you start your Spring Boot application.

The prometheus endpoint shows various metrics, such as JVM threads state, information about HTTP server requests, etc.

• Metics data

After opening the above endpoint, you will find some metrics data in the following format

jvm_memory_used_bytes{application="spring-prometheus-client",area="nonheap",env="local",id="Metaspace",} 4.417008E7
jvm_memory_used_bytes{application="spring-prometheus-client",area="heap",env="local",id="G1 Survivor Space",} 8388608.0
jvm_memory_used_bytes{application="spring-prometheus-client",area="nonheap",env="local",id="CodeHeap 'non-nmethods'",} 1294336.0
jvm_memory_used_bytes{application="spring-prometheus-client",area="heap",env="local",id="G1 Old Gen",} 9224992.0
jvm_memory_used_bytes{application="spring-prometheus-client",area="nonheap",env="local",id="CodeHeap 'non-profiled nmethods'",} 1.0788608E7
jvm_memory_used_bytes{application="spring-prometheus-client",area="nonheap",env="local",id="Compressed Class Space",} 5484736.0
jvm_memory_used_bytes{application="spring-prometheus-client",area="heap",env="local",id="G1 Eden Space",} 2.5165824E7

The first part (jvm_memory_used_bytes) is called the label, while the fields inside the curly braces are called attributes. Each of these labels represents a particular metric and the attribute provides you with a way to query so that you can get the values.

2 Prometheus

Prometheus gathers metrics at intervals and needs to know how often to scrape them.
We will be using a Prometheus docker image and provide it with some configuration

2.1 Configuration file

# my global config
global:
  scrape_interval:     120s  # By default, scrape targets every 15 seconds.
  evaluation_interval: 120s  # By default, scrape targets every 15 seconds.

# A scrape configuration containing exactly one endpoint to scrape:
# Here it's Prometheus itself.
scrape_configs:  
  - job_name: 'Spring Boot Application input'
    metrics_path: '/actuator/prometheus'
    scrape_interval: 2s
    static_configs:
      - targets: ['host.docker.internal:8080']

Important notes :

• scrape_interval : Scrape the application and collect information every 2 seconds
• targets : The target is the host and port of our application.
• metrics_path : The path we want to scrape.

2.2 Start service

Create a docker-compose file that will bring the Prometheus docker image up and running.

services:
  prometheus:
    image: prom/prometheus
    container_name: prometheus
    command:
      - '--config.file=/etc/prometheus/prometheus.yml'
    ports:
      - 9090:9090
    volumes:
      - ./prometheus/:/etc/prometheus/

the config file is mounted at the location /etc/prometheus and we use the location of the config file as an argument to the command.

2.3 Test

1- Start spring application
2- Start the docker image with docker compose up -d
3- Open the URL http://localhost:9090 on browser.
4- Search for the label http_server_requests_seconds_count

In case you don’t find the label, You can check if the job is running by navigating to « Status > Targets ». You should see the state as “UP ».

Now, the data is getting ingested into Prometheus every 2 seconds.
Although Prometheus has a decent UI, Grafana’s Dashboard is more powerful.

3- Grafana

Before starting Grafana we need to do some configuration to prepare the data source and dashboard. with that, we no longer need to create them manually.

3.1 Datasource

First we need to add and configure the Prometheus data source.

apiVersion: 1

# list of datasources that should be deleted from the database
deleteDatasources:
  - name: Prometheus
    orgId: 1

datasources:
- uid: prometheus
  orgId: 1
  name: Prometheus
  type: prometheus
  url: http://prometheus:9090 
  isDefault: true
  access: proxy
  readOnly: false
  editable: true

3.2 Dashboard

To prepare the Dashboard we need two things :

• Dashboard config file : dashboards.yaml
• Dashboard source file : data-observability.json

3.3 Start service

Create a docker-compose file that will bring the Grafana docker image up and running.

  grafana:
    image: grafana/grafana
    container_name: grafana
    depends_on:
      - prometheus
    ports:
      - 3000:3000
    user: root
    environment:
      - GF_SECURITY_ADMIN_USER=admin
      - GF_SECURITY_ADMIN_PASSWORD=admin
    volumes:
      - ./grafana/datasources:/etc/grafana/provisioning/datasources # data sources
      - ./grafana/dashboards.yaml:/etc/grafana/provisioning/dashboards/dashboards.yaml # dashboard setting
      - ./grafana/dashboards:/etc/grafana/dashboards # dashboard json files directory

3.4 Test

2- Start the docker image with docker compose up -d
3- Open the URL http://localhost:3000 on browser.

We can see our Dashboard that we have already configured

4. Source code

The complete source code of this article can be found over on GitHub.

Reference

https://refactorfirst.com/spring-boot-prometheus-grafana

https://dev.to/luafanti/spring-boot-monitoring-with-prometheus-operator-40g1

https://grafana.com/blog/2022/04/26/set-up-and-observe-a-spring-boot-application-with-grafana-cloud-prometheus-and-opentelemetry/

https://betterprogramming.pub/how-to-monitor-a-spring-boot-app-with-prometheus-and-grafana-22e2338f97fc

L’article Monitoring with Prometheus and Grafana est apparu en premier sur ji-ka.

1 Actuator

Actuator endpoints let you monitor and interact with your Spring Boot application.

1.1 Setup

By adding the following dependency to your project: 

<dependencies>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-web</artifactId>
	</dependency>
	<dependency>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-actuator</artifactId>
	</dependency>
</dependencies>

the actuator endpoints will become available in your project. : http://localhost:8080/actuator

Be aware that all actuators except for /health are disabled by default for security reasons. They might expose sensitive information. You can use the management.endpoints.web.exposure.include property to enable the actuators.

To expose all actuator endpoint :

management:
  endpoints:
    web:
      exposure:
        include: '*'

**To expose only info actuator endpoint :

management:
  endpoints:
    web:
      exposure:
        include: "info"

You can reach the info actuator on your local machine: http://localhost:8080/actuator/info once you start your Spring Boot application.

1.2 Spring Boot info actuator contributors

There are different info contributors that “contribute” to the information exposed by the actuator info endpoint:

• build Enabled by default: true Goal: Exposes build information. Requires: you to generate build information Configuration property: management.info.build.enabled
• env Enabled by default: false (since Spring Boot 2.6. For the older Spring Boot version, this contributor is enabled by default!) Goal: Exposes any property from the SpringEnvironment . Required: to specify properties with names that start with info.* in you application.yml or application.properties Configuration property: management.info.env.enabled
• git Enabled by default: true Goal: exposes git information. Requires: you to generate git information Configuration property: management.info.git.enabled
• java Enabled by default: false (since Spring Boot 2.6) Goal: exposes Java runtime information. Configuration property: management.info.java.enabled

1.3 Static Properties in /info

You can customize the environment info contributor by adding info.*properties to your application.yml or application.properties :

management.info:
  env.enabled: true
info:
  application:
    name: ${spring.application.name}
    description: spring actuator application
    version: '@project.version@'

1.4 GIT details in /info

We can add git details using the respective Maven dependency:

<dependency>
    <groupId>pl.project13.maven</groupId>
    <artifactId>git-commit-id-plugin</artifactId>
</dependency>

and enable management.info.git in configuration property:

management.info:
 git.enabled: true

1.5 GIT build information details in /info

We can also include build information including name, group, and version using the Maven plugin:

<plugin>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-maven-plugin</artifactId>
    <executions>
        <execution>
            <goals>
                <goal>build-info</goal>
            </goals>
        </execution>
    </executions>
</plugin>

and enable management.info.build in configuration property:

management.info:
 build.enabled: true

2 Startup Tracking

Tracking the various steps during application startup can provide useful information that can help us to understand the time spent during various phases of application startup. Such instrumentation can also improve our understanding of the context lifecycle and the application startup sequence.

2.1 Setup

• Add the spring-boot-starter-actuator dependency to our POM

<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-actuator</artifactId>
  </dependency>
</dependencies>

• Expose the required endpoint over HTTP by setting the configuration property in our application properties file:

management:
  endpoints:
    web:
      exposure:
        include: "startup"

2.2 Startup Endpoint

We need to set the application’s startup configuration to an instance of `BufferingApplicationStartup`. This is an in-memory implementation of the `ApplicationStartup` interface provided by Spring Boot. It captures the events during Spring’s startup process and stores them in an internal buffer.

• Create a simple application with this implementation:

@SpringBootApplication
public class SpringActuatorApplication {
  public static void main(String[] args) {
    SpringApplication app = new SpringApplication(SpringActuatorApplication.class);
    app.setApplicationStartup(new BufferingApplicationStartup(2048));
    app.run(args);
  }
}

• Now, we can start our application and query the startup actuator endpoint. http://localhost:8080/actuator/startup

Be aware before spring boot version 2.6 startup endpoint only allow POST method call.

2.3 Filtering Startup Events

The buffering implementation has a fixed capacity for storing events in memory. Therefore, it might not be desirable to store a large number of events in the buffer.

We can filter the instrumented events and only store those that may be of interest to us:

	public static void main(String[] args) {
		SpringApplication app = new SpringApplication(SpringActuatorApplication.class);
		BufferingApplicationStartup startup = new BufferingApplicationStartup(2048);
		startup.addFilter(startupStep -> startupStep.getName().matches("spring.boot.application.starting"));
		app.setApplicationStartup(startup);
		app.run(args);
	}

Here, we’ve used the addFilter method to only instrument steps with the specified name.

3 Source code

The complete source code of this article can be found over on GitHub.

Reference

https://www.baeldung.com/spring-boot-actuators

https://www.baeldung.com/spring-boot-info-actuator-custom

https://medium.com/@TimvanBaarsen/help-my-spring-boot-info-actuator-endpoint-is-enabled-but-i-dont-see-any-environment-details-c2d41a7b24d7

https://www.baeldung.com/spring-boot-actuator-startup

https://medium.com/techwasti/startup-actuator-endpoint-spring-boot-54a8dd0a1fdb

L’article Spring boot actuator est apparu en premier sur ji-ka.