LoggedMessageSvc Class Reference

#include <LoggedMessageSvc.h>

Inheritance diagram for LoggedMessageSvc:

Classes
struct	MsgAry
	Private helper class to keep the count of messages of a type (MSG::LEVEL). More...

Public Types
typedef std::pair< std::string, std::ostream * >	NamedStream
typedef std::multimap< int, NamedStream >	StreamMap
typedef std::multimap< StatusCode, Message >	MessageMap
typedef std::map< std::string, int, std::less<> >	ThresholdMap

Public Member Functions
	LoggedMessageSvc (const std::string &name, ISvcLocator *svcloc)
virtual	~LoggedMessageSvc ()
virtual StatusCode	reinitialize () override
	Reinitialize Service.
virtual StatusCode	initialize () override
	Initialize Service.
virtual StatusCode	finalize () override
	Finalize Service.
virtual void	reportMessage (const Message &message) override
virtual void	reportMessage (const Message &msg, int outputLevel) override
virtual void	reportMessage (const StatusCode &code, std::string_view source="") override
virtual void	reportMessage (std::string source, int type, std::string message) override
virtual void	insertMessage (const StatusCode &code, Message message) override
virtual void	eraseMessage () override
virtual void	eraseMessage (const StatusCode &code) override
virtual void	eraseMessage (const StatusCode &code, const Message &message) override
virtual void	insertStream (int message_type, std::string name, std::ostream *stream) override
virtual void	eraseStream () override
virtual void	eraseStream (int message_type) override
virtual void	eraseStream (int message_type, std::ostream *stream) override
virtual void	eraseStream (std::ostream *stream) override
virtual std::ostream *defaultStream	ATLAS_NOT_CONST_THREAD_SAFE () const override
virtual void	setDefaultStream (std::ostream *stream) override
virtual int	outputLevel () const override
virtual int	outputLevel (std::string_view source) const override
virtual void	setOutputLevel (int new_level) override
virtual void	setOutputLevel (std::string_view source, int new_level) override
virtual bool	useColor () const override
virtual std::string	getLogColor (int logLevel) const override
virtual int	messageCount (MSG::Level logLevel) const override
virtual void	incrInactiveCount (MSG::Level level, std::string_view src) override
virtual std::vector< std::pair< std::string, std::string > >	getMessages (MSG::Level level) const override
virtual std::vector< LoggedMessage >	getKeyMessages () const override

Private Types
typedef std::map< std::string, MSG::Color >	ColorMap
typedef std::map< std::string, std::ostream * >	LoggedStreamsMap_t

Private Member Functions
std::string	colTrans (const std::string &, int)
void	initColors (Gaudi::Details::PropertyBase &prop)
void	setupColors (Gaudi::Details::PropertyBase &prop)
void	setupLimits (Gaudi::Details::PropertyBase &prop)
void	setupThreshold (Gaudi::Details::PropertyBase &prop)
void	setupInactCount (Gaudi::Details::PropertyBase &prop)
void	setupLogStreams ()
void	tee (const std::string &sourceName, const std::string &logFileName, const std::set< std::string > &declaredOutFileNames)

Private Attributes
std::ostream *	m_defaultStream
	Pointer to the output stream.
Message	m_defaultMessage
	Default Message.
StreamMap	m_streamMap
	Stream map.
MessageMap	m_messageMap
	Message map.
ThresholdMap	m_thresholdMap
	Output level threshold map.
std::string	m_defaultFormat
	Default format for the messages.
std::string	m_defaultTimeFormat
	Default format for timestamps in the messages.
StringArrayProperty	m_thresholdProp [MSG::NUM_LEVELS]
	Properties controling.
BooleanProperty	m_color
BooleanProperty	m_stats
UnsignedIntegerProperty	m_statLevel
StringArrayProperty	m_logColors [MSG::NUM_LEVELS]
IntegerProperty	m_msgLimit [MSG::NUM_LEVELS]
IntegerProperty	m_logLevel
StringArrayProperty	m_keywords
std::string	m_logColorCodes [MSG::NUM_LEVELS]
std::map< std::string, MsgAry, std::less<> >	m_sourceMap
std::map< std::string, MsgAry, std::less<> >	m_inactiveMap
BooleanProperty	m_suppress
BooleanProperty	m_inactCount
ColorMap	m_colMap
int	m_msgCount [MSG::NUM_LEVELS]
std::map< std::string, std::string >	m_loggedStreamsName
LoggedStreamsMap_t	m_loggedStreams
std::mutex	m_reportMutex
	Mutex to synchronize multiple threads printing.
std::recursive_mutex	m_messageMapMutex
	Mutex to synchronize multiple access to m_messageMap.
