spdlog一个非常好用的C++日志库(五): 源码分析之registry类

已经有了用于接收前端用户log消息的类logger，代表log消息的类是log_msg，后端写log消息到目标文件的类sink，格式化log消息为最终字符串的类formatter，解析pattern flag的类pattern_formatter等等。但似乎还存在一个问题：库的使用者，如何使用它们？

每次使用时，可能需要先创建logger对象，然后通过logger对象来接收用户log消息。然而，当用户希望创建多个logger对象时，谁来组织logger对象？谁来辨识logger name对应logger对象是否已经创建？如何通过logger name获取对应logger对象？能否有一个全局的默认logger，用户不需要做复杂设置？

这就可以用registry类，维护：
1）一个默认的全局logger对象；
2）一个logger对象的全局注册表，logger name就是其唯一标识；
3）一个线程池，用于异步写log；
4）一个周期工作线程，用于执行定时任务；

2.registry类实现

2.1.registry数据成员

registry是一个综合性的类，包含多种功能。其核心功能是提供全局logger对象注册表，主要数据成员，分为这几部分：
1）logger对象注册表loggers_，map存放；
2）缺省的logger对象default_logger_，便捷接口；
3）缺省的formatter格式器formatter_，通常为pattern_formatter，方便编译pattern字符串；
4）一个线程池tp_，用于异步写log；
5）线程安全，3个不同的锁用于保护数据；
6）异常处理，缺省的全局配置，以及错误回调；
7）杂项；

具体来说：

class SPDLOG_API registry
{
private:
    // logger_map_mutex_是loggers_的互斥锁, flusher_mutex_是periodic_flusher_的互斥锁
    std::mutex logger_map_mutex_, flusher_mutex_; 
    std::recursive_mutex tp_mutex_;              // 线程池tp_的递归锁

    std::unordered_map<std::string, std::shared_ptr<logger>> loggers_; // logger对象注册表, 存放(logger name, logger对象共享指针)
    log_levels log_levels_;                      // 用户事先指定的log等级, map存放(logger name, log level)
    std::unique_ptr<formatter> formatter_;       // pattern 格式器, 默认为pattern_formatter实例
    spdlog::level::level_enum global_log_level_ = level::info; // 全局log等级值, 新logger对象缺省log等级
    level::level_enum flush_level_ = level::off; // flush等级值, 新logger对象缺省flush等级
    err_handler err_handler_;                    // 错误处理, 发生错误时回调
    std::shared_ptr<thread_pool> tp_;            // 线程池, 用于异步写log, 但registry并不是线程池创建者
    std::unique_ptr<periodic_worker> periodic_flusher_;        // 定时flush
    std::shared_ptr<logger> default_logger_;     // 默认的logger对象
    bool automatic_registration_ = true;         // 自动注册logger对象选项
    size_t backtrace_n_messages_ = 0;            // 回溯消息个数, 每个logger对象都可以设置一个环形缓冲区
};

2.2.registry函数成员

2.2.1.构造与析构

构造函数创建一个默认的logger对象，将stdout作为输出目标。formatter_也是用默认的pattern_formatter类构造，用于所有注册的logger对象作为编译pattern字符串的对象。

// 构造函数
SPDLOG_INLINE registry::registry()
    : formatter_(new pattern_formatter())
{
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER // 控制是否关闭default logger对象
    // 针对不同的平台, 创建不同的sink, 作为logger输出目标
    // create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt  in windows).
#    ifdef _WIN32 // Windows平台
    auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
#    else         // non-Windows平台
    auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
#    endif

    const char *default_logger_name = ""; // default logger名称
    default_logger_ = std::make_shared<spdlog::logger>(default_logger_name,  std::move(color_sink));
    loggers_[default_logger_name] = default_logger_; // 加入注册表
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
}

// 默认合成的析构函数
SPDLOG_INLINE registry::~registry() = default;

2.2.2.单例模式

registry为何要实现为单例？
因为registry提供全局唯一的注册表、默认的logger对象、缺省全局配置、后端线程池等唯一性资源，需要确保registry对象的唯一性。

registry类实现单例模式，是采用典型的惯用实现方法。我之前在这篇文章设计模式之单例模式中分析过，这种方式创建的单例模式并不是线程安全的。

// 单例模式惯用法实现registry
class SPDLOG_API registry
{
public:
    registry(const registry &) = delete;
    registry &operator=(const registry &) = delete;
    ...
    static registry &instance();
private:
    registry();
    ~registry();
...

SPDLOG_INLINE registry &registry::instance()
{
    static registry s_instance;
    return s_instance;
}

2.2.3.全局注册表

作为一个单例模式，registry确保了自身全局唯一实例。而registry通过维护一个map结构的注册表loggers_，存放logger对象，索引key是logger name。当用户新建了一个logger对象，想要在注册表中搜到，先要通过register_logger将其加入注册表；如果后面想要获取，可以通过get接口得到。

public:
    // 注册一个logger对象到注册表
    void register_logger(std::shared_ptr<logger> new_logger);
    
    std::shared_ptr<logger> get(const std::string &logger_name);
    ...
private:
    std::unordered_map<std::string, std::shared_ptr<logger>> loggers_; // logger对象注册表, 存放(logger name, logger对象)

注册logger对象

注册logger对象的实现register_logger很简单，就是先检测注册表中是否存在对应名称的logger对象，如果存在，就抛出异常；如果不存在，就加入。因此，需要十分注意：不能重复注册同一个logger名称的logger对象。

// 注册logger对象
SPDLOG_INLINE void registry::register_logger(std::shared_ptr<logger> new_logger)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_); // 由于是public接口，先获得锁，再对loggers_进行操作
    register_logger_(std::move(new_logger));
}

