Pratiques de collecte de journaux dans les projets : technologies, outils et bonnes pratiques

Dans le développement de logiciels modernes, la journalisation est un élément essentiel pour garantir la stabilité du système, le dépannage et la surveillance des performances. Cet article approfondira l'expérience pratique de la collecte de journaux dans les projets et présentera les technologies, les outils et certaines bonnes pratiques couramment utilisés dans les projets Java.

1. Choisissez le cadre de journalisation approprié

Dans les projets Java, le choix d'un cadre de journalisation approprié constitue la première étape de la collecte des journaux. Les frameworks de journalisation courants incluent Log4j, Logback et SLF4J. Voici quelques considérations pour le choix d’un framework :

performance: Certains frameworks peuvent être plus performants en termes de performances, alors choisissez celui qui convient en fonction des besoins de votre projet.
la flexibilité: Certains frameworks offrent des options de configuration et de sortie plus flexibles pour s'adapter à différents scénarios d'application.
Soutien communautaire : Choisissez un framework avec un support communautaire actif et des mises à jour continues pour garantir une résolution rapide des problèmes et un accès aux dernières fonctionnalités.

2. Configurez le cadre de journalisation

Après avoir sélectionné un framework de journalisation, il doit être configuré de manière appropriée pour répondre aux besoins du projet. De manière générale, les fichiers de configuration sont généralement des fichiers XML ou de propriétés, qui contiennent des informations sur les niveaux de journalisation, les formats de sortie, les emplacements de destination, etc.

En prenant Logback comme exemple, un exemple simple de fichier de configuration est le suivant :


<!-- logback.xml -->
<configuration>
 
    <appender name="CONSOLE" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <appender name="FILE" class="ch.qos.logback.core.FileAppender">
        <file>logs/myapp.log</file>
        <encoder>
            <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
        </encoder>
    </appender>
 
    <logger name="com.example" level="DEBUG"/>
    
    <root level="INFO">
        <appender-ref ref="CONSOLE"/>
        <appender-ref ref="FILE"/>
    </root>
 
</configuration>

La configuration ci-dessus définit deux appenders, un pour la sortie de la console et l'autre pour la sortie du fichier, et définit le niveau de journalisation et le format de sortie.

3. Utilisez les niveaux de journalisation appropriés

L'utilisation de niveaux de journalisation appropriés dans votre projet est l'un des facteurs clés pour garantir l'efficacité maximale de votre système de journalisation. Choisir le niveau de journalisation approprié peut garantir que le niveau approprié d'informations de journalisation détaillées est obtenu dans différents environnements et étapes, tout en évitant trop ou pas assez de journaux pour améliorer les performances et la maintenabilité du système.

1. Aperçu des niveaux de journalisation

Dans l'infrastructure de journalisation Java, les niveaux de journalisation courants incluent :

TRACER: Fournit les informations de journal les plus détaillées, souvent utilisées pour le débogage.
DÉBOGUER: Fournit des détails pour le débogage, adaptés aux environnements de développement et de test.
INFO: Fournit des informations d’exécution critiques indiquant que l’application fonctionne correctement.
AVERTIR: Indique des problèmes potentiels qui peuvent nécessiter une attention mais n'affectent pas le fonctionnement normal du programme.
ERREUR: Indique qu'une erreur s'est produite et qu'un traitement supplémentaire peut être nécessaire.

2. Sélectionnez le niveau de journalisation approprié (prenez logbkck comme exemple ici)

Utilisez DEBUG pendant la phase de développement : Pendant la phase de développement, utilisez le niveau DEBUG pour obtenir des informations de journal plus détaillées afin d'aider les développeurs à suivre et à déboguer le code.


public class ExampleClass {
    private static final Logger logger = LoggerFactory.getLogger(ExampleClass.class);
 
    public void someMethod() {
        // ...
        logger.debug("Debug information for developers");
        // ...
    }
}

L'environnement de production utilise INFO : Dans un environnement de production, définissez le niveau de journalisation sur INFO pour garantir que les informations d'exécution critiques sont enregistrées tout en réduisant les informations de débogage redondantes.

Avertissement et gestion des erreurs : Pour les problèmes potentiels et les conditions d’erreur, utilisez les niveaux WARN et ERROR. Ces niveaux de journalisation aideront les équipes à identifier et à résoudre rapidement les problèmes du système.