std::mutex	m_thresholdMapMutex
	Mutex to synchronize multiple access to m_thresholdMap (.
std::vector< std::pair< std::string, std::string > >	m_msgLog [MSG::NUM_LEVELS]
std::vector< LoggedMessage >	m_msgKeyLog
bool	m_keysUsed

Detailed Description

Definition at line 37 of file LoggedMessageSvc.h.

Member Typedef Documentation

ColorMap

typedef std::map<std::string, MSG::Color> LoggedMessageSvc::ColorMap

private

Definition at line 169 of file LoggedMessageSvc.h.

LoggedStreamsMap_t

typedef std::map<std::string, std::ostream*> LoggedMessageSvc::LoggedStreamsMap_t

private

Definition at line 175 of file LoggedMessageSvc.h.

MessageMap

typedef std::multimap< StatusCode, Message > LoggedMessageSvc::MessageMap

Definition at line 43 of file LoggedMessageSvc.h.

NamedStream

typedef std::pair< std::string, std::ostream* > LoggedMessageSvc::NamedStream

Definition at line 41 of file LoggedMessageSvc.h.

StreamMap

typedef std::multimap< int, NamedStream > LoggedMessageSvc::StreamMap

Definition at line 42 of file LoggedMessageSvc.h.

ThresholdMap

typedef std::map< std::string, int, std::less<> > LoggedMessageSvc::ThresholdMap

Definition at line 44 of file LoggedMessageSvc.h.

Constructor & Destructor Documentation

LoggedMessageSvc()

LoggedMessageSvc::LoggedMessageSvc	(	const std::string &	name,
		ISvcLocator *	svcloc )

Definition at line 23 of file LoggedMessageSvc.cxx.

  : base_class( name, svcloc ), m_keysUsed(false)
 {
  m_defaultStream = &std::cout;
  m_outputLevel   = MSG::INFO;
  declareProperty( "Format",      m_defaultFormat = Message::getDefaultFormat() );
  declareProperty( "timeFormat",  m_defaultTimeFormat = Message::getDefaultTimeFormat() );
  declareProperty( "showStats",   m_stats = false );
  declareProperty( "statLevel",   m_statLevel = 0 );
 
  // Special properties to control output level of individual sources
  declareProperty( "setVerbose",  m_thresholdProp[MSG::VERBOSE] );
  declareProperty( "setDebug",    m_thresholdProp[MSG::DEBUG] );
  declareProperty( "setInfo",     m_thresholdProp[MSG::INFO] );
  declareProperty( "setWarning",  m_thresholdProp[MSG::WARNING] );
  declareProperty( "setError",    m_thresholdProp[MSG::ERROR] );
  declareProperty( "setFatal",    m_thresholdProp[MSG::FATAL] );
  declareProperty( "setAlways",   m_thresholdProp[MSG::ALWAYS] );
 
  declareProperty( "useColors",        m_color=false);
  m_color.declareUpdateHandler(&LoggedMessageSvc::initColors, this);
 
  declareProperty( "fatalColorCode",   m_logColors[MSG::FATAL] );
  declareProperty( "errorColorCode",   m_logColors[MSG::ERROR] );
  declareProperty( "warningColorCode", m_logColors[MSG::WARNING] );
  declareProperty( "infoColorCode",    m_logColors[MSG::INFO] );
  declareProperty( "debugColorCode",   m_logColors[MSG::DEBUG] );
  declareProperty( "verboseColorCode", m_logColors[MSG::VERBOSE] );
  declareProperty( "alwaysColorCode",  m_logColors[MSG::ALWAYS] );
 
  const int defaultLimit = 500;
  declareProperty( "fatalLimit",    m_msgLimit[MSG::FATAL]   = defaultLimit );
  declareProperty( "errorLimit",    m_msgLimit[MSG::ERROR]   = defaultLimit );
  declareProperty( "warningLimit",  m_msgLimit[MSG::WARNING] = defaultLimit );
  declareProperty( "infoLimit",     m_msgLimit[MSG::INFO]    = defaultLimit );
  declareProperty( "debugLimit",    m_msgLimit[MSG::DEBUG]   = defaultLimit );
  declareProperty( "verboseLimit",  m_msgLimit[MSG::VERBOSE] = defaultLimit );
  declareProperty( "alwaysLimit",   m_msgLimit[MSG::ALWAYS]  = 0 );
 
  declareProperty( "defaultLimit",  m_msgLimit[MSG::NIL]     = defaultLimit );
 
  declareProperty( "enableSuppression", m_suppress = false );
  declareProperty( "countInactive", m_inactCount = false )->declareUpdateHandler( &LoggedMessageSvc::setupInactCount, this );
#ifndef NDEBUG
  // initialize the MsgStream static flag.
  MsgStream::enableCountInactive(m_inactCount);
#endif
 
  declareProperty( "loggingLevel", m_logLevel = MSG::FATAL, "Message level above which all messages are saved" );
  m_logLevel.declareUpdateHandler(&LoggedMessageSvc::setupThreshold, this);
 
  declareProperty( "keywords", m_keywords, "keywords to scan messages for and save");
  m_keywords.declareUpdateHandler(&LoggedMessageSvc::setupThreshold, this);
 
  declareProperty( "loggedStreams",
                   m_loggedStreamsName,
                   "MessageStream sources we want to dump into a logfile" );
 
  for (int ic=0; ic<MSG::NUM_LEVELS; ++ic) {
    m_logColors[ic].declareUpdateHandler(&LoggedMessageSvc::setupColors, this);
    m_msgLimit[ic].declareUpdateHandler(&LoggedMessageSvc::setupLimits, this);
    m_thresholdProp[ic].declareUpdateHandler(&LoggedMessageSvc::setupThreshold, this);
  }
 
  for (int i=0; i<MSG::NUM_LEVELS; ++i) {
      m_msgCount[i] = 0;
  }
 
}

~LoggedMessageSvc()

LoggedMessageSvc::~LoggedMessageSvc ( )

virtual

Definition at line 95 of file LoggedMessageSvc.cxx.

{
  // closing log-files, if any
  LoggedStreamsMap_t::iterator iStream   = m_loggedStreams.begin();
  LoggedStreamsMap_t::iterator endStream = m_loggedStreams.end();
  for ( ; iStream != endStream; ++iStream ) {
    delete iStream->second;
    iStream->second = nullptr;
  }
}

Member Function Documentation

ATLAS_NOT_CONST_THREAD_SAFE()

virtual std::ostream *defaultStream LoggedMessageSvc::ATLAS_NOT_CONST_THREAD_SAFE ( ) const

inlineoverridevirtual

Definition at line 98 of file LoggedMessageSvc.h.

                                                                                  {
    std::lock_guard<std::mutex> lock(m_reportMutex);
    return m_defaultStream;
  }

colTrans()

std::string LoggedMessageSvc::colTrans ( const std::string & col, int offset )

private

Definition at line 446 of file LoggedMessageSvc.cxx.

                                                                     {
  ColorMap::const_iterator itr = m_colMap.find(col);
  int icol;
  if (itr != m_colMap.end()) {
    icol = offset + itr->second;
  } else {
    icol = offset + 8;
  }
  return std::to_string (icol);
 
}

eraseMessage() [1/3]

void LoggedMessageSvc::eraseMessage ( )

overridevirtual

Definition at line 726 of file LoggedMessageSvc.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
 
  m_messageMap.erase( m_messageMap.begin(), m_messageMap.end() );
}

