MessageSvc Class Reference

#include <src/MessageSvc/MessageSvc.h>

Inheritance diagram for MessageSvc:

Collaboration diagram for MessageSvc:

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 >	ThresholdMap
Public Types inherited from extends< Service, IMessageSvc, IInactiveMessageCounter >
using	base_class = extends
	Typedef to this class. More...
using	extend_interfaces_base = extend_interfaces< Interfaces...>
	Typedef to the base of this class. More...
Public Types inherited from Service
typedef Gaudi::PluginService::Factory< IService *, const std::string &, ISvcLocator * >	Factory
Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using	base_class = CommonMessaging
Public Types inherited from extend_interfaces< Interfaces...>
using	ext_iids = typename Gaudi::interface_list_cat< typename Interfaces::ext_iids...>::type
	take union of the ext_iids of all Interfaces... More...

Public Member Functions
	MessageSvc (const std::string &name, ISvcLocator *svcloc)
	~MessageSvc () override=default
StatusCode	reinitialize () override
	Reinitialize Service. More...
StatusCode	initialize () override
	Initialize Service. More...
StatusCode	finalize () override
	Finalize Service. More...
void	reportMessage (const Message &message) override
void	reportMessage (const Message &msg, int outputLevel) override
void	reportMessage (const StatusCode &code, const std::string &source="") override
void	reportMessage (const char *source, int type, const char *message) override
void	reportMessage (const std::string &source, int type, const std::string &message) override
void	insertMessage (const StatusCode &code, const Message &message) override
void	eraseMessage () override
void	eraseMessage (const StatusCode &code) override
void	eraseMessage (const StatusCode &code, const Message &message) override
void	insertStream (int message_type, const std::string &name, std::ostream *stream) override
void	eraseStream () override
void	eraseStream (int message_type) override
void	eraseStream (int message_type, std::ostream *stream) override
void	eraseStream (std::ostream *stream) override
std::ostream *	defaultStream () const override
void	setDefaultStream (std::ostream *stream) override
int	outputLevel () const override
int	outputLevel (const std::string &source) const override
void	setOutputLevel (int new_level) override
void	setOutputLevel (const std::string &source, int new_level) override
bool	useColor () const override
std::string	getLogColor (int logLevel) const override
int	messageCount (MSG::Level logLevel) const override
void	incrInactiveCount (MSG::Level level, const std::string &src) override
Public Member Functions inherited from extends< Service, IMessageSvc, IInactiveMessageCounter >
void *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast. More...
StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface. More...
std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames. More...
	~extends () override=default
	Virtual destructor. More...
Public Member Functions inherited from Service
const std::string &	name () const override
	Retrieve name of the service. More...
StatusCode	configure () override
StatusCode	initialize () override
StatusCode	start () override
StatusCode	stop () override
StatusCode	finalize () override
StatusCode	terminate () override
Gaudi::StateMachine::State	FSMState () const override
Gaudi::StateMachine::State	targetFSMState () const override
StatusCode	reinitialize () override
StatusCode	restart () override
StatusCode	sysInitialize () override
	Initialize Service. More...
StatusCode	sysStart () override
	Initialize Service. More...
StatusCode	sysStop () override
	Initialize Service. More...
StatusCode	sysFinalize () override
	Finalize Service. More...
StatusCode	sysReinitialize () override
	Re-initialize the Service. More...
StatusCode	sysRestart () override
	Re-initialize the Service. More...
StatusCode	setProperty (const Property &p) override
StatusCode	setProperty (const std::string &s) override
StatusCode	setProperty (const std::string &n, const std::string &v) override
StatusCode	getProperty (Property *p) const override
const Property &	getProperty (const std::string &name) const override
StatusCode	getProperty (const std::string &n, std::string &v) const override
const std::vector< Property * > &	getProperties () const override
bool	hasProperty (const std::string &name) const override
template<class TYPE >
StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value More...
	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor. More...
SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator. More...
StatusCode	setProperties ()
	Method for setting declared properties to the values specified for the job. More...
template<class T >
StatusCode	service (const std::string &name, const T *&psvc, bool createIf=true) const
	Access a service by name, creating it if it doesn't already exist. More...
template<class T >
StatusCode	service (const std::string &name, T *&psvc, bool createIf=true) const
template<typename IFace = IService>
SmartIF< IFace >	service (const std::string &name, bool createIf=true) const
template<class T >
StatusCode	service (const std::string &svcType, const std::string &svcName, T *&psvc) const
	Access a service by name and type, creating it if it doesn't already exist. More...
