Ticket #8840: test_logging.cpp

#include <iostream>
#include <iomanip>
#include <cstdlib>
#include <fstream>
#include <boost/log/core.hpp>
#include <boost/log/sources/global_logger_storage.hpp>
#include <boost/log/sources/severity_logger.hpp>
#include <boost/log/sources/record_ostream.hpp>
#include <boost/log/attributes/clock.hpp>
#include <boost/log/attributes/current_process_name.hpp>
#include <boost/log/attributes/current_process_id.hpp>
#include <boost/log/attributes/current_thread_id.hpp>
#include <boost/log/utility/setup/file.hpp>
#include <boost/log/utility/setup/from_stream.hpp>
#include <boost/log/utility/manipulators/to_log.hpp>
#include <boost/log/utility/formatting_ostream.hpp>

using namespace std;

namespace logging = boost::log;
namespace keywords = boost::log::keywords;
namespace expr = boost::log::expressions;
namespace attr = boost::log::attributes;
namespace src = boost::log::sources;

#define LFC1_LOG(logger, level) BOOST_LOG_SEV(logger, level) << "(" << __FILE__ << ", " << __LINE__ << ") "

#define LFC1_LOG_TRACE(logger) LFC1_LOG(logger, trace)
#define LFC1_LOG_DEBUG(logger) LFC1_LOG(logger, debug)
#define LFC1_LOG_INFO(logger) LFC1_LOG(logger, info)
#define LFC1_LOG_WARNING(logger) LFC1_LOG(logger, warning)
#define LFC1_LOG_ERROR(logger) LFC1_LOG(logger, error)

static const auto RET_SUCCESS = 0;
static const auto RET_FAIL = 1;
static const auto LOGGING_ENVIRONMENT_NAME = "LOGGING_CONFIG_FILE_NAME";
static const auto DEFAULT_LOGGING_CONFIG_FILE_NAME = "config/LogSettings.txt";

enum ESeverityLevel
{
        trace,
        debug,
        info,
        warning,
        error
};

BOOST_LOG_ATTRIBUTE_KEYWORD(severity, "Severity", ESeverityLevel)

ostream& operator<<(ostream& arStream, ESeverityLevel avLevel)
{
        static const char* pStrings[] =
        {
                "trace",
                "debug",
                "info",
                "warning",
                "error"
        };

        if (static_cast<size_t>(avLevel) < sizeof(pStrings) / sizeof(*pStrings))
        {
                arStream << pStrings[avLevel];
        }
        else
        {
                arStream << static_cast<int>(avLevel);
        }

        return arStream;
}

logging::formatting_ostream& operator<<
(
        logging::formatting_ostream& arStream,
        logging::to_log_manip<ESeverityLevel, tag::severity> const& arManip
)
{
        static const char* pStrings[] =
        {
                "TRACE",
                "DEBUG",
                "INFO",
                "WARNING",
                "ERROR"
        };

        ESeverityLevel vLevel = arManip.get();
        if (static_cast<size_t>(vLevel) < sizeof(pStrings) / sizeof(*pStrings))
        {
                arStream << pStrings[vLevel];
        }
        else
        {
                arStream << static_cast<int>(vLevel);
        }

        return arStream;
}

BOOST_LOG_INLINE_GLOBAL_LOGGER_DEFAULT(SLogger, src::severity_logger<ESeverityLevel>)

static void gvLoggingInit(const char* apConfigFileName = nullptr)
{
        // Obtain the name of the logging configuration file.
        if (apConfigFileName == nullptr || apConfigFileName[0] == 0)
        {
                if ((apConfigFileName = getenv(LOGGING_ENVIRONMENT_NAME)) == 0 || apConfigFileName[0] == 0)
                {
                        apConfigFileName = DEFAULT_LOGGING_CONFIG_FILE_NAME;
                }
        }

        // Open the logging configuration file.
        ifstream vConfigFile(apConfigFileName);
        if (!vConfigFile.is_open())
        {
                // TODO: throw an exception
        }

        // Read the contents of the logging configuration file.
        logging::init_from_stream(vConfigFile);

        // Add the logging attributes that we require.
        auto pCore = logging::core::get();
        pCore->add_global_attribute("TimeStamp", attr::local_clock());
        pCore->add_global_attribute("Process", attr::current_process_name());
        pCore->add_global_attribute("ProcessID", attr::current_process_id());
        pCore->add_global_attribute("ThreadID", attr::current_thread_id());
        pCore->set_filter(severity >= info);
}

int main()
{
        auto vRetVal = RET_SUCCESS;

        try
        {
                gvLoggingInit();

                auto& vLogger = SLogger::get();

        LFC1_LOG_TRACE(vLogger) << "A trace severity message";
        LFC1_LOG_DEBUG(vLogger) << "A debug severity message";
        LFC1_LOG_INFO(vLogger) << "An informational severity message";
        LFC1_LOG_WARNING(vLogger) << "A warning severity message";
        LFC1_LOG_ERROR(vLogger) << "An error severity message";
        }
        catch (exception& crException)
        {
                cerr << crException.what() << endl;
                vRetVal = RET_FAIL;
        }
        catch (...)
        {
                cerr << "Unknown exception" << endl;
                vRetVal = RET_FAIL;
        }

        return vRetVal;
}