<QtLogging> - Qt Logging Types

Le fichier d'en-tête <QtLogging> définit les types, les fonctions et les macros de journalisation de Qt. En savoir plus...

Header: #include <QtLogging>

Types

QtMessageHandler
enum QtMsgType { QtDebugMsg, QtInfoMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg }

Fonctions

QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)
QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)
void qSetMessagePattern(const QString &pattern)

Macros

qCritical(const char *format, ...)
qDebug(const char *format, ...)
qFatal(const char *format, ...)
qInfo(const char *format, ...)
qWarning(const char *format, ...)

Description détaillée

Le fichier d'en-tête <QtLogging> contient plusieurs types, fonctions et macros destinés à la journalisation.

L'énumération QtMsgType identifie les différents messages pouvant être générés et envoyés à un gestionnaire de messages Qt ; QtMessageHandler est une définition de type pour un pointeur vers une fonction dont la signature est void myMessageHandler(QtMsgType, const QMessageLogContext &, const char *). La fonction qInstallMessageHandler() permet d'installer l'QtMessageHandler. La classe QMessageLogContext contient la ligne, le fichier et la fonction où le message a été consigné. Ces informations sont créées par la classe QMessageLogger.

<QtLogging> contient également des fonctions qui génèrent des messages à partir de l'argument de type chaîne de caractères fourni : qDebug(), qInfo(), qWarning(), qCritical() et qFatal(). Ces fonctions appellent le gestionnaire de messages avec le message fourni.

Exemple :

if (!driver()->isOpen()|| driver()->isOpenError()) {
    qWarning("QSqlQuery::exec: database not open");
   return false;
}

Voir aussi QLoggingCategory.

Documentation sur les types

QtMessageHandler

Il s'agit d'un `typedef` pour un pointeur vers une fonction présentant la signature suivante :

void myMessageHandler(QtMsgType, const QMessageLogContext &, const QString &);

Voir également QtMsgType et qInstallMessageHandler().

enum QtMsgType

Cette énumération décrit les messages pouvant être envoyés à un gestionnaire de messages (QtMessageHandler). Vous pouvez utiliser cette énumération pour identifier les différents types de messages et leur associer les actions appropriées. Ses valeurs sont, par ordre croissant de gravité :

ConstanteValeurDescription
QtDebugMsg0Message généré par la fonction qDebug().
QtInfoMsg4Un message généré par la fonction qInfo().
QtWarningMsg1Un message généré par la fonction qWarning().
QtCriticalMsg2Un message généré par la fonction qCritical().
QtFatalMsg3Message généré par la fonction qFatal().

Voir également QtMessageHandler, qInstallMessageHandler() et QLoggingCategory.

Documentation de la fonction

QString qFormatLogMessage(QtMsgType type, const QMessageLogContext &context, const QString &str)

Génère une chaîne formatée à partir des arguments type, context et str.

qFormatLogMessage renvoie un QString formaté selon le modèle de message actuel. Elle peut être utilisée par des gestionnaires de messages personnalisés pour formater la sortie de manière similaire au gestionnaire de messages par défaut de Qt.

Cette fonction est sûre pour les threads.

Voir également qInstallMessageHandler() et qSetMessagePattern().

QtMessageHandler qInstallMessageHandler(QtMessageHandler handler)

Installe un gestionnaire de messages Qt handler. Renvoie un pointeur vers le gestionnaire de messages précédemment installé.

Un gestionnaire de messages est une fonction qui affiche les messages de débogage, d’information, d’avertissement, critiques et fatals provenant de l’infrastructure de journalisation de Qt. Par défaut, Qt utilise un gestionnaire de messages standard qui met en forme et affiche les messages vers différents récepteurs spécifiques au système d’exploitation et à la configuration de Qt. L'installation de votre propre gestionnaire de messages vous permet d'en assumer le contrôle total et, par exemple, de consigner les messages dans le système de fichiers.

Notez que Qt prend en charge les « logging categories » pour regrouper les messages apparentés en catégories sémantiques. Vous pouvez les utiliser pour activer ou désactiver la journalisation par catégorie et par « message type ». Comme le filtrage des catégories de journalisation s’effectue avant même la création d’un message, les messages correspondant aux types et catégories désactivés n’atteindront pas le gestionnaire de messages.

Un gestionnaire de messages doit être « reentrant ». Autrement dit, il peut être appelé depuis différents threads, en parallèle. Par conséquent, les écritures vers des réceptacles communs (tels qu’une base de données ou un fichier) doivent souvent être synchronisées.

Qt permet d’enrichir les messages de journalisation avec des méta-informations supplémentaires en appelant ` qSetMessagePattern()` ou en définissant la variable d’environnement ` QT_MESSAGE_PATTERN `. Pour conserver ce formatage, un gestionnaire de messages personnalisé peut utiliser ` qFormatLogMessage()`.

