Logging avec opérateur <<

Salut,

J'ai récupéré la bibliothèque Poco qui me permet de logger des messages compatibles avec le type std::string.

Grosso modo il y a une methode comme ça :
Code:

1 2 void debug(std::string& s);
Mon idée est de permettre d'utiliser cette methode avec une std::stringstream
Donc je peux créer un adaptateur qui fait :
Code:

1 2 3 4 5 void stream_debug(std::stringstream& stream) { instanceLogger.debug(stream.str()); }
Pour que le logger soit pratique à utiliser je voudrais pouvoir passer des streams "composées" directement, par exemple :
Code:

1 2 3 double d = 1.2345; stream_debug("la valeur de d est " << d);
Mais ça ne marche pas car la chaine constante ne supporte pas "<<".
Donc j'ai imaginé le contournement suivant :
Code:

1 2 3 4 #define LOG(a) stringstream s; s << a << endl; stream_debug(s); double d = 1.2345; LOG("la valeur de d est " << d);
Ca marche mais est ce qu'il y a mieux à faire ???
Peut-on se passer de la macro ?

Merci

Un logger qui ne permet pas de faire des sorties façon flux C++, ça me paraît déjà pas terrible. Tu es sûr que Poco ne le propose pas ?

Sinon au pire tu peux te fabriquer ton propre flux / streambuf :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 struct MyLogStreambuf : public std::stringbuf { virtual int sync() { instanceLogger.debug(str()); str(""); return std::stringbuf::sync(); } }; MyLogStreambuf buf; std::ostream Log(&buf); Log << "la valeur de d est " << d << std::endl;

Citation:

Un logger qui ne permet pas de faire des sorties façon flux C++, ça me paraît déjà pas terrible. Tu es sûr que Poco ne le propose pas ?

Non, Poco ne le propose pas. Son design est assez proche bien que différent de log4cxx ou log4cpp (donc de log4j). Concernant les sorties C++, je ne connaît pas de logger qui permettait de faire de telles sorties (si tu en connais, je suis preneur :P ).

Citation:
Envoyé par Laurent Gomila
Un logger qui ne permet pas de faire des sorties façon flux C++, ça me paraît déjà pas terrible. Tu es sûr que Poco ne le propose pas ?

Sinon au pire tu peux te fabriquer ton propre flux / streambuf :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 struct MyLogStreambuf : public std::stringbuf { virtual int sync() { instanceLogger.debug(str()); str(""); return std::stringbuf::sync(); } }; MyLogStreambuf buf; std::ostream Log(&buf); Log << "la valeur de d est " << d << std::endl;
J'ai essayé en créant une classe comme ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 class LogStreamBuf : public std::stringbuf { public: LogStreamBuf(Logger* logger = NULL); virtual ~LogStreamBuf(); void setLogger(Logger* logger); virtual int sync(); protected: Logger* _logger; };
Mais on dirait que sync() n'est pas appelé à l'exécution de "Log << "..."" , du coup ça n'affiche rien... sync() c'est bien une méthode virtuelle de la classe de base ??? Je crois que le polymorphisme de cette méthode ne marche pas...

Citation:

Envoyé par Patriarch24

Concernant les sorties C++, je ne connaît pas de logger qui permettait de faire de telles sorties (si tu en connais, je suis preneur :P ).

boost::log le permet, mais il utilise aussi une macro, afin en particulier d'éliminer tout calcul si les logs sont statiquement désactivés.

Citation:

Mais on dirait que sync() n'est pas appelé à l'exécution de "Log << "..."" , du coup ça n'affiche rien... sync() c'est bien une méthode virtuelle de la classe de base ??? Je crois que le polymorphisme de cette méthode ne marche pas...

sync() est appelé à chaque fois que le buffer du flux doit être vidé vers sa destination. En clair, si tu veux forcer la sortie mets un std::endl à la fin, ou un std::flush si tu ne veux pas passer de ligne.

Pendant mon temps libre, j'essaie de concevoir une petite biblio de log. Le mieux auquel je sois arrivé concernant les flux est un truc du style:

Code:

logger.trace().stream() << "salut " << "le monde";

Théoriquement on devrait pouvoir le raccourcir en

Code:

logger.trace() << "salut " << "le monde";

mais j'ai eu des bugs et j'ai laissé tomber pour un temps.
C'est un problème plus compliqué qu'il n'y parait, il ne suffit pas de dériver d'une classe stream quelconque, qui plus est il faut penser à l'intégrité d'un message de log. La syntaxe suivante est purement illogique:

Code:

logger << "salut " << "le monde";

Du point de vue du compilo ça correspond à deux appels de fonction, donc deux messages alors que ça n'en forme qu'un seul.

Citation:

Du point de vue du compilo ça correspond à deux appels de fonction, donc deux messages alors que ça n'en forme qu'un seul

Ca dépend, pas si on ne considère un message que sur sync() comme je l'ai fait. Et si on veut avoir un contrôle total on peut toujours créer un manipulateur spécial qui délimite la fin d'un message, comme je l'avais vu dans je ne sais plus quelle bibliothèque.

Code:

