#include </builds/gaudi/Gaudi/GaudiCoreSvc/src/MessageSvc/MessageSvc.h>

Inheritance diagram for MessageSvc:

[legend]

Collaboration diagram for MessageSvc:

[legend]

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 Types inherited from extends< Service, IMessageSvc, IInactiveMessageCounter >
using	base_class
	Typedef to this class.

using	extend_interfaces_base
	Typedef to the base of this class.

Public Types inherited from Service
using	Factory = Gaudi::PluginService::Factory<IService( const std::string&, ISvcLocator )>

Public Types inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
using	PropertyHolderImpl
	Typedef used to refer to this class from derived classes, as in.

Public Types inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
using	base_class

Public Types inherited from extend_interfaces< Interfaces... >
using	ext_iids
	take union of the ext_iids of all Interfaces...

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

StatusCode	reinitialize () override

StatusCode	initialize () override

StatusCode	finalize () override

void	reportMessage (const Message &message) override

void	reportMessage (const Message &msg, int outputLevel) override

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

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

void	insertMessage (const StatusCode &code, 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, 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 (std::string_view source) const override

void	setOutputLevel (int new_level) override

void	setOutputLevel (std::string_view 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, std::string_view src) override

Public Member Functions inherited from extends< Service, IMessageSvc, IInactiveMessageCounter >
void const *	i_cast (const InterfaceID &tid) const override
	Implementation of IInterface::i_cast.

StatusCode	queryInterface (const InterfaceID &ti, void **pp) override
	Implementation of IInterface::queryInterface.

std::vector< std::string >	getInterfaceNames () const override
	Implementation of IInterface::getInterfaceNames.

Public Member Functions inherited from Service
const std::string &	name () const override
	Retrieve name of the service.

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.

StatusCode	sysStart () override
	Initialize Service.

StatusCode	sysStop () override
	Initialize Service.

StatusCode	sysFinalize () override
	Finalize Service.

StatusCode	sysReinitialize () override
	Re-initialize the Service.

StatusCode	sysRestart () override
	Re-initialize the Service.

	Service (std::string name, ISvcLocator *svcloc)
	Standard Constructor.

SmartIF< ISvcLocator > &	serviceLocator () const override
	Retrieve pointer to service locator.

template<typename IFace = IService>
SmartIF< IFace >	service (const std::string &name, bool createIf=true) const

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandle< T > &hndl, const std::string &doc="none")

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, bool createIf=true)

template<class T>
StatusCode	declareTool (ToolHandle< T > &handle, const std::string &toolTypeAndName, bool createIf=true)
	Declare used tool.

template<class T>
Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, ToolHandleArray< T > &hndlArr, const std::string &doc="none")

template<class T>
void	addToolsArray (ToolHandleArray< T > &hndlArr)

const std::vector< IAlgTool * > &	tools () const

SmartIF< IAuditorSvc > &	auditorSvc () const
	The standard auditor service.May not be invoked before sysInitialize() has been invoked.

Public Member Functions inherited from PropertyHolder< CommonMessaging< implements< IService, IProperty, IStateful > > >
StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

	PropertyHolder ()=default

Gaudi::Details::PropertyBase &	declareProperty (Gaudi::Details::PropertyBase &prop)
	Declare a property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, TYPE &value, const std::string &doc="none")
	Helper to wrap a regular data member and use it as a regular property.

Gaudi::Details::PropertyBase *	declareProperty (const std::string &name, Gaudi::Property< TYPE, VERIFIER, HANDLERS > &prop, const std::string &doc="none")
	Declare a PropertyBase instance setting name and documentation.

Gaudi::Details::PropertyBase *	declareRemoteProperty (const std::string &name, IProperty *rsvc, const std::string &rname="")
	Declare a remote property.

StatusCode	setProperty (const std::string &name, const Gaudi::Details::PropertyBase &p) override
	set the property from another property with a different name

StatusCode	setProperty (const std::string &s) override
	set the property from the formatted string

