LogSystem.h

/**************************************************************************
 * basf2 (Belle II Analysis Software Framework)                           *
 * Author: The Belle II Collaboration                                     *
 *                                                                        *
 * See git log for contributors and copyright holders.                    *
 * This file is licensed under LGPL-3.0, see LICENSE.md.                  *
 **************************************************************************/
 
#pragma once
 
#include <framework/logging/LogConfig.h>
#include <framework/logging/LogMessage.h>
 
#include <string>
#include <vector>
#include <map>
#include <unordered_map>
 
 
namespace Belle2 {
  class LogConnectionBase;
 
  class LogSystem {
  public:
    static const unsigned int c_errorSummaryMaxLines = 10000; 
    static LogSystem& Instance();
 
    void addLogConnection(LogConnectionBase* logConnection);
 
    void resetLogConnections();
 
    void resetLogging();
 
    LogConfig* getLogConfig() {return &m_logConfig;}
 
    void addPackageLogConfig(const std::string& package, const LogConfig& logConfig) { m_packageLogConfigs[package] = logConfig; }
 
    LogConfig& getPackageLogConfig(const std::string& package) { return m_packageLogConfigs[package]; }
 
    bool isLevelEnabled(LogConfig::ELogLevel level, int debugLevel = 0, const char* package = nullptr) const;
 
    bool sendMessage(LogMessage&& message);
 
    void resetMessageCounter();
 
    int getMessageCounter(LogConfig::ELogLevel logLevel) const;
 
    const LogConfig& getCurrentLogConfig(const char* package = nullptr) const;
 
    LogConfig::ELogLevel getCurrentLogLevel(const char* package = nullptr) const { return getCurrentLogConfig(package).getLogLevel(); }
 
    int getCurrentDebugLevel(const char* package = nullptr) const { return getCurrentLogConfig(package).getDebugLevel(); }
 
    unsigned getMaxMessageRepetitions() const { return m_maxErrorRepetition; }
 
    void setMaxMessageRepetitions(unsigned repetitions) { m_maxErrorRepetition = repetitions; }
 
    void printErrorSummary();
 
    void enableErrorSummary(bool on) { m_printErrorSummary = on; }
 
    void updateModule(const LogConfig* moduleLogConfig = nullptr, const std::string& moduleName = "") { m_moduleLogConfig = moduleLogConfig; m_moduleName = moduleName; }
 
    static void enableDebug() {s_debugEnabled = true;}
 
    inline static bool debugEnabled() {return s_debugEnabled;}
 
  private:
    std::vector<LogConnectionBase*> m_logConnections;
    LogConfig m_logConfig;
    const LogConfig* m_moduleLogConfig;
    std::string m_moduleName;
    std::map<std::string, LogConfig> m_packageLogConfigs;
    bool m_printErrorSummary;
    std::unordered_map<LogMessage, int, LogMessage::TextHasher, LogMessage::TextHasher> m_messageLog{100};
    unsigned int m_maxErrorRepetition{0};
    unsigned int m_suppressedMessages{0};
    int m_messageCounter[LogConfig::c_Default];
    static bool s_debugEnabled;
 
    LogSystem();
 
    LogSystem(const LogSystem&) = delete;
 
    LogSystem& operator=(const LogSystem&) = delete;
 
    ~LogSystem();
 
    void incMessageCounter(LogConfig::ELogLevel logLevel);
 
    bool deliverMessageToConnections(const LogMessage& msg);
 
    void showText(LogConfig::ELogLevel level, const std::string& txt, int info = LogConfig::c_Message);
  };
 
  inline const LogConfig& LogSystem::getCurrentLogConfig(const char* package) const
  {
    //module specific config?
    if (m_moduleLogConfig && (m_moduleLogConfig->getLogLevel() != LogConfig::c_Default)) {
      return *m_moduleLogConfig;
    }
    //package specific config?
    if (package && !m_packageLogConfigs.empty()) {
      // cppcheck-suppress stlIfFind ; cppcheck doesn't like scoped variables in if statements
      if (auto it = m_packageLogConfigs.find(package); it != m_packageLogConfigs.end()) {
        const LogConfig& logConfig = it->second;
        if (logConfig.getLogLevel() != LogConfig::c_Default)
          return logConfig;
      }
    }
    //global config
    return m_logConfig;
  }
 
  inline bool LogSystem::isLevelEnabled(LogConfig::ELogLevel level, int debugLevel, const char* package) const
  {
    const LogConfig& config = getCurrentLogConfig(package);
    const LogConfig::ELogLevel logLevelLimit = config.getLogLevel();
    const int debugLevelLimit = config.getDebugLevel();
    return logLevelLimit <= level && (level != LogConfig::c_Debug || debugLevelLimit >= debugLevel);
  }
 
} //end of namespace Belle2