template<class T >
Property *	declareProperty (const std::string &name, T &property, const std::string &doc="none") const
	Declare the named property. More...
Property *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="") const
	Declare remote named properties. More...
template<class T >
StatusCode	declarePrivateTool (ToolHandle< T > &handle, std::string toolTypeAndName="", bool createIf=true)
	Declare used Private tool. More...
template<class T >
StatusCode	declarePublicTool (ToolHandle< T > &handle, std::string toolTypeAndName="", bool createIf=true)
	Declare used Public tool. More...
SmartIF< IAuditorSvc > &	auditorSvc () const
	The standard auditor service.May not be invoked before sysInitialize() has been invoked. More...
Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor. More...
SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service. More...
MsgStream &	msgStream () const
	Return an uninitialized MsgStream. More...
MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts. More...
MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS) More...
MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL) More...
MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR) More...
MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING) More...
MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO) More...
MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG) More...
MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE) More...
MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO) More...
MSG::Level	msgLevel () const
	get the output level from the embedded MsgStream More...
MSG::Level	outputLevel () const __attribute__((deprecated))
	Backward compatibility function for getting the output level. More...
bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream More...
Public Member Functions inherited from extend_interfaces< Interfaces...>
	~extend_interfaces () override=default
	Virtual destructor. More...

Protected Member Functions
virtual void	i_reportMessage (const Message &msg, int outputLevel)
	Internal implementation of reportMessage(const Message&,int) without lock. More...
virtual void	i_reportMessage (const StatusCode &code, const std::string &source)
	Internal implementation of reportMessage(const StatusCode&,const std::string&) without lock. More...
Protected Member Functions inherited from Service
	~Service () override
	Standard Destructor. More...
int	outputLevel () const
	get the Service's output level More...
Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream. More...

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

Private Member Functions
std::string	colTrans (std::string, int)
void	initColors (Property &prop)
void	setupColors (Property &prop)
void	setupLimits (Property &prop)
void	setupThreshold (Property &prop)
void	setupInactCount (Property &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. More...
Message	m_defaultMessage
	Default Message. More...
StreamMap	m_streamMap
	Stream map. More...
MessageMap	m_messageMap
	Message map. More...
ThresholdMap	m_thresholdMap
	Output level threshold map. More...
std::string	m_defaultFormat
	Default format for the messages. More...
std::string	m_defaultTimeFormat
	Default format for timestamps in the messages. More...
StringArrayProperty	m_thresholdProp [MSG::NUM_LEVELS]
	Properties controlling. More...
BooleanProperty	m_color
BooleanProperty	m_stats
UnsignedIntegerProperty	m_statLevel
StringArrayProperty	m_logColors [MSG::NUM_LEVELS]
IntegerProperty	m_msgLimit [MSG::NUM_LEVELS]
std::string	m_logColorCodes [MSG::NUM_LEVELS]
std::map< std::string, MsgAry >	m_sourceMap
std::map< std::string, MsgAry >	m_inactiveMap
BooleanProperty	m_suppress
BooleanProperty	m_inactCount
std::vector< std::string >	m_tracedInactiveSources
ColorMap	m_colMap
std::array< int, MSG::NUM_LEVELS >	m_msgCount
std::map< std::string, std::string >	m_loggedStreamsName
std::map< std::string, std::shared_ptr< std::ostream > >	m_loggedStreams
std::recursive_mutex	m_reportMutex
	Mutex to synchronize multiple threads printing. More...
std::recursive_mutex	m_messageMapMutex
	Mutex to synchronize multiple access to m_messageMap. More...
std::recursive_mutex	m_thresholdMapMutex
	Mutex to synchronize multiple access to m_thresholdMap (. More...

Additional Inherited Members
Protected Attributes inherited from Service
IntegerProperty	m_outputLevel = MSG::NIL
	Service output level. More...
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state. More...
Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state. More...

Detailed Description

Definition at line 30 of file MessageSvc.h.

Member Typedef Documentation

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

private

Definition at line 167 of file MessageSvc.h.

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

Definition at line 36 of file MessageSvc.h.

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

Definition at line 34 of file MessageSvc.h.

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

Definition at line 35 of file MessageSvc.h.

typedef std::map< std::string, int > MessageSvc::ThresholdMap

Definition at line 37 of file MessageSvc.h.

Constructor & Destructor Documentation

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

Definition at line 58 of file MessageSvc.cpp.

  : base_class( name, svcloc ) {
  m_defaultStream = &std::cout;
  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)->declareUpdateHandler(&MessageSvc::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( &MessageSvc::setupInactCount, this );
  declareProperty( "tracedInactiveSources", m_tracedInactiveSources,
                   "for each message source specified, print a stack trace for"
                   "the unprotected and unseen messages" );
#ifndef NDEBUG
  // initialize the MsgStream static flag.
  MsgStream::enableCountInactive(m_inactCount);
#endif

  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(&MessageSvc::setupColors, this);
    m_msgLimit[ic].declareUpdateHandler(&MessageSvc::setupLimits, this);
    m_thresholdProp[ic].declareUpdateHandler(&MessageSvc::setupThreshold, this);
  }

  std::fill( std::begin(m_msgCount),std::end(m_msgCount), 0 );
}

MessageSvc::~MessageSvc ( )

overridedefault

Member Function Documentation

std::string MessageSvc::colTrans ( std::string  col, int  offset  )

private

Definition at line 434 of file MessageSvc.cpp.

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

std::ostream* MessageSvc::defaultStream ( ) const

inlineoverride

Definition at line 94 of file MessageSvc.h.

                                             {
    return m_defaultStream;
  }

void MessageSvc::eraseMessage ( )

override

Definition at line 658 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);
  m_messageMap.clear();
}

