Classe avancée de log, thread safe et diverses surcharges

Soyez le premier à donner votre avis sur cette source.

Vue 96 375 fois - Téléchargée 479 fois

Description

Bonjour,

Je met à votre disposition cette classe de Log, thread safe, avec les possibilités qui me conviennent pour un projet.
Je n'ai pas trouvé une qui répondait à mes attentes alors j'ai décidé de me pencher la dessus et voila ce que ça donne.
Vous aurez besoin des bibliothèques boost.utility et boost.interprocess pour compiler, je les utilise principalement pour le mutex et la non-copie. Vous pouvez toujours endormir les parties mutex si vous n'avez pas boost, mais dans ce cas ce ne sera plus du thread safe.
Un petit "doxygen" dans le dossier vous générera une documentation complète.

Source / Exemple :


/*
    This program is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program.  If not, see <http://www.gnu.org/licenses/>.

  • /
#ifndef LOGGER_HEADER_BS #define LOGGER_HEADER_BS #include <boost/interprocess/sync/interprocess_mutex.hpp> #include <boost/interprocess/sync/scoped_lock.hpp> #include <boost/noncopyable.hpp> #include <iostream> #include <fstream> #include <ctime> #include <vector> #include <iomanip> namespace bs { /**
  • \class Logger
  • \author boli
  • \date 07/25/09
  • \file logger.hpp
  • \brief A thread safe class which manage a log file, using boost and the standard library
  • /
class Logger : private boost::noncopyable { public: /**
  • \brief Default constructor
  • \param a_fileName the file name to use
  • \param a_dateTimeFormat the format of date time to use, see documentaiton of strftime
  • \param a_useDateTime Tell to add the date time to logs or not
  • \param a_useEndLine Tell to add end line to logs or not
  • /
Logger(const std::string& a_fileName = std::string(), const std::string& a_dateTimeFormat = std::string("[%m/%d/%y - %H:%M] : "), const bool a_useDateTime = true, const bool a_useEndLine = false ); /**
  • \brief Change the the file name
  • \param a_fileName The new file name
  • /
bool setFileName(const std::string& a_fileName); /**
  • \brief Set the output of the logger to any ostream, std::cerr by default
  • \param os The output stream to use
  • /
void setOutputStream(std::ostream& os); /**
  • \brief Add a line to the log output
  • \param txt The text of the line to add
  • \return true is succesful, false other wise
  • /
bool append(const std::string& txt); /**
  • \brief Add a line to the log output
  • \param txt The text to add
  • \return The internal ostream object
  • /
std::ostream& operator<<(const std::string& txt); /**
  • \brief Overload which call std::ostream& operator<<(const std::string& txt) after conversion
  • /
std::ostream& operator<<(const char* cstyle); /**
  • \brief Overload which call std::ostream& operator<<(const std::string& txt) after conversion
  • /
std::ostream& operator<<(const int& nb); /**
  • \brief Overload which call std::ostream& operator<<(const std::string& txt) after conversion
  • /
std::ostream& operator<<(const double& real); /**
  • \brief Overload which call std::ostream& operator<<(const std::string& txt) after conversion
  • /
std::ostream& operator<<(const char& c); /**
  • \brief Overload which call std::ostream& operator<<(const std::string& txt) after conversion
  • /
std::ostream& operator<<(const unsigned char& uc); /**
  • \brief Overload which call std::ostream& operator<<(const std::string& txt) after conversion
  • /
std::ostream& operator<<(const void* ptr); /**
  • \brief Set the output format of the date and time, see the documentation of strftime for more info
  • default is: "[MM/DD/YY - HH:MM] : "
  • \param a_dateTimeFormat A string representing the desired format
  • /
void setDateTimeFormat(const std::string& a_dateTimeFormat); /**
  • \brief Tell to use the dateTime or not, default use it
  • \param use true to use the dateTime, false to not use it
  • /
void useDateTime(const bool use); /**
  • \brief Tell to automaticaly add the end of line (std::endl) or not, default don't use it
  • \param use True to use it, false to not
  • /
void useEndline(const bool use); /**
  • \brief Tell if the ouput stream is valid
  • \return true if the stream is valid (operator void*())
  • /
bool isValid(); /**
  • \brief Remove the log file
  • \return True if the file have been successfully removed
  • /
bool removeFile(); /**
  • \brief Rename the file and continue logging on the new file
  • \param newName the new name of the file
  • \return True if the file has been successfully renamed
  • /
bool renameFile(const std::string& newName); /**
  • \brief Reset the file, clear his content by erasing the old file
  • \return True if the file has been successfully reseted
  • /
bool resetFile(); /**
  • \brief Get the associated output stream of the logger
  • \return a reference to the std::ostream used
  • /
std::ostream& outputStream(); private: std::string dateTime(); /**
  • \brief Convert any type to std::string, see the documentation of std::ostringstream:operator<< for convertible types
  • \param The corresponding std::string
  • /
template<typename T> std::string convertToString(const T& elem) { std::ostringstream oss; oss << std::fixed << elem; return oss.str(); } private: std::string m_fileName; std::string m_dateTimeFormat; bool m_useDateTime; bool m_useEndLine; std::ofstream m_file; boost::interprocess::interprocess_mutex m_mutex; std::ostream *m_output; }; }; //end namespace bs #endif //end LOGGER_HEADER_BS

Conclusion :


Utilisez la et faites moi part de vos retours/suggestions.

Codes Sources

A voir également

Ajouter un commentaire

Commentaires

Messages postés
112
Date d'inscription
lundi 29 juin 2009
Statut
Membre
Dernière intervention
5 novembre 2009

Question de profane de la bibliothèque Boost (j'y connais absolument rien):
A quoi sert ton lien d'héritage ? Pour des mutex de boost ?

D'autres questions esthétiques:
* je me souviens quand je codais mes serveurs, j'avais fait une implémentation d'un logger à l'arrache (c'était une encapsulation d'un bête printf(stderr)), mais j'avais un problème,dans mon fichier, les données était classée par thread (puis date) et non par date ; t'as ce même probleme ? (J'étais sous linux 2.6 /pthread).. une histoire de flush je pense

* Pour les includes de templates, j'utilisais la nomenclature ".inl" (pour inline)

En tout cas, excellente qualité de code.
Quel éditeur ?
Messages postés
229
Date d'inscription
dimanche 14 septembre 2003
Statut
Membre
Dernière intervention
20 août 2014

je pensai bien que ce n'était pas géré
par contre, ton code peut être plus simple :
Logger& operator<<(Logger& out, std::ostream& (*fn)(std::ostream&))
{
fn(out.outputStream());
return out;
}

enfin c'était juste pour te titiller un peu sur des cas particuliers ;)
Messages postés
3813
Date d'inscription
dimanche 12 décembre 2004
Statut
Modérateur
Dernière intervention
12 juin 2020
107
Non, ça ne le gère pas, mais si tu veux ajouter cette feature sans toucher à son code, ceci devrait le faire:

Logger&
operator<<(Logger& out,
std::ostream& (*fn)(std::ostream&))
{
std::ostringstream oss;
fn(oss);
out << oss.str();
return out;
}
Messages postés
229
Date d'inscription
dimanche 14 septembre 2003
Statut
Membre
Dernière intervention
20 août 2014

une question dans ce cas, est-ce que ceci fonctionne ?
log << std::endl;
Messages postés
10
Date d'inscription
vendredi 14 août 2009
Statut
Membre
Dernière intervention
31 mai 2010

Avec l'op<< je retourne directement l'ostream donc c'est possible d'utiliser std::endl et tout les autres manipulateurs de flux, voire l'exemple du main.
Pour ce qui est de plantage du programme, c'est à l'utilisateur de la classe de se préoccuper de ça, vu que la classe s'utilise comme un flux standard, (donc std::endl, std::flush).
D'ailleurs je n'aurais pas à l'idée de rajouter des lignes de log sans std::endl (ou l'option useEndLine(true))sinon le fichier serait un vrai foutoir.
Sinon pour ta première remarque, si c'est à propos du "a_", je l'utilise pour identifier les variables qui ne feront rien d'autre qu'être "assignés" à des membres.
Afficher les 8 commentaires

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.