Journalisation en C++ : aperçu des meilleures bibliothèques et solutions

Journalisation pour C++ : les meilleures solutions

La journalisation est l'un des outils les plus importants dans l'arsenal du développeur. Elle permet de suivre l'exécution d'un programme, de trouver des erreurs, d'analyser les performances et de collecter des données pour le débogage. Le langage C++ ne dispose pas de système de journalisation intégré (contrairement à Java ou Python), mais la communauté et les grandes entreprises ont créé de nombreuses excellentes bibliothèques. Dans cet article, nous examinerons les meilleures solutions de journalisation en C++ : spdlog, Boost.Log, Google glog et fmtlog. Vous découvrirez leurs caractéristiques, leurs avantages et obtiendrez des exemples de code.

Pourquoi la journalisation en C++ ?

Dans les projets C++ modernes, la journalisation répond à plusieurs besoins :

• Débogage : enregistrement des valeurs des variables, de la pile d'appels, de l'état des objets.
• Surveillance : relevé des temps d'exécution des fonctions, des opérations d'entrée-sortie.
• Audit : conservation de l'historique des actions de l'utilisateur ou du système.
• Diagnostic des pannes : enregistrement des exceptions et des erreurs critiques.

Une bonne bibliothèque de journalisation doit être rapide, flexible, prendre en charge différents niveaux de logs (debug, info, warn, error, fatal) et pouvoir afficher les données dans un fichier, la console ou un serveur distant.

1. spdlog — un logger rapide et moderne

spdlog est actuellement la bibliothèque de journalisation la plus populaire en C++. Elle est écrite en C++ moderne (C++11/14/17), header-only (uniquement des fichiers d'en-tête) et n'a pas de dépendances externes, à l'exception de fmtlib pour le formatage des chaînes. Principaux avantages :

• Haute performance (journalisation asynchrone).
• Prise en charge de multiples sinks : fichier, console, syslog, bases de données.
• Configuration flexible du formatage.
• API simple.

Exemple d'utilisation de spdlog :

#include <spdlog/spdlog.h>#include <spdlog/sinks/basic_file_sink.h>

int main() {    // Création d'un logger écrivant dans le fichier "logs.txt"    auto logger = spdlog::basic_logger_mt("file_logger", "logs.txt");    spdlog::set_default_logger(logger);    spdlog::set_level(spdlog::level::debug); // Niveau de journalisation

    spdlog::info("Bienvenue dans spdlog !");    spdlog::debug("Message de débogage : {}", 42);    spdlog::error("Erreur survenue : {}", errno);

    // Journalisation asynchrone    spdlog::flush_on(spdlog::level::err);    return 0;}

spdlog prend également en charge le mode asynchrone, ce qui est crucial pour les applications à forte charge. La configuration de l'asynchrone est triviale : il suffit d'appeler spdlog::init_thread_pool(...).

2. Boost.Log — puissant mais lourd

Boost.Log fait partie des bibliothèques Boost. C'est la solution la plus fonctionnelle, mais elle nécessite l'installation de Boost et peut ralentir la compilation. Caractéristiques :

• Flexibilité maximale : filtres personnalisés, formateurs, sinks.
• Prise en charge du multithreading et de la sécurité des flux.
• Possibilité d'écrire les logs à plusieurs endroits simultanément (fichier + console + réseau).
• Prise en charge de la rotation des logs par taille, date ou heure.

Exemple avec Boost.Log :

#include <boost/log/trivial.hpp>#include <boost/log/expressions.hpp>#include <boost/log/utility/setup/file.hpp>

namespace logging = boost::log;

int main() {    // Configuration de la sortie vers un fichier    logging::add_file_log("sample.log");    logging::core::get()->set_filter(        logging::trivial::severity >= logging::trivial::info    );

    BOOST_LOG_TRIVIAL(trace) << "Un message de niveau trace";    BOOST_LOG_TRIVIAL(debug) << "Un message de niveau debug";    BOOST_LOG_TRIVIAL(error) << "Un message de niveau erreur";    return 0;}

Boost.Log — un choi