LCOV - code coverage report
Current view: top level - Utils - Logger.cpp (source / functions) Coverage Total Hit
Test: OdbDesign Test Coverage Lines: 37.6 % 93 35
Test Date: 2026-11-19 04:56:22 Functions: 38.1 % 21 8
Legend: Lines: hit not hit

            Line data    Source code
       1              : #include "Logger.h"
       2              : #include <iostream>
       3              : #include "timestamp.h"
       4              : #include <filesystem>
       5              : #include <typeinfo>
       6              : 
       7              : using namespace std::filesystem;
       8              : 
       9              : 
      10              : namespace Utils
      11              : {
      12          123 :         Logger::Logger()
      13          123 :                 : m_level(Level::Info)
      14          246 :                 , m_logFilename(DEFAULT_LOG_FILENAME)
      15          123 :                 , m_outputTypes(OutputTypes::StdOut | OutputTypes::File)
      16              :                 //, m_enableInternalLogging(false)
      17              :                 //, m_logFileStream(m_logFilename, std::ios::out | std::ios::app)
      18          123 :                 , m_logMessageLoop(
      19            0 :                         [&](Message& message)
      20              :                         {
      21            0 :                                 return this->logMessage(message);
      22          123 :                         })
      23              :         {               
      24          123 :         }
      25              : 
      26            0 :         Logger::~Logger()
      27              :         {
      28            0 :                 if (m_logFileStream) m_logFileStream.close();
      29            0 :         }
      30              : 
      31       439306 :         /*static*/ Logger* Logger::instance()
      32              :         {
      33       439306 :                 if (_instance == nullptr)
      34              :                 {
      35          123 :                         _instance = new Logger();
      36              :                 }
      37       439306 :                 return _instance;
      38              :         }
      39              : 
      40              :         /*static*/ Logger* Logger::_instance = nullptr;
      41              : 
      42            0 :         Logger::Level Logger::logLevel() const { return m_level; }
      43            0 :         void Logger::logLevel(Logger::Level level) { m_level = level; }
      44              : 
      45            0 :         void Logger::outputTypes(int outputTypes)
      46              :         {
      47            0 :                 m_outputTypes = outputTypes;                            
      48            0 :         }
      49              : 
      50            0 :         int Logger::outputTypes() const
      51              :         {
      52            0 :                 return m_outputTypes;
      53              :         }
      54              : 
      55            0 :         std::string Logger::filename() const
      56              :         {
      57            0 :                 return m_logFilename;
      58              :         }
      59              : 
      60       439306 :         void Logger::log(Level level, const std::string& message, const std::string& file, int line)
      61              :         {
      62       439306 :                 m_logMessageLoop.addWorkItem(Message { message, level, file, line });                                           
      63       439306 :         }
      64              : 
      65           41 :         void Logger::error(const std::string& message, const std::string& file, int line)
      66              :         {
      67           41 :                 log(Level::Error, message, file, line);
      68           41 :         }
      69              : 
      70         6691 :         void Logger::warn(const std::string& message, const std::string& file, int line)
      71              :         {
      72         6691 :                 log(Level::Warn, message, file, line);
      73         6691 :         }
      74              : 
      75       233770 :         void Logger::info(const std::string& message, const std::string& file, int line)
      76              :         {
      77       233770 :                 log(Level::Info, message, file, line);
      78       233770 :         }
      79              : 
      80            0 :         void Logger::info(const std::stringstream& stream, const std::string& file, int line)
      81              :         {
      82            0 :                 info(stream.str(), file, line);
      83            0 :         }
      84              : 
      85       198804 :         void Logger::debug(const std::string& message, const std::string& file, int line)
      86              :         {
      87       198804 :                 log(Level::Debug, message, file, line);
      88       198804 :         }
      89              : 
      90            0 :         void Logger::exception(const std::exception& e, const std::string& file, int line)
      91              :         {
      92            0 :                 exception(e, "", file, line);
      93            0 :         }
      94              : 
      95            6 :         void Logger::exception(const std::exception& e, const std::string& message, const std::string& file, int line)
      96              :         {
      97            6 :                 const auto& tid = typeid(e);
      98              : 
      99            6 :                 std::stringstream ss;
     100              :                 ss << "EXCEPTION: "
     101              :                         << tid.name() 
     102              :                         << ": \""
     103            6 :                         << e.what()
     104            6 :                         << "\"";
     105              : 
     106            6 :                 if (!message.empty())
     107              :                 {
     108            2 :                         ss << std::endl << message;
     109              :                 }
     110              : 
     111            6 :                 error(ss.str(), file, line);
     112            6 :         }
     113              : 
     114              :         //void Logger::exception(const std::string& message, const std::string& file, int line)
     115              :         //{
     116              :         //      std::string s = "EXCEPTION!: " + message;
     117              :         //      error(s, file, line);
     118              :         //}
     119              : 
     120            0 :         void Logger::start()
     121              :         {
     122            0 :                 loginfo("**************** logger started ****************");
     123            0 :                 m_logMessageLoop.startProcessing();
     124            0 :         }
     125              : 
     126            0 :         void Logger::stop()
     127              :         {
     128            0 :                 loginfo("**************** logger stopped ****************");
     129            0 :                 m_logMessageLoop.stopProcessing();
     130            0 :         }
     131              : 
     132              :         //bool Logger::processWorkItem(LogMessage& logMessage)
     133              :         //{
     134              :         //      return this->logMessage(logMessage);
     135              :         //}
     136              : 
     137            0 :         /*static*/ std::string Logger::formatLogMessage(const Message& logMessage)
     138              :         {
     139            0 :                 std::stringstream ss;
     140              : 
     141              :                 ss << "["
     142              :                         //<< std::format("", logMessage.timeStamp)
     143              :                         //<< logMessage.timeStamp.
     144            0 :                         << make_timestamp(logMessage.timeStamp);
     145              : 
     146            0 :                 if (logMessage.file != "" &&
     147            0 :                         logMessage.line != -1)
     148              :                 {                       
     149              :                         ss << " " 
     150            0 :                                 << std::setw(20)
     151            0 :                                 << std::left
     152            0 :                                 << path{ logMessage.file }.filename().string()
     153              :                                 << ":"
     154            0 :                                 << std::setw(4)
     155            0 :                                 << logMessage.line;
     156              :                 }
     157              :                 
     158              :                 ss << " "
     159            0 :                         << std::setw(6)
     160            0 :                         << std::right
     161            0 :                         << logLevelMap.getValue(logMessage.level)
     162            0 :                         << "]";
     163              :                 
     164              :                 ss << " "
     165            0 :                         << logMessage.message
     166            0 :                         << std::endl;
     167              : 
     168            0 :                 return ss.str();
     169            0 :         }
     170              : 
     171            0 :         bool Logger::logMessage(const Message& logMessage)
     172              :         {
     173              :                 //std::cout << "[Logger::logMessage] enter, formatting message" << std::endl;
     174              : 
     175            0 :                 auto message = formatLogMessage(logMessage);
     176              : 
     177              :                 //std::cout << "[Logger::logMessage] message formatted, writing to cout and cerr" << std::endl;
     178              : 
     179            0 :                 if (logMessage.level >= m_level)
     180              :                 {
     181            0 :                         if (m_outputTypes & OutputTypes::StdOut) std::cout << message << std::flush;
     182            0 :                         if (m_outputTypes & OutputTypes::StdErr) std::cerr << message << std::flush;
     183              :                 }
     184              : 
     185              :                 //else if (logMessage.level == Level::Error ||
     186              :                 //               logMessage.level == Level::Warn)
     187              :                 //{
     188              :                 //      if (m_outputTypes & OutputTypes::StdErr) std::cerr << message << std::flush;
     189              :                 //}
     190              : 
     191              :                 //std::cout << "[Logger::logMessage] wrote to cout and cerr, writing to file..." << std::endl;
     192              : 
     193            0 :                 if (m_outputTypes & OutputTypes::File)
     194              :                 {
     195              :                         //std::cout << "[Logger::logMessage] opening log file stream (" << m_logFilename << ")..." << std::endl;
     196              : 
     197            0 :                         m_logFileStream.open(m_logFilename, std::ios::out | std::ios::app);
     198            0 :                         if (m_logFileStream)
     199              :                         {
     200              :                                 //std::cout << "[Logger::logMessage] file stream opened, writing to file..." << std::endl;
     201              : 
     202            0 :                                 m_logFileStream << message << std::flush;
     203              :                                 //m_logFileStream.flush();
     204            0 :                                 m_logFileStream.close();
     205              : 
     206              :                                 //std::cout << "[Logger::logMessage] wrote to file and closed stream" << std::endl;
     207              :                         }
     208              :                 }
     209              : 
     210              :                 //std::cout << "[Logger::logMessage] exit" << std::endl;
     211              : 
     212            0 :                 return true;
     213            0 :         }       
     214              : }
        

Generated by: LCOV version 2.0-1