// private实现
SPDLOG_INLINE void registry::register_logger_(std::shared_ptr<logger> new_logger)
{
    auto logger_name = new_logger->name();
    throw_if_exists_(logger_name); // 确保logger name唯一
    loggers_[logger_name] = std::move(new_logger);
}

// 如果logger_name对应项存在, 就抛出异常
SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
{
    if (loggers_.find(logger_name) != loggers_.end())
    {
        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
    }
}

查找logger对象

get实现查找logger对象更简单，直接对map的结构loggers_根据key（logger name）进行查找。

// 根据logger_name查找logger对象
SPDLOG_INLINE std::shared_ptr<logger> registry::get(const std::string  &logger_name)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_); // 由于是public接口，先获得锁，再对loggers_进行操作
    auto found = loggers_.find(logger_name);
    return found == loggers_.end() ? nullptr : found->second;
}

2.2.4.initialize_logger初始化logger对象

当用户新建一个logger对象后，该如何设置其属性成员呢？
registry通过initialize_logger接口，为其提供默认初始化方式，无需为每个属性再单独设置。使用initialize_logger初始化的logger对象，会自动添加进全局注册表；如果是手动初始化的logger对象，则需要手动添加进全局注册表。

// 初始化一个logger对象new_logger
SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    new_logger->set_formatter(formatter_->clone());

    if (err_handler_) // 注意：err_handler_受互斥锁logger_map_mutex_保护
    {
        new_logger->set_error_handler(err_handler_);
    }

    // 判断用户是否有事先指定new_logger的log level, 如果有就按事先指定的设置; 如果没有, 就用默认的
    // set new level according to previously configured level or default level
    auto it = log_levels_.find(new_logger->name());
    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
    new_logger->set_level(new_level);

    // 设置flush level
    new_logger->flush_on(flush_level_);

    // 设置环形缓冲区, 用于回溯最近的log消息
    if (backtrace_n_messages_ > 0)
    {
        new_logger->enable_backtrace(backtrace_n_messages_);
    }

    // 自动注册进全局注册表
    if (automatic_registration_)
    {
        register_logger_(std::move(new_logger));
    }
}

2.2.5.全局格式器

每个logger对象都拥有自己的格式器（formatter）成员，也就是说，能指定各自的pattern，从而决定输出的log消息格式。但如果想通过一个接口，为所有logger设置格式器，该怎么办？
此时，可以用到registry的全局格式器，接口set_formatter能为所有已注册的logger对象更新格式器。

// 为所有已注册的logger对象设置格式器
// Set global formatter. Each sink in each logger will get a clone of this object
SPDLOG_INLINE void registry::set_formatter(std::unique_ptr<formatter> formatter)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    formatter_ = std::move(formatter);
    // 为所有注册表loggers_中的logger对象更新formatter
    for (auto &l : loggers_)
    {
        l.second->set_formatter(formatter_->clone()); // 注意这类调用了formatter::clone深度克隆对象
    }
}

2.2.6.预置日志等级

预置日志等级

spdlog支持事先为logger对象预置日志等级，待到新建的logger对象用initialize_logger()初始化时，为其指定log level。也就是说，此时尚未创建logger对象。

预置的日志等级log_levels_是log_levels类型，本质上一个unordered_map，key是logger name， value是log level枚举值。也就是说，spdlog只支持内置的日志等级（已经定义的那几个）。

using log_levels = std::unordered_map<std::string, level::level_enum>;

预置日志等级工作原理：通过环境变量或main启动参数，为logger对象指定log level，通过registry::set_level将其存放进map log_levels_中。当调用initialize_logger对logger对象进行初始化时，会从log_levels_中查找是否已经预置log level，如果已经预置，就直接用预置的日志等级初始化当前新建的logger对象；如果没有预置，就用缺省的global_log_level_来设置。

SPDLOG_INLINE void registry::initialize_logger(std::shared_ptr<logger> new_logger)
{
    ...
    // 根据预置的log level或缺省的level, 来设置新logger对象的level
    // set new level according to previously configured level or default level
    auto it = log_levels_.find(new_logger->name());
    auto new_level = it != log_levels_.end() ? it->second : global_log_level_;
    new_logger->set_level(new_level);
    ...
}

更新日志等级

程序启动后，或者logger对象加入注册表后，有没有办法根据修改的预置日志等级更新？
答案是有的，可以通过registry::set_levels为所有已注册logger对象更新预置日志等级。

initialize_logger中设置预置日志等级，只会更新单个logger对象的日志等级，而set_levels中设置，则会更新所有已注册logger对象的日志等级。

// 更新日志等级
// 当想为已注册logger对象更新时，指定levels即可；当想更新全局日志等级时，需要指定global_level
SPDLOG_INLINE void registry::set_levels(log_levels levels, level::level_enum  *global_level)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    log_levels_ = std::move(levels);

    auto global_level_requested = global_level != nullptr;
    global_log_level_ = global_level_requested ? *global_level :  global_log_level_;

    // 为所有已注册logger对象更新日志等级, 优先用预置的, 没有找到预置时, 再用全局的
    for (auto &logger : loggers_)
    {
        auto logger_entry = log_levels_.find(logger.first);
        if (logger_entry != log_levels_.end())
        {
            logger.second->set_level(logger_entry->second);
        }
        else if (global_level_requested)
        {
            logger.second->set_level(*global_level);
        }
    }
}

