spdlog/details/registry.h

0001 // Copyright(c) 2015-present, Gabi Melman & spdlog contributors.
0002 // Distributed under the MIT License (http://opensource.org/licenses/MIT)
0003
0004 #pragma once
0005
0006 // Loggers registry of unique name->logger pointer
0007 // An attempt to create a logger with an already existing name will result with spdlog_ex exception.
0008 // If user requests a non existing logger, nullptr will be returned
0009 // This class is thread safe
0010
0011 #include <spdlog/common.h>
0012 #include <spdlog/details/periodic_worker.h>
0013
0014 #include <chrono>
0015 #include <functional>
0016 #include <memory>
0017 #include <mutex>
0018 #include <string>
0019 #include <unordered_map>
0020
0021 namespace spdlog {
0022 class logger;
0023
0024 namespace details {
0025 class thread_pool;
0026
0027 class SPDLOG_API registry {
0028 public:
0029     using log_levels = std::unordered_map<std::string, level::level_enum>;
0030     registry(const registry &) = delete;
0031     registry &operator=(const registry &) = delete;
0032
0033     void register_logger(std::shared_ptr<logger> new_logger);
0034     void initialize_logger(std::shared_ptr<logger> new_logger);
0035     std::shared_ptr<logger> get(const std::string &logger_name);
0036     std::shared_ptr<logger> default_logger();
0037
0038     // Return raw ptr to the default logger.
0039     // To be used directly by the spdlog default api (e.g. spdlog::info)
0040     // This make the default API faster, but cannot be used concurrently with set_default_logger().
0041     // e.g do not call set_default_logger() from one thread while calling spdlog::info() from
0042     // another.
0043     logger *get_default_raw();
0044
0045     // set default logger and add it to the registry if not registered already.
0046     // default logger is stored in default_logger_ (for faster retrieval) and in the loggers_ map.
0047     // Note: Make sure to unregister it when no longer needed or before calling again with a new
0048     // logger.
0049     void set_default_logger(std::shared_ptr<logger> new_default_logger);
0050
0051     void set_tp(std::shared_ptr<thread_pool> tp);
0052
0053     std::shared_ptr<thread_pool> get_tp();
0054
0055     // Set global formatter. Each sink in each logger will get a clone of this object
0056     void set_formatter(std::unique_ptr<formatter> formatter);
0057
0058     void enable_backtrace(size_t n_messages);
0059
0060     void disable_backtrace();
0061
0062     void set_level(level::level_enum log_level);
0063
0064     void flush_on(level::level_enum log_level);
0065
0066     template <typename Rep, typename Period>
0067     void flush_every(std::chrono::duration<Rep, Period> interval) {
0068         std::lock_guard<std::mutex> lock(flusher_mutex_);
0069         auto clbk = [this]() { this->flush_all(); };
0070         periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
0071     }
0072
0073     std::unique_ptr<periodic_worker> &get_flusher() {
0074         std::lock_guard<std::mutex> lock(flusher_mutex_);
0075         return periodic_flusher_;
0076     }
0077
0078     void set_error_handler(err_handler handler);
0079
0080     void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun);
0081
0082     void flush_all();
0083
0084     void drop(const std::string &logger_name);
0085
0086     void drop_all();
0087
0088     // clean all resources and threads started by the registry
0089     void shutdown();
0090
0091     std::recursive_mutex &tp_mutex();
0092
0093     void set_automatic_registration(bool automatic_registration);
0094
0095     // set levels for all existing/future loggers. global_level can be null if should not set.
0096     void set_levels(log_levels levels, level::level_enum *global_level);
0097
0098     static registry &instance();
0099
0100     void apply_logger_env_levels(std::shared_ptr<logger> new_logger);
0101
0102 private:
0103     registry();
0104     ~registry();
0105
0106     void throw_if_exists_(const std::string &logger_name);
0107     void register_logger_(std::shared_ptr<logger> new_logger);
0108     bool set_level_from_cfg_(logger *logger);
0109     std::mutex logger_map_mutex_, flusher_mutex_;
0110     std::recursive_mutex tp_mutex_;
0111     std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
0112     log_levels log_levels_;
0113     std::unique_ptr<formatter> formatter_;
0114     spdlog::level::level_enum global_log_level_ = level::info;
0115     level::level_enum flush_level_ = level::off;
0116     err_handler err_handler_;
0117     std::shared_ptr<thread_pool> tp_;
0118     std::unique_ptr<periodic_worker> periodic_flusher_;
0119     std::shared_ptr<logger> default_logger_;
0120     bool automatic_registration_ = true;
0121     size_t backtrace_n_messages_ = 0;
0122 };
0123
0124 }  // namespace details
0125 }  // namespace spdlog
0126
0127 #ifdef SPDLOG_HEADER_ONLY
0128     #include "registry-inl.h"
0129 #endif