Logging et monitoring Spring Boot

Pourquoi Logging et monitoring Spring Boot ?

Logging et monitoring sont des aspects cruciaux de la maintenance et de l'optimisation d'une application Spring Boot en production. Ils permettent aux développeurs de suivre les performances, de détecter les anomalies, et d'identifier rapidement les problèmes techniques.

• Contexte réel : Un développeur a besoin de logging pour comprendre le flux normal des opérations de l'application. Le monitoring lui permet de surveiller en temps réel la santé globale de l'application.
• Un cas d'utilisation concret : Imaginez une application e-commerce où les transactions sont traitées en masse. Une erreur grave peut causer un pénurage de vendeurs et le déclin des ventes si elle est décelée trop tard. Avec un bon logging et monitoring, vous pouvez rapidement détecter cette erreur et la corriger avant qu'elle n'affecte les utilisateurs.

Prerequis

• Connaissances en Java et Spring Boot
• Familiarité avec les outils de développement IDE comme IntelliJ IDEA ou Eclipse
• Connaissance des bases du logging (log4j, logback)
• Compréhension des concepts de base de monitoring (metrics, traces)

Outils à installer :

• JDK 1.8 ou plus récent
• Maven 3.x ou Gradle 5.x
• IDE IntelliJ IDEA ou Eclipse
• Docker (facultatif pour le déploiement et le monitoring)

Concepts fondamentaux

Logging

Logging est le processus de création et de stockage des journaux d'application. Il permet aux développeurs de suivre l'exécution de leur application en temps réel.

// Ajoutez cette configuration dans votre application.properties ou application.yml
logging.level.root=INFO
logging.file.name=myapp.log

Ce code configure le niveau de logging à INFO et spécifie que les journaux seront stockés dans un fichier nommé myapp.log.

Monitoring

Monitoring implique la collecte, l'analyse et la visualisation des données liées à l'état d'une application. Cela permet aux opérateurs de déterminer si l'application est en bonne santé et de détecter les problèmes potentiels.

// Ajoutez cette configuration dans votre pom.xml pour ajouter Micrometer et Prometheus
<dependencies>
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-core</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>
</dependencies>

// Ajoutez ce code dans votre application.properties
management.endpoints.web.exposure.include=*
management.endpoint.metrics.enabled=true

Ce code active les endpoints web de gestion et expose les métriques prometheus.

Mise en pratique : projet fil rouge

Nous allons créer une API simple pour un blog. L'application aura des fonctionnalités pour ajouter, récupérer et supprimer des articles.

Étape 1 : Créer le projet Spring Boot

Créez un nouveau projet Spring Boot avec Spring Initializr (https://start.spring.io/). Choisissez les dépendances suivantes :

• Spring Web
• Spring Boot DevTools
• Lombok (pour réduire la quantité de code)

Étape 2 : Créer le modèle d'entité

Créez un fichier Article.java dans src/main/java/com/example/blog.

package com.example.blog;

import lombok.Data;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;

@Data
@Entity
public class Article {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;
    private String title;
    private String content;
}

Étape 3 : Créer le repository

Créez un fichier ArticleRepository.java dans src/main/java/com/example/blog.

package com.example.blog;

import org.springframework.data.jpa.repository.JpaRepository;

public interface ArticleRepository extends JpaRepository<Article, Long> {
}

Étape 4 : Créer le service

Créez un fichier ArticleService.java dans src/main/java/com/example/blog.

package com.example.blog;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

@Service
public class ArticleService {

    @Autowired
    private ArticleRepository articleRepository;

    public List<Article> getAllArticles() {
        return articleRepository.findAll();
    }

    public Optional<Article> getArticleById(Long id) {
        return articleRepository.findById(id);
    }

    public Article saveArticle(Article article) {
        return articleRepository.save(article);
    }

    public void deleteArticle(Long id) {
        articleRepository.deleteById(id);
    }
}

Étape 5 : Créer le contrôleur

Créez un fichier ArticleController.java dans src/main/java/com/example/blog.

package com.example.blog;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.*;

import java.util.List;
import java.util.Optional;

@RestController
@RequestMapping("/api/articles")
public class ArticleController {

    @Autowired
    private ArticleService articleService;

    @GetMapping
    public List<Article> getAllArticles() {
        return articleService.getAllArticles();
    }

    @GetMapping("/{id}")
    public Optional<Article> getArticleById(@PathVariable Long id) {
        return articleService.getArticleById(id);
    }

    @PostMapping
    public Article saveArticle(@RequestBody Article article) {
        return articleService.saveArticle(article);
    }

    @DeleteMapping("/{id}")
    public void deleteArticle(@PathVariable Long id) {
        articleService.deleteArticle(id);
    }
}

Étape 6 : Exécuter l'application

Exécutez le projet en utilisant IntelliJ IDEA ou Eclipse. Vous devriez pouvoir accéder à votre API via http://localhost:8080/api/articles.

Erreurs frequentes et debugging

1. **Erreur : No qualifying bean of type 'org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping' available

## ❌ Mauvais
@RestController
@RequestMapping("/api")
public class ArticleController {
    // ...
}

## ✅ Correct
@RestController
@RequestMapping("/api/articles")
public class ArticleController {
    // ...
}

2. **Erreur : Failed to load ApplicationContext

## ❌ Mauvais
application.properties

## ✅ Correct
application.properties
logging.level.root=INFO

3. **Erreur : Could not find property 'management.endpoints.web.exposure.include' on object of type 'org.springframework.boot.context.properties.ConfigurationPropertiesBean'

## ❌ Mauvais
pom.xml

## ✅ Correct
<dependencies>
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-core</artifactId>
    </dependency>
    <dependency>
        <groupId>io.micrometer</groupId>
        <artifactId>micrometer-registry-prometheus</artifactId>
    </dependency>
</dependencies>

Pour aller plus loin

1. Intégration avec Prometheus et Grafana : En utilisant les métriques prometheus, vous pouvez exporter vos données de monitoring à un outil comme Grafana pour une visualisation graphique.

2. Utilisation de Logback pour le logging avancé : Spring Boot utilise par défaut log4j2, mais vous pouvez facilement configurer Logback pour plus de contrôle et d'options.

3. Intégration avec ELK Stack (Elasticsearch, Logstash, Kibana) : Pour un logging distributed, l'ELK stack est une solution puissante qui permet de collecter, stocker et analyser les journaux en temps réel.

Défi pratique : Créez une application Spring Boot qui utilise un microservice pour gérer les utilisateurs. Ajoutez des endpoints pour ajouter, récupérer, mettre à jour et supprimer des utilisateurs. Configurez le logging et le monitoring pour cette application.