// // Copyright(c) 2015 Gabi Melman. // Distributed under the MIT License (http://opensource.org/licenses/MIT) // #pragma once // Loggers registy of unique name->logger pointer // An attempt to create a logger with an already existing name will be ignored // If user requests a non existing logger, nullptr will be returned // This class is thread safe #include <spdlog/details/null_mutex.h> #include <spdlog/logger.h> #include <spdlog/async_logger.h> #include <spdlog/common.h> #include <chrono> #include <functional> #include <memory> #include <mutex> #include <string> #include <unordered_map> namespace spdlog { namespace details { template <class Mutex> class registry_t { public: void register_logger(std::shared_ptr<logger> logger) { std::lock_guard<Mutex> lock(_mutex); auto logger_name = logger->name(); throw_if_exists(logger_name); _loggers[logger_name] = logger; } std::shared_ptr<logger> get(const std::string& logger_name) { std::lock_guard<Mutex> lock(_mutex); auto found = _loggers.find(logger_name); return found == _loggers.end() ? nullptr : found->second; } template<class It> std::shared_ptr<logger> create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end) { std::lock_guard<Mutex> lock(_mutex); throw_if_exists(logger_name); std::shared_ptr<logger> new_logger; if (_async_mode) new_logger = std::make_shared<async_logger>(logger_name, sinks_begin, sinks_end, _async_q_size, _overflow_policy, _worker_warmup_cb, _flush_interval_ms, _worker_teardown_cb); else new_logger = std::make_shared<logger>(logger_name, sinks_begin, sinks_end); if (_formatter) new_logger->set_formatter(_formatter); if (_err_handler) new_logger->set_error_handler(_err_handler); new_logger->set_level(_level); //Add to registry _loggers[logger_name] = new_logger; return new_logger; } void apply_all(std::function<void(std::shared_ptr<logger>)> fun) { std::lock_guard<Mutex> lock(_mutex); for (auto &l : _loggers) fun(l.second); } void drop(const std::string& logger_name) { std::lock_guard<Mutex> lock(_mutex); _loggers.erase(logger_name); } void drop_all() { std::lock_guard<Mutex> lock(_mutex); _loggers.clear(); } std::shared_ptr<logger> create(const std::string& logger_name, sinks_init_list sinks) { return create(logger_name, sinks.begin(), sinks.end()); } std::shared_ptr<logger> create(const std::string& logger_name, sink_ptr sink) { return create(logger_name, { sink }); } void formatter(formatter_ptr f) { std::lock_guard<Mutex> lock(_mutex); _formatter = f; for (auto& l : _loggers) l.second->set_formatter(_formatter); } void set_pattern(const std::string& pattern) { std::lock_guard<Mutex> lock(_mutex); _formatter = std::make_shared<pattern_formatter>(pattern); for (auto& l : _loggers) l.second->set_formatter(_formatter); } void set_level(level::level_enum log_level) { std::lock_guard<Mutex> lock(_mutex); for (auto& l : _loggers) l.second->set_level(log_level); _level = log_level; } void set_error_handler(log_err_handler handler) { for (auto& l : _loggers) l.second->set_error_handler(handler); _err_handler = handler; } void set_async_mode(size_t q_size, const async_overflow_policy overflow_policy, const std::function<void()>& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function<void()>& worker_teardown_cb) { std::lock_guard<Mutex> lock(_mutex); _async_mode = true; _async_q_size = q_size; _overflow_policy = overflow_policy; _worker_warmup_cb = worker_warmup_cb; _flush_interval_ms = flush_interval_ms; _worker_teardown_cb = worker_teardown_cb; } void set_sync_mode() { std::lock_guard<Mutex> lock(_mutex); _async_mode = false; } static registry_t<Mutex>& instance() { static registry_t<Mutex> s_instance; return s_instance; } private: registry_t<Mutex>() {} registry_t<Mutex>(const registry_t<Mutex>&) = delete; registry_t<Mutex>& operator=(const registry_t<Mutex>&) = delete; void 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"); } Mutex _mutex; std::unordered_map <std::string, std::shared_ptr<logger>> _loggers; formatter_ptr _formatter; level::level_enum _level = level::info; log_err_handler _err_handler; bool _async_mode = false; size_t _async_q_size = 0; async_overflow_policy _overflow_policy = async_overflow_policy::block_retry; std::function<void()> _worker_warmup_cb = nullptr; std::chrono::milliseconds _flush_interval_ms; std::function<void()> _worker_teardown_cb = nullptr; }; #ifdef SPDLOG_NO_REGISTRY_MUTEX typedef registry_t<spdlog::details::null_mutex> registry; #else typedef registry_t<std::mutex> registry; #endif } }