3. Ajustez dynamiquement les niveaux de journalisation

Certains frameworks de journalisation permettent un ajustement dynamique des niveaux de journalisation au moment de l'exécution, ce qui peut être utile pour ajuster la verbosité de la journalisation sans redémarrer l'application.

En utilisant des niveaux de journalisation appropriés, les équipes de développement peuvent mieux équilibrer les détails des informations et la surcharge de performances, garantissant ainsi des résultats de journalisation optimaux dans différents environnements et scénarios.

4. Combiné avec les informations contextuelles du journal

La combinaison des informations contextuelles du journal consiste à ajouter des informations contextuelles supplémentaires aux enregistrements du journal afin de mieux comprendre l'arrière-plan des événements du journal. Ceci est utile pour suivre des demandes spécifiques, des sessions utilisateur ou d'autres processus métier. Dans les projets Java, une pratique courante consiste à utiliser le MDC (Mapped Diagnostic Context) de SLF4J ou le ThreadContext de Log4j 2 pour ajouter des informations de contexte de journal.

1. Utilisation de SLF4J MDC

Le MDC de SLF4J permet d'ajouter des informations clé-valeur au contexte du journal dans une requête ou un processus métier, afin qu'elles persistent tout au long du traitement.


import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.MDC;
 
public class RequestContextLogger {
    private static final Logger logger = LoggerFactory.getLogger(RequestContextLogger.class);
 
    public void processRequest(String requestId, String userId) {
        try {
            // 将请求ID和用户ID放入日志上下文
            MDC.put("requestId", requestId);
            MDC.put("userId", userId);
 
            // 处理请求
            logger.info("Processing request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing request", e);
        } finally {
            // 清理日志上下文，确保不影响其他请求
            MDC.clear();
        }
    }
}

2. Utilisation du ThreadContext de Log4j 2

Log4j 2 fournit ThreadContext, qui est similaire au MDC de SLF4J et peut également stocker des informations contextuelles sur les paires clé-valeur dans la portée du thread.


import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;
import org.apache.logging.log4j.ThreadContext;
 
public class RequestContextLogger {
    private static final Logger logger = LogManager.getLogger(RequestContextLogger.class);
 
    public void processRequest(String requestId, String userId) {
        try {
            // 将请求ID和用户ID放入日志上下文
            ThreadContext.put("requestId", requestId);
            ThreadContext.put("userId", userId);
 
            // 处理请求
            logger.info("Processing request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing request", e);
        } finally {
            // 清理日志上下文，确保不影响其他请求
            ThreadContext.clearAll();
        }
    }
}

3. Tirez parti des informations contextuelles

L'avantage d'incorporer des informations contextuelles de journal est que vous pouvez corréler une série d'événements de journal associés, ce qui facilite le suivi du flux d'une demande spécifique ou des actions de l'utilisateur. Par exemple, dans un système distribué, l'ensemble du processus de traitement des demandes peut être suivi sur plusieurs services en ajoutant un ID de demande unique au journal.


public class DistributedService {
    private static final Logger logger = LoggerFactory.getLogger(DistributedService.class);
 
    public void processDistributedRequest(String requestId) {
        try {
            MDC.put("requestId", requestId);
 
            // 处理分布式请求
            logger.info("Processing distributed request");
 
            // ...
        } catch (Exception e) {
            logger.error("Error processing distributed request", e);
        } finally {
            MDC.clear();
        }
    }
}

En combinant des informations contextuelles, les enregistrements de journaux ne sont plus des événements isolés, mais sont organiquement connectés entre eux, fournissant ainsi un outil plus puissant pour le dépannage du système et l'optimisation des performances.

5. Surveillance en temps réel et stockage centralisé

La surveillance en temps réel et le stockage centralisé sont des aspects importants de la gestion des journaux du projet. Grâce à ces moyens, l'équipe peut suivre l'état de fonctionnement du système en temps réel, détecter les problèmes potentiels et effectuer un dépannage en temps opportun si nécessaire. Dans les projets Java, les outils couramment utilisés incluent ELK Stack (Elasticsearch, Logstash, Kibana), Splunk, etc.

1. Pile ELK (Elasticsearch, Logstash, Kibana)

ELK Stack est un ensemble d'outils open source pour la collecte, le stockage et la visualisation de journaux.