2.2.7.flush日志等级

spdlog支持单独flush（冲刷）指定level的日志消息（与记录日志的level分开）到目标文件，registry提供flush_on接口，设置（注册的）logger对象全局的flush_level_。

// 为每个已注册logger对象设置flush等级
// 当各个logger对象调用自身flush函数时, 会根据该flush等级与log消息的等级判断是否应该将文件立即冲刷到目标文件
SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    for (auto &l : loggers_)
    {
        l.second->flush_on(log_level);
    }
    flush_level_ = log_level;
}

flush_level_并不是单独工作，而是搭配定时器periodic_flusher_，定时调用flush_every，从而实现定时冲刷指定level的log消息。

// 指定一个周期性工作的线程, 定时flush所有logger
    template<typename Rep, typename Period>
    void flush_every(std::chrono::duration<Rep, Period> interval)
    {
        std::lock_guard<std::mutex> lock(flusher_mutex_);
        auto clbk = [this]() { this->flush_all(); };
        periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
    }

// flush所有已注册logger对象的log消息到目标文件
// 要求logger对象必须是线程安全的
SPDLOG_INLINE void registry::flush_all()
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    for (auto &l : loggers_)
    {
        l.second->flush();
    }
}

2.2.8.默认logger

为了方便用户spdlog，registry提供了默认logger对象default_logger_，无需用户再手动创建、设置。default_logger_的默认目标（sink）是控制台（stdout），可以很方便用户调试。

获取默认的logger

获取默认的logger对象，有两种方式：
1）default_logger()获取共享指针管理的logger对象，线程安全；
2）通过shared_ptr<>::get()获取raw pointer，速度default_logger()比更快，但无法与set_default_logger()并发调用。

// 获取shared_ptr管理的默认logger, 线程安全
SPDLOG_INLINE std::shared_ptr<logger> registry::default_logger()
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    return default_logger_;
}

// 获取指向默认logger的raw pointer, 非线程安全, 但速度更快
// Return raw ptr to the default logger.
// To be used directly by the spdlog default api (e.g. spdlog::info)
// This make the default API faster, but cannot be used concurrently with  set_default_logger().
// e.g do not call set_default_logger() from one thread while calling  spdlog::info() from another.
SPDLOG_INLINE logger *registry::get_default_raw()
{
    return default_logger_.get();
}

更新默认的logger

如果用户不想使用默认的logger对象，或者说，在不改变接口情况下，想将其替换成用户自定logger对象，那么可以调用registry::set_default_logger。
set_default_logger的实现很简单，思路是：先从全局注册表loggers_移除现有的默认logger对象，然后将新对象new_default_logger添加进注册表，最后将default_logger_指向新对象new_default_logger。

// set default logger.
// default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
SPDLOG_INLINE void registry::set_default_logger(std::shared_ptr<logger> new_default_logger)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    // 先从注册表删除
    // remove previous default logger from the map
    if (default_logger_ != nullptr)
    {
        loggers_.erase(default_logger_->name());
    }
    // 再将新的new_default_logger加入注册表
    if (new_default_logger != nullptr)
    {
        loggers_[new_default_logger->name()] = new_default_logger;
    }
    // 更新默认的logger
    default_logger_ = std::move(new_default_logger);
}

2.2.9.在已注册logger上应用函数

有时，用户希望将已注册的logger对象作为参数，调用一个自定义函数。此时，可以用到apply_all接口。
实现思路是：将自定义函数作为函数参数，传入apply_all，对每个已注册的logger对象都调用fun()。

// 将已注册logger作为参数, 应用到函数fun
SPDLOG_INLINE void registry::apply_all(const std::function<void(const  std::shared_ptr<logger>)> &fun)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    for (auto &l : loggers_)
    {
        fun(l.second);
    }
}

2.2.10.回溯最近的log消息

logger对象包含backtracer（环形队列）成员用于回溯最近的log消息，registry提供enable_backtrace接口，方便用户设置、开启该功能。

开启回溯功能

开启回溯功能，实际上是将用户指定的消息条数转发给已注册logger，以开启并设置队列大小。

// 开启回溯功能
// 指定logger对象的环形缓冲区大小，设置了大小才能回溯最近的log消息
SPDLOG_INLINE void registry::enable_backtrace(size_t n_messages)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_); // 加锁确保线程安全
    backtrace_n_messages_ = n_messages;

    for (auto &l : loggers_)
    {
        l.second->enable_backtrace(n_messages);
    }
}

关闭回溯功能

关闭回溯功能，类似于开启，都是转发给已注册的logger，进行相应的设置。

// 关闭回溯功能
SPDLOG_INLINE void registry::disable_backtrace()
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    backtrace_n_messages_ = 0;
    for (auto &l : loggers_)
    {
        l.second->disable_backtrace();
    }
}

2.3.线程安全

registry用了2把互斥锁（std::mutex） + 1把递归锁（std::recursive_mutex）。总原则: logger_map_mutex_保护几乎所有数据成员，flusher_mutex_和tp_mutex_分别只保护periodic_flusher_、tp_。