log << "salut" << " le monde" << logger::end;

Si on veut, mais il faut aussi pouvoir paramétrer le niveau de log (toutes les apis de log utilisent ces trucs la).
Il faut aussi penser au multithread, si tu n'utilises qu'un unique buffer contenu dans ton objet logger, même à grand coup de mutex tu n'arriveras jamais à rien.
La seule solution valable pour moi est d'instancier un nouveau buffer sur la pile à chaque demande de log. Si je parvenais à faire fonctionner la deuxième syntaxe que j'ai indiqué ce serait excellent, mais c'est pas encore au point. Faut dire que l'architecture choisie pour les flux standard du C++ est vraiment complexe, quand on voit la simplicité et la puissance de ceux du java on en pleure. C'est pas pour rien qu'il n'existe qu'un très faible nombre de projet qui étend cette archi.

Edit:
A ben pour finir j'ai jeté à nouveau un coup d'oeil et je suis arrivé à un truc potable. Pour info voici à quoi ressemble la petite classe que j'ai créée pour ça:
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 class log_stream { private: friend class logger; std::auto_ptr<std::ostringstream> buf; logger* my_logger; level my_level; log_stream(); log_stream(logger& log,const level& lev); log_stream& operator = (const log_stream& o); public: std::ostringstream& stream(); template<typename A> std::ostream& operator << (A& a) { return stream() << a; } template<typename A> std::ostream& operator << (const A& a) { return stream() << a; } ostream& operator<<(ostream& (*pf)(ostream&)) { return stream() << pf; } ostream& operator<<(ios& (*pf)(ios&)) { return stream() << pf; } ostream& operator<<(ios_base& (*pf)(ios_base&)) { return stream() << pf; } void send_to_logger(); log_stream(const log_stream& o); ~log_stream(); }; logger::log_stream::log_stream(logger& log,const level& lev):my_logger(&log),my_level(lev){ buf= std::auto_ptr<std::ostringstream>(new std::ostringstream()); } std::ostringstream& logger::log_stream::stream() { return *buf; } void logger::log_stream::send_to_logger() { if(buf->str()!="") my_logger->log(buf->str(),my_level); buf->str(""); } logger::log_stream::log_stream(const log_stream& o) { my_logger = o.my_logger; my_level = o.my_level; buf = std::auto_ptr<std::ostringstream>(new std::ostringstream); } logger::log_stream::~log_stream() { send_to_logger(); }
En gros j'instancie un de ces objets en lui filant une réfèrence sur mon objet logger. Il surcharge l'opérateur << en le redirigeant vers un buffer interne (qui est mis à zero à la création de l'objet). A sa destruction, il envoie le contenu du buffer vers le logger à la seule condition que ce buffer ne soit pas vide.
L'interet est limité puisqu'on peut simplement instancier notre propre stringstream puis envoyer son contenu vers le logger, mais ça donne un look sympa au code:
Code:

1 2 logger.log("salut\nle monde"); logger.log() << "salut" << endl << "le monde";

Citation:

Si on veut, mais il faut aussi pouvoir paramétrer le niveau de log (toutes les apis de log utilisent ces trucs la).

Ca c'est un détail, il y a mille façons de faire, par exemple :
Code:

1 2 3 4 5 6 7 8 9 // Utiliser un flux par niveau log_info << ...; log_warn << ...; log_err << ...; // Spécifier le niveau au début ou à la fin log << logger::warning << ...; log(warning) << ...; log << ... << logger::end(warning);
L'avantage de log(warning) c'est que c'est un appel de fonction (de l'opérateur () pour être exact) et que ça te permet d'utiliser ton système, à savoir générer et renvoyer un temporaire.

Pour l'utilisation de manipulateurs, ça ne règle toujours pas le problème du multithread.
Et à partir du moment où tu utilises un foncteur, ça revient exactement au même que d'utiliser une méthode (j'aime un peu moins dans ce cas, je trouve ça moins explicite).
Qu'est-ce qui te gène tant dans ma syntaxe?

Citation:

Qu'est-ce qui te gène tant dans ma syntaxe?

Absolument rien :lol:
Je montrais juste qu'on pouvait adapter un système de log aux flux C++. Après tu m'as montré quelques problèmes suite à ton expérience avec la chose, j'ai simplement tenté d'y répondre.

Je n'ai jamais développé de système de log complexe, donc je ne vais pas m'avancer dans une discussion poussée ; par exemple dans mes réponses je n'ai pas pris en compte les problèmes de multithreading que tu soulèves.

Citation:

Envoyé par Laurent Gomila

Absolument rien :lol:
Je montrais juste qu'on pouvait adapter un système de log aux flux C++. Après tu m'as montré quelques problèmes suite à ton expérience avec la chose, j'ai simplement tenté d'y répondre.

Je n'ai jamais développé de système de log complexe, donc je ne vais pas m'avancer dans une discussion poussée ; par exemple dans mes réponses je n'ai pas pris en compte les problèmes de multithreading que tu soulèves.

En tout cas j'ai réussi à ce que ça marche avec le endl et ça me suffit amplement pour l'instant. Merci de votre aide.