MessageSvc used by the HLT applications. More...

#include <TrigMessageSvc.h>

Inheritance diagram for TrigMessageSvc:

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

Public Types
typedef std::map< std::string, int, std::less<> >	ThresholdMap

Public Member Functions
	TrigMessageSvc (const std::string &name, ISvcLocator *svcloc)
virtual StatusCode	reinitialize () override
virtual StatusCode	initialize () override
virtual StatusCode	start () override
virtual StatusCode	stop () override
virtual StatusCode	finalize () override
virtual void	handle (const Incident &incident) override
virtual void	reportMessage (const Message &message) override
virtual void	reportMessage (const Message &msg, int outputLevel) override
virtual void	reportMessage (std::string source, int type, std::string message) 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 int	messageCount (MSG::Level logLevel) const override
virtual bool	useColor () const override
virtual std::string	getLogColor (int) const override

virtual void	reportMessage (const StatusCode &, std::string_view) override
	Not supported by this implementation.
virtual void	insertMessage (const StatusCode &, Message) override
virtual void	eraseMessage () override
virtual void	eraseMessage (const StatusCode &) override
virtual void	eraseMessage (const StatusCode &, const Message &) override
virtual void	insertStream (int, std::string, std::ostream *) override
virtual void	eraseStream () override
virtual void	eraseStream (int) override
virtual void	eraseStream (int, std::ostream *) override
virtual void	eraseStream (std::ostream *) override

Private Member Functions
void	setupLimits (Gaudi::Details::PropertyBase &prop)
void	setupThreshold (Gaudi::Details::PropertyBase &prop)
bool	passErsFilter (const std::string &source, const std::vector< std::string > &filter) const
bool	passErsLimit (const Message &msg)
void	i_reportMessage (const Message &msg, int outputLevel)
	Internal implementation of reportMessage(const Message&,int) without lock.
void	i_reportERS (const Message &msg) const
	Report message to online messaging system (ERS)
void	asyncReporting ()
void	bookHistograms ()

Private Attributes
Gaudi::Property< std::string >	m_defaultFormat
Gaudi::Property< std::string >	m_ersFormat
Gaudi::Property< std::string >	m_defaultTimeFormat
Gaudi::Property< bool >	m_stats {this, "showStats", false, "Show message statistics"}
Gaudi::Property< unsigned int >	m_statLevel
Gaudi::Property< unsigned int >	m_publishLevel
Gaudi::Property< unsigned int >	m_eventIDLevel
Gaudi::Property< bool >	m_color
Gaudi::Property< bool >	m_suppress {this, "enableSuppression", false, "Enable message suppression"}
Gaudi::Property< bool >	m_suppressRunningOnly
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS >	m_thresholdProp
std::array< Gaudi::Property< int >, MSG::NUM_LEVELS >	m_msgLimit
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS >	m_useERS
	Special properties to control output to ERS of individual sources.
Gaudi::Property< int >	m_ersEventLimit
std::ostream *	m_defaultStream = &std::cout
	Pointer to the output stream.
ThresholdMap	m_thresholdMap
	Output level threshold map.
std::map< std::string, MsgAry >	m_sourceMap
	counts per source
std::array< int, MSG::NUM_LEVELS >	m_msgCount {}
	counts per level
std::map< size_t, unsigned int >	m_msgHashCount
	counts per message hash
std::unordered_map< EventContext::ContextID_t, std::pair< EventContext::ContextEvt_t, MsgAry > >	m_slotMsgCount
	counts per slot and level
bool	m_doPublish {false}
	are we publishing message statistics?
bool	m_doSuppress {false}
	is suppression currently enabled?
TH1I *	m_msgCountHist {nullptr}
	Message counting per level histogram.
TH2I *	m_msgCountSrcHist {nullptr}
	Message counting per message source.