Essayez de limiter au maximum le code dans le gestionnaire de messages lui-même, car des opérations trop gourmandes en ressources pourraient bloquer l’application. De plus, pour éviter toute récursivité, tout message de journalisation généré au sein même du gestionnaire de messages sera ignoré.

Le gestionnaire de messages doit toujours renvoyer une valeur. Pour fatal messages, l'application s'arrête immédiatement après le traitement de ce message.

Un seul gestionnaire de messages peut être installé à la fois pour l’ensemble de l’application. Si un gestionnaire de messages personnalisé était déjà installé, la fonction renvoie un pointeur vers celui-ci. Ce gestionnaire peut ensuite être réinstallé ultérieurement par un autre appel à la méthode. Par ailleurs, l’appel de ` qInstallMessageHandler(nullptr) ` rétablit le gestionnaire de messages par défaut.

Voici un exemple de gestionnaire de messages qui enregistre les informations dans un fichier local avant d’appeler le gestionnaire par défaut :

#include <QApplication>
#include <stdio.h>
#include <stdlib.h>

QtMessageHandler originalHandler = nullptr;

void logToFile(QtMsgType type, const QMessageLogContext &context, const QString &msg)
{
    QString message = qFormatLogMessage(type, context, msg);
    static FILE *f = fopen("log.txt", "a");
    fprintf(f, "%s\n", qPrintable(message));
    fflush(f);

    if (originalHandler)
        originalHandler(type, context, msg);
}

int main(int argc, char **argv)
{
    originalHandler = qInstallMessageHandler(logToFile);
    QApplication app(argc, argv);
    // ...
    return app.exec();
}

Notez que la norme C++ garantit que ` static FILE *f ` est initialisé de manière sûre pour les threads. On peut également s’attendre à ce que ` fprintf() ` et ` fflush() ` soient sûrs pour les threads ; aucune synchronisation supplémentaire n’est donc nécessaire.

Voir également QtMessageHandler, QtMsgType, qDebug(), qInfo(), qWarning(), qCritical(), qFatal(), Techniques de débogage et qFormatLogMessage().

void qSetMessagePattern(const QString &pattern)

Modifie la sortie du gestionnaire de messages par défaut.

Permet de personnaliser l'affichage des fonctions ` qDebug()`, ` qInfo()`, ` qWarning()`, ` qCritical()` et ` qFatal()`. L'affichage des catégories de journalisation des fonctions ` qCDebug()`, ` qCInfo()`, ` qCWarning()` et ` qCCritical()` est également formaté.

Les espaces réservés suivants sont pris en charge :

Espace réservéDescription
%{appname}QCoreApplication::applicationName()
%{category}Catégorie de journalisation
%{file}Chemin d'accès au fichier source
%{function}Fonction
%{line}Ligne dans le fichier source
%{message}Le message proprement dit
%{pid}QCoreApplication::applicationPid()
%{threadid}L'identifiant système du thread actuel (s'il peut être obtenu)
%{threadname}Le nom du thread actuel (s'il est disponible, ou l'ID du thread depuis Qt 6.10)
%{qthreadptr}Un pointeur vers l'QThread actuel (résultat de QThread::currentThread())
%{type}« debug », « warning », « critical » ou « fatal »
%{time process}l'heure du message, en secondes depuis le démarrage du processus (le token « process » est littéral)
%{time boot}l'heure du message, en secondes depuis le démarrage du système si celle-ci peut être déterminée (le token « boot » est littéral). Si le temps écoulé depuis le démarrage n'a pas pu être obtenu, le résultat est indéterminé (voir QElapsedTimer::msecsSinceReference()).
%{time [format]}l'heure système à laquelle le message s'est produit, formatée en transmettant l'format à QDateTime::toString(). Si le format n'est pas spécifié, le format de Qt::ISODate est utilisé.
%{backtrace [depth=N] [separator="..."]}Une trace de pile avec le nombre de trames spécifié par le paramètre facultatif depth (valeur par défaut : 5), et séparées par le paramètre facultatif separator (valeur par défaut : « | »). À partir de Qt 6.12, le nombre maximal de trames depth est limité à 16 384.

Cette extension n’est disponible que sur certaines plateformes :

  • les plateformes utilisant glibc ;
  • les plateformes fournissant l'en-tête ` <stacktrace> ` de C++23 (nécessite de compiler Qt en mode C++23).

Selon la plateforme, certaines restrictions s'appliquent aux noms de fonctions affichés par cette extension.

Sur certaines plateformes, seuls les noms des fonctions exportées sont connus. Si vous souhaitez voir le nom de toutes les fonctions de votre application, assurez-vous que celle-ci est compilée et liée avec -rdynamic ou un équivalent de celui-ci.

