LogSystem Class Reference

Class for logging debug, info and error messages. More...

#include <LogSystem.h>

Collaboration diagram for LogSystem:

Public Member Functions
void	addLogConnection (LogConnectionBase *logConnection)
	Adds a log connection object which is used to the send the logging messages.
void	resetLogConnections ()
	Removes all log connections.
void	resetLogging ()
	Reset logging system to defaults: empty all log messages and reset connections to the default.
LogConfig *	getLogConfig ()
	Returns global log system configuration.
void	addPackageLogConfig (const std::string &package, const LogConfig &logConfig)
	Add the per package log configuration.
LogConfig &	getPackageLogConfig (const std::string &package)
	Get the log configuration for the package with the given name.
bool	isLevelEnabled (LogConfig::ELogLevel level, int debugLevel=0, const char *package=nullptr) const
	Returns true if the given log level is allowed by the log system (i.e.
bool	sendMessage (LogMessage &&message)
	Sends a log message using the log connection object.
void	resetMessageCounter ()
	Resets the message counter and error log by setting all message counts to 0.
int	getMessageCounter (LogConfig::ELogLevel logLevel) const
	Returns the number of logging calls per log level.
const LogConfig &	getCurrentLogConfig (const char *package=nullptr) const
	Returns the current LogConfig object used by the logging system.
LogConfig::ELogLevel	getCurrentLogLevel (const char *package=nullptr) const
	Returns the current log level used by the logging system.
int	getCurrentDebugLevel (const char *package=nullptr) const
	Returns the current debug level used by the logging system.
unsigned	getMaxMessageRepetitions () const
	Get maximum number of repetitions before silencing "identical" log messages.
void	setMaxMessageRepetitions (unsigned repetitions)
	Set maximum number of repetitions before silencing "identical" log messages.
void	printErrorSummary ()
	Print error/warning summary at end of execution.
void	enableErrorSummary (bool on)
	enable/disable error/warning summary after successful execution and B2FATAL.
void	updateModule (const LogConfig *moduleLogConfig=nullptr, const std::string &moduleName="")
	Sets the log configuration to the given module log configuration and sets the module name This method should only be called by the EventProcessor.

Static Public Member Functions
static LogSystem &	Instance ()
	Static method to get a reference to the LogSystem instance.
static void	enableDebug ()
	Enable debug output.
static bool	debugEnabled ()
	Is debug output enabled?

Static Public Attributes
static const unsigned int	c_errorSummaryMaxLines = 10000
	Error log will contain at most this many lines.

Private Member Functions
	LogSystem ()
	The constructor is hidden to avoid that someone creates an instance of this class.
	LogSystem (const LogSystem &)=delete
	Disable/Hide the copy constructor.
LogSystem &	operator= (const LogSystem &)=delete
	Disable/Hide the copy assignment operator.
	~LogSystem ()
	The LogSystem destructor.
void	incMessageCounter (LogConfig::ELogLevel logLevel)
	Increases the counter for the called message level by one.
bool	deliverMessageToConnections (const LogMessage &msg)
	Do nothing else than to send the message to all connected connections.
void	showText (LogConfig::ELogLevel level, const std::string &txt, int info=LogConfig::c_Message)
	Send a custom message which looks like a log message but should not be counted as such.

Private Attributes
std::vector< LogConnectionBase * >	m_logConnections
	Stores the pointers to the log connection objects.
LogConfig	m_logConfig
	The global log system configuration.
const LogConfig *	m_moduleLogConfig
	log config of current module
std::string	m_moduleName
	The current module name.
std::map< std::string, LogConfig >	m_packageLogConfigs
	Stores the log configuration objects for packages.
bool	m_printErrorSummary
	Wether to re-print errors-warnings encountered during execution at the end.
std::unordered_map< LogMessage, int, LogMessage::TextHasher, LogMessage::TextHasher >	m_messageLog {100}
	Count of previous log messages for the summary and to suppress repetitive messages.
unsigned int	m_maxErrorRepetition {0}
	Maximum number to show the same message.
unsigned int	m_suppressedMessages {0}
	The amount of messages we have suppressed so far just to get an indication we print this from time to time.
int	m_messageCounter [LogConfig::c_Default]
	Counts the number of messages sent per message level.

Static Private Attributes
static bool	s_debugEnabled = false
	Global flag for fast checking if debug output is enabled.

Detailed Description

Class for logging debug, info and error messages.

For log messages the following preprocessor macros should be used: B2DEBUG for code development B2INFO for informational messages, e.g. about opened files, processed events, etc. B2RESULT for informational summary messages, e.g. about number of selected events B2WARNING for potential problems that the user should pay attention to B2ERROR for things that went wrong and have to be fixed B2FATAL for situations were the program execution can not be continued

By default the Logger sends messages to std::cout.

Using preprocessor macros has two advantages.

• the log statements can be removed from the code completely by redefining the macros.
• they allow to add information about the location (package, function, file, line).

This class is designed as a singleton.

Definition at line 46 of file LogSystem.h.

Constructor & Destructor Documentation

LogSystem()

LogSystem ( )

private

The constructor is hidden to avoid that someone creates an instance of this class.

Definition at line 171 of file LogSystem.cc.

                     :
  m_logConfig(LogConfig::c_Info),
  m_moduleLogConfig(nullptr),
  m_printErrorSummary(false),
  m_messageCounter{0}
{
  resetLogging();
}

~LogSystem()

~LogSystem ( )

private

The LogSystem destructor.

Definition at line 292 of file LogSystem.cc.

{
  resetLogConnections();
}

Member Function Documentation

addLogConnection()

void addLogConnection

(

LogConnectionBase *

logConnection

)

Adds a log connection object which is used to the send the logging messages.

Note

The LogSystem class takes ownership of the log connection object.

Parameters

logConnection

Pointer to the logging connection object. The LogSystem takes ownership of this object.

Definition at line 38 of file LogSystem.cc.

{
  m_logConnections.push_back(logConnection);
}

addPackageLogConfig()

void addPackageLogConfig ( const std::string &  package, const LogConfig &  logConfig  )

inline

Add the per package log configuration.

Adds a new log configuration for the given package name.

Parameters

package	The name of the package whose log configuration should be added.
logConfig	The log configuration which should be assigned to the given package.

Definition at line 87 of file LogSystem.h.

{ m_packageLogConfigs[package] = logConfig; }

debugEnabled()

static bool debugEnabled ( )

inlinestatic

Is debug output enabled?

Definition at line 201 of file LogSystem.h.

{return s_debugEnabled;}

deliverMessageToConnections()

bool deliverMessageToConnections ( const LogMessage &  msg )

private

Do nothing else than to send the message to all connected connections.

No bookkeeping, just and and be done

Definition at line 53 of file LogSystem.cc.

{
  bool messageSent = false;
  for (auto con : m_logConnections) {
    messageSent |= con->sendMessage(message);
  }
  return messageSent;
}

enableDebug()

static void enableDebug ( )

inlinestatic

Enable debug output.

Definition at line 196 of file LogSystem.h.

{s_debugEnabled = true;}

enableErrorSummary()

void enableErrorSummary ( bool  on )

inline

enable/disable error/warning summary after successful execution and B2FATAL.

During normal basf2 execution, this is turned on by the Framework object. For unit tests (i.e. without a Framework object), the default is used instead (off).

Definition at line 181 of file LogSystem.h.

{ m_printErrorSummary = on; }

getCurrentDebugLevel()

int getCurrentDebugLevel ( const char *  package = nullptr ) const

inline

Returns the current debug level used by the logging system.

See also

getCurrentLogConfig()

Definition at line 153 of file LogSystem.h.

{ return getCurrentLogConfig(package).getDebugLevel(); }

getCurrentLogLevel()

LogConfig::ELogLevel getCurrentLogLevel ( const char *  package = nullptr ) const

inline

Returns the current log level used by the logging system.

See also

getCurrentLogConfig()

Definition at line 146 of file LogSystem.h.

{ return getCurrentLogConfig(package).getLogLevel(); }

getLogConfig()

LogConfig * getLogConfig ( )

inline

Returns global log system configuration.

Definition at line 78 of file LogSystem.h.

{return &m_logConfig;}

getMaxMessageRepetitions()

unsigned getMaxMessageRepetitions ( ) const

inline

Get maximum number of repetitions before silencing "identical" log messages.

Identity only checks for log level and message content (excluding variables)

Definition at line 160 of file LogSystem.h.

{ return m_maxErrorRepetition; }

getMessageCounter()

int getMessageCounter

(

LogConfig::ELogLevel

logLevel

)

const

Returns the number of logging calls per log level.

Parameters

logLevel

The logging level which should be returned.

Returns

The number of message calls for the given log level.

Definition at line 161 of file LogSystem.cc.

{
  return m_messageCounter[logLevel];
}

getPackageLogConfig()

LogConfig & getPackageLogConfig ( const std::string &  package )

inline

Get the log configuration for the package with the given name.

If no package specific configuration exists a new one is created.

Parameters

package

The name of the package whose log configuration should be returned

Returns

The log configuration of the given package

Definition at line 96 of file LogSystem.h.

{ return m_packageLogConfigs[package]; }

incMessageCounter()

void incMessageCounter ( LogConfig::ELogLevel  logLevel )

private

Increases the counter for the called message level by one.

Parameters

logLevel

The logging level which should be increased by one.

Definition at line 297 of file LogSystem.cc.

{
  m_messageCounter[logLevel]++;
}

Instance()

LogSystem & Instance ( )

static

Static method to get a reference to the LogSystem instance.

Returns

A reference to an instance of this class.

Definition at line 31 of file LogSystem.cc.

{
  static LogSystem instance;
  return instance;
}

printErrorSummary()

void printErrorSummary

(

)

Print error/warning summary at end of execution.

Does nothing if m_printErrorSummary is false.

Definition at line 206 of file LogSystem.cc.

{
  if (!m_printErrorSummary)
    return; //disabled
 
  int numLogWarn = getMessageCounter(LogConfig::c_Warning);
  int numLogError = getMessageCounter(LogConfig::c_Error);
 
  // ok, only errors and warnings in the error summary
  std::vector<std::pair<LogMessage, unsigned int>> messages;
  for (auto&& value : m_messageLog) {
    if (value.first.getLogLevel() < LogConfig::c_Warning) continue;
    messages.emplace_back(std::move(value));
  }
  // but show them sorted by severity and occurrence
  std::stable_sort(messages.begin(), messages.end(), [](const auto & a, const auto & b) {
    return a.first.getLogLevel() > b.first.getLogLevel() or
           (a.first.getLogLevel() == b.first.getLogLevel() and  a.second > b.second);
  });
  if (messages.size() == 0) {
    return; //nothing to do
  }
 
  // save configuration
  const LogConfig oldConfig = m_logConfig;
  // and make sure module configuration is bypassed, otherwise changing the settings in m_logConfig would be ignored
  const LogConfig* oldModuleConfig {nullptr};
  std::swap(m_moduleLogConfig, oldModuleConfig);
  // similar for package configuration
  map<string, LogConfig> oldPackageConfig;
  std::swap(m_packageLogConfigs, oldPackageConfig);
  // prevent calling printErrorSummary() again when printing
  m_logConfig.setAbortLevel(LogConfig::c_Default);
 
  // only show level & message
  int logInfo = LogConfig::c_Level | LogConfig::c_Message;
  m_logConfig.setLogInfo(LogConfig::c_Info, logInfo);
  logInfo |= LogConfig::c_Module;
  m_logConfig.setLogInfo(LogConfig::c_Warning, logInfo);
  m_logConfig.setLogInfo(LogConfig::c_Error, logInfo);
  m_logConfig.setLogInfo(LogConfig::c_Fatal, logInfo);
  m_logConfig.setLogLevel(LogConfig::c_Info);
 
  // and then show all the messages
  showText(LogConfig::c_Info, "===Error Summary================================================================",
           LogConfig::c_Message | LogConfig::c_Level);
  for (auto & [msg, count] : messages) {
    const bool multiple = count > 1;
    // don't show variables if the message appeared more than once, could have different values/variables
    msg.setLogInfo(m_logConfig.getLogInfo(msg.getLogLevel()) | (multiple ? LogConfig::c_NoVariables : 0));
    // and directly print the message as it was saved.
    deliverMessageToConnections(msg);
    // and also tell us the count
    if (multiple) {
      showText(LogConfig::c_Info, "    (last message occurred " + std::to_string(count) + " times)");
    }
  }
  showText(LogConfig::c_Info, "================================================================================",
           LogConfig::c_Message | LogConfig::c_Level);
  if (numLogError) {
    showText(LogConfig::c_Error, "in total, " + std::to_string(numLogError) + " errors occurred during processing",
             LogConfig::c_Message | LogConfig::c_Level);
  }
  if (numLogWarn) {
    showText(LogConfig::c_Warning, "in total, " + std::to_string(numLogWarn) + " warnings occurred during processing",
             LogConfig::c_Message | LogConfig::c_Level);
  }
  if (m_messageLog.size() == c_errorSummaryMaxLines) {
    showText(LogConfig::c_Warning, "Note: The error summary was truncated to " +
             std::to_string(c_errorSummaryMaxLines) + " (distinct) messages",
             LogConfig::c_Message | LogConfig::c_Level);
  }
  if (m_suppressedMessages) {
    showText(LogConfig::c_Warning, std::to_string(m_suppressedMessages) + " log messages were suppressed",
             LogConfig::c_Message | LogConfig::c_Level);
  }
 
  // and then clear the log
  m_messageLog.clear();
 
  // restore old configuration
  m_logConfig = oldConfig;
  std::swap(m_moduleLogConfig, oldModuleConfig);
  std::swap(m_packageLogConfigs, oldPackageConfig);
}

resetLogConnections()

void resetLogConnections

(

)

Removes all log connections.

Definition at line 44 of file LogSystem.cc.

{
  for (auto connection : m_logConnections) {
    delete connection;
  }
  m_logConnections.clear();
}

resetLogging()

void resetLogging

(

)

Reset logging system to defaults: empty all log messages and reset connections to the default.

Definition at line 180 of file LogSystem.cc.

{
  m_logConfig.setLogLevel(LogConfig::c_Info);
  m_logConfig.setDebugLevel(LogConfig::c_DefaultDebugLevel);
  m_moduleLogConfig = nullptr;
  m_packageLogConfigs.clear();
  constexpr unsigned int logInfo = LogConfig::c_Level + LogConfig::c_Message;
  constexpr unsigned int warnLogInfo = LogConfig::c_Level + LogConfig::c_Message + LogConfig::c_Module;
  constexpr unsigned int debugLogInfo = LogConfig::c_Level + LogConfig::c_Message + LogConfig::c_Module + LogConfig::c_File +
                                        LogConfig::c_Line;
  constexpr unsigned int fatalLogInfo = LogConfig::c_Level + LogConfig::c_Message + LogConfig::c_Module + LogConfig::c_Function;
  m_logConfig.setLogInfo(LogConfig::c_Debug, debugLogInfo);
  m_logConfig.setLogInfo(LogConfig::c_Info, logInfo);
  m_logConfig.setLogInfo(LogConfig::c_Result, logInfo);
  m_logConfig.setLogInfo(LogConfig::c_Warning, warnLogInfo);
  m_logConfig.setLogInfo(LogConfig::c_Error, warnLogInfo);
  m_logConfig.setLogInfo(LogConfig::c_Fatal, fatalLogInfo);
 
  resetMessageCounter();
  resetLogConnections();
  addLogConnection(new LogConnectionFilter(new LogConnectionConsole(STDOUT_FILENO)));
 
  m_printErrorSummary = false;
  s_debugEnabled = false;
}

resetMessageCounter()

void resetMessageCounter

(

)

Resets the message counter and error log by setting all message counts to 0.

Definition at line 150 of file LogSystem.cc.

{
  for (int& i : m_messageCounter) {
    i = 0;
  }
  m_suppressedMessages = 0;
  m_messageLog.clear();
  m_messageLog.reserve(100);
}

sendMessage()

bool sendMessage

(

LogMessage &&

message

)

Sends a log message using the log connection object.

This method should only be called by the logger macros.

Parameters

message

The log message object. The message might be moved into internal storage and is not valid any more after the method call.

Returns

Returns true if the message could be send.

Definition at line 69 of file LogSystem.cc.

{
  LogConfig::ELogLevel logLevel = message.getLogLevel();
  auto packageLogConfig = m_packageLogConfigs.find(message.getPackage());
  if ((packageLogConfig != m_packageLogConfigs.end()) && packageLogConfig->second.getLogInfo(logLevel)) {
    message.setLogInfo(packageLogConfig->second.getLogInfo(logLevel));
  } else if (m_moduleLogConfig && m_moduleLogConfig->getLogInfo(logLevel)) {
    message.setLogInfo(m_moduleLogConfig->getLogInfo(logLevel));
  } else {
    message.setLogInfo(m_logConfig.getLogInfo(logLevel));
  }
 
  message.setModule(m_moduleName);
 
  // We want to count it whether we've seen it or not
  incMessageCounter(logLevel);
 
  // add message to list of message or increase repetition value
  bool lastTime(false);
  unsigned int repetition{0};
  if (m_messageLog.size() >= c_errorSummaryMaxLines) {
    // we already have maximum size of the error log so don't add more messages.
    // but we might want to increase the counter if it already exists
    if (auto it = m_messageLog.find(message); it != m_messageLog.end()) {
      repetition = ++(it->second);
    }
  } else if (logLevel >= LogConfig::c_Warning or m_maxErrorRepetition > 0) {
    // otherwise we only keep warnings or higher unless we suppress repetitions,
    // then we keep everything
    repetition = ++m_messageLog[message];
    message.setCount(repetition);
  }
  lastTime = m_maxErrorRepetition > 0 and repetition == m_maxErrorRepetition;
  if (m_maxErrorRepetition > 0 and repetition > m_maxErrorRepetition) {
    // We've seen this message more than once before so it cannot be an abort
    // level message. So we can just not do anything here except counting ...
    ++m_suppressedMessages;
    // However we should warn from time to time that messages are being
    // suppressed ... but not too often otherwise we don't gain anything so
    // let's warn first each 100, then each 1000 suppressed messages.
    if ((m_suppressedMessages < 1000 and m_suppressedMessages % 100 == 0) or
        (m_suppressedMessages < 10000 and m_suppressedMessages % 1000 == 0) or
        (m_suppressedMessages % 10000 == 0)) {
      showText(LogConfig::c_Warning, "... " + std::to_string(m_suppressedMessages) + " log messages suppressed due to repetition ...");
    }
    return true;
  }
 
  // Ok we want to see the message
  bool messageSent = deliverMessageToConnections(message);
 
  if (logLevel >= m_logConfig.getAbortLevel()) {
    printErrorSummary();
    // make sure loc connections are finalized to not loose output
    for (auto connection : m_logConnections) {
      connection->finalizeOnAbort();
    }
    DataStore::Instance().reset(); // ensure we are executed before ROOT's exit handlers
 
    //in good tradition, ROOT signal handlers are unsafe.
    //this avoids a problem seen in ROOT's atexit() handler, which might crash
    //and then deadlock the process in the SIGSEGV handler...
    signal(SIGSEGV, nullptr);
 
    //ROOT will also try to do this, but doesn't get the order right.
    gROOT->CloseFiles();
    exit(1);
  }
 
  // And if it is the last time we show it let's add a trailer for good measure
  if (messageSent and lastTime) {
    showText(max(message.getLogLevel(), LogConfig::c_Warning),
             "The previous message has occurred " + std::to_string(m_maxErrorRepetition) +
             " times and will be suppressed in future",
             LogConfig::c_Level | LogConfig::c_Message);
  }
 
  return messageSent;
}

setMaxMessageRepetitions()

void setMaxMessageRepetitions ( unsigned  repetitions )

inline

Set maximum number of repetitions before silencing "identical" log messages.

Identity only checks for log level and message content (excluding variables)

Definition at line 167 of file LogSystem.h.

{ m_maxErrorRepetition = repetitions; }

showText()

void showText ( LogConfig::ELogLevel  level, const std::string &  txt, int  info = LogConfig::c_Message  )

private

Send a custom message which looks like a log message but should not be counted as such.

This is used in a few places to emit descriptive messages related to other messages without danger of being suppressed

Definition at line 62 of file LogSystem.cc.

{
  LogMessage customText(level, txt, "", "", "", 0);
  customText.setLogInfo(info);
  deliverMessageToConnections(customText);
}

updateModule()

void updateModule ( const LogConfig *  moduleLogConfig = nullptr, const std::string &  moduleName = ""  )

inline

Sets the log configuration to the given module log configuration and sets the module name This method should only be called by the EventProcessor.

Parameters

moduleLogConfig	Pointer to the logging configuration object of the module. Set to NULL to use the global log configuration.
moduleName	Name of the module.

Definition at line 191 of file LogSystem.h.

{ m_moduleLogConfig = moduleLogConfig; m_moduleName = moduleName; }

Member Data Documentation

c_errorSummaryMaxLines

const unsigned int c_errorSummaryMaxLines = 10000

static

Error log will contain at most this many lines.

Definition at line 48 of file LogSystem.h.

m_logConfig

LogConfig m_logConfig

private

The global log system configuration.

Definition at line 207 of file LogSystem.h.

m_logConnections

std::vector<LogConnectionBase*> m_logConnections

private

Stores the pointers to the log connection objects.

(owned by us)

Definition at line 205 of file LogSystem.h.

m_maxErrorRepetition

unsigned int m_maxErrorRepetition {0}

private

Maximum number to show the same message.

If zero we don't suppress repeated messages

Definition at line 219 of file LogSystem.h.

m_messageCounter

int m_messageCounter[LogConfig::c_Default]

private

Counts the number of messages sent per message level.

Definition at line 223 of file LogSystem.h.

m_messageLog

std::unordered_map<LogMessage, int, LogMessage::TextHasher, LogMessage::TextHasher> m_messageLog {100}

private

Count of previous log messages for the summary and to suppress repetitive messages.

Definition at line 217 of file LogSystem.h.

m_moduleLogConfig

const LogConfig* m_moduleLogConfig

private

log config of current module

Definition at line 209 of file LogSystem.h.

m_moduleName

std::string m_moduleName

private

The current module name.

Definition at line 211 of file LogSystem.h.

m_packageLogConfigs

std::map<std::string, LogConfig> m_packageLogConfigs

private

Stores the log configuration objects for packages.

Definition at line 213 of file LogSystem.h.

m_printErrorSummary

bool m_printErrorSummary

private

Wether to re-print errors-warnings encountered during execution at the end.

Definition at line 215 of file LogSystem.h.

m_suppressedMessages

unsigned int m_suppressedMessages {0}

private

The amount of messages we have suppressed so far just to get an indication we print this from time to time.

Definition at line 221 of file LogSystem.h.

s_debugEnabled

bool s_debugEnabled = false

staticprivate

Global flag for fast checking if debug output is enabled.

Definition at line 225 of file LogSystem.h.

---

The documentation for this class was generated from the following files:

• framework/logging/include/LogSystem.h
• framework/logging/src/LogSystem.cc