StatusCode	setProperty (const Gaudi::Details::PropertyBase &p)
	Set the property from a property.

StatusCode	setProperty (const std::string &name, const char *v)
	Special case for string literals.

StatusCode	setProperty (const std::string &name, const std::string &v)
	Special case for std::string.

StatusCode	setProperty (const std::string &name, const TYPE &value)
	set the property form the value

StatusCode	setPropertyRepr (const std::string &n, const std::string &r) override
	set the property from name and value string representation

StatusCode	getProperty (Gaudi::Details::PropertyBase *p) const override
	get the property

const Gaudi::Details::PropertyBase &	getProperty (std::string_view name) const override
	get the property by name

StatusCode	getProperty (std::string_view n, std::string &v) const override
	convert the property to the string

const std::vector< Gaudi::Details::PropertyBase * > &	getProperties () const override
	get all properties

bool	hasProperty (std::string_view name) const override
	Return true if we have a property with the given name.

Gaudi::Details::PropertyBase *	property (std::string_view name) const
	\fixme property and bindPropertiesTo should be protected

void	bindPropertiesTo (Gaudi::Interfaces::IOptionsSvc &optsSvc)

	PropertyHolder (const PropertyHolder &)=delete

PropertyHolder &	operator= (const PropertyHolder &)=delete

Public Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	msgLevel () const
	get the cached level (originally extracted from the embedded MsgStream)

bool	msgLevel (MSG::Level lvl) const
	get the output level from the embedded MsgStream

Public Member Functions inherited from CommonMessagingBase
virtual	~CommonMessagingBase ()=default
	Virtual destructor.

const SmartIF< IMessageSvc > &	msgSvc () const
	The standard message service.

MsgStream &	msgStream () const
	Return an uninitialized MsgStream.

MsgStream &	msgStream (const MSG::Level level) const
	Predefined configurable message stream for the efficient printouts.

MsgStream &	always () const
	shortcut for the method msgStream(MSG::ALWAYS)

MsgStream &	fatal () const
	shortcut for the method msgStream(MSG::FATAL)

MsgStream &	err () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	error () const
	shortcut for the method msgStream(MSG::ERROR)

MsgStream &	warning () const
	shortcut for the method msgStream(MSG::WARNING)

MsgStream &	info () const
	shortcut for the method msgStream(MSG::INFO)

MsgStream &	debug () const
	shortcut for the method msgStream(MSG::DEBUG)

MsgStream &	verbose () const
	shortcut for the method msgStream(MSG::VERBOSE)

MsgStream &	msg () const
	shortcut for the method msgStream(MSG::INFO)

Protected Member Functions
virtual void	i_reportMessage (const Message &msg, int outputLevel)
	Internal implementation of reportMessage(const Message&,int) without lock.

virtual void	i_reportMessage (const StatusCode &code, std::string_view source)
	Internal implementation of reportMessage(const StatusCode&,const std::string&) without lock.

Protected Member Functions inherited from Service
std::vector< IAlgTool * > &	tools ()

	~Service () override

int	outputLevel () const
	get the `Service's` output level

Protected Member Functions inherited from CommonMessaging< implements< IService, IProperty, IStateful > >
MSG::Level	setUpMessaging () const
	Set up local caches.

MSG::Level	resetMessaging ()
	Reinitialize internal states.

void	updateMsgStreamOutputLevel (int level)
	Update the output level of the cached MsgStream.

Private Member Functions
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 ()

Private Attributes
Gaudi::Property< std::string >	m_defaultFormat { this, "Format", Message::getDefaultFormat(), "" }

Gaudi::Property< std::string >	m_defaultTimeFormat { this, "timeFormat", Message::getDefaultTimeFormat(), "" }

Gaudi::Property< bool >	m_stats { this, "showStats", false, "" }

Gaudi::Property< unsigned int >	m_statLevel { this, "statLevel", 0, "" }