std::recursive_mutex	m_thresholdMapMutex
bool	m_asyncReporting {false}
	(
std::thread	m_thread
	Thread for asynchronous reporting.
tbb::concurrent_bounded_queue< std::function< void()> >	m_messageActionsQueue

Detailed Description

MessageSvc used by the HLT applications.

This MessageSvc implementation it used by the HLT applications. It has some additional features compared to the default Gaudi MessageSvc. Most notably the forwarding of messages to the TDAQ ERS message system.

The message suppression is configured with the following parameters:

Parameters

<level>Limit	= 0: no message suppression for <level>
<level>Limit	= N > 0: suppress messages after N messages (per source)
<level>Limit	= -N < 0: use logarithmic suppression after N messages (per message)

Note, that the logarithmic suppression works on a per-message basis (ignoring any digits in the message).

Author: Iain Last, Werner Wiedenmann, Frank Winklmeier

Definition at line 56 of file TrigMessageSvc.h.

Member Typedef Documentation

◆ ThresholdMap

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

Definition at line 58 of file TrigMessageSvc.h.

Constructor & Destructor Documentation

◆ TrigMessageSvc()

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

Definition at line 38 of file TrigMessageSvc.cxx.

                                                                         :
    base_class(name, svcloc)
{
  m_outputLevel.declareUpdateHandler([svcloc](Gaudi::Details::PropertyBase&) {
    SmartIF<IAppMgrUI> app = svcloc;
    if (app) app->outputLevelUpdate();
  });
 
  for (int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
    m_msgLimit[ic].declareUpdateHandler(&TrigMessageSvc::setupLimits, this);
    m_thresholdProp[ic].declareUpdateHandler(&TrigMessageSvc::setupThreshold, this);
  }
 
  std::fill(std::begin(m_msgCount), std::end(m_msgCount), 0);
}

Member Function Documentation

◆ asyncReporting()

void TrigMessageSvc::asyncReporting ( )

private

Definition at line 269 of file TrigMessageSvc.cxx.

{
  m_asyncReporting = true;
  std::function<void()> action;
  while ( m_asyncReporting || !m_messageActionsQueue.empty() ) {
    m_messageActionsQueue.pop(action);
    action();
  }
}

◆ ATLAS_NOT_CONST_THREAD_SAFE()

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

inlineoverridevirtual

Definition at line 72 of file TrigMessageSvc.h.

  {
    return m_defaultStream;
  }

◆ bookHistograms()

void TrigMessageSvc::bookHistograms ( )

private

Definition at line 114 of file TrigMessageSvc.cxx.

{
  ServiceHandle<ITHistSvc> histSvc("THistSvc", name());
  if ( histSvc.retrieve().isFailure() ) {
    reportMessage(name(), MSG::WARNING, "Cannot find THistSvc. Message stats will not be published.");
    m_doPublish = false;
    return;
  }
 
  // monitoring information root directory
  const std::string path = "/EXPERT/HLTFramework/" + name() + "/";
  const int nLevelBins = MSG::NUM_LEVELS - m_publishLevel;
  m_msgCountHist = new TH1I("MessageCount", "Messages while RUNNING;Severity;Count",
                            nLevelBins, 0, nLevelBins);
 
  const int nSrcBins = 1;
  m_msgCountSrcHist = new TH2I("MessageCountBySource", "Messages while RUNNING;Severity;Source",
                               nLevelBins, 0, nLevelBins, nSrcBins, 0, nSrcBins);
 
  for (int i=m_publishLevel; i<MSG::NUM_LEVELS; i++) {
    m_msgCountHist->GetXaxis()->SetBinLabel(i-m_publishLevel+1, levelNames[i].c_str());
    m_msgCountSrcHist->GetXaxis()->SetBinLabel(i-m_publishLevel+1, levelNames[i].c_str());
  }
 
  if ( histSvc->regHist(path + m_msgCountHist->GetName(), m_msgCountHist).isFailure() ) {
    reportMessage(name(), MSG::WARNING, "Cannot register monitoring histogram 'MessageCount'");
  }
  if ( histSvc->regHist(path + m_msgCountSrcHist->GetName(), m_msgCountSrcHist).isFailure() ) {
    reportMessage(name(), MSG::WARNING, "Cannot register monitoring histogram 'MessageCountBySource'");
  }
}

◆ eraseMessage() [1/3]

virtual void TrigMessageSvc::eraseMessage ( )

inlineoverridevirtual

Definition at line 94 of file TrigMessageSvc.h.

94{ NOTSUPPORTED; }

NOTSUPPORTED

#define NOTSUPPORTED

Definition TrigMessageSvc.h:31

◆ eraseMessage() [2/3]

virtual void TrigMessageSvc::eraseMessage ( const StatusCode & )

inlineoverridevirtual

Definition at line 95 of file TrigMessageSvc.h.

95{ NOTSUPPORTED; }

◆ eraseMessage() [3/3]

virtual void TrigMessageSvc::eraseMessage	(	const StatusCode &	,
		const Message &	)

inlineoverridevirtual

Definition at line 96 of file TrigMessageSvc.h.

96{ NOTSUPPORTED; }

◆ eraseStream() [1/4]

virtual void TrigMessageSvc::eraseStream ( )

inlineoverridevirtual

Definition at line 98 of file TrigMessageSvc.h.

98{ NOTSUPPORTED; }

◆ eraseStream() [2/4]

virtual void TrigMessageSvc::eraseStream ( int )

inlineoverridevirtual

Definition at line 99 of file TrigMessageSvc.h.

99{ NOTSUPPORTED; }

◆ eraseStream() [3/4]

virtual void TrigMessageSvc::eraseStream	(	int	,
		std::ostream *	)

inlineoverridevirtual

Definition at line 100 of file TrigMessageSvc.h.

100{ NOTSUPPORTED; }

◆ eraseStream() [4/4]

virtual void TrigMessageSvc::eraseStream ( std::ostream * )

inlineoverridevirtual

Definition at line 101 of file TrigMessageSvc.h.

101{ NOTSUPPORTED; }

◆ finalize()

StatusCode TrigMessageSvc::finalize ( )

overridevirtual

Definition at line 207 of file TrigMessageSvc.cxx.

{
  m_suppress = false;
  std::ostringstream os;
 
  if (m_stats) {
    os << "Summarizing all message counts"
       << " (severity >= " << levelNames[m_statLevel] << ")" << 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 ((m_suppress && itr->second.msg[ic] >= abs(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) {
    reportMessage(name(), MSG::INFO, os.str());
  }
 
  return StatusCode::SUCCESS;
}

◆ getLogColor()

virtual std::string TrigMessageSvc::getLogColor ( int ) const

inlineoverridevirtual

Definition at line 89 of file TrigMessageSvc.h.

89{ return ""; }

◆ handle()

void TrigMessageSvc::handle ( const Incident & incident )

overridevirtual

Definition at line 106 of file TrigMessageSvc.cxx.

{
  if (incident.type() == AthenaInterprocess::UpdateAfterFork::type()) {
    reportMessage(name(), MSG::INFO, "Enabling asynchronous message reporting");
    m_thread = std::thread( &TrigMessageSvc::asyncReporting, this);
  }
}

◆ i_reportERS()

void TrigMessageSvc::i_reportERS ( const Message & msg ) const

private

Report message to online messaging system (ERS)

Definition at line 375 of file TrigMessageSvc.cxx.

{
  /*
   * Create ERS context object
   *
   * The (cross-node) MRS throttling is based on filename+line_number, i.e.
   * ignoring the message text itself. We therefor use the message source as
   * filename and the message hash as line_number. That way the same message
   * from different nodes gets properly throttled by MRS.
   */
  const char* filename = msg.getSource().c_str();
  const char* function_name = "";
  const int line_number = msgHash(msg);
  const char* package_name = "HLT";
  ers::LocalContext hlt_context_info(package_name, filename, line_number, function_name);
 
  // Create ERS issue object
  Message m(msg);
  if (m_eventIDLevel != MSG::NIL && msg.getType() >= static_cast<int>(m_eventIDLevel)) {
    m.setFormat(m_ersFormat + " %E");
  }
  else {
    m.setFormat(m_ersFormat);
  }
  std::ostringstream oss;
  oss << m;
  ers::HLTMessage ersMsg(hlt_context_info, oss.str());
  ersMsg.add_qualifier("HLT"); // useful for filtering
 
  // Forward Message to ERS
  switch (msg.getType()) {
  case MSG::NIL: break;
  case MSG::VERBOSE: ers::debug(ersMsg, 2); break;
  case MSG::DEBUG: ers::debug(ersMsg, 1); break;
  case MSG::INFO: ers::info(ersMsg); break;
  case MSG::WARNING: ers::warning(ersMsg); break;
  case MSG::ERROR: ers::error(ersMsg); break;
  case MSG::FATAL: ers::fatal(ersMsg); break;
  default:
    std::ostringstream oss;
    oss << "Unknown message severity level: " << msg.getType() << " Original message was: " << m;
    ers::error(ers::HLTMessage(ERS_HERE, oss.str()));
  }
}

◆ i_reportMessage()

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

private

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

Definition at line 283 of file TrigMessageSvc.cxx.

{
  const int key = msg.getType();
  ++m_msgCount[key];
 
  const Message* cmsg = &msg;
  bool doPrint = true;
  std::unique_ptr<Message> newMessage;
 
  if (m_doSuppress || m_stats.value()) {
 
    // Increase the counter of 'key' type of messages for the source and
    // get the new value.
    int nmsg = ++(m_sourceMap[msg.getSource()].msg[key]);
 
    const int msgLimit = m_msgLimit[key].value();
    if (m_doSuppress) {
      if (msgLimit > 0) { // regular suppression
        if (nmsg > msgLimit) doPrint = false;
        if (nmsg == msgLimit) {
          std::string txt = levelNames[key] + " message limit (" + std::to_string(msgLimit) +
                            ") reached for " + msg.getSource() + ". Suppressing further output.";
          newMessage = std::make_unique<Message>(msg.getSource(), MSG::WARNING, std::move(txt));
          cmsg = newMessage.get();
        }
      }
    }
    else if (msgLimit < 0) { // logarithmic suppression
      // Calculate message hash
      const unsigned int mh = msgHash(*cmsg);
      // Check if we saw this message already and increase counter
      auto m = m_msgHashCount.find(mh);
      if (m != m_msgHashCount.end()) {
        nmsg = ++m->second;
      }
      else {
        nmsg = m_msgHashCount[mh] = 1;
      }
      if (nmsg == abs(msgLimit)) {
        std::ostringstream os;
        os << msg.getMessage() << " [Message limit (" << abs(msgLimit)
           << ") reached. Log-suppression of further output.]";
        newMessage = std::make_unique<Message>(msg.getSource(), msg.getType(), os.str());
        cmsg = newMessage.get();
      }
      else if (nmsg > abs(msgLimit)) {
        const int everyNth = (int)exp10((int)log10(nmsg));
        if ((nmsg % everyNth) == 0) {
          std::ostringstream os;
          os << msg.getMessage() << " [suppressed " << everyNth << " similar messages]";
          newMessage = std::make_unique<Message>(msg.getSource(), msg.getType(), os.str());
          cmsg = newMessage.get();
        }
      }
    }
  }
 
  // Print the message
  if (doPrint && key >= outputLevel) {
    if (m_eventIDLevel != MSG::NIL && key >= static_cast<int>(m_eventIDLevel)) {
      cmsg->setFormat(m_defaultFormat + " %E");
    }
    else {
      cmsg->setFormat(m_defaultFormat);
    }
    cmsg->setTimeFormat(m_defaultTimeFormat);
    (*m_defaultStream) << *cmsg << std::endl << std::flush;
 
    // ERS forwarding
    if (passErsFilter(cmsg->getSource(), m_useERS[key]) && passErsLimit(*cmsg)) {
      i_reportERS(*cmsg);
    }
  }
 
  // Publish message statistics if enabled and only while RUNNING
  if ( m_doPublish && key>=static_cast<int>(m_publishLevel) ) {
    m_msgCountHist->Fill(key-m_publishLevel, 1);
    if (ATH_UNLIKELY(m_msgCountSrcHist->GetYaxis()->FindFixBin(msg.getSource().c_str())<0)) {
      // Adding bins on the fly needs to be protected by mutex
      oh_scoped_lock_histogram lock;
      m_msgCountSrcHist->Fill(key-m_publishLevel, msg.getSource().c_str(), 1);
      m_msgCountSrcHist->LabelsDeflate("Y");
    }
    else {
      m_msgCountSrcHist->Fill(key-m_publishLevel, msg.getSource().c_str(), 1);
    }
  }
}

◆ initialize()

StatusCode TrigMessageSvc::initialize ( )

overridevirtual

Definition at line 54 of file TrigMessageSvc.cxx.

{
  StatusCode sc = Service::initialize();
  if (sc.isFailure()) return sc;
 
  ServiceHandle<IIncidentSvc> incSvc("IncidentSvc", name());
  sc = incSvc.retrieve();
  if (sc.isFailure()) {
    reportMessage(name(), MSG::WARNING, "Cannot find IncidentSvc");
  }
  else {
    incSvc->addListener(this, AthenaInterprocess::UpdateAfterFork::type());
  }
 
  m_doSuppress = m_suppress && (!m_suppressRunningOnly);
 
  if (m_color) {
    std::cout << "TrigMessageSvc WARNING: Colors are not supported by TrigMessageSvc" << std::endl;
  }
  return StatusCode::SUCCESS;
}

◆ insertMessage()

virtual void TrigMessageSvc::insertMessage	(	const StatusCode &	,
		Message	)

inlineoverridevirtual

Definition at line 93 of file TrigMessageSvc.h.

93{ NOTSUPPORTED; }

◆ insertStream()

virtual void TrigMessageSvc::insertStream	(	int	,
		std::string	,
		std::ostream *	)

inlineoverridevirtual

Definition at line 97 of file TrigMessageSvc.h.

97{ NOTSUPPORTED; }

◆ messageCount()

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

overridevirtual

Definition at line 460 of file TrigMessageSvc.cxx.

{
  return m_msgCount[level];
}

◆ outputLevel() [1/2]

int TrigMessageSvc::outputLevel ( ) const

overridevirtual

Definition at line 430 of file TrigMessageSvc.cxx.

{
  return m_outputLevel;
}

◆ outputLevel() [2/2]

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

overridevirtual

Definition at line 435 of file TrigMessageSvc.cxx.

{
  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();
}

◆ passErsFilter()

bool TrigMessageSvc::passErsFilter	(	const std::string &	source,
		const std::vector< std::string > &	filter ) const

private

Definition at line 465 of file TrigMessageSvc.cxx.

{
  if (filter.empty()) return false; // forward none
  auto it = filter.begin();
  if (filter.size() == 1 && (*it) == "*") return true; // forward all
 
  bool pass(false);
  for (; it != filter.end(); ++it) {
    if ((*it) == "*") pass = true;           // forward except if there is a veto later
    if (source == (*it)) return true;        // forward specific source
    if ("!" + source == (*it)) return false; // veto specific source
  }
  return pass;
}

◆ passErsLimit()

bool TrigMessageSvc::passErsLimit ( const Message & msg )

private

Definition at line 481 of file TrigMessageSvc.cxx.

{
  if (m_ersEventLimit < 0) return true;
 
  const EventContext::ContextID_t slot = msg.getEventSlot();
  const EventContext::ContextEvt_t evt = msg.getEventNumber();
  // get or create message statistics for this slot
  auto [itr, inserted] = m_slotMsgCount.insert( {slot, {evt, MsgAry()} } );
 
  // if new event in slot then reset counters
  if ( itr->second.first != evt ) {
    itr->second = {evt, MsgAry()};
  }
 
  // increment number of messages for this level and slot
  const int N = ++itr->second.second.msg[msg.getType()];
 
  return N <= m_ersEventLimit;
}

◆ reinitialize()

StatusCode TrigMessageSvc::reinitialize ( )

overridevirtual

Definition at line 76 of file TrigMessageSvc.cxx.

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

◆ reportMessage() [1/4]

void TrigMessageSvc::reportMessage ( const Message & message )

overridevirtual

Definition at line 420 of file TrigMessageSvc.cxx.

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

◆ reportMessage() [2/4]

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

overridevirtual

Definition at line 257 of file TrigMessageSvc.cxx.

{
  if (m_asyncReporting) {
    // msg has to be copied as the reference may become invalid by the time it is used
    m_messageActionsQueue.emplace([this, m=Message(msg), outputLevel]() {
      this->i_reportMessage(m, outputLevel); });
  }
  else {
    i_reportMessage(msg, outputLevel);
  }
}

◆ reportMessage() [3/4]

virtual void TrigMessageSvc::reportMessage	(	const StatusCode &	,
		std::string_view	)

inlineoverridevirtual

Not supported by this implementation.

Definition at line 92 of file TrigMessageSvc.h.

92{ NOTSUPPORTED; }

◆ reportMessage() [4/4]

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

overridevirtual

Definition at line 425 of file TrigMessageSvc.cxx.

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

◆ setDefaultStream()

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

inlineoverridevirtual

Definition at line 77 of file TrigMessageSvc.h.

  {
    m_defaultStream = stream;
  }

◆ setOutputLevel() [1/2]

void TrigMessageSvc::setOutputLevel ( int new_level )

overridevirtual

Definition at line 442 of file TrigMessageSvc.cxx.

{
  m_outputLevel = new_level;
}

◆ setOutputLevel() [2/2]

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

overridevirtual

Definition at line 447 of file TrigMessageSvc.cxx.

{
  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.emplace( source, level );
  } else if ( i->second != level ) {
    i->second = level;
  }
}

◆ setupLimits()

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

private

Definition at line 147 of file TrigMessageSvc.cxx.

{
  // 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 << "TrigMessageSvc 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 << "TrigMessageSvc ERROR: Unknown message limit parameter: " << prop.name()
              << std::endl;
    return;
  }
}

◆ setupThreshold()

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

private

Definition at line 174 of file TrigMessageSvc.cxx.

{
  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 << "TrigMessageSvc 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);
  }
}

◆ start()

StatusCode TrigMessageSvc::start ( )

overridevirtual

Definition at line 84 of file TrigMessageSvc.cxx.

{
  bookHistograms();
  m_doPublish = true;
  m_doSuppress = m_suppress;
  return StatusCode::SUCCESS;
}

◆ stop()

StatusCode TrigMessageSvc::stop ( )

overridevirtual

Definition at line 92 of file TrigMessageSvc.cxx.

{
  // Disable asynchronous reporting again
  if (m_asyncReporting) {
    m_messageActionsQueue.emplace( [this]() {m_asyncReporting = false;} );
    reportMessage(name(), MSG::INFO, "Disabling asynchronous message reporting");
    m_thread.join();
  }
 
  m_doPublish = false;
  m_doSuppress = m_suppress && (!m_suppressRunningOnly);
  return StatusCode::SUCCESS;
}

◆ useColor()

virtual bool TrigMessageSvc::useColor ( ) const

inlineoverridevirtual

Definition at line 88 of file TrigMessageSvc.h.

88{ return m_color; }

Member Data Documentation

◆ m_asyncReporting

bool TrigMessageSvc::m_asyncReporting {false}

private

(

See also: MsgStream::doOutput). Async reporting active

Definition at line 196 of file TrigMessageSvc.h.

196{false};

◆ m_color

Gaudi::Property<bool> TrigMessageSvc::m_color

private

Initial value:

{this, "useColors", false,

"Colors are not supported by TrigMessageSvc"}

Definition at line 121 of file TrigMessageSvc.h.

121 {this, "useColors", false,

122 "Colors are not supported by TrigMessageSvc"};

◆ m_defaultFormat

Gaudi::Property<std::string> TrigMessageSvc::m_defaultFormat

private

Initial value:

{this, "Format", Message::getDefaultFormat(),

"Default message format"}

Definition at line 108 of file TrigMessageSvc.h.

108 {this, "Format", Message::getDefaultFormat(),

109 "Default message format"};

◆ m_defaultStream

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

private

Pointer to the output stream.

Definition at line 171 of file TrigMessageSvc.h.

◆ m_defaultTimeFormat

Gaudi::Property<std::string> TrigMessageSvc::m_defaultTimeFormat

private

Initial value:

{

this, "timeFormat", Message::getDefaultTimeFormat(), "Message time format"}

Definition at line 112 of file TrigMessageSvc.h.

112 {

113 this, "timeFormat", Message::getDefaultTimeFormat(), "Message time format"};

◆ m_doPublish

bool TrigMessageSvc::m_doPublish {false}

private

are we publishing message statistics?

Definition at line 188 of file TrigMessageSvc.h.

188{false};

◆ m_doSuppress

bool TrigMessageSvc::m_doSuppress {false}

private

is suppression currently enabled?

Definition at line 189 of file TrigMessageSvc.h.

189{false};

◆ m_ersEventLimit

Gaudi::Property<int> TrigMessageSvc::m_ersEventLimit

private

Initial value:

{this, "ersPerEventLimit", -1,

"Maximum number of messages (per event and level) that are forwarded to ERS (-1: disabled)"}

Definition at line 165 of file TrigMessageSvc.h.

165 {this, "ersPerEventLimit", -1,

166 "Maximum number of messages (per event and level) that are forwarded to ERS (-1: disabled)"};

◆ m_ersFormat

Gaudi::Property<std::string> TrigMessageSvc::m_ersFormat

private

Initial value:

{this, "ErsFormat", Message::getDefaultFormat(),

"ERS message format"}

Definition at line 110 of file TrigMessageSvc.h.

110 {this, "ErsFormat", Message::getDefaultFormat(),

111 "ERS message format"};

◆ m_eventIDLevel

Gaudi::Property<unsigned int> TrigMessageSvc::m_eventIDLevel

private

Initial value:

{this, "printEventIDLevel", MSG::NIL,

"Print event ID for this and higher message levels"}

Definition at line 119 of file TrigMessageSvc.h.

119 {this, "printEventIDLevel", MSG::NIL,

120 "Print event ID for this and higher message levels"};

◆ m_messageActionsQueue

tbb::concurrent_bounded_queue<std::function<void()> > TrigMessageSvc::m_messageActionsQueue

private

Definition at line 198 of file TrigMessageSvc.h.

◆ m_msgCount

std::array<int, MSG::NUM_LEVELS> TrigMessageSvc::m_msgCount {}

private

counts per level

Definition at line 183 of file TrigMessageSvc.h.

183{};

◆ m_msgCountHist

TH1I* TrigMessageSvc::m_msgCountHist {nullptr}

private

Message counting per level histogram.

Definition at line 191 of file TrigMessageSvc.h.

191{nullptr};

◆ m_msgCountSrcHist

TH2I* TrigMessageSvc::m_msgCountSrcHist {nullptr}

private

Message counting per message source.

Definition at line 192 of file TrigMessageSvc.h.

192{nullptr};

◆ m_msgHashCount

std::map<size_t, unsigned int> TrigMessageSvc::m_msgHashCount

private

counts per message hash

Definition at line 184 of file TrigMessageSvc.h.

◆ m_msgLimit

std::array<Gaudi::Property<int>, MSG::NUM_LEVELS> TrigMessageSvc::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 137 of file TrigMessageSvc.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_publishLevel

Gaudi::Property<unsigned int> TrigMessageSvc::m_publishLevel

private

Initial value:

{this, "publishLevel", MSG::INFO,

"Publish message statistics for this and higher message levels"}

Definition at line 117 of file TrigMessageSvc.h.

117 {this, "publishLevel", MSG::INFO,

118 "Publish message statistics for this and higher message levels"};

◆ m_slotMsgCount

std::unordered_map<EventContext::ContextID_t, std::pair<EventContext::ContextEvt_t, MsgAry> > TrigMessageSvc::m_slotMsgCount

private

counts per slot and level

Definition at line 186 of file TrigMessageSvc.h.

◆ m_sourceMap

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

private

counts per source

Definition at line 182 of file TrigMessageSvc.h.

◆ m_statLevel

Gaudi::Property<unsigned int> TrigMessageSvc::m_statLevel

private

Initial value:

{this, "statLevel", 0,

"Show total message statistics for >= level"}

Definition at line 115 of file TrigMessageSvc.h.

115 {this, "statLevel", 0,

116 "Show total message statistics for >= level"};

◆ m_stats

Gaudi::Property<bool> TrigMessageSvc::m_stats {this, "showStats", false, "Show message statistics"}

private

Definition at line 114 of file TrigMessageSvc.h.

114{this, "showStats", false, "Show message statistics"};

◆ m_suppress

Gaudi::Property<bool> TrigMessageSvc::m_suppress {this, "enableSuppression", false, "Enable message suppression"}

private

Definition at line 123 of file TrigMessageSvc.h.

123{this, "enableSuppression", false, "Enable message suppression"};

◆ m_suppressRunningOnly

Gaudi::Property<bool> TrigMessageSvc::m_suppressRunningOnly

private

Initial value:

{this, "suppressRunningOnly", true,

"Use message suppression only during RUNNING state"}

Definition at line 124 of file TrigMessageSvc.h.

124 {this, "suppressRunningOnly", true,

125 "Use message suppression only during RUNNING state"};

◆ m_thread

std::thread TrigMessageSvc::m_thread

private

Thread for asynchronous reporting.

Definition at line 197 of file TrigMessageSvc.h.

◆ m_thresholdMap

ThresholdMap TrigMessageSvc::m_thresholdMap

private

Output level threshold map.

Definition at line 172 of file TrigMessageSvc.h.

◆ m_thresholdMapMutex

std::recursive_mutex TrigMessageSvc::m_thresholdMapMutex

mutableprivate

Definition at line 194 of file TrigMessageSvc.h.

◆ m_thresholdProp

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

private

Initial value:

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

Definition at line 127 of file TrigMessageSvc.h.

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

◆ m_useERS

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

private

Initial value:

{
      {{},
       {this, "useErsVerbose", {}},
       {this, "useErsDebug", {}},
       {this, "useErsInfo", {}},
       {this, "useErsWarning", {}},
       {this, "useErsError", {}},
       {this, "useErsFatal", {}},
       {this, "useErsAlways", {}}}}

Special properties to control output to ERS of individual sources.

The syntax is as follows (these are NOT regular expressions):

useErsFatal = [] # forward none (default) useErsFatal = [''] # forward all useErsFatal = ['CoreDumpSvc','MyAlg'] # forward these sources useErsFatal = ['','!MyAlg'] # forward all except MyAlg

Definition at line 155 of file TrigMessageSvc.h.

                                                                       {
      {{/*ignored*/},
       {this, "useErsVerbose", {}},
       {this, "useErsDebug", {}},
       {this, "useErsInfo", {}},
       {this, "useErsWarning", {}},
       {this, "useErsError", {}},
       {this, "useErsFatal", {}},
       {this, "useErsAlways", {}}}};

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

Classes

Public Types

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ ThresholdMap

Constructor & Destructor Documentation

◆ TrigMessageSvc()

Member Function Documentation

◆ asyncReporting()

◆ ATLAS_NOT_CONST_THREAD_SAFE()

◆ bookHistograms()

◆ eraseMessage() [1/3]

◆ eraseMessage() [2/3]

◆ eraseMessage() [3/3]

◆ eraseStream() [1/4]

◆ eraseStream() [2/4]

◆ eraseStream() [3/4]

◆ eraseStream() [4/4]

◆ finalize()

◆ getLogColor()

◆ handle()

◆ i_reportERS()

◆ i_reportMessage()

◆ initialize()

◆ insertMessage()

◆ insertStream()

◆ messageCount()

◆ outputLevel() [1/2]

◆ outputLevel() [2/2]

◆ passErsFilter()

◆ passErsLimit()

◆ reinitialize()

◆ reportMessage() [1/4]

◆ reportMessage() [2/4]

◆ reportMessage() [3/4]

◆ reportMessage() [4/4]

◆ setDefaultStream()

◆ setOutputLevel() [1/2]

◆ setOutputLevel() [2/2]

◆ setupLimits()

◆ setupThreshold()

◆ start()

◆ stop()

◆ useColor()

Member Data Documentation

◆ m_asyncReporting

◆ m_color

◆ m_defaultFormat

◆ m_defaultStream

◆ m_defaultTimeFormat

◆ m_doPublish

◆ m_doSuppress

◆ m_ersEventLimit

◆ m_ersFormat

◆ m_eventIDLevel

◆ m_messageActionsQueue

◆ m_msgCount

◆ m_msgCountHist

◆ m_msgCountSrcHist

◆ m_msgHashCount

◆ m_msgLimit

◆ m_publishLevel

◆ m_slotMsgCount

◆ m_sourceMap

◆ m_statLevel

◆ m_stats

◆ m_suppress

◆ m_suppressRunningOnly

◆ m_thread

◆ m_thresholdMap

◆ m_thresholdMapMutex

◆ m_thresholdProp

◆ m_useERS