logger.h

Go to the documentation of this file.

/*
Copyright (c) 2016 Alexei Novakov
https://github.com/novalexei

Distributed under the Boost Software License, Version 1.0.
http://boost.org/LICENSE_1_0.txt
*/
#ifndef SERVLET_LOGGER_H
#define SERVLET_LOGGER_H

#include <experimental/string_view>
#include <atomic>
#include <string>
#include <memory>
#include <map>
#include <mutex>
#include <thread>
#include <iomanip>
#include <vector>

#include <servlet/lib/io_string.h>

namespace servlet {

using std::experimental::string_view;

namespace logging {

class log_output
{
public:
    virtual ~log_output() noexcept {}

    virtual void write_string(string_view str) = 0;
    virtual void flush() = 0;

    virtual void load_config(std::map<std::string, std::string, std::less<>>& props,
                             const std::string& conf_prefix, const std::string &base_dir) = 0;
};

struct log_output_factory
{
    virtual ~log_output_factory() noexcept {}
    virtual log_output* new_log_output() = 0;
};

enum class SYNC_POLICY
{
    SINGLE_THREAD,
    SYNC,
    ASYNC
};

enum class LEVEL
{
    CRITICAL,
    ERROR,
    WARNING,
    INFO,
    CONFIG,
    DEBUG,
    TRACE
};

class prefix_printer
{
public:
    virtual ~prefix_printer() noexcept {}

    virtual void print_prefix(LEVEL level, const std::string &name, std::ostream &out) const = 0;
    virtual void load_config(std::map<std::string, std::string, std::less<>>& props, const std::string& conf_prefix) = 0;
};

struct prefix_printer_factory
{
    virtual ~prefix_printer_factory() noexcept {}
    virtual prefix_printer* new_prefix_printer() = 0;
};

class logger;

class level_logger
{
public:
    ~level_logger() noexcept;

    template<typename T>
    inline level_logger &operator<<(const T &value);

    level_logger &operator<<(std::ostream &(*manip)(std::ostream &));

    level_logger &operator<<(char ch);
    level_logger &operator<<(char16_t ch);
    level_logger &operator<<(const char16_t* str);
    level_logger &operator<<(const std::u16string& str);
    level_logger &operator<<(char32_t ch);
    level_logger &operator<<(const char32_t* str);
    level_logger &operator<<(const std::u32string& str);
    level_logger &operator<<(wchar_t ch);
    level_logger &operator<<(const wchar_t* str);
    level_logger &operator<<(const std::wstring& str);

    level_logger &flush() { _out->flush(); return *this; }

    level_logger &put(char ch) { return (*this) << ch; }
    level_logger &put(char16_t ch) { return (*this) << ch; }
    level_logger &put(char32_t ch) { return (*this) << ch; }
    level_logger &put(wchar_t ch) { return (*this) << ch; }

    level_logger &write (const char* s, std::streamsize n);
private:
    friend class logger;
    level_logger(LEVEL level, logger &log) : _log_level{level}, _logger{log} {}

    LEVEL _log_level;
    logger &_logger;
    inplace_ostream *_out = nullptr;
};

class locked_stream
{
public:
    virtual ~locked_stream() noexcept {}

    virtual inplace_ostream *get_buffer(const std::locale& loc) = 0;
    virtual void return_buffer(inplace_ostream *buf) = 0;
};

class log_registry;

class logger
{
public:
    ~logger() noexcept = default;

    const std::string& name() const { return _name; }

    level_logger critical() { return level_logger{LEVEL::CRITICAL, *this}; }
    level_logger error() { return level_logger{LEVEL::ERROR, *this}; }
    level_logger warning() { return level_logger{LEVEL::WARNING, *this}; }
    level_logger info() { return level_logger{LEVEL::INFO, *this}; }
    level_logger config() { return level_logger{LEVEL::CONFIG, *this}; }
    level_logger debug() { return level_logger{LEVEL::DEBUG, *this}; }
    level_logger trace() { return level_logger{LEVEL::TRACE, *this}; }

    level_logger log(LEVEL level) { return level_logger{level, *this}; }
    bool is_loggable(LEVEL level) const { return level <= _log_level.load(); }

    void set_log_level(LEVEL log_level) { _log_level = log_level; }
    void set_prefix_printer(std::shared_ptr<prefix_printer> new_pp) { std::atomic_store(&_formatter, new_pp); }
    void set_log_output(log_output* new_out, SYNC_POLICY policy = SYNC_POLICY::SYNC);

    void imbue(const std::locale& loc) { _loc = loc; }

private:
    friend class level_logger;
    friend class log_registry;