eraseMessage() [2/3]

void LoggedMessageSvc::eraseMessage ( const StatusCode & code )

overridevirtual

Definition at line 740 of file LoggedMessageSvc.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
 
  m_messageMap.erase( key );
}

eraseMessage() [3/3]

void LoggedMessageSvc::eraseMessage ( const StatusCode & code, const Message & message )

overridevirtual

Definition at line 754 of file LoggedMessageSvc.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
 
  bool changed = true;
  while( changed ) {
    changed = false;
    MessageMap::iterator first = m_messageMap.lower_bound( key );
    MessageMap::iterator last = m_messageMap.upper_bound( key );
    while( first != last ) {
      const Message& message = (*first).second;
      if ( message == msg ) {
        m_messageMap.erase( first );
        changed = true;
        break;
      }
    }
  }
}

eraseStream() [1/4]

void LoggedMessageSvc::eraseStream ( )

overridevirtual

Definition at line 638 of file LoggedMessageSvc.cxx.

{
  m_streamMap.erase( m_streamMap.begin(), m_streamMap.end() );
}

eraseStream() [2/4]

void LoggedMessageSvc::eraseStream ( int message_type )

overridevirtual

Definition at line 650 of file LoggedMessageSvc.cxx.

{
  m_streamMap.erase( message_type );
}

eraseStream() [3/4]

void LoggedMessageSvc::eraseStream ( int message_type, std::ostream * stream )

overridevirtual

Definition at line 662 of file LoggedMessageSvc.cxx.

                                                                  {
  if ( nullptr != stream )    {
    bool changed = true;
    while( changed ) {
      changed = false;
      StreamMap::iterator first = m_streamMap.lower_bound( key );
      StreamMap::iterator last = m_streamMap.upper_bound( key );
      while( first != last ) {
        if ( (*first).second.second == stream ) {
          m_streamMap.erase( first );
          changed = true;
          break;
        }
      }
    }
  }
}

eraseStream() [4/4]

void LoggedMessageSvc::eraseStream ( std::ostream * stream )

overridevirtual

Definition at line 687 of file LoggedMessageSvc.cxx.

                                                          {
  if ( nullptr != stream )    {
    bool changed = true;
    while( changed ) {
      changed = false;
      StreamMap::iterator first = m_streamMap.begin();
      while( first != m_streamMap.end() ) {
        if ( (*first).second.second == stream ) {
          m_streamMap.erase( first );
          changed = true;
          break;
        }
      }
    }
  }
}

finalize()

StatusCode LoggedMessageSvc::finalize ( )

overridevirtual

Finalize Service.

Definition at line 347 of file LoggedMessageSvc.cxx.

                                      {
 
  m_suppress = false;
 
#define PR(FMT, ...) std::println(os, FMT __VA_OPT__(,) __VA_ARGS__)
 
  {
    std::ostringstream os;
 
    if (m_stats) {
      PR ("Summarizing all message counts");
    } else {
      PR ("Listing sources of suppressed message: ");
    }
 
    PR ("=====================================================");
    PR (" Message Source              |   Level |    Count");
    PR ("-----------------------------+---------+-------------");
 
 
    bool found(false);
 
    std::lock_guard<std::mutex> lock(m_reportMutex);
    std::map<std::string,MsgAry>::const_iterator itr;
    for (itr=m_sourceMap.begin(); itr!=m_sourceMap.end(); ++itr) {
      for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
        if ( (itr->second.msg[ic] >= m_msgLimit[ic] && m_msgLimit[ic] != 0 ) ||
             (m_stats && itr->second.msg[ic] > 0 && ic >= m_statLevel.value()) ) {
          PR (" {:<28}|{:>8}|{:>9}",
              itr->first, levelNames[ic], itr->second.msg[ic]);
 
            found = true;
        }
      }
    }
    PR ("=====================================================");
 
    if (found || m_stats) {
      cout << os.str();
    }
  }
 
 