tp_mutex_为何用递归锁，而不用普通互斥锁？
因为tp_mutex_保护的是线程池tp_，registry为其提供了public接口tp_mutex()导致该锁可能会被多个线程访问，get_tp()接口导致可能多次加锁。由于线程池对象tp_创建后不再修改（除了释放），因此多线程环境下并发访问通常也是安全的，因此使用递归锁没有问题。

2.4.错误处理

logger对象本身包含错误回调err_handler_，registry的err_handler_存在意义就是为logger的错误回调提供缓存及用户接口。

设置错误回调

可通过registry的set_error_handler接口，为每个logger对象更新错误回调。

SPDLOG_INLINE void registry::set_error_handler(err_handler handler)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    for (auto &l : loggers_)
    {
        l.second->set_error_handler(handler);
    }
    err_handler_ = std::move(handler);
}

什么时候调用错误回调？

对logger的错误回调，实际上包装到了用于异常处理的宏SPDLOG_LOGGER_CATCH中，当catch到异常时，就会回调err_handler_。如果用户通过registry::set_error_handler提供了自定义错误处理函数，那么就调用用户的；如果没有提供，就调用默认的logger::err_handler_，在控制台打印错误信息。

#ifndef SPDLOG_NO_EXCEPTIONS
#    define SPDLOG_LOGGER_CATCH(location)                                                                                        \
        catch (const std::exception &ex)                                                                                         \
        {                                                                                                                        \
            if (location.filename)                                                                                               \
            {                                                                                                                    \
                err_handler_(fmt_lib::format(SPDLOG_FMT_STRING("{} [{}({})]"),  ex.what(), location.filename, location.line));   \
            }                                                                                                                    \
            else                                                                                                                 \
            {                                                                                                                    \
                err_handler_(ex.what());                                                                                         \
            }                                                                                                                    \
        }                                                                                                                        \
        catch (...)                                                                                                              \
        {                                                                                                                        \
            err_handler_("Rethrowing unknown exception in logger");                                                              \
            throw;                                                                                                               \
        }
#else
#    define SPDLOG_LOGGER_CATCH(location)
#endif

例如，loger在将log消息转交给sink，将内容写到文件的时候，可能发生写失败的错误，抛出异常；在registry查找指定logger name不存在的时候，抛出异常。

// 在注册表查找logger name
SPDLOG_INLINE void registry::throw_if_exists_(const std::string &logger_name)
{
    if (loggers_.find(logger_name) != loggers_.end())
    { // 不存在则抛出异常
        throw_spdlog_ex("logger with name '" + logger_name + "' already exists");
    }
}

common模块为抛出异常提供便捷接口，有2个重载版本，分别针对系统调用错误、非系统调用错误。

#    define SPDLOG_TRY try
#    define SPDLOG_THROW(ex) throw(ex)
#    define SPDLOG_CATCH_STD catch (const std::exception &) {}

[[noreturn]] SPDLOG_API void throw_spdlog_ex(const std::string &msg, int  last_errno);
[[noreturn]] SPDLOG_API void throw_spdlog_ex(std::string msg);


// 系统调用错误 抛出异常
SPDLOG_INLINE void throw_spdlog_ex(const std::string &msg, int last_errno)
{
    SPDLOG_THROW(spdlog_ex(msg, last_errno));
}

// 非系统调用错误 抛出异常
SPDLOG_INLINE void throw_spdlog_ex(std::string msg)
{
    SPDLOG_THROW(spdlog_ex(std::move(msg)));
}

2.5.定时工作类periodic_worker

registry::flush_every中，创建了一个定时工作类periodic_worker对象。该类构造时，会启动一个线程，在其中利用锁+条件变量定时执行用户回调，从而实现用户自定义任务的定时执行。

// 定时工作者类periodic_worker, 为用户自定义任务fun提供定时回调功能
class SPDLOG_API periodic_worker
{
public:
    // 构造函数
    template<typename Rep, typename Period>
    periodic_worker(const std::function<void()> &callback_fun,  std::chrono::duration<Rep, Period> interval);

    // 禁用copy操作
    periodic_worker(const periodic_worker &) = delete;
    periodic_worker &operator=(const periodic_worker &) = delete;

    // stop the worker thread and join it
    ~periodic_worker();

private:
    bool active_;
    std::thread worker_thread_;
    std::mutex mutex_;
    std::condition_variable cv_;
};

构造函数

注意到periodic_worker构造函数是一个函数模板，这是为什么？
因为用户传入的时间间隔参数（interval）的类型并不确定，可能是秒（chrono::seconds），也可能是毫秒（chrono::milliseconds），或者分钟（chrono::minutes）等等，为了兼容这些类型，因而使用模板来支持。

    template<typename Rep, typename Period>
    periodic_worker(const std::function<void()> &callback_fun,  std::chrono::duration<Rep, Period> interval) 
    {
        active_ = (interval > std::chrono::duration<Rep, Period>::zero());
        if (!active_)
        {
            return;
        }

        // for循环+互斥锁+条件变量 实现子线程主循环, 以定时执行callback_fun
        worker_thread_ = std::thread([this, callback_fun, interval]() {
            for (;;)
            {
                std::unique_lock<std::mutex> lock(this->mutex_);
                // wait_for等到超时, 返回cv_status::timeout(true)
                // 如果wait_for第三个参数如果返回true, 则不再等待; 如果返回false, 则继续等待
                // active_ 控制线程(循环)是否退出
                if (this->cv_.wait_for(lock, interval, [this] { return !this->active_; }))
                {
                    return; // active_ == false, so exit this thread
                }
                callback_fun();
            }
        });
    }

