stabilized logger classes

source/core/logger/log_manager.cpp

@@ -5,19 +5,18 @@ namespace matador::logger {
 log_level_range log_manager::default_log_level_range_ = {};
 
 logger log_manager::create_logger(std::string source) const {
-  return logger(std::move(source), default_log_domain_);
+  return {std::move(source), default_log_domain_};
 }
 
 logger log_manager::create_logger(std::string source, const std::string &domain_name) {
-  return logger(std::move(source), acquire_domain(domain_name));
+  return {std::move(source), acquire_domain(domain_name)};
 }
 
 void log_manager::add_sink(sink_ptr sink) const {
   default_log_domain_->add_sink(std::move(sink));
 }
 
-void log_manager::add_sink(sink_ptr sink, const std::string &domain_name)
-{
+void log_manager::add_sink(sink_ptr sink, const std::string &domain_name) {
   const auto log_domain = acquire_domain(domain_name);
 
   log_domain->add_sink(std::move(sink));
@@ -27,44 +26,40 @@ void log_manager::clear_all_sinks() const {
   default_log_domain_->clear();
 }
 
-void log_manager::clear_all_sinks(const std::string &domain_name)
-{
+void log_manager::clear_all_sinks(const std::string &domain_name) {
+  std::lock_guard lock(mutex_);
   if (const auto it = log_domain_map_.find(domain_name); it != log_domain_map_.end()) {
     it->second->clear();
   }
 }
 
-void log_manager::clear()
-{
+void log_manager::clear() {
+  std::lock_guard lock(mutex_);
   log_domain_map_.clear();
-  default_log_domain_->clear();
 }
 
-void log_manager::max_default_log_level(log_level max_level)
-{
+void log_manager::max_default_log_level(const log_level max_level) {
   default_log_level_range_.max_level = max_level;
 }
 
-log_level log_manager::max_default_log_level()
-{
+log_level log_manager::max_default_log_level() {
   return default_log_level_range_.max_level;
 }
 
-void log_manager::min_default_log_level(log_level min_level)
-{
+void log_manager::min_default_log_level(const log_level min_level) {
   default_log_level_range_.min_level = min_level;
 }
 
-log_level log_manager::min_default_log_level()
-{
+log_level log_manager::min_default_log_level() {
   return default_log_level_range_.min_level;
 }
 
-std::shared_ptr<log_domain> log_manager::acquire_domain(const std::string &name)
-{
+std::shared_ptr<log_domain> log_manager::acquire_domain(const std::string &name) {
   if (name == "default") {
     return default_log_domain_;
   }
+
+  std::lock_guard lock(mutex_);
   auto it = log_domain_map_.find(name);
   if (it == log_domain_map_.end()) {
     it = log_domain_map_.insert(std::make_pair(name, std::make_shared<log_domain>(name, default_log_level_range_))).first;
@@ -72,34 +67,34 @@ std::shared_ptr<log_domain> log_manager::acquire_domain(const std::string &name)
   return it->second;
 }
 
-std::shared_ptr<log_domain> log_manager::find_domain(const std::string &name)
-{
+std::shared_ptr<log_domain> log_manager::find_domain(const std::string &name) {
   if (name == "default") {
     return default_log_domain_;
   }
-  auto it = log_domain_map_.find(name);
-  if (it != log_domain_map_.end()) {
+  std::lock_guard lock(mutex_);
+  if (const auto it = log_domain_map_.find(name); it != log_domain_map_.end()) {
     return it->second;
   }
-  return std::shared_ptr<log_domain>();
+  return {};
 }
 
 void log_manager::log_default(const log_level lvl, const std::string &source, const char *message) const {
   default_log_domain_->log(lvl, source, message);
 }
 
-std::shared_ptr<file_sink> create_file_sink(const std::string &logfile)
-{
+log_manager::log_manager() {
+  default_log_domain_ = std::make_shared<log_domain>("default", default_log_level_range_);
+}
+
+std::shared_ptr<file_sink> create_file_sink(const std::string &logfile) {
   return std::make_shared<file_sink>(logfile);
 }
 
-std::shared_ptr<stderr_sink> create_stderr_sink()
-{
+std::shared_ptr<stderr_sink> create_stderr_sink() {
   return std::make_shared<stderr_sink>();
 }
 
-std::shared_ptr<stdout_sink> create_stdout_sink()
-{
+std::shared_ptr<stdout_sink> create_stdout_sink() {
   return std::make_shared<stdout_sink>();
 }
 
@@ -128,7 +123,7 @@ void domain_min_log_level(const std::string &name, const log_level min_lvl)
 void domain_max_log_level(const std::string &name, const log_level max_lvl)
 {
   if (const auto domain = log_manager::instance().find_domain(name)) {
-    domain->min_log_level(max_lvl);
+    domain->max_log_level(max_lvl);
   }
 }