#ifndef NDEBUG
  if (m_inactCount.value()) {
 
    std::ostringstream os;
    PR ("Listing sources of Unprotected and Unseen messages");
 
    bool found(false);
 
    unsigned int ml(0);
    std::map<std::string,MsgAry>::const_iterator itr;
    for (itr=m_inactiveMap.begin(); itr!=m_inactiveMap.end(); ++itr) {
      for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
    if (itr->second.msg[ic] != 0) {
      if (itr->first.length() > ml) { ml = itr->first.length(); }
    }
      }
    }
 
    for (unsigned int i=0; i<ml+25; ++i) {
      os << "=";
    }
 
    PR("");
    PR(" {:<{}}|   Level |    Count", "MessageSource", ml+2);
 
    for (unsigned int i=0; i<ml+3; ++i) {
      os << "-";
    }
    PR ("+---------+-----------");
 
 
    for (itr=m_inactiveMap.begin(); itr!=m_inactiveMap.end(); ++itr) {
      for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
    if (itr->second.msg[ic] != 0) {
          PR (" {:<{}}|{:>8}|{:>9}",
              itr->first, ml+2, levelNames[ic], itr->second.msg[ic]);
      found = true;
    }
      }
    }
    for (unsigned int i=0; i<ml+25; ++i) {
      os << "=";
    }
    PR("");
 
    if (found) {
      cout << os.str();
    }
  }
#endif
#undef PR
 
  return StatusCode::SUCCESS;
}

getKeyMessages()

auto LoggedMessageSvc::getKeyMessages ( ) const

overridevirtual

Definition at line 929 of file LoggedMessageSvc.cxx.

{
  std::lock_guard<std::mutex> lock(m_reportMutex);
  return m_msgKeyLog;
}

getLogColor()

std::string LoggedMessageSvc::getLogColor ( int logLevel ) const

overridevirtual

Definition at line 810 of file LoggedMessageSvc.cxx.

                                                            {
// ---------------------------------------------------------------------------
  if (logLevel < MSG::NUM_LEVELS) {
    return m_logColorCodes[logLevel];
  } else {
    return "";
  }
}

getMessages()

std::vector< std::pair< std::string, std::string > > LoggedMessageSvc::getMessages ( MSG::Level level ) const

overridevirtual

Definition at line 922 of file LoggedMessageSvc.cxx.

{
  std::lock_guard<std::mutex> lock(m_reportMutex);
  return m_msgLog[ level ];
}

incrInactiveCount()

void LoggedMessageSvc::incrInactiveCount ( MSG::Level level, std::string_view src )

overridevirtual

Definition at line 828 of file LoggedMessageSvc.cxx.

                                                                         {
 
  auto entry = m_inactiveMap.find( source );
  if ( entry == m_inactiveMap.end() ) {
    entry = m_inactiveMap.emplace( source, MsgAry{} ).first;
  }
  ++entry->second.msg[level];
}

initColors()

void LoggedMessageSvc::initColors ( Gaudi::Details::PropertyBase & prop )

private

Definition at line 151 of file LoggedMessageSvc.cxx.

                                                             {
 
  if (m_color == true) {
 
    if (m_logColors[MSG::FATAL].value().size() == 0) {
      vector<string> fatDef;
      fatDef.push_back( "[94;101;1m" );
      m_logColors[MSG::FATAL].set( fatDef );
    } else {
      LoggedMessageSvc::setupColors( m_logColors[MSG::FATAL] );
    }
 
    if (m_logColors[MSG::ERROR].value().size() == 0) {
      vector<string> errDef;
      errDef.push_back( "[97;101;1m" );
      m_logColors[MSG::ERROR].set( errDef );
    } else {
      LoggedMessageSvc::setupColors( m_logColors[MSG::ERROR] );
    }
 
    if (m_logColors[MSG::WARNING].value().size() == 0) {
      vector<string> warDef;
      warDef.push_back( "[93;1m" );
      m_logColors[MSG::WARNING].set( warDef );
    } else {
      LoggedMessageSvc::setupColors( m_logColors[MSG::WARNING] );
    }
 
  } else {
 
    // reset all color codes;
    for (int ic=0; ic<MSG::NUM_LEVELS; ++ic) {
      vector<string> def;
      m_logColors[ic].set( def );
    }
 
  }
 
}

initialize()

StatusCode LoggedMessageSvc::initialize ( )

overridevirtual

Initialize Service.

Definition at line 109 of file LoggedMessageSvc.cxx.

                                        {
  StatusCode sc;
  sc = base_class::initialize();
  if( sc.isFailure() ) return sc;
  // hack since in Gaudi v30, msgSvc() now returns a const SmartIF<IMessageSvc>
  // Release pointer to myself done in Service base class
  SmartIF<IMessageSvc> &si ATLAS_THREAD_SAFE = const_cast<SmartIF<IMessageSvc>&> (msgSvc());
  si.reset();
 
#ifdef _WIN32
  m_color = false;
#endif
 
  m_colMap["black"]  = MSG::BLACK;
  m_colMap["red"]    = MSG::RED;
  m_colMap["green"]  = MSG::GREEN;
  m_colMap["yellow"] = MSG::YELLOW;
  m_colMap["blue"]   = MSG::BLUE;
  m_colMap["purple"] = MSG::PURPLE;
  m_colMap["cyan"]   = MSG::CYAN;
  m_colMap["white"]  = MSG::WHITE;
 
  // make sure the map of logged stream names is initialized
  setupLogStreams();
 
  if (m_keywords.value().size() > 0) {
    m_keysUsed = true;
  }
 
  return StatusCode::SUCCESS;
}

insertMessage()

