1// Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
2// Distributed under the MIT License (http://opensource.org/licenses/MIT)
3
4#pragma once
5
6// Loggers registry of unique name->logger pointer
7// An attempt to create a logger with an already existing name will result with spdlog_ex exception.
8// If user requests a non existing logger, nullptr will be returned
9// This class is thread safe
10
11#include <spdlog/common.h>
12#include <spdlog/details/periodic_worker.h>
13
14#include <chrono>
15#include <functional>
16#include <memory>
17#include <mutex>
18#include <string>
19#include <unordered_map>
20
21namespace spdlog {
22class logger;
23
24namespace details {
25class thread_pool;
26
27class SPDLOG_API registry {
28public:
29 using log_levels = std::unordered_map<std::string, level::level_enum>;
30 registry(const registry &) = delete;
31 registry &operator=(const registry &) = delete;
32
33 void register_logger(std::shared_ptr<logger> new_logger);
34 void initialize_logger(std::shared_ptr<logger> new_logger);
35 std::shared_ptr<logger> get(const std::string &logger_name);
36 std::shared_ptr<logger> default_logger();
37
38 // Return raw ptr to the default logger.
39 // To be used directly by the spdlog default api (e.g. spdlog::info)
40 // This make the default API faster, but cannot be used concurrently with set_default_logger().
41 // e.g do not call set_default_logger() from one thread while calling spdlog::info() from
42 // another.
43 logger *get_default_raw();
44
45 // set default logger and add it to the registry if not registered already.
46 // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
47 // Note: Make sure to unregister it when no longer needed or before calling again with a new
48 // logger.
49 void set_default_logger(std::shared_ptr<logger> new_default_logger);
50
51 void set_tp(std::shared_ptr<thread_pool> tp);
52
53 std::shared_ptr<thread_pool> get_tp();
54
55 // Set global formatter. Each sink in each logger will get a clone of this object
56 void set_formatter(std::unique_ptr<formatter> formatter);
57
58 void enable_backtrace(size_t n_messages);
59
60 void disable_backtrace();
61
62 void set_level(level::level_enum log_level);
63
64 void flush_on(level::level_enum log_level);
65
66 template <typename Rep, typename Period>
67 void flush_every(std::chrono::duration<Rep, Period> interval) {
68 std::lock_guard<std::mutex> lock(flusher_mutex_);
69 auto clbk = [this]() { this->flush_all(); };
70 periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
71 }
72
73 std::unique_ptr<periodic_worker> &get_flusher() {
74 std::lock_guard<std::mutex> lock(flusher_mutex_);
75 return periodic_flusher_;
76 }
77
78 void set_error_handler(err_handler handler);
79
80 void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
81
82 void flush_all();
83
84 void drop(const std::string &logger_name);
85
86 void drop_all();
87
88 // clean all resources and threads started by the registry
89 void shutdown();
90
91 std::recursive_mutex &tp_mutex();
92
93 void set_automatic_registration(bool automatic_registration);
94
95 // set levels for all existing/future loggers. global_level can be null if should not set.
96 void set_levels(log_levels levels, level::level_enum *global_level);
97
98 static registry &instance();
99
100 void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
101
102private:
103 registry();
104 ~registry();
105
106 void throw_if_exists_(const std::string &logger_name);
107 void register_logger_(std::shared_ptr<logger> new_logger);
108 bool set_level_from_cfg_(logger *logger);
109 std::mutex logger_map_mutex_, flusher_mutex_;
110 std::recursive_mutex tp_mutex_;
111 std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
112 log_levels log_levels_;
113 std::unique_ptr<formatter> formatter_;
114 spdlog::level::level_enum global_log_level_ = level::info;
115 level::level_enum flush_level_ = level::off;
116 err_handler err_handler_;
117 std::shared_ptr<thread_pool> tp_;
118 std::unique_ptr<periodic_worker> periodic_flusher_;
119 std::shared_ptr<logger> default_logger_;
120 bool automatic_registration_ = true;
121 size_t backtrace_n_messages_ = 0;
122};
123
124} // namespace details
125} // namespace spdlog
126
127#ifdef SPDLOG_HEADER_ONLY
128 #include "registry-inl.h"
129#endif
130