析构函数

析构函数就是让子线程退出死循环，结束线程运行；母线程连接子线程以回收资源。

// stop the worker thread and join it
SPDLOG_INLINE periodic_worker::~periodic_worker()
{
    if (worker_thread_.joinable()) // 只有线程可连接情况下, 连接线程才有意义
    {
        {
            std::lock_guard<std::mutex> lock(mutex_);
            // 为什么active_使用bool类型, 而不用atomic<bool>类型？
            // 因为进入子线程后, 只有periodic_worker对象析构时才会写active, 其他情况只读, 不会造成线程安全问题
            active_ = false; 
        }
        cv_.notify_one();
        worker_thread_.join();
    }
}

3.registry类应用

虽然registry是单例模式，但spdlog并没有打算让用户直接像下面这种方式，调用registry对库进行，而是提供了便捷的全局接口。实现方式，是在registry对应接口基础上，进行了包装，简化了调用。

3.1.initialize_logger初始化logger对象

比如，初始化一个logger对象，如果直接使用registry，就得这样：

details::registry::instance().initialize_logger(std::move(logger));

spdlog提供了便捷接口：

// 初始化、注册一个logger对象

// Example:
//   auto mylogger = std::make_shared<spdlog::logger>("mylogger", ...);
//   spdlog::initialize_logger(mylogger);
SPDLOG_INLINE void initialize_logger(std::shared_ptr<logger> logger)
{
    details::registry::instance().initialize_logger(std::move(logger));
}

3.2.get查找logger对象

// 根据logger name查找已注册logger对象
SPDLOG_INLINE std::shared_ptr<logger> get(const std::string &name)
{
    return details::registry::instance().get(name);
}

3.3.set_formatter设置格式器

由于logger对象构建时，就必须有格式器，因此set_formatter只是更新其格式器。

// 为所有已注册logger对象设置新的格式器formatter
SPDLOG_INLINE void set_formatter(std::unique_ptr<spdlog::formatter> formatter)
{
    details::registry::instance().set_formatter(std::move(formatter));
}

3.4.set_pattern设置格式串

logger对象需要pattern，利用formatter根据pattern将log消息转换最终期望的log消息格式。便捷全局接口set_pattern，实际上利用set_formatter向logger传递一个pattern_formatter对象。其原理类似于logger::set_pattern实现。不同点在于：logger::set_pattern是针对单个logger对象，而set_pattern是针对所有已注册logger对象。

// 设置全局格式串
SPDLOG_INLINE void set_pattern(std::string pattern, pattern_time_type time_type)
{
    set_formatter(std::unique_ptr<spdlog::formatter>(new  pattern_formatter(std::move(pattern), time_type)));
}

3.5.全局backtrace操作

我们知道registry提供了开启、关闭backtrace（回溯）log消息功能。全局backtrace接口，也只是利用registry单例进行转发。还有一个比较特殊的，那就是如何将回溯栈的log消息转档（dump）？

SPDLOG_INLINE void enable_backtrace(size_t n_messages)
{
    details::registry::instance().enable_backtrace(n_messages);
}

SPDLOG_INLINE void disable_backtrace()
{
    details::registry::instance().disable_backtrace();
}

转档回溯栈，实际上是通过logger::dump_backtrace对环形队列的每个元素（log消息），调用自定义函数，将其写到指定目标。

// 转档回溯栈
// default_logger_raw()实际上是registry::default_logger_所指logger对象, 全局唯一
SPDLOG_INLINE void dump_backtrace()
{
    default_logger_raw()->dump_backtrace();
}

// 转发给私有实现
SPDLOG_INLINE void logger::dump_backtrace()
{
    dump_backtrace_();
}

// 转档回溯栈tracer_中的log消息
SPDLOG_INLINE void logger::dump_backtrace_()
{
    using details::log_msg;
    if (tracer_.enabled())
    {
        sink_it_(log_msg{name(), level::info, "****************** Backtrace Start  ******************"});
        // 弹出回溯栈所有元素并回调lambda, 将log消息写入每个sink对应的目标文件
        tracer_.foreach_pop([this](const log_msg &msg) { this->sink_it_(msg); });
        sink_it_(log_msg{name(), level::info, "****************** Backtrace End  ********************"});
    }
}

可以看到dump_backtrace_中的关键，是logger::sink_it_以及details::backtracer::foreach_pop。
sink_it_是logger一个私有virtual函数，logger提供了公共实现，将log消息写到所有sink目标上，属于同步操作；子类可以继承，也可以重写，例如子类async_logger也实现了一个版本，不过是将log消息添加到环形队列，然后交给线程池处理。

// logger类对sink_it_的实现, 提供公共实现方式
SPDLOG_INLINE void logger::sink_it_(const details::log_msg &msg)
{
    // 将log消息msg写到每个目标sink上
    for (auto &sink : sinks_)
    {
        if (sink->should_log(msg.level))
        {
            SPDLOG_TRY
            {
                sink->log(msg);
            }
            SPDLOG_LOGGER_CATCH(msg.source)
        }
    }
    
    // 如果msg的flush level满足条件, 就冲刷所有sink
    if (should_flush_(msg))
    {
        flush_();
    }
}