Lors de la lecture des traces de pile, tenez compte du fait que des cadres peuvent manquer en raison de l'inlining ou de l'optimisation des appels de queue.

Vous pouvez également utiliser des conditions sur le type du message à l’aide de ` %{if-debug}`, ` %{if-info} `, ` %{if-warning}`, ` %{if-critical} ` ou ` %{if-fatal} `, suivies d’un ` %{endif}`. Le contenu de ` %{if-*} ` et ` %{endif} ` ne sera affiché que si le type correspond.

Enfin, le texte contenu dans %{if-category}... %{endif} n’est affiché que si la catégorie n’est pas celle par défaut.

Exemple :

    QT_MESSAGE_PATTERN="[%{time yyyyMMdd h:mm:ss.zzz ttt} %{if-debug}D%{endif}%{if-info}I%{endif}%{if-warning}W%{endif}%{if-critical}C%{endif}%{if-fatal}F%{endif}] %{file}:%{line} - %{message}"

L'pattern par défaut est %{if-category}%{category}: %{endif}%{message}.

Remarque : sous Android, l’ pattern par défaut est %{message} car la catégorie est utilisée comme balise, le logcat d’Android disposant d’un champ dédié aux catégories de journalisation (voir Journalisation Android). Si un pattern personnalisé incluant la catégorie est utilisé, QCoreApplication::applicationName() est utilisé comme balise.

Le modèle de message ( pattern ) peut également être modifié à l’exécution en définissant la variable d’environnement QT_MESSAGE_PATTERN ; si la fonction qSetMessagePattern() est appelée et que QT_MESSAGE_PATTERN est définie, la variable d’environnement prévaut.

Remarque : les informations relatives aux espaces réservés category, file, function et line ne sont enregistrées que dans les versions de débogage. Il est également possible de définir explicitement QT_MESSAGELOGCONTEXT. Pour plus d’informations, consultez la documentation relative à QMessageLogContext.

Remarque : ce modèle de message s'applique uniquement à la journalisation non structurée, telle que la sortie par défaut de ` stderr `. La journalisation structurée, comme celle de `systemd`, enregistrera le message tel quel, accompagné d'autant d'informations structurées que possible.

Les gestionnaires de messages personnalisés peuvent utiliser la fonction ` qFormatLogMessage()` pour prendre en compte l'pattern.

Considérations de sécurité

Qt ne supprime ni n’échappe les caractères de contrôle présents dans ` pattern `, notamment les octets ` LF`, ` CR`, ` NUL ` et les séquences de contrôle du terminal. Accepter un modèle provenant d’une source non fiable permet donc de falsifier le journal ou d’envoyer des séquences de contrôle au consommateur du flux de journalisation. De plus, sur certains backends de journalisation, les messages peuvent être tronqués au niveau de l’octet ` NUL `, le cas échéant.

Voir également qInstallMessageHandler(), Techniques de débogage, QLoggingCategory et QMessageLogContext.

Documentation sur les macros

qCritical(const char *format, ...)

Enregistre les messages critiques format dans le gestionnaire de messages central. format peut contenir des spécificateurs de format qui sont remplacés par les valeurs indiquées dans des arguments supplémentaires.

Exemple :

void load(const QString &fileName)
{
    QFile file(fileName);
    if (!file.exists())
        qCritical("File '%s' does not exist!", qUtf8Printable(fileName));
}

format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8, ou %i pour les entiers. Cela fonctionne de manière similaire à la fonction C printf(). Pour plus de détails sur le formatage, consultez QString::asprintf().

Pour plus de commodité et une prise en charge étendue des types, vous pouvez également utiliser QDebug::qCritical(), qui suit le paradigme de flux (similaire à std::cout ou std::cerr).

Pour désactiver la sortie lors de l’exécution, vous pouvez définir logging rules ou enregistrer une fonction personnalisée filter.

À des fins de débogage, il est parfois pratique de laisser le programme s’interrompre en cas de messages critiques. Cela vous permet d’inspecter le vidage de mémoire ou de connecter un débogueur — voir également qFatal(). Pour activer cette fonctionnalité, définissez la variable d’environnement QT_FATAL_CRITICALS sur un nombre n. Le programme s’arrête alors au n-ième message critique. Autrement dit, si la variable d’environnement est définie sur 1, le programme s’arrêtera dès le premier appel ; si elle contient la valeur 10, il s’arrêtera au 10e appel. Toute valeur non numérique dans la variable d’environnement équivaut à 1.

Remarque : cette macro est thread-safe.

Voir également QDebug::qCritical, qCCritical(), qDebug(), qInfo(), qWarning(), qFatal(), qInstallMessageHandler() et Techniques de débogage.

qDebug(const char *format, ...)

Enregistre le message de débogage format dans le gestionnaire de messages central. Le message format peut contenir des spécificateurs de format qui sont remplacés par les valeurs indiquées dans des arguments supplémentaires.

