Journalisation efficace pour la fonction

La maîtrise de la journalisation au niveau des fonctions est une étape cruciale vers la compréhension et la mise en œuvre d'une journalisation complète pour des systèmes logiciels entiers. En nous concentrant sur le niveau granulaire des fonctions, nous pouvons construire une base solide qui facilite la mise à l'échelle vers des systèmes complexes.

Voici cinq points clés à retenir lors de la rédaction de journaux pour une fonction :

1. Spécifiez l'origine du journal :

   • Notez toujours la source du journal. Cela peut inclure l'heure à laquelle il a été créé, le nom du fichier, la fonction à laquelle il est lié et bien d'autres détails. Ceci est utile lors du dépannage, car le développeur peut se concentrer sur un fichier ou une fonction spécifique.

2. Écrivez en pensant au débogage :

   • Lorsque vous rédigez des journaux, tenez compte des problèmes potentiels qui pourraient survenir. Les journaux doivent être rédigés de manière à aider à résoudre ces problèmes, s'ils surviennent.

3. Raconter une histoire :

   • Les journaux doivent être comme une histoire qui adhère à l'essentiel mais couvre tous les détails importants. Chaque fonction doit avoir son propre récit, commençant par les arguments qu'elle a reçus et se terminant par les données qu'elle a renvoyées. Le journal peut inclure le temps d'exécution, toutes les fonctions internes qu'il a appelées, l'entrée qu'il a reçue et la sortie qu'il a renvoyée.

4. Tester minutieusement les journaux :

   • Tout comme la fonctionnalité de test une fois terminé, les journaux doivent également être testés. Assurez-vous que les journaux affichent les informations correctes pour les cas réussis et échoués. Consultez toujours les journaux du point de vue de quelqu'un qui essaie de résoudre un problème.

5. Évitez la sur-journalisation :

   • Tout ne doit pas être enregistré. Les informations sensibles, en particulier lorsqu'elles concernent les données des utilisateurs, doivent être omises. Par exemple, plutôt que d'enregistrer tous les détails de l'utilisateur, seuls l'identifiant de l'utilisateur ou les informations utilisées dans le code doivent être enregistrés.

Pensez à vous connecter au bon niveau :

• INFO - Enregistre les détails non sensibles sur le fonctionnement de l'application.
• WARN - Signale les problèmes potentiels sans affecter l'expérience utilisateur.
• ERREUR - Signale de graves problèmes affectant l'expérience utilisateur.
• FATAL - Marque les erreurs majeures ayant un impact important sur l'expérience utilisateur.
• DEBUG - Fournit des informations de débogage aux développeurs.

Meilleures pratiques pour la journalisation des fonctions

Éléments essentiels dans une chaîne de journal : L'inclusion de Timestamp, ApplicationName, FileName, FunctionName , LEVEL et tout autre détail pertinent peuvent améliorer considérablement l'efficacité des journaux pour une application. Ces éléments fournissent un contexte crucial et facilitent le suivi du flux des événements, notamment lors du débogage ou de la surveillance de l'application. N'oubliez pas que l'objectif est de créer des journaux informatifs et utiles, tout en respectant les considérations de confidentialité et de sécurité.

Le message doit transmettre : l'action prévue, l'initiateur de l'action, ainsi que l'entrée et la sortie.

Considérez les entrées de journal non structurées suivantes :

2019-06-20T17:21:00.002899+00:00 myApp [c.d.g.UserRequestClass]: [getUser]: DEBUG: Fetching mailing list 14777
2019-06-20T17:21:00.002899+00:00 myApp [c.d.g.UserRequestClass]: [getUser]: DEBUG: User 3654 opted out
2019-06-20T17:21:00.002899+00:00 myApp [c.d.g.UserRequestClass]: [getUser]: DEBUG: User 1334563 plays 4 of spades in game 23425656

En structurant ces entrées au format JSON, nous améliorons la lisibilité et la facilité d'analyse :

2019-06-20T17:21:00.002899+00:00 myApp [c.d.g.UserRequestClass]: [getUser]: DEBUG: Fetching mailing list {"listid":14777}
2019-06-20T17:21:00.002899+00:00 myApp [c.d.g.UserRequestClass]: [getUser]: DEBUG: User opted out {"userid":3654}
2019-06-20T17:21:00.002899+00:00 myApp [c.d.g.UserRequestClass]: [getUser]: DEBUG: User plays {'user':1334563, 'card':'4 of spade', 'game':23425656}

En adhérant à ces pratiques, nous pouvons garantir que nos journaux sont informatifs, faciles à lire et utiles pour le débogage.

Exemple de code et meilleures pratiques

