13 #include "../async_logger.h" 14 #include "../common.h" 15 #include "../details/null_mutex.h" 16 #include "../logger.h" 23 #include <unordered_map> 34 void register_logger(std::shared_ptr<logger>
logger)
36 std::lock_guard<Mutex> lock(_mutex);
37 auto logger_name = logger->name();
38 throw_if_exists(logger_name);
39 _loggers[logger_name] = logger;
42 std::shared_ptr<logger>
get(
const std::string &logger_name)
44 std::lock_guard<Mutex> lock(_mutex);
45 auto found = _loggers.find(logger_name);
46 return found == _loggers.end() ? nullptr : found->second;
50 std::shared_ptr<logger> create(
const std::string &logger_name,
const It &sinks_begin,
const It &sinks_end)
52 std::lock_guard<Mutex> lock(_mutex);
53 throw_if_exists(logger_name);
54 std::shared_ptr<logger> new_logger;
57 new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy,
58 _worker_warmup_cb, _flush_interval_ms, _worker_teardown_cb);
62 new_logger = std::make_shared<logger>(logger_name, sinks_begin, sinks_end);
67 new_logger->set_formatter(_formatter);
72 new_logger->set_error_handler(_err_handler);
75 new_logger->set_level(_level);
76 new_logger->flush_on(_flush_level);
79 _loggers[logger_name] = new_logger;
84 std::shared_ptr<async_logger> create_async(
const std::string &logger_name,
size_t queue_size,
85 const async_overflow_policy overflow_policy,
const std::function<
void()> &worker_warmup_cb,
86 const std::chrono::milliseconds &flush_interval_ms,
const std::function<
void()> &worker_teardown_cb,
const It &sinks_begin,
89 std::lock_guard<Mutex> lock(_mutex);
90 throw_if_exists(logger_name);
91 auto new_logger = std::make_shared<async_logger>(
92 logger_name, sinks_begin, sinks_end, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb);
96 new_logger->set_formatter(_formatter);
101 new_logger->set_error_handler(_err_handler);
104 new_logger->set_level(_level);
105 new_logger->flush_on(_flush_level);
108 _loggers[logger_name] = new_logger;
112 void apply_all(std::function<
void(std::shared_ptr<logger>)> fun)
114 std::lock_guard<Mutex> lock(_mutex);
115 for (
auto &l : _loggers)
121 void drop(
const std::string &logger_name)
123 std::lock_guard<Mutex> lock(_mutex);
124 _loggers.erase(logger_name);
129 std::lock_guard<Mutex> lock(_mutex);
133 std::shared_ptr<logger> create(
const std::string &logger_name, sinks_init_list sinks)
135 return create(logger_name, sinks.begin(), sinks.end());
138 std::shared_ptr<logger> create(
const std::string &logger_name, sink_ptr sink)
140 return create(logger_name, {sink});
143 std::shared_ptr<async_logger> create_async(
const std::string &logger_name,
size_t queue_size,
144 const async_overflow_policy overflow_policy,
const std::function<
void()> &worker_warmup_cb,
145 const std::chrono::milliseconds &flush_interval_ms,
const std::function<
void()> &worker_teardown_cb, sinks_init_list sinks)
148 logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, sinks.begin(), sinks.end());
151 std::shared_ptr<async_logger> create_async(
const std::string &logger_name,
size_t queue_size,
152 const async_overflow_policy overflow_policy,
const std::function<
void()> &worker_warmup_cb,
153 const std::chrono::milliseconds &flush_interval_ms,
const std::function<
void()> &worker_teardown_cb, sink_ptr sink)
155 return create_async(logger_name, queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb, {sink});
160 std::lock_guard<Mutex> lock(_mutex);
162 for (
auto &l : _loggers)
164 l.second->set_formatter(_formatter);
168 void set_pattern(
const std::string &pattern)
170 std::lock_guard<Mutex> lock(_mutex);
171 _formatter = std::make_shared<pattern_formatter>(pattern);
172 for (
auto &l : _loggers)
174 l.second->set_formatter(_formatter);
178 void set_level(level::level_enum log_level)
180 std::lock_guard<Mutex> lock(_mutex);
181 for (
auto &l : _loggers)
183 l.second->set_level(log_level);
188 void flush_on(level::level_enum log_level)
190 std::lock_guard<Mutex> lock(_mutex);
191 for (
auto &l : _loggers)
193 l.second->flush_on(log_level);
195 _flush_level = log_level;
198 void set_error_handler(log_err_handler handler)
200 for (
auto &l : _loggers)
202 l.second->set_error_handler(handler);
204 _err_handler = handler;
207 void set_async_mode(
size_t q_size,
const async_overflow_policy overflow_policy,
const std::function<
void()> &worker_warmup_cb,
208 const std::chrono::milliseconds &flush_interval_ms,
const std::function<
void()> &worker_teardown_cb)
210 std::lock_guard<Mutex> lock(_mutex);
212 _async_q_size = q_size;
213 _overflow_policy = overflow_policy;
214 _worker_warmup_cb = worker_warmup_cb;
215 _flush_interval_ms = flush_interval_ms;
216 _worker_teardown_cb = worker_teardown_cb;
221 std::lock_guard<Mutex> lock(_mutex);
234 void throw_if_exists(
const std::string &logger_name)
236 if (_loggers.find(logger_name) != _loggers.end())
238 throw spdlog_ex(
"logger with name '" + logger_name +
"' already exists");
243 std::unordered_map<std::string, std::shared_ptr<logger>> _loggers;
244 formatter_ptr _formatter;
245 level::level_enum _level = level::info;
246 level::level_enum _flush_level = level::off;
247 log_err_handler _err_handler;
248 bool _async_mode =
false;
249 size_t _async_q_size = 0;
250 async_overflow_policy _overflow_policy = async_overflow_policy::block_retry;
251 std::function<void()> _worker_warmup_cb;
252 std::chrono::milliseconds _flush_interval_ms{std::chrono::milliseconds::zero()};
253 std::function<void()> _worker_teardown_cb;
256 #ifdef SPDLOG_NO_REGISTRY_MUTEX Definition: lib/spdlog/common.h:146
Definition: async_logger.h:26
Definition: registry.h:28