Exemple :

qDebug("Items in list: %d", myList.size());

format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8, ou %i pour les entiers. Ce fonctionnement est similaire à celui de la fonction C printf(). Pour plus de détails sur le formatage, consultez QString::asprintf().

Pour plus de commodité et une prise en charge étendue des types, vous pouvez également utiliser QDebug::qDebug(), qui suit le paradigme de flux (à l’instar de std::cout ou std::cerr).

Cette fonction ne fait rien si QT_NO_DEBUG_OUTPUT a été défini lors de la compilation.

Pour supprimer la sortie lors de l'exécution, installez votre propre gestionnaire de messages avec qInstallMessageHandler().

Remarque : cette macro est thread-safe.

Voir également QDebug::qDebug(), qCDebug(), qInfo(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler() et Techniques de débogage.

qFatal(const char *format, ...)

Enregistre le message fatal format dans le gestionnaire de messages central. format peut contenir des spécificateurs de format qui sont remplacés par les valeurs indiquées dans des arguments supplémentaires.

Exemple :

int divide_by_zero(int a, int b)
{
    if (b == 0)                                // program error
        qFatal("divide: cannot divide by zero");
    return a / b;
}

Si vous utilisez le gestionnaire de messages par défaut, cette fonction s'interrompt pour créer un vidage de mémoire. Sous Windows, pour les versions de débogage, cette fonction signale une erreur _CRT_ERROR, ce qui vous permet de connecter un débogueur à l'application.

Pour supprimer cette sortie lors de l'exécution, installez votre propre gestionnaire de messages à l'aide de qInstallMessageHandler().

Voir également qCFatal(), qDebug(), qInfo(), qWarning(), qCritical(), qInstallMessageHandler() et Techniques de débogage.

qInfo(const char *format, ...)

Enregistre le message d'information format dans le gestionnaire de messages central. format peut contenir des spécificateurs de format qui sont remplacés par les valeurs indiquées dans des arguments supplémentaires.

Exemple :

qInfo("Items in list: %d", myList.size());

format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8, ou %i pour les entiers. Ce fonctionnement est similaire à celui de la fonction C printf(). Pour plus de détails sur le formatage, voir QString::asprintf().

Pour plus de commodité et une prise en charge étendue des types, vous pouvez également utiliser QDebug::qInfo(), qui suit le paradigme de flux (à l’instar de std::cout ou std::cerr).

Cette fonction ne fait rien si QT_NO_INFO_OUTPUT a été défini lors de la compilation.

Pour supprimer la sortie lors de l'exécution, installez votre propre gestionnaire de messages à l'aide de qInstallMessageHandler().

Remarque : cette macro est thread-safe.

Voir également QDebug::qInfo(), qCInfo(), qDebug(), qWarning(), qCritical(), qFatal(), qInstallMessageHandler() et Techniques de débogage.

qWarning(const char *format, ...)

Enregistre le message d'avertissement format dans le gestionnaire de messages central. Le message format peut contenir des spécificateurs de format qui sont remplacés par les valeurs indiquées dans des arguments supplémentaires.

Exemple :

void f(int c)
{
    if (c > 200)
        qWarning("f: bad argument, c == %d", c);
}

format peut contenir des spécificateurs de format tels que %s pour les chaînes UTF-8, ou %i pour les entiers. Ce fonctionnement est similaire à celui de la fonction C printf(). Pour plus de détails sur le formatage, consultez QString::asprintf().

Pour plus de commodité et une prise en charge étendue des types, vous pouvez également utiliser QDebug::qWarning(), qui suit le paradigme de flux (à l’instar de std::cout ou std::cerr).

Cette fonction ne fait rien si QT_NO_WARNING_OUTPUT a été défini lors de la compilation. Pour supprimer la sortie lors de l’exécution, vous pouvez définir logging rules ou enregistrer un filter personnalisé.

À des fins de débogage, il est parfois pratique de laisser le programme s’arrêter en cas de messages d’avertissement. Cela vous permet d’inspecter le vidage de mémoire (core dump) ou de connecter un débogueur — voir également qFatal(). Pour activer cette fonctionnalité, définissez la variable d’environnement QT_FATAL_WARNINGS sur un nombre n. Le programme s’arrête alors au n-ième avertissement. Autrement dit, si la variable d’environnement est définie sur 1, le programme s’arrêtera dès le premier appel ; si elle contient la valeur 10, il s’arrêtera au 10e appel. Toute valeur non numérique dans la variable d’environnement équivaut à 1.

Remarque : cette macro est thread-safe.

Voir également QDebug::qWarning(), qCWarning(), qDebug(), qInfo(), qCritical(), qFatal(), qInstallMessageHandler() et Techniques de débogage.

© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.