// 子类async_logger的sink_it, 为异步写log消息提供实现
// send the log message to the thread pool
SPDLOG_INLINE void spdlog::async_logger::sink_it_(const details::log_msg &msg)
{
    if (auto pool_ptr = thread_pool_.lock())
    {
        // post log消息到环形队列, 交给线程池处理
        pool_ptr->post_log(shared_from_this(), msg, overflow_policy_);
    }
    else // 线程池thread_pool_ 已经释放
    {
        throw_spdlog_ex("async log: thread pool doesn't exist anymore");
    }
}

foreach_pop是通过不断从环形队列头弹出元素（log消息），然后作为fun的参数进行回调的。该操作会清空回溯栈内容。

// pop all items in the q and apply the given fun on each of them.
SPDLOG_INLINE void backtracer::foreach_pop(std::function<void(const  details::log_msg &)> fun)
{
    std::lock_guard<std::mutex> lock{mutex_};
    // 从环形队列头循环取出元素并回调fun
    while (!messages_.empty())
    {
        auto &front_msg = messages_.front();
        fun(front_msg);
        messages_.pop_front();
    }
}

3.6.全局level操作

个人认为spdlog关于日志等级的操作，并不是对称的，不知出于何种原因，get_level()取的是default logger的level，而set_level()却设置的是global_level，并且影响所有已注册的logger。

// get_level返回的是default logger的log level
// Get global logging level
SPDLOG_INLINE level::level_enum get_level()
{
    return default_logger_raw()->level();
}

SPDLOG_INLINE spdlog::logger *default_logger_raw()
{
    return details::registry::instance().get_default_raw();
}

// get_default_raw 返回default_logger_的raw pointer
SPDLOG_INLINE logger *registry::get_default_raw()
{
    return default_logger_.get();
}

set_level()实现：

SPDLOG_INLINE void set_level(level::level_enum log_level)
{
    details::registry::instance().set_level(log_level);
}

// registry::set_level 设置全局log level, 影响所有已注册logger
SPDLOG_INLINE void registry::set_level(level::level_enum log_level)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    for (auto &l : loggers_)
    {
        l.second->set_level(log_level);
    }
    global_log_level_ = log_level;
}

flush_on()类似于set_level，设置的是flush_level_，并且影响所有已注册logger的flush level。

SPDLOG_INLINE void flush_on(level::level_enum log_level)
{
    details::registry::instance().flush_on(log_level);
}

// registry::flush_on 设置全局flush level, 影响所有已注册logger
SPDLOG_INLINE void registry::flush_on(level::level_enum log_level)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    for (auto &l : loggers_)
    {
        l.second->flush_on(log_level);
    }
    flush_level_ = log_level;
}

// Get global logging level
SPDLOG_API level::level_enum get_level();
// Set global logging level
SPDLOG_API void set_level(level::level_enum log_level);
// Determine whether the default logger should log messages with a certain level
SPDLOG_API bool should_log(level::level_enum lvl);
// Set global flush level
SPDLOG_API void flush_on(level::level_enum log_level);

3.7.flush_every定时冲刷

利用registry::flush_every 启动一个全局定时器，定时冲刷log消息到目标。

// 全局接口, 定时flush所有已注册logger, 时间间隔interval由调用者决定
template<typename Rep, typename Period>
inline void flush_every(std::chrono::duration<Rep, Period> interval)
{
    details::registry::instance().flush_every(interval);
}

template<typename Rep, typename Period>
void registry::flush_every(std::chrono::duration<Rep, Period> interval)
{
    std::lock_guard<std::mutex> lock(flusher_mutex_);
    auto clbk = [this]() { this->flush_all(); }; // 子线程循环定时回调的匿名函数
    periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
}

3.8.drop清除logger

清除指定logger name的logger对象

要清除的logger对象，分两种情况：1）属于已注册的logger对象；2）默认的logger对象（default logger）。
如果是第1）种情况，就从map中删除；如果是第2）种情况，就释放所指对象。

// 根据logger name 清除logger对象
SPDLOG_INLINE void registry::drop(const std::string &logger_name)
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    loggers_.erase(logger_name); // 从map中擦除logger
    if (default_logger_ && default_logger_->name() == logger_name)
    {
        default_logger_.reset();
    }
}

清除所有logger对象

清除所有logger对象：已经注册的logger对象 + 默认的logger对象。

// 清除所有logger对象
SPDLOG_INLINE void registry::drop_all()
{
    std::lock_guard<std::mutex> lock(logger_map_mutex_);
    loggers_.clear();
    default_logger_.reset();
}

3.9.关闭log功能

如果用户想手动关闭spdlog的日志记录功能（log功能），释放相关资源，该怎么办？
可以调用shutdown()。registry关闭log功能，有三类资源：
1）periodic_flusher_开启了一个子线程，因此需要手动释放；
2）已注册logger对象+默认的logger对象，需要调用drop_all()释放；
3）用于异步写log的线程池资源，需要手动释放；

// 清除所有资源以及关闭registry启动的线程
SPDLOG_INLINE void shutdown()
{
    details::registry::instance().shutdown();
}

// clean all resources and threads started by the registry
SPDLOG_INLINE void registry::shutdown()
{
    {
        std::lock_guard<std::mutex> lock(flusher_mutex_);
        periodic_flusher_.reset();
    }

    drop_all();

    {
        std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
        tp_.reset();
    }
}

3.10.设置自动注册