void MessageSvc::eraseMessage ( const StatusCode &  code )

override

Definition at line 671 of file MessageSvc.cpp.

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

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

override

Definition at line 684 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);

  erase_if( m_messageMap, m_messageMap.equal_range(key),
            [&](MessageMap::const_reference j) { return j.second==msg; } ) ;
}

void MessageSvc::eraseStream ( )

override

Definition at line 592 of file MessageSvc.cpp.

{
  m_streamMap.clear();
}

void MessageSvc::eraseStream ( int  message_type )

override

Definition at line 604 of file MessageSvc.cpp.

{
  m_streamMap.erase( message_type );
}

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

override

Definition at line 616 of file MessageSvc.cpp.

                                                            {
  if ( stream ) {
    erase_if( m_streamMap, m_streamMap.equal_range(key),
              [&](StreamMap::const_reference j)
              { return j.second.second == stream; } );
  }
}

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

override

Definition at line 631 of file MessageSvc.cpp.

                                                    {
  if ( stream ) {
    erase_if( m_streamMap, [&](StreamMap::const_reference j)
              { return j.second.second == stream; } );
  }
}

StatusCode MessageSvc::finalize ( )

override

Finalize Service.

Definition at line 321 of file MessageSvc.cpp.

                                {

  m_suppress = false;

  {
    std::ostringstream os;

    if (m_stats) {
      os << "Summarizing all message counts" << std::endl;
    } else {
      os << "Listing sources of suppressed message: " << std::endl;
    }

    os << "=====================================================" << std::endl;
    os << " Message Source              |   Level |    Count" << std::endl;
    os << "-----------------------------+---------+-------------" << std::endl;


    bool found(false);

    for (auto 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()) ) {
          os << " ";
          os.width(28);
          os.setf(std::ios_base::left,std::ios_base::adjustfield);
          os << itr->first;
          os << "|";

          os.width(8);
          os.setf(std::ios_base::right,std::ios_base::adjustfield);
          os << levelNames[ic];
          os << " |";

          os.width(9);
          os << itr->second.msg[ic];
          os << std::endl;

          found = true;
        }
      }
    }
    os << "=====================================================" << std::endl;
    if (found || m_stats) std::cout << os.str();
  }