    logger(std::shared_ptr<prefix_printer> pref, std::shared_ptr<locked_stream> lock_stream,
           LEVEL log_level, std::string name, const std::locale& loc) :
            _formatter{pref}, _lock_stream{lock_stream}, _name{std::move(name)}, _log_level{log_level}, _loc{loc} {}

    void set_locked_stream(std::shared_ptr<locked_stream> lock_stream)
    { std::atomic_store(&_lock_stream, lock_stream); }

    std::shared_ptr<prefix_printer> _formatter;
    std::shared_ptr<locked_stream> _lock_stream;

    std::atomic<LEVEL> _log_level;
    const std::string _name;
    std::locale _loc;
};

class log_registry
{
public:
    static constexpr std::size_t DEFAULT_FILE_ROTATION_SIZE = 1024*1024*16;
    static constexpr std::size_t DEFAULT_ASYNC_QUEUE_SIZE = 1024;

    typedef std::map<std::string, std::string, std::less<>> properties_type;

    log_registry();

    std::shared_ptr<logger> log(const std::string& name = "root");

    void read_configuration(const std::string& config_file_name,
                            const std::string& base_dir, bool update_loggers = true);
    void read_configuration(properties_type props, const std::string& base_dir, bool update_loggers = true);

    LEVEL get_log_level(const std::string& name);
    void set_log_level(LEVEL level) { _log_level = level; }

    void imbue(const std::locale& loc) { _loc = loc; }

    void set_base_directory(const std::string& base_dir);
    void set_base_directory(std::string&& base_dir);

    SYNC_POLICY get_synchronization_policy() const { return _sync_policy; }
    void set_synchronization_policy(SYNC_POLICY sync_policy);

    void set_prefix_printer(prefix_printer *pp)
    { std::atomic_store(&_prefix_printer, std::shared_ptr<prefix_printer>(pp)); }

    void set_log_output(log_output *log_out);

    void reset_loggers_config(bool update_prefix_printer, bool update_log_output, bool update_locale);

protected:
    void add_prefix_printer_factory(const std::string& name, prefix_printer_factory* fac)
    { _prefix_printer_factories.emplace(name, fac); }
    void add_log_output_factory(const std::string& name, log_output_factory* fac)
    { _log_output_factories.emplace(name, fac); }

private:
    logger* create_new_logger(std::string name);
    std::shared_ptr<log_output> get_or_create_output(bool force_create = false);
    std::shared_ptr<prefix_printer> get_or_create_prefix_printer(bool force_create = false);
    std::shared_ptr<locked_stream> get_or_create_locked_stream(bool force_create = false);

    std::map<std::string, std::shared_ptr<logger>, std::less<>> _loggers;

    std::locale _loc;
    std::string _base_dir;
    properties_type _properties;

    std::atomic<LEVEL> _log_level{LEVEL::WARNING};
    std::atomic<SYNC_POLICY> _sync_policy{SYNC_POLICY::SYNC};

    std::shared_ptr<log_output> _log_out;
    std::shared_ptr<locked_stream> _locked_stream;
    std::shared_ptr<prefix_printer> _prefix_printer;
    std::recursive_mutex _config_mx;

    std::map<std::string, std::unique_ptr<prefix_printer_factory>, std::less<>> _prefix_printer_factories;
    std::map<std::string, std::unique_ptr<log_output_factory>, std::less<>> _log_output_factories;
};

extern thread_local std::shared_ptr<log_registry> THREAD_REGISTRY;

log_registry& registry();
void load_config(const char* cfg_file_name, const std::string& base_dir = "");

inline std::shared_ptr<logger> get_logger(const std::string& name) { return registry().log(name); }
inline std::shared_ptr<logger> get_logger() { return registry().log(); }

std::shared_ptr<logger> get_class_logger(log_registry& registry, const char * class_name);

inline std::shared_ptr<logger> get_class_logger(const char * class_name)
{ return get_class_logger(registry(), class_name); }

/* Necessary implementations */

inline level_logger::~level_logger() noexcept { if (_out) _logger._lock_stream->return_buffer(_out); }

template<typename T>
level_logger &level_logger::operator<<(const T &value)
{
    if (!_logger.is_loggable(_log_level)) return *this;
    if (!_out)
    {
        _out = _logger._lock_stream->get_buffer(_logger._loc);
        _logger._formatter->print_prefix(_log_level, _logger._name, *_out);
    }
    else if ((*_out)->view().empty()) _logger._formatter->print_prefix(_log_level, _logger._name, *_out);
    (*_out) << value;
    if ((*_out)->view().back() == '\n')
    {
        _logger._lock_stream->return_buffer(_out);
        _out = nullptr;
    }
    return *this;
}

} // end of servlet::logging namespace

} // end of servlet namespace

#endif // SERVLET_LOGGER_H