如果用户想控制新建的logger对象，调用initialize_logger()后，是否自动添加进全局注册表，可以通过set_automatic_registration()来设置。

// Automatic registration of loggers when using spdlog::create() or  spdlog::create_async
SPDLOG_INLINE void set_automatic_registration(bool automatic_registration)
{
     details::registry::instance().set_automatic_registration(automatic_registration);
}

3.11.默认logger

获取共享指针管理的logger

用户可以直接通过全局default_logger()接口，获取单例registry的default_logger对象。其实现也是转发给registry::default_logger()

// get shared_ptr of default logger
SPDLOG_INLINE std::shared_ptr<spdlog::logger> default_logger()
{
    return details::registry::instance().default_logger();
}

获取logger对象原生指针

转发给registry::get_default_raw()。

// get raw pointer of default logger
SPDLOG_INLINE spdlog::logger *default_logger_raw()
{
    return details::registry::instance().get_default_raw();
}

设置默认logger

转发给registry::set_default_logger()。

SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger>  default_logger)
{
    details::registry::instance().set_default_logger(std::move(default_logger));
}

3.12.写log

既然能通过default_logger(), default_logger_raw()获取default logger，那么用户如何方便地写日志内容呢？
可以通过spdlog.h中定义的一组便捷接口，使用默认的logger写log。

log()写日志版本

spdlog实现了2个重载函数模板log：第一个支持调用者指定源文件；第二个源文件为空。

// 写log便捷接口, 重载函数模板

// 支持源文件的log版本
// 要写的正文内容是格式串形式
template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, format_string_t<Args...>  fmt, Args &&... args)
{
    default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...);
}

// 源文件为空的log版本
// 要写的正文内容是格式串形式
template<typename... Args>
inline void log(level::level_enum lvl, format_string_t<Args...> fmt, Args &&...  args)
{
    default_logger_raw()->log(source_loc{}, lvl, fmt,  std::forward<Args>(args)...);
}

// 源文件由调用者指定
// 要写正文msg的类型T是模板参数, 如果T不能转换为format string(包括string_view/wstring_view), 就直接将msg当做string
template<typename T>
inline void log(source_loc source, level::level_enum lvl, const T &msg)
{
    default_logger_raw()->log(source, lvl, msg);
}

// 源文件为空
// 要写正文msg的类型T是模板参数, 通常要求T可转换为format string(string_view/wstring_view)
template<typename T>
inline void log(level::level_enum lvl, const T &msg)
{
    default_logger_raw()->log(lvl, msg);
}

使用固定log level写日志

如果用户想要写log的level固定，还有使用更简便的一组接口，实现也是转发给logger类对应的接口。

// 一组全局的固定log level的写log接口

template<typename... Args>
inline void trace(format_string_t<Args...> fmt, Args &&... args)
{
    default_logger_raw()->trace(fmt, std::forward<Args>(args)...);
}

template<typename... Args>
inline void debug(format_string_t<Args...> fmt, Args &&... args)
{
    default_logger_raw()->debug(fmt, std::forward<Args>(args)...);
}

template<typename... Args>
inline void info(format_string_t<Args...> fmt, Args &&... args)
{
    default_logger_raw()->info(fmt, std::forward<Args>(args)...);
}

template<typename... Args>
inline void warn(format_string_t<Args...> fmt, Args &&... args)
{
    default_logger_raw()->warn(fmt, std::forward<Args>(args)...);
}

template<typename... Args>
inline void error(format_string_t<Args...> fmt, Args &&... args)
{
    default_logger_raw()->error(fmt, std::forward<Args>(args)...);
}

template<typename... Args>
inline void critical(format_string_t<Args...> fmt, Args &&... args)
{
    default_logger_raw()->critical(fmt, std::forward<Args>(args)...);
}

// 要写的正文内容msg类型T, 通常要求T可转换为format string(string_view/wstring_view)

template<typename T>
inline void trace(const T &msg)
{
    default_logger_raw()->trace(msg);
}

template<typename T>
inline void debug(const T &msg)
{
    default_logger_raw()->debug(msg);
}

template<typename T>
inline void info(const T &msg)
{
    default_logger_raw()->info(msg);
}

template<typename T>
inline void warn(const T &msg)
{
    default_logger_raw()->warn(msg);
}

template<typename T>
inline void error(const T &msg)
{
    default_logger_raw()->error(msg);
}

template<typename T>
inline void critical(const T &msg)
{
    default_logger_raw()->critical(msg);
}

4.知识点

4.1.std::enable_if, is_convertible_to_any_format_string

C++之std::enable_if_std enable if-CSDN博客

两个重要元函数std::enable_if, is_convertible_to_any_format_string

logger有一个非常重要的实现logger::log()，用到了2个元函数：std::enable_if和自定义is_convertible_to_any_format_string。

// T cannot be statically converted to format string (including  string_view/wstring_view)
template<class T, typename  std::enable_if<!is_convertible_to_any_format_string<const T &>::value, int>::type  = 0>
void logger::log(source_loc loc, level::level_enum lvl, const T &msg)
{
    log(loc, lvl, "{}", msg);
}

std::enable_if作用是满足条件（第一个模板参数）时类型（第二个参数）有效。可能实现如下，当模板参数B为true时，可以通过::type得到T的类型；否则，就没有定义::type，无法通过::type得到T的类型。如果B为false，程序通过::type获取T的类型时，就会编译报错。