void LoggedMessageSvc::insertMessage ( const StatusCode & code, Message message )

overridevirtual

Definition at line 712 of file LoggedMessageSvc.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
 
  m_messageMap.emplace( key, std::move( msg ) );
}

insertStream()

void LoggedMessageSvc::insertStream ( int message_type, std::string name, std::ostream * stream )

overridevirtual

Definition at line 623 of file LoggedMessageSvc.cxx.

{
  typedef StreamMap::value_type value_type;
  m_streamMap.insert( value_type( key, NamedStream( std::move(name), stream) ) );
}

messageCount()

int LoggedMessageSvc::messageCount ( MSG::Level logLevel ) const

overridevirtual

Definition at line 820 of file LoggedMessageSvc.cxx.

                                                          {
 
  return m_msgCount[level];
 
}

outputLevel() [1/2]

int LoggedMessageSvc::outputLevel ( ) const

overridevirtual

Definition at line 775 of file LoggedMessageSvc.cxx.

                                          {
// ---------------------------------------------------------------------------
  return m_outputLevel;
}

outputLevel() [2/2]

int LoggedMessageSvc::outputLevel ( std::string_view source ) const

overridevirtual

Definition at line 780 of file LoggedMessageSvc.cxx.

                                                                 {
// ---------------------------------------------------------------------------
  std::lock_guard<std::mutex> lock(m_thresholdMapMutex);
 
  auto it   = m_thresholdMap.find( source );
  return it != m_thresholdMap.end() ? it->second : m_outputLevel.value();
}

reinitialize()

StatusCode LoggedMessageSvc::reinitialize ( )

overridevirtual

Reinitialize Service.

Definition at line 144 of file LoggedMessageSvc.cxx.

                                          {
  m_state = Gaudi::StateMachine::OFFLINE;
  return initialize();
}

reportMessage() [1/4]

void LoggedMessageSvc::reportMessage ( const Message & message )

overridevirtual

Definition at line 562 of file LoggedMessageSvc.cxx.

                                                            {
  reportMessage(msg, outputLevel(msg.getSource()));
}

reportMessage() [2/4]

void LoggedMessageSvc::reportMessage ( const Message & msg, int outputLevel )

overridevirtual

Definition at line 465 of file LoggedMessageSvc.cxx.

                                                                             {
  std::lock_guard<std::mutex> lock(m_reportMutex);
 
  int key = msg.getType();
  int nmsg;
 
  m_msgCount[key] ++;
 
  if (outputLevel >= m_logLevel) {
    m_msgLog[ outputLevel ].push_back( make_pair (msg.getSource(), msg.getMessage() ) );
  }
 
  if (m_keysUsed) {
    if (msg.getSource() != "AthenaSummarySvc") {
      for (vector<string>::const_iterator itr=m_keywords.value().begin(); itr!= m_keywords.value().end(); ++itr) {
    if (msg.getMessage().find( *itr ) != string::npos) {
      m_msgKeyLog.push_back( LoggedMessage( outputLevel, msg.getSource(), msg.getMessage() ));
      break;
    }
      }
    }
  }
 
  const Message *cmsg = &msg;
  std::unique_ptr<Message> suppressed_msg;
 
  // processing logged streams
  if ( !m_loggedStreams.empty() ) {
    const LoggedStreamsMap_t::iterator iLog = m_loggedStreams.find( msg.getSource() );
    if ( m_loggedStreams.end() != iLog ) {
      (*iLog->second) << *cmsg << std::endl;
    }
  }
 
  if ( m_suppress.value() || m_stats.value() ) {
 
    std::map<std::string,MsgAry>::iterator itr =
      m_sourceMap.find(msg.getSource());
    if (itr != m_sourceMap.end()) {
      itr->second.msg[key] += 1;
      nmsg = itr->second.msg[key];
    } else {
      MsgAry A;
      for (int i=0; i<MSG::NUM_LEVELS; ++i) {
        A.msg[i] = 0;
      }
      A.msg[key] = 1;
      m_sourceMap[msg.getSource()] = A;
      nmsg = 1;
    }
 
    if (m_suppress.value()) {
 
      if ( m_msgLimit[key] != 0 ) {
        if (nmsg == m_msgLimit[key]) {
          std::string str = levelNames[key] + " message limit (";
          str += std::to_string( m_msgLimit[key].value() );
          str += ") reached for ";
          str += msg.getSource() + ". Suppressing further output.";
          suppressed_msg = std::make_unique<Message>(msg.getSource(),MSG::WARNING,str);
          suppressed_msg->setFormat(msg.getFormat());
          cmsg = suppressed_msg.get();
        } else if (nmsg > m_msgLimit[key]) {
          return;
        }
      }
    }
 
  }
 
  StreamMap::const_iterator first = m_streamMap.lower_bound( key );
  if ( first != m_streamMap.end() ) {
    StreamMap::const_iterator last = m_streamMap.upper_bound( key );
    while( first != last ) {
      std::ostream& stream = *( (*first).second.second );
      stream << *cmsg << std::endl;
      ++first;
    }
  }
  else if ( key >= outputLevel )   {
    msg.setFormat(m_defaultFormat);
    msg.setTimeFormat(m_defaultTimeFormat);
    if (!m_color) {
      (*m_defaultStream) << *cmsg << std::endl << std::flush;
    } else {
      (*m_defaultStream) <<  m_logColorCodes[key] << *cmsg << "\033[m"
                         << std::endl << std::flush;
    }
  }
}

