Line data    Source code

       1             : /**
       2             :  * Copyright Soramitsu Co., Ltd. All Rights Reserved.
       3             :  * SPDX-License-Identifier: Apache-2.0
       4             :  */
       5             : 
       6             : #include "logger/logger_manager.hpp"
       7             : 
       8             : #include <atomic>
       9             : 
      10             : static const std::string kTagHierarchySeparator = "/";
      11             : 
      12             : static inline std::string joinTags(const std::string &parent,
      13             :                                    const std::string &child) {
      14        1745 :   return parent.empty() ? child : parent + kTagHierarchySeparator + child;
      15           0 : }
      16             : 
      17             : namespace logger {
      18             : 
      19             :   LoggerManagerTree::LoggerManagerTree(ConstLoggerConfigPtr config)
      20           1 :       : config_(std::move(config)){};
      21             : 
      22             :   LoggerManagerTree::LoggerManagerTree(LoggerConfig config)
      23          82 :       : config_(std::make_shared<const LoggerConfig>(std::move(config))){};
      24             : 
      25             :   LoggerManagerTree::LoggerManagerTree(std::string full_tag,
      26             :                                        std::string node_tag,
      27             :                                        ConstLoggerConfigPtr config)
      28        1745 :       : node_tag_(std::move(node_tag)),
      29        1745 :         full_tag_(std::move(full_tag)),
      30        1745 :         config_(std::move(config)){};
      31             : 
      32             :   LoggerManagerTreePtr LoggerManagerTree::registerChild(
      33             :       std::string tag,
      34             :       boost::optional<LogLevel> log_level,
      35             :       boost::optional<LogPatterns> patterns) {
      36           0 :     LoggerConfig child_config{
      37           0 :         log_level.value_or(config_->log_level),
      38           0 :         patterns ? LogPatterns{*std::move(patterns)} : config_->patterns};
      39             :     // Operator new is employed due to private visibility of used constructor.
      40           0 :     LoggerManagerTreePtr child(new LoggerManagerTree(
      41           0 :         joinTags(full_tag_, tag),
      42           0 :         tag,
      43           0 :         std::make_shared<const LoggerConfig>(std::move(child_config))));
      44           0 :     auto map_elem = std::make_pair<const std::string, LoggerManagerTreePtr>(
      45           0 :         std::move(tag), std::move(child));
      46           0 :     std::lock_guard<std::mutex> lock(children_mutex_);
      47           0 :     return children_.emplace(std::move(map_elem)).first->second;
      48           0 :   }
      49             : 
      50             :   LoggerPtr LoggerManagerTree::getLogger() {
      51             :     LoggerPtr logger =
      52       33147 :         std::atomic_load_explicit(&logger_, std::memory_order_acquire);
      53       33147 :     if (not logger) {
      54        1499 :       LoggerPtr new_logger = std::make_shared<LoggerSpdlog>(full_tag_, config_);
      55        1502 :       while (not logger) {
      56        1499 :         if (std::atomic_compare_exchange_weak_explicit(
      57        1499 :                 &logger_,
      58             :                 &logger,
      59        1499 :                 new_logger,
      60             :                 std::memory_order_release,
      61             :                 std::memory_order_acquire)) {
      62        1496 :           return new_logger;
      63             :         }
      64             :       }
      65        1499 :     }
      66       31651 :     return logger;
      67       33147 :   }
      68             : 
      69             :   LoggerManagerTreePtr LoggerManagerTree::getChild(const std::string &tag) {
      70       34650 :     std::lock_guard<std::mutex> lock(children_mutex_);
      71       34709 :     const auto child_it = children_.find(tag);
      72       34710 :     if (child_it != children_.end()) {
      73       32965 :       return child_it->second;
      74             :     }
      75             :     // If a node for this child is not found in the tree config, create a
      76             :     // new standalone logger using this logger's settings.
      77        1745 :     LoggerManagerTreePtr new_child(
      78        1745 :         new LoggerManagerTree(joinTags(full_tag_, tag), tag, config_));
      79        1745 :     return children_.emplace(std::make_pair(tag, std::move(new_child)))
      80        1745 :         .first->second;
      81       34710 :   }
      82             : 
      83             : }  // namespace logger