#ifndef NDEBUG
  if (m_inactCount.value()) {

    std::ostringstream os;
    os << "Listing sources of Unprotected and Unseen messages\n";

    bool found(false);

    unsigned int ml(0);
    for (const auto& itr : m_inactiveMap) {
      for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
        if (itr.second.msg[ic] != 0 && itr.first.length() > ml) {
          ml = itr.first.length();
        }
      }
    }

    for (unsigned int i=0; i<ml+25; ++i) os << "=";

    os << std::endl << " ";
    os.width(ml+2);
    os.setf(std::ios_base::left,std::ios_base::adjustfield);
    os << "Message Source";
    os.width(1);
    os << "|   Level |    Count" << std::endl;

    for (unsigned int i=0; i<ml+3; ++i) os << "-";
    os << "+---------+-----------" << std::endl;


    for (auto 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) {
      os << " ";
      os.width(ml+2);
      os.setf(std::ios_base::left,std::ios_base::adjustfield);
      os << itr->first;

      os << "|";

      os.width(8);
      os.setf(std::ios_base::right,std::ios_base::adjustfield);
      os << levelNames[ic];

      os << " |";

      os.width(9);
      os << itr->second.msg[ic];

      os << std::endl;

      found = true;
    }
      }
    }
    for (unsigned int i=0; i<ml+25; ++i) os << "=";
    os << std::endl;

    if (found) std::cout << os.str();
  }
#endif

  return StatusCode::SUCCESS;
}

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

override

Definition at line 727 of file MessageSvc.cpp.

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

void MessageSvc::i_reportMessage ( const Message &  msg, int  outputLevel  )

protectedvirtual

Internal implementation of reportMessage(const Message&,int) without lock.

Definition at line 451 of file MessageSvc.cpp.

                                                                         {
  int key = msg.getType();

  ++m_msgCount[key];

  const Message *cmsg = &msg;

  // processing logged streams
  if ( !m_loggedStreams.empty() ) {
    auto iLog = m_loggedStreams.find( msg.getSource() );
    if ( m_loggedStreams.end() != iLog ) {
      (*iLog->second) << *cmsg << std::endl;
    }
  }

  if ( m_suppress.value() || m_stats.value() ) {

    // Increase the counter of 'key' type of messages for the source and
    // get the new value.
    const int nmsg = ++(m_sourceMap[msg.getSource()].msg[key]);

    if (m_suppress.value() && m_msgLimit[key] != 0 ) {
      if (nmsg > m_msgLimit[key]) return;
      if (nmsg == m_msgLimit[key]) {
        std::string txt = levelNames[key] + " message limit ("
            + std::to_string( m_msgLimit[key].value() )
            + ") reached for " + msg.getSource() + ". Suppressing further output.";
        cmsg = new Message(msg.getSource(), MSG::WARNING, std::move(txt));
        cmsg->setFormat(msg.getFormat());
      }
    }
  }

  auto range = m_streamMap.equal_range( key );
  if ( range.first != m_streamMap.end() ) {
    std::for_each( range.first,range.second, [&](StreamMap::const_reference sm) {
      *sm.second.second << *cmsg << std::endl;
    });
  } 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;
    }
  }

  if (cmsg != &msg) { delete cmsg; }

}

void MessageSvc::i_reportMessage ( const StatusCode &  code, const std::string &  source  )

protectedvirtual

Internal implementation of reportMessage(const StatusCode&,const std::string&) without lock.

Definition at line 551 of file MessageSvc.cpp.

{
  int level = outputLevel(source);
  auto report = [&](Message mesg) {
    mesg.setSource( source );
    Message stat_code( source,  mesg.getType(), "Status Code " + std::to_string( code.getCode() ) );
    i_reportMessage( std::move(stat_code), level );
    i_reportMessage( std::move(mesg), level );
  };

  auto range = m_messageMap.equal_range( code );
  if ( range.first != m_messageMap.end() ) {
    std::for_each( range.first, range.second,
                   [&](MessageMap::const_reference sm) { report(sm.second); } );
  } else {
    report(m_defaultMessage);
  }
}

void MessageSvc::incrInactiveCount ( MSG::Level  level, const std::string &  src  )

override

Definition at line 741 of file MessageSvc.cpp.

                                                                     {
  ++(m_inactiveMap[source].msg[level]);

  if (std::find(begin(m_tracedInactiveSources),
                end(m_tracedInactiveSources),
                source) != end(m_tracedInactiveSources)) {
    std::cout << "== inactive message detected from "
        << source << " ==" << std::endl;
    std::string t;
    System::backTrace(t, 25, 0);
    std::cout << t << std::endl;
  }
}

void MessageSvc::initColors ( Property &  prop )

private