reportMessage() [3/4]

void LoggedMessageSvc::reportMessage ( const StatusCode & code, std::string_view source = "" )

overridevirtual

Definition at line 586 of file LoggedMessageSvc.cxx.

{
  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
 
  MessageMap::const_iterator first = m_messageMap.lower_bound( key );
  if ( first != m_messageMap.end() ) {
    MessageMap::const_iterator last = m_messageMap.upper_bound( key );
    while( first != last ) {
      Message msg = (*first).second;
      msg.setSource( source );
      std::ostringstream os1;
      os1 << "Status Code " << key.getCode() << std::ends;
      Message stat_code1( std::string{source}, msg.getType(), os1.str() );
      reportMessage( stat_code1 );
      reportMessage( msg );
      ++first;
    }
  }
  else {
    Message mesg = m_defaultMessage;
    mesg.setSource( source );
      std::ostringstream os2;
    os2 << "Status Code " << key.getCode() << std::ends;
    Message stat_code2( std::string{source},  mesg.getType(), os2.str() );
    reportMessage( stat_code2 );
    reportMessage( mesg );
  }
}

reportMessage() [4/4]

void LoggedMessageSvc::reportMessage ( std::string source, int type, std::string message )

overridevirtual

Definition at line 572 of file LoggedMessageSvc.cxx.

                                                         {
  Message msg( std::move(source), type, std::move(message));
  reportMessage( msg );
}

setDefaultStream()

virtual void LoggedMessageSvc::setDefaultStream ( std::ostream * stream )

inlineoverridevirtual

Definition at line 104 of file LoggedMessageSvc.h.

                                                               {
    std::lock_guard<std::mutex> lock(m_reportMutex);
    m_defaultStream = stream;
  }

setOutputLevel() [1/2]

void LoggedMessageSvc::setOutputLevel ( int new_level )

overridevirtual

Definition at line 789 of file LoggedMessageSvc.cxx.

                                                      {
// ---------------------------------------------------------------------------
  m_outputLevel = new_level;
}

setOutputLevel() [2/2]

void LoggedMessageSvc::setOutputLevel ( std::string_view source, int new_level )

overridevirtual

Definition at line 795 of file LoggedMessageSvc.cxx.

                                                                         {
// ---------------------------------------------------------------------------
  std::lock_guard<std::mutex> lock(m_thresholdMapMutex);
 
  // only write if we really have to...
  auto i = m_thresholdMap.find( source );
  if ( i == m_thresholdMap.end() ) {
    m_thresholdMap.emplace( source, level );
  } else if ( i->second != level ) {
    i->second = level;
  }
 
}

setupColors()

void LoggedMessageSvc::setupColors ( Gaudi::Details::PropertyBase & prop )

private

Definition at line 193 of file LoggedMessageSvc.cxx.

                                                                 {
 
  if (! m_color) return;
 
  int ic;
  if (prop.name() == "fatalColorCode") {
    ic = MSG::FATAL;
  } else if (prop.name() == "errorColorCode") {
    ic = MSG::ERROR;
  } else if (prop.name() == "warningColorCode") {
    ic = MSG::WARNING;
  } else if (prop.name() == "infoColorCode") {
    ic = MSG::INFO;
  } else if (prop.name() == "debugColorCode") {
    ic = MSG::DEBUG;
  } else if (prop.name() == "verboseColorCode") {
    ic = MSG::VERBOSE;
  } else if (prop.name() == "alwaysColorCode") {
    ic = MSG::ALWAYS;
  } else {
    std::println ("ERROR: Unknown message color parameter: {}", prop.name());
    return;
  }
 
  string code;
  vector<string>::const_iterator itr;
  itr = m_logColors[ic].value().begin();
 
  if ( m_logColors[ic].value().size() == 1 ) {
 
    if (itr->empty() ) {
      code = "";
    } else if ((*itr)[0] == '[') {
      code = "\033" + *itr;
    } else {
      code = "\033[" + colTrans(*itr, 90) + ";1m";
    }
 
  } else if (m_logColors[ic].value().size() == 2) {
    vector<string>::const_iterator itr2 = itr + 1;
 
    code =  "\033[" + colTrans(*itr, 90) + ";"
      + colTrans(*itr2, 100) + ";1m";
 
  }
 
  m_logColorCodes[ic] = std::move(code);
 
}

setupInactCount()

void LoggedMessageSvc::setupInactCount ( Gaudi::Details::PropertyBase & prop )

private

Definition at line 335 of file LoggedMessageSvc.cxx.

                                                                     {
  if (prop.name() == "countInactive") {
#ifndef NDEBUG
    BooleanProperty *p = dynamic_cast<BooleanProperty*>(&prop);
    if (p)
      MsgStream::enableCountInactive(p->value());
#endif
  }
}

setupLimits()

void LoggedMessageSvc::setupLimits ( Gaudi::Details::PropertyBase & prop )

private

