[Boost-users] boost logging to file

Subject: [Boost-users] boost logging to file
From: Jarrett Chisholm (j.chisholm_at_[hidden])
Date: 2013-08-03 13:06:30

Thanks to everyone who's replied to my previous boost logging question -
still having some issues I'm afraid :S

I've been struggling with boost log for a while now - I got their simple
example writing to a log file
(http://boost-log.sourceforge.net/libs/log/example/doc/tutorial_file.cpp). 
However, when I try to copy that code into my own 'Logger' class, I
can't get it to write to the log file.  I can see the file `default.log`
get created, but there is nothing in it.

I'm on debian 7 64bit.  Everything compiles fine - compile line is:

    g++ -o build/Logger.o -c -std=c++11 -Wall -g -O0
-DBOOST_LOG_DYN_LINK -DDEBUG src/Logger.cpp
    g++ -o build/logtest build/Logger.o -lboost_log -lboost_log_setup
-lboost_date_time -lboost_thread -lboost_wave -lboost_regex
-lboost_program_options

Here's my code:

`Logger.cpp`
    
    #include "Logger.h"
    
    namespace logging = boost::log;
    namespace sinks = boost::log::sinks;
    namespace src = boost::log::sources;
    namespace expr = boost::log::expressions;
    namespace attrs = boost::log::attributes;
    namespace keywords = boost::log::keywords;
    
    namespace dhlogging {
        
    Logger::Logger(std::string fileName)
    {
        initialize(fileName);
    }
    
    Logger::Logger(Logger const&)
    {
    }
    
    Logger::~Logger()
    {
    
    }
    
    Logger* Logger::logger_ = nullptr;
    Logger* Logger::getInstance(std::string logFile)
    {
        if ( Logger::logger_ == nullptr ) {
            logging::add_file_log( logFile );
    
            logging::core::get()->set_filter
            (
                logging::trivial::severity >= logging::trivial::info
            );
            
            logging::add_common_attributes();
            Logger::logger_ = new Logger(logFile);
        }
    
        return Logger::logger_;
    }
    
    void Logger::initialize(std::string fileName)
    {    
        BOOST_LOG(log_) << "Hello, World!";
        BOOST_LOG_SEV(log_, info) << "Hello, World2!";
    }
    
    void Logger::logInfo(std::string message)
    {
        BOOST_LOG_SEV(log_, info) << message;
    }
    
    void Logger::logDebug(std::string message)
    {
        BOOST_LOG_SEV(log_, debug) << message;
    }
    
    void Logger::logWarn(std::string message)
    {
        BOOST_LOG_SEV(log_, warning) << message;
    }
    
    void Logger::logError(std::string message)
    {
        BOOST_LOG_SEV(log_, error) << message;
    }
    
    void Logger::logFatal(std::string message)
    {
        BOOST_LOG_SEV(log_, fatal) << message;
    }
    
    }
    
    int main(int, char*[])
    {
        logging::add_common_attributes();
    
        using namespace logging::trivial;
        
        dhlogging::Logger::getInstance()->logInfo("himom");
        
        return 0;
    }

`Logger.h`
    
    #ifndef LOGGER_H_
    #define LOGGER_H_
   
    #include <boost/log/core.hpp>
    #include <boost/log/trivial.hpp>
    #include <boost/log/expressions.hpp>
    #include <boost/log/sinks/text_file_backend.hpp>
    #include <boost/log/utility/setup/file.hpp>
    #include <boost/log/utility/setup/common_attributes.hpp>
    #include <boost/log/sources/severity_logger.hpp>
    #include <boost/log/sources/record_ostream.hpp>
    
    namespace logging = boost::log;
    namespace sinks = boost::log::sinks;
    namespace src = boost::log::sources;
    namespace expr = boost::log::expressions;
    namespace attrs = boost::log::attributes;
    namespace keywords = boost::log::keywords;
    
    using namespace logging::trivial;
    
    namespace dhlogging {
    class Logger {
        
    public:
        static Logger* getInstance(std::string logFile = "default.log");
        
        void logInfo(std::string message);
        void logDebug(std::string message);
        void logWarn(std::string message);
        void logError(std::string message);
        void logFatal(std::string message);
        
    
    private:
        Logger(std::string fileName);
        Logger(Logger const&);
        Logger& operator=(Logger const&);
        virtual ~Logger();
    
        void initialize(std::string fileName);
    
        src::severity_logger< severity_level > log_;
    
        static Logger* logger_; // singleton instance
    };
    }
    #endif /* LOGGER_H_ */

Anyone have any ideas?

Jarrett