Line data    Source code

       1             : #include "Logger.h"
       2             : 
       3             : #include <spdlog/sinks/stdout_color_sinks.h>
       4             : #include <spdlog/sinks/basic_file_sink.h>
       5             : #include <spdlog/sinks/dist_sink.h>
       6             : #include <spdlog/sinks/ostream_sink.h>
       7             : 
       8             : namespace elsa
       9             : {
      10             :     void Logger::setLevel(LogLevel level)
      11         327 :     {
      12         327 :         getInstance()._level = level;
      13             : 
      14             :         // set level globally (probably superfluous..)
      15         327 :         spdlog::set_level(convertLevelToSpdlog(level));
      16             : 
      17             :         // set level for all active loggers
      18         327 :         for (auto& [key, logger] : getInstance()._loggers)
      19         484 :             logger->set_level(convertLevelToSpdlog(level));
      20         327 :     }
      21             : 
      22             :     Logger::LogLevel Logger::getLevel()
      23           4 :     {
      24             :         // this should return the correct global level as we only set a global/forall level
      25           4 :         return getInstance()._level;
      26           4 :     }
      27             : 
      28             :     std::shared_ptr<spdlog::sinks::dist_sink_st> Logger::initSinks()
      29          78 :     {
      30          78 :         auto sink = std::make_shared<spdlog::sinks::dist_sink_st>();
      31             : 
      32             :         // Add a console output sink
      33          78 :         sink->add_sink(std::make_shared<spdlog::sinks::stdout_color_sink_mt>());
      34             : 
      35             :         // If a filename is set, also add a file output sink
      36          78 :         if (getInstance()._fileName != "")
      37           0 :             sink->add_sink(
      38           0 :                 std::make_shared<spdlog::sinks::basic_file_sink_st>(getInstance()._fileName));
      39             : 
      40          78 :         return sink;
      41          78 :     }
      42             : 
      43             :     std::shared_ptr<spdlog::sinks::dist_sink_st> Logger::sinks()
      44         142 :     {
      45         142 :         static auto sink = initSinks();
      46         142 :         return sink;
      47         142 :     }
      48             : 
      49             :     std::shared_ptr<spdlog::logger> Logger::get(std::string name)
      50       38777 :     {
      51             :         // If we don't have sinks setup yet, initialize it
      52             : 
      53       38777 :         if (getInstance()._loggers.count(name) == 0) {
      54         138 :             auto newLogger = std::make_shared<spdlog::logger>(name, sinks());
      55         138 :             newLogger->set_level(convertLevelToSpdlog(getInstance()._level));
      56         138 :             getInstance()._loggers[name] = newLogger;
      57         138 :         }
      58             : 
      59       38777 :         return getInstance()._loggers[name];
      60       38777 :     }
      61             : 
      62             :     void Logger::enableFileLogging(std::string filename)
      63           3 :     {
      64           3 :         getInstance()._fileName = std::move(filename);
      65             : 
      66           3 :         sinks()->add_sink(
      67           3 :             std::make_shared<spdlog::sinks::basic_file_sink_st>(getInstance()._fileName));
      68             : 
      69             :         // for (auto& [key, logger] : getInstance()._loggers) {}
      70           3 :     }
      71             : 
      72             :     void Logger::flush()
      73           0 :     {
      74           0 :         for (auto& [key, logger] : getInstance()._loggers) {
      75           0 :             for (auto sink : logger->sinks())
      76           0 :                 sink->flush();
      77           0 :         }
      78           0 :     }
      79             : 
      80             :     void Logger::addSink(std::ostream& os)
      81           1 :     {
      82           1 :         sinks()->add_sink(std::make_shared<spdlog::sinks::ostream_sink_st>(os));
      83             :         // for (auto& [key, logger] : getInstance()._loggers) {
      84             :         //     auto distSink = dynamic_cast<spdlog::sinks::dist_sink_st*>(logger->sinks()[0].get());
      85             :         //     if (distSink) {
      86             :         //         distSink->add_sink(std::make_shared<spdlog::sinks::ostream_sink_st>(os));
      87             :         //     }
      88             :         // }
      89           1 :     }
      90             : 
      91             :     Logger& Logger::getInstance()
      92       78572 :     {
      93       78572 :         static Logger instance;
      94       78572 :         return instance;
      95       78572 :     }
      96             : 
      97             :     spdlog::level::level_enum Logger::convertLevelToSpdlog(Logger::LogLevel level)
      98         951 :     {
      99         951 :         switch (level) {
     100           0 :             case LogLevel::TRACE:
     101           0 :                 return spdlog::level::trace;
     102           0 :             case LogLevel::DEBUG:
     103           0 :                 return spdlog::level::debug;
     104          78 :             case LogLevel::INFO:
     105          78 :                 return spdlog::level::info;
     106          63 :             case LogLevel::WARN:
     107          63 :                 return spdlog::level::warn;
     108          98 :             case LogLevel::ERR:
     109          98 :                 return spdlog::level::err;
     110           0 :             case LogLevel::CRITICAL:
     111           0 :                 return spdlog::level::critical;
     112         712 :             case LogLevel::OFF:
     113         712 :                 return spdlog::level::off;
     114           0 :             default:
     115           0 :                 return spdlog::level::info;
     116         951 :         }
     117         951 :     }
     118             : 
     119             : } // namespace elsa