Definition at line 244 of file LoggedMessageSvc.cxx.

                                                                 {
 
  //int ic = 0;
  if (prop.name() == "fatalLimit") {
    //ic = MSG::FATAL;
  } else if (prop.name() == "errorLimit") {
    //ic = MSG::ERROR;
  } else if (prop.name() == "warningLimit") {
    //ic = MSG::WARNING;
  } else if (prop.name() == "infoLimit") {
    //ic = MSG::INFO;
  } else if (prop.name() == "debugLimit") {
    //ic = MSG::DEBUG;
  } else if (prop.name() == "verboseLimit") {
    //ic = MSG::VERBOSE;
  } else if (prop.name() == "alwaysLimit") {
    IntegerProperty *p = dynamic_cast<IntegerProperty*>(&prop);
    if (p && p->value() != 0) {
      std::println ("LoggedMessageSvc ERROR: cannot suppress ALWAYS messages");
      p->setValue(0);
    }
    //ic = MSG::ALWAYS;
  } else if (prop.name() == "defaultLimit") {
    for (int i = MSG::VERBOSE; i< MSG::NUM_LEVELS; ++i) {
      if (i != MSG::ALWAYS) {
        m_msgLimit[i] = m_msgLimit[MSG::NIL].value();
      }
    }
  } else {
    std::println ("LoggedMessageSvc ERROR: Unknown message limit parameter: {}",
                  prop.name());
    return;
  }
 
}

setupLogStreams()

void LoggedMessageSvc::setupLogStreams ( )

private

Definition at line 838 of file LoggedMessageSvc.cxx.

{
  // reset state
  for ( LoggedStreamsMap_t::iterator iLog = m_loggedStreams.begin();
        iLog != m_loggedStreams.end();
        ++iLog ) {
    delete iLog->second;
  }
  m_loggedStreams.clear();
 
  typedef std::map<std::string,std::string> StreamMap_t;
  const StreamMap_t& streamMap = m_loggedStreamsName;
  typedef StreamMap_t::const_iterator StreamMapIter;
 
  for ( StreamMapIter iProp = streamMap.begin(), iEnd = streamMap.end();
        iProp != iEnd;
        ++iProp ) {
 
    const std::string sourceName  = iProp->first;
    const std::string outFileName = iProp->second;
 
    std::set<std::string> outFileNames;
    for ( StreamMapIter jProp = streamMap.begin();
          jProp != iEnd;
          ++jProp ) {
      if ( jProp->first != iProp->first ) {
        outFileNames.insert( jProp->second );
      }
    }
 
    tee( sourceName, outFileName, outFileNames );
 
  }//> loop over property entries
 
  return;
}

setupThreshold()

void LoggedMessageSvc::setupThreshold ( Gaudi::Details::PropertyBase & prop )

private

Definition at line 281 of file LoggedMessageSvc.cxx.

                                                                    {
 
  int ic = 0;
  if (prop.name() == "setFatal") {
    ic = MSG::FATAL;
  } else if (prop.name() == "setError") {
    ic = MSG::ERROR;
  } else if (prop.name() == "setWarning") {
    ic = MSG::WARNING;
  } else if (prop.name() == "setInfo") {
    ic = MSG::INFO;
  } else if (prop.name() == "setDebug") {
    ic = MSG::DEBUG;
  } else if (prop.name() == "setVerbose") {
    ic = MSG::VERBOSE;
  } else if (prop.name() == "setAlways") {
    ic = MSG::ALWAYS;
  } else if (prop.name() == "loggingLevel") {
    IntegerProperty *iap = dynamic_cast<IntegerProperty*>( &prop );
    if (iap)
      m_logLevel = iap->value();
    return;
  } else if (prop.name() == "keywords") {
    StringArrayProperty *sap = dynamic_cast<StringArrayProperty*>( &prop );
    if (sap!= nullptr && sap->value().size() > 0) {
      m_keysUsed = true;
    } else {
      m_keysUsed = false;
    }
    return;
  } else {
    std::println (cerr, "LoggedMessageSvc ERROR: Unknown message theshold parameter: {}",
                  prop.name());
    return;
  }
 
  StringArrayProperty *sap = dynamic_cast<StringArrayProperty*>( &prop);
  if (sap == nullptr) {
    std::println (std::cerr, "could not dcast {} to a StringArrayProperty (which it should be!)",
                  prop.name());
    return;
  } else {
    std::vector<std::string>::const_iterator itr;
    for ( itr =  sap->value().begin();
          itr != sap->value().end();
          ++itr) {
      setOutputLevel( *itr, ic );
    }
  }
 
}

tee()

void LoggedMessageSvc::tee ( const std::string & sourceName, const std::string & logFileName, const std::set< std::string > & declaredOutFileNames )

private

Definition at line 876 of file LoggedMessageSvc.cxx.

{
  const std::ios_base::openmode openMode = std::ios_base::out |
                                           std::ios_base::trunc;
 
  LoggedStreamsMap_t::iterator iEnd    = m_loggedStreams.end();
  LoggedStreamsMap_t::iterator iStream = m_loggedStreams.find( sourceName );
  if ( iStream != iEnd ) {
    delete iStream->second;
    iStream->second = nullptr;
    m_loggedStreams.erase( iStream );
  }
 
  // before creating a new ofstream, make sure there is no already existing
  // one with the same file name...
  iEnd = m_loggedStreams.end();
  for ( iStream = m_loggedStreams.begin(); iStream != iEnd; ++iStream ) {
    if ( outFileNames.find( outFileName ) != outFileNames.end() ) {
      m_loggedStreams[sourceName] = m_loggedStreams[iStream->first];
      return;
    }
  }
 
  std::ofstream * out =  new std::ofstream( outFileName.c_str(), openMode );
 
  if ( !out->good() ) {
    out->close();
    delete out;
    return;
  }
 
  m_loggedStreams[sourceName] = out;
 
  return;
}

useColor()

virtual bool LoggedMessageSvc::useColor ( ) const