Definition at line 165 of file MessageSvc.cpp.

                                       {

  if (m_color) {
     static const std::array<std::pair<MSG::Level,std::vector<std::string>>,3> tbl{
                          { { MSG::FATAL, { { "[94;101;1m" } } },
                            { MSG::ERROR, { { "[97;101;1m" } } },
                            { MSG::WARNING, { { "[93;1m" } } } } };

     for (const auto& p : tbl ) {
        auto &lC = m_logColors[p.first];
        if (lC.value().empty()) {
            lC.set(p.second);
        } else {
            MessageSvc::setupColors( lC );
        }
    }

  } else {

    // reset all color codes;
    for (int ic=0; ic<MSG::NUM_LEVELS; ++ic) {
      m_logColors[ic].set( { } );
    }

  }

}

StatusCode MessageSvc::initialize ( )

override

Initialize Service.

Definition at line 123 of file MessageSvc.cpp.

                                  {
  StatusCode sc;
  sc = Service::initialize();
  if( sc.isFailure() ) return sc;
  // Set my own properties
  sc = setProperties();
  if (sc.isFailure()) return sc;

#ifdef _WIN32
  m_color = false;
#endif

  //NOTE: m_colMap is used _before_ it is filled here,
  //      i.e. while it is still empty.
  //      Moving this initialization 'up' by eg. just
  //      having a 'static const' colMap does not leave
  //      the results invariant...
  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();

  return StatusCode::SUCCESS;
}

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

override

Definition at line 645 of file MessageSvc.cpp.

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

void MessageSvc::insertStream ( int  message_type, const std::string &  name, std::ostream *  stream  )

override

Definition at line 578 of file MessageSvc.cpp.

{
  m_streamMap.emplace( key, NamedStream(name,stream) );
}

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

override

Definition at line 733 of file MessageSvc.cpp.

                                                    {

  return m_msgCount[level];

}

int MessageSvc::outputLevel ( ) const

override

Definition at line 693 of file MessageSvc.cpp.

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

int MessageSvc::outputLevel ( const std::string &  source ) const

override

Definition at line 699 of file MessageSvc.cpp.

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

StatusCode MessageSvc::reinitialize ( )

override

Reinitialize Service.

Definition at line 158 of file MessageSvc.cpp.

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

void MessageSvc::reportMessage ( const Message &  message )

override

Definition at line 510 of file MessageSvc.cpp.

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

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

override

Definition at line 446 of file MessageSvc.cpp.

                                                                       {
  std::unique_lock<std::recursive_mutex> lock(m_reportMutex);
  i_reportMessage(msg, outputLevel);
}

void MessageSvc::reportMessage ( const StatusCode &  code, const std::string &  source = ""  )

override

Definition at line 544 of file MessageSvc.cpp.

{
  std::unique_lock<std::recursive_mutex> lock(m_messageMapMutex);
  i_reportMessage(code, source);
}

void MessageSvc::reportMessage ( const char *  source, int  type, const char *  message  )

override

Definition at line 520 of file MessageSvc.cpp.

                                                     {
  reportMessage( Message{ source, type, message } );
}

void MessageSvc::reportMessage ( const std::string &  source, int  type, const std::string &  message  )

override

Definition at line 532 of file MessageSvc.cpp.

                                                          {
  reportMessage( Message{source, type, message} );
}

void MessageSvc::setDefaultStream ( std::ostream *  stream )

inlineoverride

Definition at line 99 of file MessageSvc.h.

                                                       {
    std::unique_lock<std::recursive_mutex> lock(m_reportMutex);
    m_defaultStream = stream;
  }

void MessageSvc::setOutputLevel ( int  new_level )

override

Definition at line 707 of file MessageSvc.cpp.

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

void MessageSvc::setOutputLevel ( const std::string &  source, int  new_level  )

override

Definition at line 713 of file MessageSvc.cpp.

                                                                     {
// ---------------------------------------------------------------------------
  std::unique_lock<std::recursive_mutex> lock(m_thresholdMapMutex);

  // only write if we really have to...
  auto i = m_thresholdMap.find( source );
  if (i == m_thresholdMap.end()) {
    m_thresholdMap[source] = level;
  } else if (i->second!=level) {
    i->second = level;
  }
}

void MessageSvc::setupColors ( Property &  prop )

private