std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS >	m_thresholdProp

Gaudi::Property< bool >	m_color { this, "useColors", false, "" }

std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS >	m_logColors

std::array< Gaudi::Property< int >, MSG::NUM_LEVELS >	m_msgLimit

Gaudi::Property< bool >	m_suppress { this, "enableSuppression", false, "" }

Gaudi::Property< bool >	m_inactCount { this, "countInactive", false, &MessageSvc::setupInactCount, "" }

Gaudi::Property< std::vector< std::string > >	m_tracedInactiveSources

Gaudi::Property< std::map< std::string, std::string, std::less<> > >	m_loggedStreamsName

std::ostream *	m_defaultStream = &std::cout
	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_logColorCodes [MSG::NUM_LEVELS]

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

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

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

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

std::recursive_mutex	m_reportMutex
	Mutex to synchronize multiple threads printing.

std::recursive_mutex	m_messageMapMutex
	Mutex to synchronize multiple access to m_messageMap.

std::recursive_mutex	m_thresholdMapMutex
	Mutex to synchronize multiple access to m_thresholdMap (.

Additional Inherited Members
Protected Attributes inherited from Service
Gaudi::StateMachine::State	m_state = Gaudi::StateMachine::OFFLINE
	Service state.

Gaudi::StateMachine::State	m_targetState = Gaudi::StateMachine::OFFLINE
	Service state.

Gaudi::Property< int >	m_outputLevel { this, "OutputLevel", MSG::NIL, "output level" }
	flag indicating whether ToolHandle tools have been added to m_tools

Gaudi::Property< bool >	m_auditorInitialize { this, "AuditInitialize", false, "trigger auditor on initialize()" }

Gaudi::Property< bool >	m_auditorStart { this, "AuditStart", false, "trigger auditor on start()" }

Gaudi::Property< bool >	m_auditorStop { this, "AuditStop", false, "trigger auditor on stop()" }

Gaudi::Property< bool >	m_auditorFinalize { this, "AuditFinalize", false, "trigger auditor on finalize()" }

Gaudi::Property< bool >	m_auditorReinitialize { this, "AuditReinitialize", false, "trigger auditor on reinitialize()" }

Gaudi::Property< bool >	m_auditorRestart { this, "AuditRestart", false, "trigger auditor on restart()" }

Gaudi::Property< bool >	m_autoRetrieveTools

Gaudi::Property< bool >	m_checkToolDeps

SmartIF< IAuditorSvc >	m_pAuditorSvc
	Auditor Service.

Detailed Description

Definition at line 35 of file MessageSvc.h.

Member Typedef Documentation

◆ MessageMap

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

Definition at line 39 of file MessageSvc.h.

◆ NamedStream

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

Definition at line 37 of file MessageSvc.h.

◆ StreamMap

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

Definition at line 38 of file MessageSvc.h.

◆ ThresholdMap

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

Definition at line 40 of file MessageSvc.h.

Constructor & Destructor Documentation

◆ MessageSvc()

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

Definition at line 64 of file MessageSvc.cpp.

                                                                   : base_class( name, svcloc ) {
 
  m_outputLevel.declareUpdateHandler( [svcloc]( Gaudi::Details::PropertyBase& ) {
    SmartIF<IAppMgrUI> app = svcloc;
    if ( app ) app->outputLevelUpdate();
  } );
 
#ifndef NDEBUG
  // initialize the MsgStream static flag.
  MsgStream::enableCountInactive( m_inactCount );
#endif
 
  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 );
  }
 
  m_logColors[MSG::FATAL].set( { "blue", "red" } );
  m_logColors[MSG::ERROR].set( { "white", "red" } );
  m_logColors[MSG::WARNING].set( { "yellow" } );
 
  std::fill( std::begin( m_msgCount ), std::end( m_msgCount ), 0 );
}

Member Function Documentation

◆ defaultStream()

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

inlineoverride

Definition at line 92 of file MessageSvc.h.

