2016-04-20 04:57:49 -04:00
|
|
|
//
|
|
|
|
// 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
|
|
|
|
|
2018-04-28 18:43:42 -04:00
|
|
|
#include "spdlog/common.h"
|
2018-07-21 16:30:26 -04:00
|
|
|
#include "spdlog/details/periodic_worker.h"
|
2018-07-21 16:48:07 -04:00
|
|
|
#include "spdlog/logger.h"
|
2016-04-20 04:57:49 -04:00
|
|
|
|
2018-10-11 20:21:21 -04:00
|
|
|
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
|
2018-10-11 20:04:55 -04:00
|
|
|
// support for the default stdout color logger
|
|
|
|
#ifdef _WIN32
|
|
|
|
#include "spdlog/sinks/wincolor_sink.h"
|
|
|
|
#else
|
|
|
|
#include "spdlog/sinks/ansicolor_sink.h"
|
|
|
|
#endif
|
2018-10-11 20:21:21 -04:00
|
|
|
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
|
2018-10-11 20:04:55 -04:00
|
|
|
|
2016-04-20 04:57:49 -04:00
|
|
|
#include <chrono>
|
|
|
|
#include <functional>
|
2018-09-01 15:41:56 -04:00
|
|
|
#include <memory>
|
2016-04-20 04:57:49 -04:00
|
|
|
#include <string>
|
|
|
|
#include <unordered_map>
|
|
|
|
|
2018-03-17 06:47:46 -04:00
|
|
|
namespace spdlog {
|
|
|
|
namespace details {
|
2018-04-13 20:34:57 -04:00
|
|
|
class thread_pool;
|
|
|
|
|
2018-07-24 15:59:34 -04:00
|
|
|
class registry
|
2016-04-20 04:57:49 -04:00
|
|
|
{
|
|
|
|
public:
|
2018-07-24 15:59:34 -04:00
|
|
|
registry(const registry &) = delete;
|
|
|
|
registry &operator=(const registry &) = delete;
|
2016-04-20 04:57:49 -04:00
|
|
|
|
2018-04-13 20:34:57 -04:00
|
|
|
void register_logger(std::shared_ptr<logger> new_logger)
|
2016-04-20 04:57:49 -04:00
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-04-13 20:34:57 -04:00
|
|
|
auto logger_name = new_logger->name();
|
2018-07-07 07:04:31 -04:00
|
|
|
throw_if_exists_(logger_name);
|
2018-08-13 03:30:02 -04:00
|
|
|
loggers_[logger_name] = std::move(new_logger);
|
2016-04-20 04:57:49 -04:00
|
|
|
}
|
|
|
|
|
2018-04-13 20:34:57 -04:00
|
|
|
void register_and_init(std::shared_ptr<logger> new_logger)
|
2017-06-15 12:08:44 -04:00
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-04-13 20:34:57 -04:00
|
|
|
auto logger_name = new_logger->name();
|
2018-07-07 07:04:31 -04:00
|
|
|
throw_if_exists_(logger_name);
|
2017-06-15 12:08:44 -04:00
|
|
|
|
2018-07-14 09:21:53 -04:00
|
|
|
// set the global formatter pattern
|
2018-07-22 14:52:46 -04:00
|
|
|
new_logger->set_formatter(formatter_->clone());
|
2017-06-15 12:08:44 -04:00
|
|
|
|
2018-05-26 12:21:20 -04:00
|
|
|
if (err_handler_)
|
2018-03-17 07:42:09 -04:00
|
|
|
{
|
2018-05-26 12:21:20 -04:00
|
|
|
new_logger->set_error_handler(err_handler_);
|
2018-03-17 07:42:09 -04:00
|
|
|
}
|
2017-06-15 12:08:44 -04:00
|
|
|
|
2018-05-26 12:21:20 -04:00
|
|
|
new_logger->set_level(level_);
|
|
|
|
new_logger->flush_on(flush_level_);
|
2017-06-15 12:08:44 -04:00
|
|
|
|
2018-07-24 15:59:34 -04:00
|
|
|
// add to registry
|
2018-08-13 03:30:02 -04:00
|
|
|
loggers_[logger_name] = std::move(new_logger);
|
2017-06-15 12:08:44 -04:00
|
|
|
}
|
|
|
|
|
2018-04-13 20:34:57 -04:00
|
|
|
std::shared_ptr<logger> get(const std::string &logger_name)
|
2016-08-20 06:55:50 -04:00
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
auto found = loggers_.find(logger_name);
|
|
|
|
return found == loggers_.end() ? nullptr : found->second;
|
2016-08-20 06:55:50 -04:00
|
|
|
}
|
2016-08-20 06:37:36 -04:00
|
|
|
|
2018-10-11 20:04:55 -04:00
|
|
|
std::shared_ptr<logger> get_default_logger() const
|
|
|
|
{
|
|
|
|
return default_logger_;
|
|
|
|
}
|
|
|
|
|
|
|
|
// set default logger.
|
|
|
|
// default logger is stored in default_logger_ (for faster retrieval) and in the map of existing loggers.
|
|
|
|
void 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());
|
|
|
|
}
|
|
|
|
loggers_[new_default_logger->name()] = new_default_logger;
|
|
|
|
default_logger_ = std::move(new_default_logger);
|
|
|
|
}
|
|
|
|
|
2018-07-24 15:59:34 -04:00
|
|
|
void set_tp(std::shared_ptr<thread_pool> tp)
|
2016-04-20 04:57:49 -04:00
|
|
|
{
|
2018-07-26 14:09:40 -04:00
|
|
|
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
tp_ = std::move(tp);
|
2016-04-20 04:57:49 -04:00
|
|
|
}
|
|
|
|
|
2018-07-24 15:59:34 -04:00
|
|
|
std::shared_ptr<thread_pool> get_tp()
|
2016-04-20 04:57:49 -04:00
|
|
|
{
|
2018-07-26 14:09:40 -04:00
|
|
|
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
return tp_;
|
2017-06-15 12:08:44 -04:00
|
|
|
}
|
2016-04-20 04:57:49 -04:00
|
|
|
|
2018-07-22 17:13:52 -04:00
|
|
|
// Set global formatter. Each sink in each logger will get a clone of this object
|
|
|
|
void set_formatter(std::unique_ptr<formatter> formatter)
|
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-07-22 17:13:52 -04:00
|
|
|
formatter_ = std::move(formatter);
|
|
|
|
for (auto &l : loggers_)
|
|
|
|
{
|
|
|
|
l.second->set_formatter(formatter_->clone());
|
|
|
|
}
|
|
|
|
}
|
2016-04-20 04:57:49 -04:00
|
|
|
|
|
|
|
void set_level(level::level_enum log_level)
|
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
for (auto &l : loggers_)
|
2018-03-17 07:42:09 -04:00
|
|
|
{
|
2016-04-20 04:57:49 -04:00
|
|
|
l.second->set_level(log_level);
|
2018-03-17 07:42:09 -04:00
|
|
|
}
|
2018-05-26 12:21:20 -04:00
|
|
|
level_ = log_level;
|
2016-04-20 04:57:49 -04:00
|
|
|
}
|
|
|
|
|
2018-01-03 10:19:56 -05:00
|
|
|
void flush_on(level::level_enum log_level)
|
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
for (auto &l : loggers_)
|
2018-03-17 07:42:09 -04:00
|
|
|
{
|
2018-01-03 10:19:56 -05:00
|
|
|
l.second->flush_on(log_level);
|
2018-03-17 07:42:09 -04:00
|
|
|
}
|
2018-05-26 12:21:20 -04:00
|
|
|
flush_level_ = log_level;
|
2018-01-03 10:19:56 -05:00
|
|
|
}
|
|
|
|
|
2018-07-21 16:30:26 -04:00
|
|
|
void flush_every(std::chrono::seconds interval)
|
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(flusher_mutex_);
|
2018-08-13 04:43:00 -04:00
|
|
|
std::function<void()> clbk = std::bind(®istry::flush_all, this);
|
2018-09-26 16:48:36 -04:00
|
|
|
periodic_flusher_ = details::make_unique<periodic_worker>(clbk, interval);
|
2018-07-21 16:30:26 -04:00
|
|
|
}
|
|
|
|
|
2016-08-04 21:43:20 -04:00
|
|
|
void set_error_handler(log_err_handler handler)
|
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
for (auto &l : loggers_)
|
2018-03-17 07:42:09 -04:00
|
|
|
{
|
2016-08-04 21:43:20 -04:00
|
|
|
l.second->set_error_handler(handler);
|
2018-03-17 07:42:09 -04:00
|
|
|
}
|
2018-05-26 12:21:20 -04:00
|
|
|
err_handler_ = handler;
|
2016-08-04 21:43:20 -04:00
|
|
|
}
|
2016-08-04 20:56:40 -04:00
|
|
|
|
2018-08-13 03:30:02 -04:00
|
|
|
void apply_all(const std::function<void(const std::shared_ptr<logger>)> &fun)
|
2016-04-20 04:57:49 -04:00
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
for (auto &l : loggers_)
|
2018-04-13 20:34:57 -04:00
|
|
|
{
|
|
|
|
fun(l.second);
|
|
|
|
}
|
2016-04-20 04:57:49 -04:00
|
|
|
}
|
|
|
|
|
2018-07-24 17:06:10 -04:00
|
|
|
void flush_all()
|
|
|
|
{
|
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
|
|
|
for (auto &l : loggers_)
|
|
|
|
{
|
|
|
|
l.second->flush();
|
|
|
|
}
|
|
|
|
}
|
2018-07-24 15:59:34 -04:00
|
|
|
|
2018-04-13 20:34:57 -04:00
|
|
|
void drop(const std::string &logger_name)
|
2016-04-20 04:57:49 -04:00
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
loggers_.erase(logger_name);
|
2018-04-13 20:34:57 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
void drop_all()
|
2018-07-24 15:59:34 -04:00
|
|
|
{
|
|
|
|
std::lock_guard<std::mutex> lock(logger_map_mutex_);
|
|
|
|
loggers_.clear();
|
2018-10-11 20:04:55 -04:00
|
|
|
default_logger_.reset();
|
2018-07-24 15:59:34 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
// clean all reasources and threads started by the registry
|
|
|
|
void shutdown()
|
2018-04-13 20:34:57 -04:00
|
|
|
{
|
2018-04-20 06:20:19 -04:00
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
std::lock_guard<std::mutex> lock(flusher_mutex_);
|
|
|
|
periodic_flusher_.reset();
|
2018-04-20 06:20:19 -04:00
|
|
|
}
|
|
|
|
|
2018-07-24 17:06:10 -04:00
|
|
|
drop_all();
|
2018-07-24 15:59:34 -04:00
|
|
|
|
2018-04-20 06:20:19 -04:00
|
|
|
{
|
2018-07-26 14:09:40 -04:00
|
|
|
std::lock_guard<std::recursive_mutex> lock(tp_mutex_);
|
2018-05-26 12:21:20 -04:00
|
|
|
tp_.reset();
|
2018-04-20 06:20:19 -04:00
|
|
|
}
|
2018-04-13 20:34:57 -04:00
|
|
|
}
|
2018-07-24 17:06:10 -04:00
|
|
|
|
2018-07-26 14:13:19 -04:00
|
|
|
std::recursive_mutex &tp_mutex()
|
2018-07-26 14:09:40 -04:00
|
|
|
{
|
|
|
|
return tp_mutex_;
|
|
|
|
}
|
|
|
|
|
2018-07-24 15:59:34 -04:00
|
|
|
static registry &instance()
|
2018-04-13 20:34:57 -04:00
|
|
|
{
|
2018-07-24 15:59:34 -04:00
|
|
|
static registry s_instance;
|
2016-04-20 04:57:49 -04:00
|
|
|
return s_instance;
|
|
|
|
}
|
|
|
|
|
|
|
|
private:
|
2018-07-24 15:59:34 -04:00
|
|
|
registry()
|
2018-07-22 17:13:52 -04:00
|
|
|
: formatter_(new pattern_formatter("%+"))
|
|
|
|
{
|
2018-10-11 20:16:22 -04:00
|
|
|
|
|
|
|
#ifndef SPDLOG_DISABLE_DEFAULT_LOGGER
|
|
|
|
// create default logger (ansicolor_stdout_sink_mt or wincolor_stdout_sink_mt in windows).
|
2018-10-11 20:04:55 -04:00
|
|
|
#ifdef _WIN32
|
|
|
|
auto color_sink = std::make_shared<sinks::wincolor_stdout_sink_mt>();
|
|
|
|
#else
|
|
|
|
auto color_sink = std::make_shared<sinks::ansicolor_stdout_sink_mt>();
|
|
|
|
#endif
|
2018-10-11 20:16:22 -04:00
|
|
|
|
|
|
|
const char *default_logger_name = "";
|
2018-10-11 20:04:55 -04:00
|
|
|
default_logger_ = std::make_shared<spdlog::logger>(default_logger_name, std::move(color_sink));
|
|
|
|
loggers_[default_logger_name] = default_logger_;
|
2018-10-11 20:16:22 -04:00
|
|
|
|
|
|
|
#endif // SPDLOG_DISABLE_DEFAULT_LOGGER
|
2018-07-22 17:13:52 -04:00
|
|
|
}
|
2016-04-20 04:57:49 -04:00
|
|
|
|
2018-08-13 03:30:02 -04:00
|
|
|
~registry() = default;
|
2018-07-21 16:30:26 -04:00
|
|
|
|
2018-07-07 07:04:31 -04:00
|
|
|
void throw_if_exists_(const std::string &logger_name)
|
2016-04-20 04:57:49 -04:00
|
|
|
{
|
2018-05-26 12:21:20 -04:00
|
|
|
if (loggers_.find(logger_name) != loggers_.end())
|
2018-03-17 07:42:09 -04:00
|
|
|
{
|
2016-04-20 04:57:49 -04:00
|
|
|
throw spdlog_ex("logger with name '" + logger_name + "' already exists");
|
2018-03-17 07:42:09 -04:00
|
|
|
}
|
2016-04-20 04:57:49 -04:00
|
|
|
}
|
2018-07-24 17:06:10 -04:00
|
|
|
|
2018-07-24 15:59:34 -04:00
|
|
|
std::mutex logger_map_mutex_, flusher_mutex_;
|
2018-07-26 14:13:19 -04:00
|
|
|
std::recursive_mutex tp_mutex_;
|
2018-07-24 17:06:10 -04:00
|
|
|
std::unordered_map<std::string, std::shared_ptr<logger>> loggers_;
|
2018-07-22 17:13:24 -04:00
|
|
|
std::unique_ptr<formatter> formatter_;
|
2018-05-26 12:21:20 -04:00
|
|
|
level::level_enum level_ = level::info;
|
|
|
|
level::level_enum flush_level_ = level::off;
|
|
|
|
log_err_handler err_handler_;
|
|
|
|
std::shared_ptr<thread_pool> tp_;
|
2018-07-21 16:30:26 -04:00
|
|
|
std::unique_ptr<periodic_worker> periodic_flusher_;
|
2018-10-11 20:04:55 -04:00
|
|
|
std::shared_ptr<logger> default_logger_;
|
2016-04-20 04:57:49 -04:00
|
|
|
};
|
2018-02-24 16:35:09 -05:00
|
|
|
|
2018-03-17 06:47:46 -04:00
|
|
|
} // namespace details
|
2018-05-25 11:20:08 -04:00
|
|
|
} // namespace spdlog
|