Record

Modules
	Record Concepts

Classes
class	sl::log::BaseRecord< TSeverityLevel, TChannel, TMessage, TTimePoint >
	A collection of logging related information. More...
class	sl::log::SetSev< TSeverityLevel >
	Manipulates the channel of the current RecordBuilder object. More...
class	sl::log::SetChan< TChannel >
	Manipulates the channel of the current RecordBuilder object. More...
class	sl::log::RecordBuilder< TRecord >
	Helper class for building new Records. More...

Detailed Description

Records are basically a collection of information, which has been gathered either implicitly or explicitly while a logging Message was created. It is not intended that users ever use a plain Record or set it up by theirselves. The library provides a simple interface which does all the trivial part of a logging step, while users can concentrate on setting up their message.
Have a look at Logger and RecordBuilder if you want to know more about how to setup Records.

Custom Record Types

In the preset namespace of this library users can find a Record_t alias, which will accept values of the SevLvl enum as SeverityLevel and std::strings as Channel type. Users may exchange any or all of these predefined types with their own. If you use any Filter, FlushPolicy or anything else which watches out for a specific Channel, it might be wise to exchange the std::string type with something less expensive to compare, e.g. an enum type or plain int. For example users could use the BaseRecord type, but exchanging some member types with any other type or even create their custom Record type from scratch. Here is an example for the former:

#include <Simple-Log/PresetTypes.hpp>
#include <Simple-Log/Simple-Log.hpp>
 
#include <sstream>
 
using namespace sl::log;
using preset::SevLvl;
 
enum class Channel
{
    standard,
    network,
    stats
};
 
// A simple overload, thus our Channel enum can be printed into every ostream object.
inline std::ostream& operator <<(std::ostream& out, Channel lvl)
{
    constexpr const char* str[] = { "standard", "network", "stats" };
    out << str[static_cast<std::size_t>(lvl)];
    return out;
}
 
// Yes, these are a few typedefs which might seem tedious at the first glance, but you'll usually need to do this once per program.
using Record_t = BaseRecord<SevLvl, Channel>;
using Core_t = Core<Record_t>;
using ConsoleSink_t = ConsoleSink<Record_t>;
using FileSink_t = FileSink<Record_t>;
using Logger_t = BaseLogger<Record_t>;
 
inline Core_t gCore;
// every Record, which will be created by this Logger will be from Channel "standard" by default 
inline auto gLog = makeLogger<Logger_t>(gCore, SevLvl::info, Channel::standard);
inline auto& gConsoleSink
{
    []() -> auto&
    {
        // let's create the console sink in disabled state. Will become automatically enabled after this scope is left.
        auto wrappedSink = gCore.makeDisabledSink<ConsoleSink_t>();
        // Only messages with the Channel network shall be printed onto the console
        wrappedSink->setFilter(makeChannelFilterFor<Record_t>(Equals{ Channel::network }));
        // setting up a custom formatter, thus for each Record only the channel followed by the message will be printed.
        wrappedSink->setFormatter(
                                [](const Record_t& record)
                                {
                                    std::stringstream out;
                                    out << record.channel() << " >> " << record.message();
                                    return std::move(out).str();
                                }
                                );
 
        return *wrappedSink;
    }()
};
 
int main()
{
    gLog() << "Hello, World!";  // this message is ignored by our Console sink
    gLog() << SetChan(Channel::network) << "Hello, Network!"; // our Console sink handles this record.
}
 
/* The output of the console looks like this:
 network >> Hello, Network!

If your needs are more specific and you want to add things such as custom properties to the Record type, this might be an example for you:

#include <Simple-Log/PresetTypes.hpp>
#include <Simple-Log/Simple-Log.hpp>
 
#include <sstream>
 
using namespace sl::log;
using preset::SevLvl;
 
class MyCustomRecord :
    public preset::Record_t
{
public:
    using Domain_t = std::string;
    
    Domain_t domain;
};
 
// Yes, these are a few typedefs which might seem tedious at the first glance, but you'll usually need to do this once per program.
using Core_t = Core<MyCustomRecord>;
using ConsoleSink_t = ConsoleSink<MyCustomRecord>;
using FileSink_t = FileSink<MyCustomRecord>;
using Logger_t = BaseLogger<MyCustomRecord>;
 
// Now that our Record class contains an additional domain property, we would like to have a manipulator for our RecordBuilder
using RecordBuilder_t = RecordBuilder<MyCustomRecord>;
 
class SetDomain
{
public:
    using Domain_t = MyCustomRecord::Domain_t;
    
    explicit SetDomain(Domain_t data) :
        m_Data{ std::move(data) }
    {
    }
 
    void operator ()(MyCustomRecord& rec)
    {
        rec.domain = std::move(m_Data);
    }
 
private:
    Domain_t m_Data;
};
 
inline Core_t gCore;
inline auto gLog = makeLogger<Logger_t>(gCore, SevLvl::info);
inline auto& gConsoleSink
{
    []() -> auto&
    {
        // let's create the console sink in disabled state. Will become automatically enabled after this scope is left.
        auto wrappedSink = gCore.makeDisabledSink<ConsoleSink_t>();
        // setting up a custom formatter, thus for each Record only the domain followed by the message will be printed.
        wrappedSink->setFormatter(
                                [](const MyCustomRecord& record)
                                {
                                    std::stringstream out;
                                    out << record.domain << " >> " << record.message();
                                    return std::move(out).str();
                                }
                                );
 
        return *wrappedSink;
    }()
};
 
int main()
{
    gLog() << "Hello, World!";
    // this clearly belongs to the domain of palindromes, thus let's tag it like this!
    gLog() << SetDomain("palindrome") << "A Man, A Plan, A Canal, Panama!";
}
 
/* The output of the console looks like this:
 >> Hello, World!
palindrome >> A Man, A Plan, A Canal, Panama!