92{ return m_defaultStream; }

MessageSvc::m_defaultStream

std::ostream * m_defaultStream

Pointer to the output stream.

Definition MessageSvc.h:178

◆ eraseMessage() [1/3]

void MessageSvc::eraseMessage ( )

override

Definition at line 411 of file MessageSvc.cpp.

                              {
  auto lock = std::scoped_lock{ m_messageMapMutex };
  m_messageMap.clear();
}

◆ eraseMessage() [2/3]

void MessageSvc::eraseMessage ( const StatusCode & code )

override

Definition at line 416 of file MessageSvc.cpp.

                                                     {
  auto lock = std::scoped_lock{ m_messageMapMutex };
  m_messageMap.erase( key );
}

◆ eraseMessage() [3/3]

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

override

Definition at line 421 of file MessageSvc.cpp.

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

◆ eraseStream() [1/4]

void MessageSvc::eraseStream ( )

override

Definition at line 389 of file MessageSvc.cpp.

389{ m_streamMap.clear(); }

MessageSvc::m_streamMap

StreamMap m_streamMap

Stream map.

Definition MessageSvc.h:180

◆ eraseStream() [2/4]

void MessageSvc::eraseStream ( int message_type )

override

Definition at line 391 of file MessageSvc.cpp.

391{ m_streamMap.erase( message_type ); }

◆ eraseStream() [3/4]

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

override

Definition at line 393 of file MessageSvc.cpp.

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

◆ eraseStream() [4/4]

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

override

Definition at line 400 of file MessageSvc.cpp.

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

◆ finalize()

StatusCode MessageSvc::finalize ( )

override

Definition at line 198 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() << std::flush;
  }
 
#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() << std::flush;
  }
#endif
 
  return StatusCode::SUCCESS;
}

◆ getLogColor()

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

override

Definition at line 450 of file MessageSvc.cpp.

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

◆ i_reportMessage() [1/2]

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

protectedvirtual

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

Definition at line 310 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; } // cppcheck-suppress autovarInvalidDeallocation; false positive
}

◆ i_reportMessage() [2/2]

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

protectedvirtual

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