inlineoverridevirtual

Definition at line 122 of file LoggedMessageSvc.h.

{ return m_color; }

Member Data Documentation

m_colMap

ColorMap LoggedMessageSvc::m_colMap

private

Definition at line 170 of file LoggedMessageSvc.h.

m_color

BooleanProperty LoggedMessageSvc::m_color

private

Definition at line 147 of file LoggedMessageSvc.h.

m_defaultFormat

std::string LoggedMessageSvc::m_defaultFormat

private

Default format for the messages.

Definition at line 144 of file LoggedMessageSvc.h.

m_defaultMessage

Message LoggedMessageSvc::m_defaultMessage

private

Default Message.

Definition at line 140 of file LoggedMessageSvc.h.

m_defaultStream

std::ostream* LoggedMessageSvc::m_defaultStream

private

Pointer to the output stream.

Definition at line 139 of file LoggedMessageSvc.h.

m_defaultTimeFormat

std::string LoggedMessageSvc::m_defaultTimeFormat

private

Default format for timestamps in the messages.

Definition at line 145 of file LoggedMessageSvc.h.

m_inactCount

BooleanProperty LoggedMessageSvc::m_inactCount

private

Definition at line 166 of file LoggedMessageSvc.h.

m_inactiveMap

std::map<std::string, MsgAry, std::less<> > LoggedMessageSvc::m_inactiveMap

private

Definition at line 165 of file LoggedMessageSvc.h.

m_keysUsed

bool LoggedMessageSvc::m_keysUsed

private

Definition at line 201 of file LoggedMessageSvc.h.

m_keywords

StringArrayProperty LoggedMessageSvc::m_keywords

private

Definition at line 153 of file LoggedMessageSvc.h.

m_logColorCodes

std::string LoggedMessageSvc::m_logColorCodes[MSG::NUM_LEVELS]

private

Definition at line 155 of file LoggedMessageSvc.h.

m_logColors

StringArrayProperty LoggedMessageSvc::m_logColors[MSG::NUM_LEVELS]

private

Definition at line 150 of file LoggedMessageSvc.h.

m_loggedStreams

LoggedStreamsMap_t LoggedMessageSvc::m_loggedStreams

private

Definition at line 176 of file LoggedMessageSvc.h.

m_loggedStreamsName

std::map<std::string, std::string> LoggedMessageSvc::m_loggedStreamsName

private

Definition at line 174 of file LoggedMessageSvc.h.

m_logLevel

IntegerProperty LoggedMessageSvc::m_logLevel

private

Definition at line 152 of file LoggedMessageSvc.h.

m_messageMap

MessageMap LoggedMessageSvc::m_messageMap

private

Message map.

Definition at line 142 of file LoggedMessageSvc.h.

m_messageMapMutex

std::recursive_mutex LoggedMessageSvc::m_messageMapMutex

mutableprivate

Mutex to synchronize multiple access to m_messageMap.

Definition at line 193 of file LoggedMessageSvc.h.

m_msgCount

int LoggedMessageSvc::m_msgCount[MSG::NUM_LEVELS]

private

Definition at line 172 of file LoggedMessageSvc.h.

m_msgKeyLog

std::vector< LoggedMessage > LoggedMessageSvc::m_msgKeyLog

private

Definition at line 200 of file LoggedMessageSvc.h.

m_msgLimit

IntegerProperty LoggedMessageSvc::m_msgLimit[MSG::NUM_LEVELS]

private

Definition at line 151 of file LoggedMessageSvc.h.

m_msgLog

std::vector< std::pair<std::string, std::string> > LoggedMessageSvc::m_msgLog[MSG::NUM_LEVELS]

private

Definition at line 199 of file LoggedMessageSvc.h.

m_reportMutex

std::mutex LoggedMessageSvc::m_reportMutex

mutableprivate

Mutex to synchronize multiple threads printing.

Definition at line 190 of file LoggedMessageSvc.h.

m_sourceMap

std::map<std::string, MsgAry, std::less<> > LoggedMessageSvc::m_sourceMap

private

Definition at line 165 of file LoggedMessageSvc.h.

m_statLevel

UnsignedIntegerProperty LoggedMessageSvc::m_statLevel

private

Definition at line 149 of file LoggedMessageSvc.h.

m_stats

BooleanProperty LoggedMessageSvc::m_stats

private

Definition at line 148 of file LoggedMessageSvc.h.

m_streamMap

StreamMap LoggedMessageSvc::m_streamMap

private

Stream map.

Definition at line 141 of file LoggedMessageSvc.h.

m_suppress

BooleanProperty LoggedMessageSvc::m_suppress

private

Definition at line 166 of file LoggedMessageSvc.h.

m_thresholdMap

ThresholdMap LoggedMessageSvc::m_thresholdMap

private

Output level threshold map.

Definition at line 143 of file LoggedMessageSvc.h.

m_thresholdMapMutex

std::mutex LoggedMessageSvc::m_thresholdMapMutex

mutableprivate

Mutex to synchronize multiple access to m_thresholdMap (.

See also

MsgStream::doOutput).

Definition at line 197 of file LoggedMessageSvc.h.

m_thresholdProp

StringArrayProperty LoggedMessageSvc::m_thresholdProp[MSG::NUM_LEVELS]

private

Properties controling.

Definition at line 146 of file LoggedMessageSvc.h.

---

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

• LoggedMessageSvc.h
• LoggedMessageSvc.cxx