Recherche élastique : Utilisé pour stocker et récupérer de grandes quantités de données de journal. Il offre de puissantes capacités de recherche et d’analyse des données en temps réel.
Logstash : Utilisé pour la collecte, le filtrage et le transfert des journaux. Logstash peut normaliser les données de journaux provenant de différentes sources et les envoyer à Elasticsearch pour stockage.
Kibana : Fournit une interface utilisateur intuitive pour interroger, visualiser et analyser les données de journaux stockées dans Elasticsearch. Avec Kibana, les équipes peuvent créer des tableaux de bord, des graphiques et effectuer une analyse approfondie des données des journaux.

2. Configurez Logstash pour collecter les journaux

La configuration de Logstash dans votre projet pour collecter les journaux est une étape critique pour ELK Stack. Logstash prend en charge une variété de sources d'entrée et de cibles de sortie, qui peuvent être définies via de simples fichiers de configuration.


# logstash.conf
 
input {
    file {
        path => "/path/to/your/application.log"
        start_position => "beginning"
    }
}
 
filter {
    # 可添加过滤规则
}
 
output {
    elasticsearch {
        hosts => ["localhost:9200"]
        index => "your_index_name"
    }
}

Cet exemple configure un plug-in d'entrée Logstash pour surveiller les fichiers journaux sous le chemin spécifié et les envoyer vers Elasticsearch. La section de filtrage peut ajouter des règles supplémentaires pour analyser, filtrer ou ajouter des informations supplémentaires aux journaux.

3. Utilisez Kibana pour la visualisation et l'analyse

Kibana fournit une interface utilisateur intuitive accessible via un navigateur Web. Dans Kibana, vous pouvez créer des tableaux de bord, des graphiques et effectuer des requêtes et des analyses complexes.

Avec Kibana, vous pouvez facilement :

surveillance en temps réel: Affichez les données du journal en temps réel et comprenez l'état de fonctionnement du système à tout moment.
Dépannage: Recherchez les journaux en fonction de critères spécifiques pour trouver la cause première des problèmes potentiels.
Analyse de performance: Utilisez des graphiques et des outils de visualisation pour analyser les goulots d'étranglement des performances du système.

4. Splunk

Splunk est un autre outil de gestion des journaux largement utilisé qui fournit une solution tout-en-un pour la collecte, la recherche, l'analyse et la visualisation des journaux.

Collecte de journaux : Splunk prend en charge la collecte de données de journaux à partir de plusieurs sources (fichiers, bases de données, trafic réseau, etc.).
Recherche et analyse en temps réel : Fournit des fonctions de recherche et d'analyse en temps réel, prend en charge les requêtes complexes et affiche les résultats de la recherche via une interface visuelle.
Tableaux de bord et rapports : Les utilisateurs peuvent créer des tableaux de bord et des rapports personnalisés pour surveiller et analyser les performances du système.

5. Stockage centralisé et évolutivité

ELK Stack et Splunk disposent tous deux de puissants mécanismes de stockage centralisés capables de stocker de grandes quantités de données de journal. Ce stockage centralisé facilite non seulement la récupération et l'analyse des journaux, mais offre également au système une évolutivité et peut gérer des journaux d'applications à grande échelle.

Conclusion

La surveillance en temps réel et le stockage centralisé sont essentiels pour garantir la stabilité et les performances du projet. En utilisant des outils tels que ELK Stack et Splunk, l'équipe de projet peut suivre les journaux en temps réel dans des environnements système complexes et effectuer un dépannage et une optimisation des performances en temps opportun. La puissance de ces outils améliore non seulement l’efficacité des équipes, mais offre également aux projets une meilleure maintenabilité et évolutivité.

6. Roulement et archivage des journaux

Le déroulement et l'archivage des journaux sont des pratiques importantes dans le projet. Ils garantissent une gestion raisonnable des fichiers journaux, évitent les problèmes de stockage causés par un excès de fichiers journaux et aident à maintenir le fonctionnement normal du système. Voici quelques pratiques courantes pour implémenter la diffusion et l'archivage des journaux dans les projets Java.

1. Configurer la stratégie de roulement du framework de journalisation

La plupart des frameworks de journalisation proposent des stratégies évolutives qui peuvent être définies via des fichiers de configuration. Ces stratégies déterminent quand basculer vers de nouveaux fichiers journaux et quand supprimer les anciens fichiers journaux. En prenant Logback comme exemple, configurez une stratégie de roulement de base :


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.TimeBasedRollingPolicy">
        <fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.log</fileNamePattern>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

