Boost.Log：如何转发日志源

Question

I am trying to figure out, what the best way is to use a logging source within a class. The straight forward solution, simply to define it as a member (stack) variable has the big drawback, that I have to include Boost.Log header files, which really slows down the compilation.

I'd like to use a severity channel logger. So my first approach was to define a new type, eg:

#include <boost/log/sources/severity_channel_logger.hpp>

typedef boost::log::sources::severity_channel_logger_mt<SeverityLogLevel, std::string> DefaultLogger;

This approach only simplifies defining a logger, but I still need to include the header file.

My next idea was to create a new class, which subtypes the logger and then using a forward declaration of this class:

// MyLogger.h
class MyLogger : public boost::log::sources::severity_channel_logger_mt<SeverityLogLevel, std::string>
{
  public:
    MyLogger(const std::string& name);
};

// MyLoggingClient.h
include <memory>

class MyLogger;

class MyLoggingClient
{
  // Actual implementation

  private:
    std::unique_ptr<MyLogger> lg;

};

But doing this, the compiler complains that MyLogger does not define the binary "[" operator or a conversion to a type acceptable to the predefined operator.

So, my question is, what is a good way of simply forwarding the definition of logger? (I am refactoring the logging of existing code, so using the PIMPL or similar pattern, would result in a lot of extra effort.)

Thanks, - Lars

Answer 1

I think you've already showed the best way to forward-declare a logger, although I would suggest to store Boost.Log logger as a member of MyLogger instead of deriving from it. Boost.Log loggers are designed using CRTP , so deriving from it may result in unexpected behavior.

The compiler error you're getting is probably caused by some part of your code which was not updated to account for the change you made - that lg is no longer a logger but a pointer.

PIMPL is another way to achieve what you want, and I think it actually might be easier than using a pointer. What you need is to implement a wrapper for the logger that implements an interface similar to Boost.Log loggers you use. For instance, for severity_channel_logger_mt this might suffice:

// MyLogger.h
#include <string>
#include <boost/log/core/record.hpp>
#include <boost/log/keywords/severity.hpp>
#include <boost/log/keywords/channel.hpp>

enum SeverityLogLevel { ... };

class MyLogger
{
private:
    struct Impl;
    Impl* impl;

public:
    MyLogger();
    MyLogger(MyLogger const&);
    MyLogger(MyLogger&& that) noexcept : impl(that.impl) { that.impl = nullptr; }
    ~MyLogger();

    MyLogger& operator= (MyLogger const&);
    MyLogger& operator= (MyLogger&& that) noexcept
    {
        MyLogger copy(static_cast< MyLogger&& >(that)); // you can use use std::move here and include <utility>
        this->swap(copy);
        return *this;
    }

    boost::log::record open_record();
    boost::log::record open_record(SeverityLogLevel sev, std::string const& chan);
    template< typename Args >
    boost::log::record open_record(Args const& args)
    {
        return open_record(args[boost::log::keywords::severity], args[boost::log::keywords::channel]);
    }

    void push_record(boost::log::record&& rec);

    void swap(MyLogger& that) noexcept
    {
        Impl* p = impl;
        impl = that.impl;
        that.impl = p;
    }
};

// MyLogger.cpp
#include "MyLogger.h"
#include <utility>
#include <boost/log/sources/severity_channel_logger.hpp>

typedef boost::log::sources::severity_channel_logger_mt<
    SeverityLogLevel,
    std::string
> DefaultLogger;

struct MyLogger::Impl
{
    DefaultLogger lg;
};

MyLogger::MyLogger() : impl(new Impl())
{
}

MyLogger::MyLogger(MyLogger const& that) : impl(new Impl(*that.impl))
{
}

MyLogger::~MyLogger()
{
   delete impl;
}

MyLogger& MyLogger::operator= (MyLogger const& that)
{
    MyLogger(that).swap(*this);
    return *this;
}

boost::log::record MyLogger::open_record()
{
    return impl->lg.open_record();
}

boost::log::record MyLogger::open_record(SeverityLogLevel sev, std::string const& chan)
{
    return impl->lg.open_record((boost::log::keywords::severity = sev, boost::log::keywords::channel = chan));
}

void MyLogger::push_record(boost::log::record&& rec)
{
    impl->lg.push_record(std::move(rec));
}

You should be able to use Boost.Log macros with this wrapper as is. You still have to include a few headers in MyLogger.h but hopefully this will be an improvement significant enough for you. It can be improved further if you remove support for keywords (the Boost.Log includes and the templated open_record overload) but then you will have to define and use your own logging macros throughout the code.

If you use other logging features, such as attributes, you may need to add more forwarding functions to the wrapper. See Reference for signatures of logger functions.