Definition at line 195 of file MessageSvc.cpp.

                                           {

  if (! m_color) return;

  static const std::array<std::pair<const char*,MSG::Level>,7> tbl {
      { {"fatalColorCode",   MSG::FATAL   },
        {"errorColorCode",   MSG::ERROR   },
        {"warningColorCode", MSG::WARNING },
        {"infoColorCode",    MSG::INFO    },
        {"debugColorCode",   MSG::DEBUG   },
        {"verboseColorCode", MSG::VERBOSE },
        {"alwaysColorCode",  MSG::ALWAYS  } } };

  auto i = std::find_if( std::begin(tbl),std::end(tbl),
                         [&](const std::pair<const char*,MSG::Level>& t) {
                                return prop.name() == t.first;
  } );
  if (i==std::end(tbl)) {
    std::cout << "ERROR: Unknown message color parameter: " << prop.name()
         << std::endl;
    return;
  }
  int ic = i->second;

  std::string code;
  auto itr = m_logColors[ic].value().begin();

  if ( m_logColors[ic].value().size() == 1 ) {

    if (itr->empty()) {
      code = "";
    } else if (itr->compare(0,1,"[") == 0) {
      code = "\033" + *itr;
    } else {
      code = "\033[" + colTrans(*itr, 90) + ";1m";
    }

  } else if (m_logColors[ic].value().size() == 2) {
    auto itr2 = itr + 1;

    code =  "\033[" + colTrans(*itr, 90) + ";"
      + colTrans(*itr2, 100) + ";1m";

  }

  m_logColorCodes[ic] = code;

}

void MessageSvc::setupInactCount ( Property &  prop )

private

Definition at line 309 of file MessageSvc.cpp.

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

void MessageSvc::setupLimits ( Property &  prop )

private

Definition at line 245 of file MessageSvc.cpp.

                                           {
  // Just report problems in the settings of the limits and unknown limit parameters
  if (prop.name() == "alwaysLimit") {
    IntegerProperty *p = dynamic_cast<IntegerProperty*>(&prop);
    if (p && p->value() != 0) {
      std::cout << "MessageSvc ERROR: cannot suppress ALWAYS messages" << std::endl;
      p->setValue(0);
    }
  } 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 if (prop.name() != "fatalLimit" &&
             prop.name() != "errorLimit" &&
             prop.name() != "warningLimit" &&
             prop.name() == "infoLimit" &&
             prop.name() == "debugLimit" &&
             prop.name() == "verboseLimit") {
    std::cout << "MessageSvc ERROR: Unknown message limit parameter: "
         << prop.name() << std::endl;
    return;
  }
}

void MessageSvc::setupLogStreams ( )

private

Definition at line 756 of file MessageSvc.cpp.

{
  // reset state
  m_loggedStreams.clear();

  for ( auto& iProp : m_loggedStreamsName ) {

    std::set<std::string> outFileNames;
    for ( auto& jProp : m_loggedStreamsName ) {
      if ( jProp.first != iProp.first ) {
        outFileNames.insert( jProp.second );
      }
    }
    tee( iProp.first, iProp.second, outFileNames );

  }//> loop over property entries
}

void MessageSvc::setupThreshold ( Property &  prop )

private

Definition at line 272 of file MessageSvc.cpp.

                                              {

  static const std::array<std::pair<const char*,MSG::Level>,7> tbl{
      { { "setFatal",   MSG::FATAL   },
        { "setError",   MSG::ERROR   },
        { "setWarning", MSG::WARNING },
        { "setInfo",    MSG::INFO    },
        { "setDebug",   MSG::DEBUG   },
        { "setVerbose", MSG::VERBOSE },
        { "setAlways",  MSG::ALWAYS  } } };

  auto i = std::find_if( std::begin(tbl),std::end(tbl),
                         [&](const std::pair<const char*,MSG::Level>& t) {
                                return prop.name() == t.first;
  } );
  if (i==std::end(tbl)) {
    std::cerr << "MessageSvc ERROR: Unknown message threshold parameter: "
         << prop.name() << std::endl;
    return;
  }
  int ic = i->second;

  StringArrayProperty *sap = dynamic_cast<StringArrayProperty*>( &prop);
  if (!sap) {
    std::cerr << "could not dcast " << prop.name()
              << " to a StringArrayProperty (which it should be!)" << std::endl;
  } else {
    for ( auto& i : sap->value() ) setOutputLevel( i, ic );
  }

}

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

private

Definition at line 775 of file MessageSvc.cpp.