La configuration ci-dessus utiliseTimeBasedRollingPolicy, qui lancera le fichier journal en fonction du temps.maxHistorySpécifie le nombre de fichiers journaux historiques à conserver. Les fichiers journaux dépassant ce nombre seront supprimés.

2. Défilement en fonction de la taille du fichier

Parfois, l'analyse temporelle peut ne pas suffire et vous devez également effectuer l'analyse en fonction de la taille du fichier journal. Ceci peut être réalisé en configurant la taille du fichier :


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="ch.qos.logback.core.rolling.SizeAndTimeBasedRollingPolicy">
        <fileNamePattern>logs/myapp.%d{yyyy-MM-dd}.%i.log</fileNamePattern>
        <maxFileSize>5MB</maxFileSize>
        <maxHistory>30</maxHistory>
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

La configuration ci-dessus utiliseSizeAndTimeBasedRollingPolicy, qui génère les fichiers journaux en fonction de la taille et de l'heure du fichier.maxFileSizeSpécifie la taille maximale de chaque fichier journal.

3. Personnalisez la stratégie de défilement

Parfois, les projets peuvent avoir besoin de générer des journaux en fonction de conditions personnalisées. Dans ce cas, pensez à mettre en œuvre une stratégie de défilement personnalisée. Par exemple, le roulement des fichiers journaux en fonction de règles métier spécifiques :


public class CustomRollingPolicy extends TimeBasedRollingPolicy<ILoggingEvent> {
    // 实现自定义的滚动逻辑
}

Utilisez ensuite une stratégie de défilement personnalisée dans le fichier de configuration :


<appender name="FILE" class="ch.qos.logback.core.rolling.RollingFileAppender">
    <file>logs/myapp.log</file>
    <rollingPolicy class="com.example.CustomRollingPolicy">
        <!-- 自定义配置 -->
    </rollingPolicy>
    <encoder>
        <pattern>%d{HH:mm:ss.SSS} [%thread] %-5level %logger{36} - %msg%n</pattern>
    </encoder>
</appender>

4. Archivez les anciens fichiers journaux

Outre la migration des fichiers journaux, l'archivage des anciens fichiers journaux est également une pratique courante. Cela peut être accompli en déplaçant régulièrement les anciens fichiers journaux vers le répertoire d'archives pour éviter qu'ils n'occupent trop d'espace disque.

Ou utilisez une approche programmatique pour l'implémenter dans du code Java :


import java.io.File;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.StandardCopyOption;
import java.time.LocalDate;
import java.time.format.DateTimeFormatter;
 
public class LogArchiver {
    public static void archiveLogFile(String logFileName, String archiveDirectory) {
        String currentDate = LocalDate.now().format(DateTimeFormatter.ofPattern("yyyy-MM-dd"));
        File logFile = new File(logFileName);
        File archiveDir = new File(archiveDirectory);
 
        if (!archiveDir.exists()) {
            archiveDir.mkdirs();
        }
 
        Path sourcePath = logFile.toPath();
        Path targetPath = new File(archiveDir, logFile.getName() + "." + currentDate + ".log").toPath();
 
        try {
            Files.move(sourcePath, targetPath, StandardCopyOption.REPLACE_EXISTING);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

Appelé à des tâches périodiquesarchiveLogFileCette méthode peut être utilisée pour archiver les fichiers journaux.

En mettant en œuvre la diffusion et l'archivage des journaux, les projets peuvent gérer les fichiers journaux plus efficacement et garantir que le système maintient de bonnes performances sur de longues périodes. Ceci est non seulement utile pour le dépannage, mais contribue également au respect des exigences de conformité.

Conclusion

En choisissant un cadre de journalisation approprié, en le configurant de manière appropriée, en utilisant les niveaux de journalisation appropriés et en combinant des informations contextuelles, les projets peuvent créer un système de journalisation puissant qui fournit un support solide pour le dépannage, l'optimisation des performances et la surveillance du système. Dans le même temps, la surveillance en temps réel et le stockage centralisé offrent aux équipes des moyens plus pratiques de suivre l’état du système. Une journalisation méticuleuse n'est pas seulement une pratique technique pour le développement de projets, mais aussi une garantie importante pour améliorer l'efficacité globale de l'équipe et la qualité du projet.

Partage de technologie