• Maintenir la cohérence et l'uniformité des journaux : Il est crucial de garantir que les journaux restent cohérents tout au long du programme, quel que soit le nombre de développeurs qui écrivent le code. Cela facilite le débogage, la compréhension du flux des opérations et une meilleure traçabilité de l'exécution du code.
• Créez un modèle de journalisation et utilisez le même modèle de journalisation : Développez un modèle de journalisation standard pour toute l'équipe et encouragez chaque développeur de l'équipe à suivre le même modèle de journalisation. Cela favorise l'uniformité et facilite la lecture et la compréhension des journaux.
• Fournir et faire référence à des exemples de fonctions : Mettre à disposition quelques exemples de fonctions qui démontrent de bonnes pratiques de journalisation dans le code. Ceux-ci peuvent servir de référence aux développeurs. Permettez aux développeurs de se référer à ces exemples lorsqu’ils écrivent leur propre code. Cela les aide à adhérer aux pratiques de journalisation établies et à maintenir la cohérence.

Voici un exemple :

import java.time.LocalDate;
import java.time.temporal.ChronoUnit;
import java.util.List;
import org.apache.logging.log4j.LogManager;
import org.apache.logging.log4j.Logger;

public class UserService {

    private static final Logger logger = LogManager.getLogger(UserService.class);
    private Database database;

    public UserService(Database database) {
        this.database = database;
    }

    public int getTotalLikesInLast30Days(String userId) {
        logger.info("Request received to get all total likes in last 30 days 
                for: {userId: " + userId + "}");
        long startTime = System.nanoTime();

        try {
            logger.debug("Fetching user with id: {userId: " + userId + "}");
            User user = database.getUserById(userId);

            if (user == null || user.isDeleted() || user.isDeactivated()) {
                logger.warn("User not found or deactivated: {userId: " + userId + "}");
                return 0;
            }

            LocalDate thirtyDaysAgo = LocalDate.now().minus(30, ChronoUnit.DAYS);
            logger.debug("Fetching posts for user since: {userId: " + userId + ", 
                    since: " + thirtyDaysAgo + "}");
            List<Post> posts = database.getPostsByUserSince(user, thirtyDaysAgo);

            int totalLikes = 0;
            for (Post post : posts) {
                totalLikes += post.getLikes().size();
            }

            long endTime = System.nanoTime();
            // compute the elapsed time in nanoseconds
            long duration = (endTime - startTime);  
            logger.info("Execution time: {timeInNanoseconds: " + duration + "}");
            logger.info("Returning total likes in last 30 days for: {userId: " + 
                    userId + ", totalLikes: " + totalLikes + "}");

            return totalLikes;
        } catch (Exception e) {
            logger.error("An error occurred: {message: " + e.getMessage() + "}", e);
            return 0;
        }
    }
}

Voici à quoi pourraient ressembler les journaux dans un cas réussi :

2024-01-07 14:00:00,001 [INFO]  UserService.java:10 [com.example.UserService] (getTotalLikesInLast30Days) : Request received to get all total likes in last 30 days for: {userId: 123}
2024-01-07 14:00:00,002 [DEBUG] UserService.java:12 [com.example.UserService] (getTotalLikesInLast30Days) : Fetching user with id: {userId: 123}
2024-01-07 14:00:00,010 [DEBUG] UserService.java:18 [com.example.UserService] (getTotalLikesInLast30Days) : Fetching posts for user since: {userId: 123, since: 2023-12-08}
2024-01-07 14:00:00,020 [INFO]  UserService.java:26 [com.example.UserService] (getTotalLikesInLast30Days) : Execution time: {timeInNanoseconds: 19000000}
2024-01-07 14:00:00,021 [INFO]  UserService.java:28 [com.example.UserService] (getTotalLikesInLast30Days) : Returning total likes in last 30 days for: {userId: 123, totalLikes: 999}

Et voici à quoi ils pourraient ressembler lorsqu'une exception se produit, par exemple lorsque la table Post n'existe pas :

2024-01-07 14:00:00,001 [INFO]  UserService.java:10 [com.example.UserService] (getTotalLikesInLast30Days) : Request received to get all total likes in last 30 days for: {userId: 123}
2024-01-07 14:00:00,002 [DEBUG] UserService.java:12 [com.example.UserService] (getTotalLikesInLast30Days) : Fetching user with id: {userId: 123}
2024-01-07 14:00:00,010 [DEBUG] UserService.java:18 [com.example.UserService] (getTotalLikesInLast30Days) : Fetching posts for user since: {userId: 123, since: 2023-12-08}
2024-01-07 14:00:00,015 [ERROR] UserService.java:18 [com.example.UserService] (getTotalLikesInLast30Days) : An error occurred: {message: "Post table does not exist"}

Packages like log4j, slf4j, and many others can be used for better management of logs in large software programs.

Focusing on creating effective logs for each function can significantly improve the overall quality of logs for the entire software. This approach ensures that each part of the software is well-documented and can facilitate easier debugging and maintenance. Remember, a well-logged function contributes to a well-logged application.

Thank you for reading this blog. _Sayonara!

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!