{
  const std::ios_base::openmode openMode = std::ios_base::out |
                                           std::ios_base::trunc;

  auto iStream = m_loggedStreams.find( sourceName );
  if ( iStream != std::end(m_loggedStreams) ) {
    m_loggedStreams.erase( iStream );
  }

  // before creating a new ofstream, make sure there is no already existing
  // one with the same file name...
  for (auto&  iStream : m_loggedStreams ) {
    if ( outFileNames.find( outFileName ) != outFileNames.end() ) {
      m_loggedStreams[sourceName] = m_loggedStreams[iStream.first];
      return;
    }
  }

  auto out = std::make_shared<std::ofstream>( outFileName, openMode );
  if ( out->good() ) m_loggedStreams[sourceName] = std::move(out);

}

bool MessageSvc::useColor ( ) const

inlineoverride

Definition at line 117 of file MessageSvc.h.

{ return m_color; }

Member Data Documentation

ColorMap MessageSvc::m_colMap

private

Definition at line 168 of file MessageSvc.h.

BooleanProperty MessageSvc::m_color

private

Definition at line 146 of file MessageSvc.h.

std::string MessageSvc::m_defaultFormat

private

Default format for the messages.

Definition at line 143 of file MessageSvc.h.

Message MessageSvc::m_defaultMessage

private

Default Message.

Definition at line 139 of file MessageSvc.h.

std::ostream* MessageSvc::m_defaultStream

private

Pointer to the output stream.

Definition at line 138 of file MessageSvc.h.

std::string MessageSvc::m_defaultTimeFormat

private

Default format for timestamps in the messages.

Definition at line 144 of file MessageSvc.h.

BooleanProperty MessageSvc::m_inactCount

private

Definition at line 163 of file MessageSvc.h.

std::map<std::string,MsgAry> MessageSvc::m_inactiveMap

private

Definition at line 162 of file MessageSvc.h.

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

private

Definition at line 152 of file MessageSvc.h.

StringArrayProperty MessageSvc::m_logColors[MSG::NUM_LEVELS]

private

Definition at line 149 of file MessageSvc.h.

std::map<std::string, std::shared_ptr<std::ostream> > MessageSvc::m_loggedStreams

private

Definition at line 173 of file MessageSvc.h.

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

private

Definition at line 172 of file MessageSvc.h.

MessageMap MessageSvc::m_messageMap

private

Message map.

Definition at line 141 of file MessageSvc.h.

std::recursive_mutex MessageSvc::m_messageMapMutex

mutableprivate

Mutex to synchronize multiple access to m_messageMap.

Definition at line 190 of file MessageSvc.h.

std::array<int,MSG::NUM_LEVELS> MessageSvc::m_msgCount

private

Definition at line 170 of file MessageSvc.h.

IntegerProperty MessageSvc::m_msgLimit[MSG::NUM_LEVELS]

private

Definition at line 150 of file MessageSvc.h.

std::recursive_mutex MessageSvc::m_reportMutex

mutableprivate

Mutex to synchronize multiple threads printing.

Definition at line 187 of file MessageSvc.h.

std::map<std::string,MsgAry> MessageSvc::m_sourceMap

private

Definition at line 162 of file MessageSvc.h.

UnsignedIntegerProperty MessageSvc::m_statLevel

private

Definition at line 148 of file MessageSvc.h.

BooleanProperty MessageSvc::m_stats

private

Definition at line 147 of file MessageSvc.h.

StreamMap MessageSvc::m_streamMap

private

Stream map.

Definition at line 140 of file MessageSvc.h.

BooleanProperty MessageSvc::m_suppress

private

Definition at line 163 of file MessageSvc.h.

ThresholdMap MessageSvc::m_thresholdMap

private

Output level threshold map.

Definition at line 142 of file MessageSvc.h.

std::recursive_mutex MessageSvc::m_thresholdMapMutex

mutableprivate

Mutex to synchronize multiple access to m_thresholdMap (.

See also

MsgStream::doOutput).

Definition at line 194 of file MessageSvc.h.

StringArrayProperty MessageSvc::m_thresholdProp[MSG::NUM_LEVELS]

private

Properties controlling.

Definition at line 145 of file MessageSvc.h.

std::vector<std::string> MessageSvc::m_tracedInactiveSources

private

Definition at line 164 of file MessageSvc.h.

---

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

• GaudiCoreSvc/src/MessageSvc/MessageSvc.h
• GaudiCoreSvc/src/MessageSvc/MessageSvc.cpp