// 通用版本
template<bool B, class T = void>
struct enable_if {};

// 偏特化版本
template<class T>
struct enable_if<true, T> { using type = T; };

// enable_if_t定义
template< bool B, class T = void >
using enable_if_t = typename enable_if<B,T>::type;

is_convertible_to_any_format_string 是通过std::is_convertible判断T是否能转化成string_view_t或者wstring_view_t，::value取回结果（true/false），实现如下：

// 如果T类型能转化成format string, 那么::value/::value_type()/::operator()就会得到true; 
// 否则, 得到false
// format string是指: 
// 1) fmt::basic_string_view<char>, 即std::string_view_t的实现
// 2) fmt::basic_string_view<wchar_t>, 即std::wstring_view_t的实现
template<class T>
struct is_convertible_to_any_format_string : std::integral_constant<bool,  
    is_convertible_to_basic_format_string<T, char>::value ||
    is_convertible_to_basic_format_string<T, wchar_t>::value>
{};

// std::integral_constant
// ::value_type 返回_Ty类型, ::type 返回
template <class _Ty, _Ty _Val>
struct integral_constant {
    // 值元函数拥有内嵌变量::value
    static constexpr _Ty value = _Val;
    // 内嵌类型
    using value_type = _Ty;
    using type       = integral_constant;
    // 内嵌函数
    constexpr operator value_type() const noexcept {
        return value;
    }
    // _NODISCARD是 [[nodiscard]] 别名, 调用函数处没有获取返回值, 编译器会警告
    _NODISCARD constexpr value_type operator()() const noexcept {
        return value;
    }
};

template <bool _Val>
using bool_constant = integral_constant<bool, _Val>;

using true_type  = bool_constant<true>;
using false_type = bool_constant<false>;

// is_convertible_to_basic_format_string 判断类型T是否能转化成类型Char
// 当T可以转换成fmt::basic_string_view<Char>(即std::string_view_t) 或者 将T去掉cv属性(const/volatile)后与fmt::basic_runtime<Char>同类型时, 则能通过::value得到true; 否则, 得到false
// fmt::basic_runtime<Char>的本质是fmt::basic_string_view<Char>
template<class T, class Char = char>
struct is_convertible_to_basic_format_string
    : std::integral_constant<bool,
          std::is_convertible<T, fmt::basic_string_view<Char>>::value ||  std::is_same<remove_cvref_t<T>, fmt::basic_runtime<Char>>::value>
{};

// std::is_convertible 判断_From类型是否能转化成_To类型
// 如果能, 那么调用者通过::value返回true; 否则, 返回false
template <class _From, class _To>
struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
    // determine whether _From is convertible to _To
};

原文地址：https://blog.csdn.net/haokan123456789/article/details/140231261

免责声明：本站文章内容转载自网络资源，如本站内容侵犯了原著者的合法权益，可联系本站删除。更多内容请关注自学内容网（zxcms.com）！

上一篇：C#——密封类详情
下一篇：Linux操作系统的引导过程

react 中 useCallback Hook 作用
在 React 函数组件中，每次组件重新渲染时，内部的函数都会被重新创建。
阅读更多2024-11-16
如何在项目中用elementui实现分页器功能
5.在需要用到分页器的组件像服务器发请求（实现按钮和页面跳转的绑定）这是 Element UI 库中的一个组件，用于创建分页器。3.在分页器组件接收参数。
阅读更多2024-11-16
命名空间（namespace）详解（一）
经查可知，头文件stdlib.h中包含了名为atof的函数，此时我们再定义atof的变量就会报错，那么如何解决这个问题呢？就有了命名空间的用法。
阅读更多2024-11-16
ssm102“魅力”繁峙宣传网站的设计与实现+vue(论文+源码)_kaic
目录摘要ABSTRACT第1章绪论1.1背景及意义1.2 国内外研究概况1.3 研究的内容第2章相关技术2.1 JSP技术介绍2.2 JAVA简介2.3 MyEclipse开发环境2.4 T
阅读更多2024-11-16
深度学习--卷积神经网络
一般认为，人对外界的认知是从局部到全局的，而图像的空间联系也是局部的像素联系较为紧密，而距离较远的像素相关性则较弱。用一个或者多个卷积核扫描照片，卷积核自带的参数就是权重，在同一个卷积核扫描的图层当中
阅读更多2024-11-16
go反射深入学习
reflect.ValueOf(&x) 将 x 的地址传递给 reflect.Value，这使得我们能够通过反射修改 x 的值。传递给 reflect.ValueOf() 的是 x 的值，而不
阅读更多2024-11-16
Git如何简单使用
GitGitlabGitLab和GitHub有什么区别？Gitlab简单使用Gitlab常用指令
阅读更多2024-11-16
动态规划-背包问题——[模版]完全背包问题
与01背包相同，这里的完全背包也是需要一个二维dp表来表示最大价值，具体如下。返回最后一个位置dp表的值。从上至下，每一行从左到右。
阅读更多2024-11-16
hhdb数据库介绍(9-14)
介绍hhdb的sql语法支持
阅读更多2024-11-16
初识算法 · 位运算(end)
面试题 17.19. 消失的两个数字 - 力扣（LeetCode）还是和前文一样，通过三个部分介绍，题目解析，算法原理，算法编写来介绍。那么话不多说，进入主题吧！题目解析题目的要求十分简单，是让我们在
阅读更多2024-11-16