Definition at line 368 of file MessageSvc.cpp.

                                                                                {
  int  level  = outputLevel( source );
  auto report = [&]( Message mesg ) {
    mesg.setSource( source );
    Message stat_code( std::string{ 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 );
  }
}

◆ incrInactiveCount()

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

override

Definition at line 456 of file MessageSvc.cpp.

                                                                          {
  auto entry = m_inactiveMap.find( source );
  if ( entry == m_inactiveMap.end() ) { entry = m_inactiveMap.emplace( source, MsgAry{} ).first; }
  ++entry->second.msg[level];
 
  if ( std::find( begin( m_tracedInactiveSources ), end( m_tracedInactiveSources ), source ) !=
       end( m_tracedInactiveSources ) ) {
    std::cout << "== inactive message detected from " << source << " ==\n";
    std::string t;
    System::backTrace( t, 25, 0 );
    std::cout << t << std::endl;
  }
}

◆ initialize()

StatusCode MessageSvc::initialize ( )

override

Definition at line 89 of file MessageSvc.cpp.

                                  {
  StatusCode sc = Service::initialize();
  if ( sc.isFailure() ) return sc;
 
  // make sure the map of logged stream names is initialized
  setupLogStreams();
 
  return StatusCode::SUCCESS;
}

◆ insertMessage()

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

override

Definition at line 406 of file MessageSvc.cpp.

                                                                   {
  auto lock = std::scoped_lock{ m_messageMapMutex };
  m_messageMap.emplace( key, std::move( msg ) );
}

◆ insertStream()

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

override

Definition at line 385 of file MessageSvc.cpp.

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

◆ messageCount()

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

override

Definition at line 454 of file MessageSvc.cpp.

454{ return m_msgCount[level]; }

◆ outputLevel() [1/2]

int MessageSvc::outputLevel ( ) const

override

Definition at line 428 of file MessageSvc.cpp.

428{ return m_outputLevel; }

◆ outputLevel() [2/2]

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

override

Definition at line 430 of file MessageSvc.cpp.

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

◆ reinitialize()

StatusCode MessageSvc::reinitialize ( )

override

Definition at line 99 of file MessageSvc.cpp.

                                    {
  m_state       = Gaudi::StateMachine::OFFLINE;
  StatusCode sc = initialize();
  if ( sc.isSuccess() ) m_state = Gaudi::StateMachine::INITIALIZED;
 
  return sc;
}

◆ reportMessage() [1/4]

void MessageSvc::reportMessage ( const Message & message )

override

Definition at line 357 of file MessageSvc.cpp.

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

MessageSvc::reportMessage

void reportMessage(const Message &message) override

Definition MessageSvc.cpp:357

◆ reportMessage() [2/4]

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

override

Definition at line 305 of file MessageSvc.cpp.

                                                                    {
  auto lock = std::scoped_lock{ m_reportMutex };
  i_reportMessage( msg, outputLevel );
}

◆ reportMessage() [3/4]

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

override

Definition at line 363 of file MessageSvc.cpp.

                                                                              {
  auto lock = std::scoped_lock{ m_messageMapMutex };
  i_reportMessage( code, source );
}

◆ reportMessage() [4/4]

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

override

Definition at line 359 of file MessageSvc.cpp.

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

◆ setDefaultStream()

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

inlineoverride

Definition at line 95 of file MessageSvc.h.

                                                       {
    auto lock       = std::scoped_lock{ m_reportMutex };
    m_defaultStream = stream;
  }

◆ setOutputLevel() [1/2]

void MessageSvc::setOutputLevel ( int new_level )

override

Definition at line 436 of file MessageSvc.cpp.

436{ m_outputLevel = new_level; }

◆ setOutputLevel() [2/2]

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

override

Definition at line 438 of file MessageSvc.cpp.

                                                                  {
  auto lock = std::scoped_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 MessageSvc::setupColors ( Gaudi::Details::PropertyBase & prop )

private

Definition at line 107 of file MessageSvc.cpp.

                                                             {
  const auto& pname = prop.name();
  int         level =
      ( pname == "fatalColorCode"     ? MSG::FATAL
        : pname == "errorColorCode"   ? MSG::ERROR
        : pname == "warningColorCode" ? MSG::WARNING
        : pname == "infoColorCode"    ? MSG::INFO
        : pname == "debugColorCode"   ? MSG::DEBUG
        : pname == "verboseColorCode" ? MSG::VERBOSE
        : pname == "alwaysColorCode"
            ? MSG::ALWAYS
            : ( throw GaudiException( "ERROR: Unknown message color parameter: " + pname, name(), StatusCode::FAILURE ),
                -1 ) );
 
  auto& code = m_logColorCodes[level];
 
  const auto& col_desc = m_logColors[level].value();
 
  if ( col_desc.size() == 1 ) {
    const std::string& desc = col_desc[0];
    if ( desc.empty() ) {
      code = "";
    } else if ( desc[0] == '[' ) {
      code = "\033" + desc;
    } else {
      code = "\033[" + colTrans( desc, 90 ) + ";1m";
    }
  } else if ( col_desc.size() == 2 ) {
    code = "\033[" + colTrans( col_desc[0], 90 ) + ";" + colTrans( col_desc[1], 100 ) + ";1m";
  } else { // empty desc: no color
    code = "";
  }
}

◆ setupInactCount()

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

private

Definition at line 190 of file MessageSvc.cpp.

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

◆ setupLimits()

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

private

Definition at line 141 of file MessageSvc.cpp.

                                                             {
  // Just report problems in the settings of the limits and unknown limit parameters
  if ( prop.name() == "alwaysLimit" ) {
    Gaudi::Property<int>* p = dynamic_cast<Gaudi::Property<int>*>( &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;
  }
}

◆ setupLogStreams()

void MessageSvc::setupLogStreams ( )

private

Definition at line 470 of file MessageSvc.cpp.

                                 {
  // reset state
  m_loggedStreams.clear();
 
  // make the unique set of output filenames
  std::set<std::string_view> outFileNames;
  std::transform( m_loggedStreamsName.begin(), m_loggedStreamsName.end(),
                  std::inserter( outFileNames, outFileNames.end() ),
                  []( const auto& p ) -> std::string_view { return p.second; } );
  // map each unique filename to an ofstream
  std::map<std::string_view, std::shared_ptr<std::ofstream>> outStreams;
  std::transform( outFileNames.begin(), outFileNames.end(), std::inserter( outStreams, outStreams.end() ),
                  []( std::string_view fname ) {
                    return std::pair{ fname, std::make_shared<std::ofstream>(
                                                 std::string{ fname }, std::ios_base::out | std::ios_base::trunc ) };
                  } );
  // associate the stream to ofstream...
  for ( auto& iProp : m_loggedStreamsName ) {
    auto& stream = outStreams.at( iProp.second );
    if ( stream->good() ) m_loggedStreams.emplace( iProp.first, stream );
  }
}

◆ setupThreshold()

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

private

Definition at line 160 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;
 
  Gaudi::Property<std::vector<std::string>>* sap = dynamic_cast<Gaudi::Property<std::vector<std::string>>*>( &prop );
  if ( !sap ) {
    std::cerr << "could not dcast " << prop.name()
              << " to a Gaudi::Property<std::vector<std::string>> (which it should be!)" << std::endl;
  } else {
    for ( auto& i : sap->value() ) setOutputLevel( i, ic );
  }
}

◆ useColor()

bool MessageSvc::useColor ( ) const

inlineoverride

Definition at line 113 of file MessageSvc.h.

113{ return m_color; }

Member Data Documentation

◆ m_color

Gaudi::Property<bool> MessageSvc::m_color { this, "useColors", false, "" }

private

Definition at line 146 of file MessageSvc.h.

146{ this, "useColors", false, "" };

◆ m_defaultFormat

Gaudi::Property<std::string> MessageSvc::m_defaultFormat { this, "Format", Message::getDefaultFormat(), "" }

private

Definition at line 132 of file MessageSvc.h.

132{ this, "Format", Message::getDefaultFormat(), "" };

Message::getDefaultFormat

static const std::string getDefaultFormat()

Get the default format string.

Definition Message.h:68

◆ m_defaultMessage

Message MessageSvc::m_defaultMessage

private

Default Message.

Definition at line 179 of file MessageSvc.h.

◆ m_defaultStream

std::ostream* MessageSvc::m_defaultStream = &std::cout

private

Pointer to the output stream.

Definition at line 178 of file MessageSvc.h.

◆ m_defaultTimeFormat

Gaudi::Property<std::string> MessageSvc::m_defaultTimeFormat { this, "timeFormat", Message::getDefaultTimeFormat(), "" }

private

Definition at line 133 of file MessageSvc.h.

133{ this, "timeFormat", Message::getDefaultTimeFormat(), "" };

Message::getDefaultTimeFormat

static const std::string getDefaultTimeFormat()

Get the default time format string.

Definition Message.h:77

◆ m_inactCount

Gaudi::Property<bool> MessageSvc::m_inactCount { this, "countInactive", false, &MessageSvc::setupInactCount, "" }

private

Definition at line 167 of file MessageSvc.h.

167{ this, "countInactive", false, &MessageSvc::setupInactCount, "" };

MessageSvc::setupInactCount

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

Definition MessageSvc.cpp:190

◆ m_inactiveMap

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

private

Definition at line 194 of file MessageSvc.h.

◆ m_logColorCodes

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

private

Definition at line 184 of file MessageSvc.h.

◆ m_logColors

std::array<Gaudi::Property<std::vector<std::string> >, MSG::NUM_LEVELS> MessageSvc::m_logColors

private

Initial value:

{ { {  },
                                                                                        { this, "verboseColorCode" },
                                                                                        { this, "debugColorCode" },
                                                                                        { this, "infoColorCode" },
                                                                                        { this, "warningColorCode" },
                                                                                        { this, "errorColorCode" },
                                                                                        { this, "fatalColorCode" },
                                                                                        { this, "alwaysColorCode" } } }

Definition at line 148 of file MessageSvc.h.

                                                                          { { { /*ignored*/ },
                                                                                        { this, "verboseColorCode" },
                                                                                        { this, "debugColorCode" },
                                                                                        { this, "infoColorCode" },
                                                                                        { this, "warningColorCode" },
                                                                                        { this, "errorColorCode" },
                                                                                        { this, "fatalColorCode" },
                                                                                        { this, "alwaysColorCode" } } };

◆ m_loggedStreams

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

private

Definition at line 198 of file MessageSvc.h.

◆ m_loggedStreamsName

Gaudi::Property<std::map<std::string, std::string, std::less<> > > MessageSvc::m_loggedStreamsName

private

Initial value:

{

this, "loggedStreams", {}, "MessageStream sources we want to dump into a logfile" }

Definition at line 175 of file MessageSvc.h.

175 {

176 this, "loggedStreams", {}, "MessageStream sources we want to dump into a logfile" };

◆ m_messageMap

MessageMap MessageSvc::m_messageMap

private

Message map.

Definition at line 181 of file MessageSvc.h.

◆ m_messageMapMutex

std::recursive_mutex MessageSvc::m_messageMapMutex

mutableprivate

Mutex to synchronize multiple access to m_messageMap.

Definition at line 211 of file MessageSvc.h.

◆ m_msgCount

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

private

Definition at line 196 of file MessageSvc.h.

◆ m_msgLimit

std::array<Gaudi::Property<int>, MSG::NUM_LEVELS> MessageSvc::m_msgLimit

private

Initial value:

{ { { this, "defaultLimit", 500 },
                                                                  { this, "verboseLimit", 500 },
                                                                  { this, "debugLimit", 500 },
                                                                  { this, "infoLimit", 500 },
                                                                  { this, "warningLimit", 500 },
                                                                  { this, "errorLimit", 500 },
                                                                  { this, "fatalLimit", 500 },
                                                                  { this, "alwaysLimit", 0 } } }

Definition at line 157 of file MessageSvc.h.

                                                        { { { this, "defaultLimit", 500 },
                                                                  { this, "verboseLimit", 500 },
                                                                  { this, "debugLimit", 500 },
                                                                  { this, "infoLimit", 500 },
                                                                  { this, "warningLimit", 500 },
                                                                  { this, "errorLimit", 500 },
                                                                  { this, "fatalLimit", 500 },
                                                                  { this, "alwaysLimit", 0 } } };

◆ m_reportMutex

std::recursive_mutex MessageSvc::m_reportMutex

mutableprivate

Mutex to synchronize multiple threads printing.

Definition at line 208 of file MessageSvc.h.

◆ m_sourceMap

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

private

Definition at line 194 of file MessageSvc.h.

◆ m_statLevel

Gaudi::Property<unsigned int> MessageSvc::m_statLevel { this, "statLevel", 0, "" }

private

Definition at line 135 of file MessageSvc.h.

135{ this, "statLevel", 0, "" };

◆ m_stats

Gaudi::Property<bool> MessageSvc::m_stats { this, "showStats", false, "" }

private

Definition at line 134 of file MessageSvc.h.

134{ this, "showStats", false, "" };

◆ m_streamMap

StreamMap MessageSvc::m_streamMap

private

Stream map.

Definition at line 180 of file MessageSvc.h.

◆ m_suppress

Gaudi::Property<bool> MessageSvc::m_suppress { this, "enableSuppression", false, "" }

private

Definition at line 166 of file MessageSvc.h.

166{ this, "enableSuppression", false, "" };

◆ m_thresholdMap

ThresholdMap MessageSvc::m_thresholdMap

private

Output level threshold map.

Definition at line 182 of file MessageSvc.h.

◆ m_thresholdMapMutex

std::recursive_mutex MessageSvc::m_thresholdMapMutex

mutableprivate

Mutex to synchronize multiple access to m_thresholdMap (.

See also: MsgStream::doOutput).

Definition at line 215 of file MessageSvc.h.

◆ m_thresholdProp

std::array<Gaudi::Property<std::vector<std::string> >, MSG::NUM_LEVELS> MessageSvc::m_thresholdProp

private

Initial value:

{ { {  },
                                                                                            { this, "setVerbose" },
                                                                                            { this, "setDebug" },
                                                                                            { this, "setInfo" },
                                                                                            { this, "setWarning" },
                                                                                            { this, "setError" },
                                                                                            { this, "setFatal" },
                                                                                            { this, "setAlways" } } }

Definition at line 137 of file MessageSvc.h.

                                                                              { { { /*ignored*/ },
                                                                                            { this, "setVerbose" },
                                                                                            { this, "setDebug" },
                                                                                            { this, "setInfo" },
                                                                                            { this, "setWarning" },
                                                                                            { this, "setError" },
                                                                                            { this, "setFatal" },
                                                                                            { this, "setAlways" } } };

◆ m_tracedInactiveSources

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

private

Initial value:

{
      this,
      "tracedInactiveSources",
      {},
      "for each message source specified,  print a stack trace for the unprotected and unseen messages" }

Definition at line 169 of file MessageSvc.h.

                                                             {
      this,
      "tracedInactiveSources",
      {},
      "for each message source specified,  print a stack trace for the unprotected and unseen messages" };

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

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

Classes

Public Types

Public Member Functions

Protected Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ MessageMap

◆ NamedStream

◆ StreamMap

◆ ThresholdMap

Constructor & Destructor Documentation

◆ MessageSvc()

Member Function Documentation

◆ defaultStream()

◆ eraseMessage() [1/3]

◆ eraseMessage() [2/3]

◆ eraseMessage() [3/3]

◆ eraseStream() [1/4]

◆ eraseStream() [2/4]

◆ eraseStream() [3/4]

◆ eraseStream() [4/4]

◆ finalize()

◆ getLogColor()

◆ i_reportMessage() [1/2]

◆ i_reportMessage() [2/2]

◆ incrInactiveCount()

◆ initialize()

◆ insertMessage()

◆ insertStream()

◆ messageCount()

◆ outputLevel() [1/2]

◆ outputLevel() [2/2]

◆ reinitialize()

◆ reportMessage() [1/4]

◆ reportMessage() [2/4]

◆ reportMessage() [3/4]

◆ reportMessage() [4/4]

◆ setDefaultStream()

◆ setOutputLevel() [1/2]

◆ setOutputLevel() [2/2]

◆ setupColors()

◆ setupInactCount()

◆ setupLimits()

◆ setupLogStreams()

◆ setupThreshold()

◆ useColor()

Member Data Documentation

◆ m_color

◆ m_defaultFormat

◆ m_defaultMessage

◆ m_defaultStream

◆ m_defaultTimeFormat

◆ m_inactCount

◆ m_inactiveMap

◆ m_logColorCodes

◆ m_logColors

◆ m_loggedStreams

◆ m_loggedStreamsName

◆ m_messageMap

◆ m_messageMapMutex

◆ m_msgCount

◆ m_msgLimit

◆ m_reportMutex

◆ m_sourceMap

◆ m_statLevel

◆ m_stats

◆ m_streamMap

◆ m_suppress

◆ m_thresholdMap

◆ m_thresholdMapMutex

◆ m_thresholdProp

◆ m_tracedInactiveSources