ATLAS Offline Software
Classes | Public Types | Public Member Functions | Private Types | Private Member Functions | Private Attributes | List of all members
LoggedMessageSvc Class Reference

#include <LoggedMessageSvc.h>

Inheritance diagram for LoggedMessageSvc:
Collaboration diagram for LoggedMessageSvc:

Classes

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

Public Types

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

Public Member Functions

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

Private Types

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

Private Member Functions

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

Private Attributes

std::ostream * m_defaultStream
 Pointer to the output stream. 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 controling. More...
 
BooleanProperty m_color
 
BooleanProperty m_stats
 
UnsignedIntegerProperty m_statLevel
 
StringArrayProperty m_logColors [MSG::NUM_LEVELS]
 
IntegerProperty m_msgLimit [MSG::NUM_LEVELS]
 
IntegerProperty m_logLevel
 
StringArrayProperty m_keywords
 
std::string m_logColorCodes [MSG::NUM_LEVELS]
 
std::map< std::string, MsgAry, std::less<> > m_sourceMap
 
std::map< std::string, MsgAry, std::less<> > m_inactiveMap
 
BooleanProperty m_suppress
 
BooleanProperty m_inactCount
 
ColorMap m_colMap
 
int m_msgCount [MSG::NUM_LEVELS]
 
std::map< std::string, std::string > m_loggedStreamsName
 
LoggedStreamsMap_t m_loggedStreams
 
std::mutex m_reportMutex
 Mutex to synchronize multiple threads printing. More...
 
std::recursive_mutex m_messageMapMutex
 Mutex to synchronize multiple access to m_messageMap. More...
 
std::mutex m_thresholdMapMutex
 Mutex to synchronize multiple access to m_thresholdMap (. More...
 
std::vector< std::pair< std::string, std::string > > m_msgLog [MSG::NUM_LEVELS]
 
std::vector< LoggedMessage > m_msgKeyLog
 
bool m_keysUsed
 

Detailed Description

Definition at line 37 of file LoggedMessageSvc.h.

Member Typedef Documentation

◆ ColorMap

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

Definition at line 171 of file LoggedMessageSvc.h.

◆ LoggedStreamsMap_t

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

Definition at line 177 of file LoggedMessageSvc.h.

◆ MessageMap

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

Definition at line 43 of file LoggedMessageSvc.h.

◆ NamedStream

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

Definition at line 41 of file LoggedMessageSvc.h.

◆ StreamMap

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

Definition at line 42 of file LoggedMessageSvc.h.

◆ ThresholdMap

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

Definition at line 44 of file LoggedMessageSvc.h.

Constructor & Destructor Documentation

◆ LoggedMessageSvc()

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

Definition at line 23 of file LoggedMessageSvc.cxx.

24  : base_class( name, svcloc ), m_keysUsed(false)
25  {
26  m_defaultStream = &std::cout;
27  m_outputLevel = MSG::INFO;
28  declareProperty( "Format", m_defaultFormat = Message::getDefaultFormat() );
29  declareProperty( "timeFormat", m_defaultTimeFormat = Message::getDefaultTimeFormat() );
30  declareProperty( "showStats", m_stats = false );
31  declareProperty( "statLevel", m_statLevel = 0 );
32 
33  // Special properties to control output level of individual sources
34  declareProperty( "setVerbose", m_thresholdProp[MSG::VERBOSE] );
35  declareProperty( "setDebug", m_thresholdProp[MSG::DEBUG] );
36  declareProperty( "setInfo", m_thresholdProp[MSG::INFO] );
37  declareProperty( "setWarning", m_thresholdProp[MSG::WARNING] );
38  declareProperty( "setError", m_thresholdProp[MSG::ERROR] );
39  declareProperty( "setFatal", m_thresholdProp[MSG::FATAL] );
40  declareProperty( "setAlways", m_thresholdProp[MSG::ALWAYS] );
41 
42  declareProperty( "useColors", m_color=false);
43  m_color.declareUpdateHandler(&LoggedMessageSvc::initColors, this);
44 
45  declareProperty( "fatalColorCode", m_logColors[MSG::FATAL] );
46  declareProperty( "errorColorCode", m_logColors[MSG::ERROR] );
47  declareProperty( "warningColorCode", m_logColors[MSG::WARNING] );
48  declareProperty( "infoColorCode", m_logColors[MSG::INFO] );
49  declareProperty( "debugColorCode", m_logColors[MSG::DEBUG] );
50  declareProperty( "verboseColorCode", m_logColors[MSG::VERBOSE] );
51  declareProperty( "alwaysColorCode", m_logColors[MSG::ALWAYS] );
52 
53  const int defaultLimit = 500;
54  declareProperty( "fatalLimit", m_msgLimit[MSG::FATAL] = defaultLimit );
55  declareProperty( "errorLimit", m_msgLimit[MSG::ERROR] = defaultLimit );
56  declareProperty( "warningLimit", m_msgLimit[MSG::WARNING] = defaultLimit );
57  declareProperty( "infoLimit", m_msgLimit[MSG::INFO] = defaultLimit );
58  declareProperty( "debugLimit", m_msgLimit[MSG::DEBUG] = defaultLimit );
59  declareProperty( "verboseLimit", m_msgLimit[MSG::VERBOSE] = defaultLimit );
60  declareProperty( "alwaysLimit", m_msgLimit[MSG::ALWAYS] = 0 );
61 
62  declareProperty( "defaultLimit", m_msgLimit[MSG::NIL] = defaultLimit );
63 
64  declareProperty( "enableSuppression", m_suppress = false );
65  declareProperty( "countInactive", m_inactCount = false )->declareUpdateHandler( &LoggedMessageSvc::setupInactCount, this );
66 #ifndef NDEBUG
67  // initialize the MsgStream static flag.
68  MsgStream::enableCountInactive(m_inactCount);
69 #endif
70 
71  declareProperty( "loggingLevel", m_logLevel = MSG::FATAL, "Message level above which all messages are saved" );
72  m_logLevel.declareUpdateHandler(&LoggedMessageSvc::setupThreshold, this);
73 
74  declareProperty( "keywords", m_keywords, "keywords to scan messages for and save");
75  m_keywords.declareUpdateHandler(&LoggedMessageSvc::setupThreshold, this);
76 
77  declareProperty( "loggedStreams",
78  m_loggedStreamsName,
79  "MessageStream sources we want to dump into a logfile" );
80 
81  for (int ic=0; ic<MSG::NUM_LEVELS; ++ic) {
82  m_logColors[ic].declareUpdateHandler(&LoggedMessageSvc::setupColors, this);
83  m_msgLimit[ic].declareUpdateHandler(&LoggedMessageSvc::setupLimits, this);
84  m_thresholdProp[ic].declareUpdateHandler(&LoggedMessageSvc::setupThreshold, this);
85  }
86 
87  for (int i=0; i<MSG::NUM_LEVELS; ++i) {
88  m_msgCount[i] = 0;
89  }
90 
91 }

◆ ~LoggedMessageSvc()

LoggedMessageSvc::~LoggedMessageSvc ( )
virtual

Definition at line 95 of file LoggedMessageSvc.cxx.

96 {
97  // closing log-files, if any
98  LoggedStreamsMap_t::iterator iStream = m_loggedStreams.begin();
99  LoggedStreamsMap_t::iterator endStream = m_loggedStreams.end();
100  for ( ; iStream != endStream; ++iStream ) {
101  delete iStream->second;
102  iStream->second = nullptr;
103  }
104 }

Member Function Documentation

◆ ATLAS_NOT_CONST_THREAD_SAFE()

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

Definition at line 98 of file LoggedMessageSvc.h.

98  {
99  return m_defaultStream;
100  }

◆ colTrans()

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

Definition at line 476 of file LoggedMessageSvc.cxx.

476  {
477  ColorMap::const_iterator itr = m_colMap.find(col);
478  int icol;
479  if (itr != m_colMap.end()) {
480  icol = offset + itr->second;
481  } else {
482  icol = offset + 8;
483  }
484  std::ostringstream os1;
485 
486  os1 << icol;
487 
488  return os1.str();
489 
490 }

◆ eraseMessage() [1/3]

void LoggedMessageSvc::eraseMessage ( )
overridevirtual

Definition at line 760 of file LoggedMessageSvc.cxx.

761 {
762  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
763 
764  m_messageMap.erase( m_messageMap.begin(), m_messageMap.end() );
765 }

◆ eraseMessage() [2/3]

void LoggedMessageSvc::eraseMessage ( const StatusCode &  code)
overridevirtual

Definition at line 774 of file LoggedMessageSvc.cxx.

775 {
776  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
777 
778  m_messageMap.erase( key );
779 }

◆ eraseMessage() [3/3]

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

Definition at line 788 of file LoggedMessageSvc.cxx.

789 {
790  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
791 
792  bool changed = true;
793  while( changed ) {
794  changed = false;
795  MessageMap::iterator first = m_messageMap.lower_bound( key );
796  MessageMap::iterator last = m_messageMap.upper_bound( key );
797  while( first != last ) {
798  const Message& message = (*first).second;
799  if ( message == msg ) {
800  m_messageMap.erase( first );
801  changed = true;
802  break;
803  }
804  }
805  }
806 }

◆ eraseStream() [1/4]

void LoggedMessageSvc::eraseStream ( )
overridevirtual

Definition at line 672 of file LoggedMessageSvc.cxx.

673 {
674  m_streamMap.erase( m_streamMap.begin(), m_streamMap.end() );
675 }

◆ eraseStream() [2/4]

void LoggedMessageSvc::eraseStream ( int  message_type)
overridevirtual

Definition at line 684 of file LoggedMessageSvc.cxx.

685 {
686  m_streamMap.erase( message_type );
687 }

◆ eraseStream() [3/4]

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

Definition at line 696 of file LoggedMessageSvc.cxx.

696  {
697  if ( nullptr != stream ) {
698  bool changed = true;
699  while( changed ) {
700  changed = false;
701  StreamMap::iterator first = m_streamMap.lower_bound( key );
702  StreamMap::iterator last = m_streamMap.upper_bound( key );
703  while( first != last ) {
704  if ( (*first).second.second == stream ) {
705  m_streamMap.erase( first );
706  changed = true;
707  break;
708  }
709  }
710  }
711  }
712 }

◆ eraseStream() [4/4]

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

Definition at line 721 of file LoggedMessageSvc.cxx.

721  {
722  if ( nullptr != stream ) {
723  bool changed = true;
724  while( changed ) {
725  changed = false;
726  StreamMap::iterator first = m_streamMap.begin();
727  while( first != m_streamMap.end() ) {
728  if ( (*first).second.second == stream ) {
729  m_streamMap.erase( first );
730  changed = true;
731  break;
732  }
733  }
734  }
735  }
736 }

◆ finalize()

StatusCode LoggedMessageSvc::finalize ( )
overridevirtual

Finalize Service.

Definition at line 348 of file LoggedMessageSvc.cxx.

348  {
349 
350  m_suppress = false;
351 
352  std::ostringstream os;
353 
354  if (m_stats) {
355  os << "Summarizing all message counts" << endl;
356  } else {
357  os << "Listing sources of suppressed message: " << endl;
358  }
359 
360  os << "=====================================================" << endl;
361  os << " Message Source | Level | Count" << endl;
362  os << "-----------------------------+---------+-------------" << endl;
363 
364 
365  bool found(false);
366 
367  std::map<std::string,MsgAry>::const_iterator itr;
368  for (itr=m_sourceMap.begin(); itr!=m_sourceMap.end(); ++itr) {
369  for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
370  if ( (itr->second.msg[ic] >= m_msgLimit[ic] && m_msgLimit[ic] != 0 ) ||
371  (m_stats && itr->second.msg[ic] > 0 && ic >= m_statLevel.value()) ) {
372  os << " ";
373  os.width(28);
374  os.setf(ios_base::left,ios_base::adjustfield);
375  os << itr->first;
376 
377  os << "|";
378 
379  os.width(8);
380  os.setf(ios_base::right,ios_base::adjustfield);
381  os << levelNames[ic];
382 
383  os << " |";
384 
385  os.width(9);
386  os << itr->second.msg[ic];
387 
388  os << endl;
389 
390  found = true;
391  }
392  }
393  }
394  os << "=====================================================" << endl;
395 
396  if (found || m_stats) {
397  cout << os.str();
398  }
399 
400 
401 #ifndef NDEBUG
402  if (m_inactCount.value()) {
403 
404  std::ostringstream os;
405  os << "Listing sources of Unprotected and Unseen messages\n";
406 
407  bool found(false);
408 
409  unsigned int ml(0);
410  std::map<std::string,MsgAry>::const_iterator itr;
411  for (itr=m_inactiveMap.begin(); itr!=m_inactiveMap.end(); ++itr) {
412  for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
413  if (itr->second.msg[ic] != 0) {
414  if (itr->first.length() > ml) { ml = itr->first.length(); }
415  }
416  }
417  }
418 
419  for (unsigned int i=0; i<ml+25; ++i) {
420  os << "=";
421  }
422 
423  os << endl << " ";
424  os.width(ml+2);
425  os.setf(ios_base::left,ios_base::adjustfield);
426  os << "Message Source";
427  os.width(1);
428  os << "| Level | Count" << endl;
429 
430  for (unsigned int i=0; i<ml+3; ++i) {
431  os << "-";
432  }
433  os << "+---------+-----------" << endl;
434 
435 
436  for (itr=m_inactiveMap.begin(); itr!=m_inactiveMap.end(); ++itr) {
437  for (unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic) {
438  if (itr->second.msg[ic] != 0) {
439  os << " ";
440  os.width(ml+2);
441  os.setf(ios_base::left,ios_base::adjustfield);
442  os << itr->first;
443 
444  os << "|";
445 
446  os.width(8);
447  os.setf(ios_base::right,ios_base::adjustfield);
448  os << levelNames[ic];
449 
450  os << " |";
451 
452  os.width(9);
453  os << itr->second.msg[ic];
454 
455  os << endl;
456 
457  found = true;
458  }
459  }
460  }
461  for (unsigned int i=0; i<ml+25; ++i) {
462  os << "=";
463  }
464  os << endl;
465 
466  if (found) {
467  cout << os.str();
468  }
469  }
470 #endif
471 
472  return StatusCode::SUCCESS;
473 }

◆ getKeyMessages()

virtual const std::vector< LoggedMessage >& LoggedMessageSvc::getKeyMessages ( ) const
inlineoverridevirtual

Definition at line 138 of file LoggedMessageSvc.h.

138 { return m_msgKeyLog; }

◆ getLogColor()

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

Definition at line 860 of file LoggedMessageSvc.cxx.

860  {
861 // ---------------------------------------------------------------------------
862  if (logLevel < MSG::NUM_LEVELS) {
863  return m_logColorCodes[logLevel];
864  } else {
865  return "";
866  }
867 }

◆ getMessages()

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

Definition at line 972 of file LoggedMessageSvc.cxx.

972  {
973 
974  return m_msgLog[ level ];
975 
976 }

◆ incrInactiveCount()

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

Definition at line 878 of file LoggedMessageSvc.cxx.

878  {
879 
880  auto entry = m_inactiveMap.find( source );
881  if ( entry == m_inactiveMap.end() ) {
882  entry = m_inactiveMap.emplace( source, MsgAry{} ).first;
883  }
884  ++entry->second.msg[level];
885 }

◆ initColors()

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

Definition at line 151 of file LoggedMessageSvc.cxx.

151  {
152 
153  if (m_color == true) {
154 
155  if (m_logColors[MSG::FATAL].value().size() == 0) {
156  vector<string> fatDef;
157  fatDef.push_back( "[94;101;1m" );
158  m_logColors[MSG::FATAL].set( fatDef );
159  } else {
160  LoggedMessageSvc::setupColors( m_logColors[MSG::FATAL] );
161  }
162 
163  if (m_logColors[MSG::ERROR].value().size() == 0) {
164  vector<string> errDef;
165  errDef.push_back( "[97;101;1m" );
166  m_logColors[MSG::ERROR].set( errDef );
167  } else {
168  LoggedMessageSvc::setupColors( m_logColors[MSG::ERROR] );
169  }
170 
171  if (m_logColors[MSG::WARNING].value().size() == 0) {
172  vector<string> warDef;
173  warDef.push_back( "[93;1m" );
174  m_logColors[MSG::WARNING].set( warDef );
175  } else {
176  LoggedMessageSvc::setupColors( m_logColors[MSG::WARNING] );
177  }
178 
179  } else {
180 
181  // reset all color codes;
182  for (int ic=0; ic<MSG::NUM_LEVELS; ++ic) {
183  vector<string> def;
184  m_logColors[ic].set( def );
185  }
186 
187  }
188 
189 }

◆ initialize()

StatusCode LoggedMessageSvc::initialize ( )
overridevirtual

Initialize Service.

Definition at line 109 of file LoggedMessageSvc.cxx.

109  {
110  StatusCode sc;
111  sc = base_class::initialize();
112  if( sc.isFailure() ) return sc;
113  // hack since in Gaudi v30, msgSvc() now returns a const SmartIF<IMessageSvc>
114  // Release pointer to myself done in Service base class
115  SmartIF<IMessageSvc> &si ATLAS_THREAD_SAFE = const_cast<SmartIF<IMessageSvc>&> (msgSvc());
116  si.reset();
117 
118 #ifdef _WIN32
119  m_color = false;
120 #endif
121 
122  m_colMap["black"] = MSG::BLACK;
123  m_colMap["red"] = MSG::RED;
124  m_colMap["green"] = MSG::GREEN;
125  m_colMap["yellow"] = MSG::YELLOW;
126  m_colMap["blue"] = MSG::BLUE;
127  m_colMap["purple"] = MSG::PURPLE;
128  m_colMap["cyan"] = MSG::CYAN;
129  m_colMap["white"] = MSG::WHITE;
130 
131  // make sure the map of logged stream names is initialized
132  setupLogStreams();
133 
134  if (m_keywords.value().size() > 0) {
135  m_keysUsed = true;
136  }
137 
138  return StatusCode::SUCCESS;
139 }

◆ insertMessage()

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

Definition at line 746 of file LoggedMessageSvc.cxx.

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

◆ insertStream()

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

Definition at line 657 of file LoggedMessageSvc.cxx.

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

◆ messageCount()

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

Definition at line 870 of file LoggedMessageSvc.cxx.

870  {
871 
872  return m_msgCount[level];
873 
874 }

◆ outputLevel() [1/2]

int LoggedMessageSvc::outputLevel ( ) const
overridevirtual

Definition at line 825 of file LoggedMessageSvc.cxx.

825  {
826 // ---------------------------------------------------------------------------
827  return m_outputLevel;
828 }

◆ outputLevel() [2/2]

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

Definition at line 830 of file LoggedMessageSvc.cxx.

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

◆ queryInterface()

StatusCode LoggedMessageSvc::queryInterface ( const InterfaceID &  riid,
void **  ppvUnknown 
)
overridevirtual

Definition at line 809 of file LoggedMessageSvc.cxx.

809  {
810 // ---------------------------------------------------------------------------
811  if ( riid == ILoggedMessageSvc::interfaceID() ) {
812  *ppvInterface = (ILoggedMessageSvc*)this;
813  }
814  else if ( riid == IMessageSvc::interfaceID() ) {
815  *ppvInterface = (IMessageSvc*)this;
816  }
817  else {
818  return base_class::queryInterface(riid, ppvInterface);
819  }
820  addRef();
821  return StatusCode::SUCCESS;
822 }

◆ reinitialize()

StatusCode LoggedMessageSvc::reinitialize ( )
overridevirtual

Reinitialize Service.

Definition at line 144 of file LoggedMessageSvc.cxx.

144  {
145  m_state = Gaudi::StateMachine::OFFLINE;
146  return initialize();
147 }

◆ reportMessage() [1/4]

void LoggedMessageSvc::reportMessage ( const Message &  message)
overridevirtual

Definition at line 596 of file LoggedMessageSvc.cxx.

596  {
597  reportMessage(msg, outputLevel(msg.getSource()));
598 }

◆ reportMessage() [2/4]

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

Definition at line 499 of file LoggedMessageSvc.cxx.

499  {
500  std::lock_guard<std::mutex> lock(m_reportMutex);
501 
502  int key = msg.getType();
503  int nmsg;
504 
505  m_msgCount[key] ++;
506 
507  if (outputLevel >= m_logLevel) {
508  m_msgLog[ outputLevel ].push_back( make_pair (msg.getSource(), msg.getMessage() ) );
509  }
510 
511  if (m_keysUsed) {
512  if (msg.getSource() != "AthenaSummarySvc") {
513  for (vector<string>::const_iterator itr=m_keywords.value().begin(); itr!= m_keywords.value().end(); ++itr) {
514  if (msg.getMessage().find( *itr ) != string::npos) {
515  m_msgKeyLog.push_back( LoggedMessage( outputLevel, msg.getSource(), msg.getMessage() ));
516  break;
517  }
518  }
519  }
520  }
521 
522  const Message *cmsg = &msg;
523  std::unique_ptr<Message> suppressed_msg;
524 
525  // processing logged streams
526  if ( !m_loggedStreams.empty() ) {
527  const LoggedStreamsMap_t::iterator iLog = m_loggedStreams.find( msg.getSource() );
528  if ( m_loggedStreams.end() != iLog ) {
529  (*iLog->second) << *cmsg << std::endl;
530  }
531  }
532 
533  if ( m_suppress.value() || m_stats.value() ) {
534 
535  std::map<std::string,MsgAry>::iterator itr =
536  m_sourceMap.find(msg.getSource());
537  if (itr != m_sourceMap.end()) {
538  itr->second.msg[key] += 1;
539  nmsg = itr->second.msg[key];
540  } else {
541  MsgAry A;
542  for (int i=0; i<MSG::NUM_LEVELS; ++i) {
543  A.msg[i] = 0;
544  }
545  A.msg[key] = 1;
546  m_sourceMap[msg.getSource()] = A;
547  nmsg = 1;
548  }
549 
550  if (m_suppress.value()) {
551 
552  if ( m_msgLimit[key] != 0 ) {
553  if (nmsg == m_msgLimit[key]) {
554  std::string str = levelNames[key] + " message limit (";
555  str += std::to_string( m_msgLimit[key].value() );
556  str += ") reached for ";
557  str += msg.getSource() + ". Suppressing further output.";
558  suppressed_msg = std::make_unique<Message>(msg.getSource(),MSG::WARNING,str);
559  suppressed_msg->setFormat(msg.getFormat());
560  cmsg = suppressed_msg.get();
561  } else if (nmsg > m_msgLimit[key]) {
562  return;
563  }
564  }
565  }
566 
567  }
568 
569  StreamMap::const_iterator first = m_streamMap.lower_bound( key );
570  if ( first != m_streamMap.end() ) {
571  StreamMap::const_iterator last = m_streamMap.upper_bound( key );
572  while( first != last ) {
573  std::ostream& stream = *( (*first).second.second );
574  stream << *cmsg << std::endl;
575  ++first;
576  }
577  }
578  else if ( key >= outputLevel ) {
579  msg.setFormat(m_defaultFormat);
580  msg.setTimeFormat(m_defaultTimeFormat);
581  if (!m_color) {
582  (*m_defaultStream) << *cmsg << std::endl << std::flush;
583  } else {
584  (*m_defaultStream) << m_logColorCodes[key] << *cmsg << "\033[m"
585  << std::endl << std::flush;
586  }
587  }
588 }

◆ reportMessage() [3/4]

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

Definition at line 620 of file LoggedMessageSvc.cxx.

622 {
623  std::lock_guard<std::recursive_mutex> lock(m_messageMapMutex);
624 
625  MessageMap::const_iterator first = m_messageMap.lower_bound( key );
626  if ( first != m_messageMap.end() ) {
627  MessageMap::const_iterator last = m_messageMap.upper_bound( key );
628  while( first != last ) {
629  Message msg = (*first).second;
630  msg.setSource( source );
631  std::ostringstream os1;
632  os1 << "Status Code " << key.getCode() << std::ends;
633  Message stat_code1( std::string{source}, msg.getType(), os1.str() );
634  reportMessage( stat_code1 );
635  reportMessage( msg );
636  ++first;
637  }
638  }
639  else {
640  Message mesg = m_defaultMessage;
641  mesg.setSource( source );
642  std::ostringstream os2;
643  os2 << "Status Code " << key.getCode() << std::ends;
644  Message stat_code2( std::string{source}, mesg.getType(), os2.str() );
645  reportMessage( stat_code2 );
646  reportMessage( mesg );
647  }
648 }

◆ reportMessage() [4/4]

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

Definition at line 606 of file LoggedMessageSvc.cxx.

608  {
609  Message msg( source, type, message);
610  reportMessage( msg );
611 }

◆ setDefaultStream()

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

Definition at line 103 of file LoggedMessageSvc.h.

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

◆ setOutputLevel() [1/2]

void LoggedMessageSvc::setOutputLevel ( int  new_level)
overridevirtual

Definition at line 839 of file LoggedMessageSvc.cxx.

839  {
840 // ---------------------------------------------------------------------------
841  m_outputLevel = new_level;
842 }

◆ setOutputLevel() [2/2]

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

Definition at line 845 of file LoggedMessageSvc.cxx.

845  {
846 // ---------------------------------------------------------------------------
847  std::lock_guard<std::mutex> lock(m_thresholdMapMutex);
848 
849  // only write if we really have to...
850  auto i = m_thresholdMap.find( source );
851  if ( i == m_thresholdMap.end() ) {
852  m_thresholdMap.emplace( source, level );
853  } else if ( i->second != level ) {
854  i->second = level;
855  }
856 
857 }

◆ setupColors()

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

Definition at line 193 of file LoggedMessageSvc.cxx.

193  {
194 
195  if (! m_color) return;
196 
197  int ic;
198  if (prop.name() == "fatalColorCode") {
199  ic = MSG::FATAL;
200  } else if (prop.name() == "errorColorCode") {
201  ic = MSG::ERROR;
202  } else if (prop.name() == "warningColorCode") {
203  ic = MSG::WARNING;
204  } else if (prop.name() == "infoColorCode") {
205  ic = MSG::INFO;
206  } else if (prop.name() == "debugColorCode") {
207  ic = MSG::DEBUG;
208  } else if (prop.name() == "verboseColorCode") {
209  ic = MSG::VERBOSE;
210  } else if (prop.name() == "alwaysColorCode") {
211  ic = MSG::ALWAYS;
212  } else {
213  cout << "ERROR: Unknown message color parameter: " << prop.name()
214  << endl;
215  return;
216  }
217 
218  string code;
219  vector<string>::const_iterator itr;
220  itr = m_logColors[ic].value().begin();
221 
222  if ( m_logColors[ic].value().size() == 1 ) {
223 
224  if (itr->empty() ) {
225  code = "";
226  } else if ((*itr)[0] == '[') {
227  code = "\033" + *itr;
228  } else {
229  code = "\033[" + colTrans(*itr, 90) + ";1m";
230  }
231 
232  } else if (m_logColors[ic].value().size() == 2) {
233  vector<string>::const_iterator itr2 = itr + 1;
234 
235  code = "\033[" + colTrans(*itr, 90) + ";"
236  + colTrans(*itr2, 100) + ";1m";
237 
238  }
239 
240  m_logColorCodes[ic] = std::move(code);
241 
242 }

◆ setupInactCount()

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

Definition at line 336 of file LoggedMessageSvc.cxx.

336  {
337  if (prop.name() == "countInactive") {
338 #ifndef NDEBUG
339  BooleanProperty *p = dynamic_cast<BooleanProperty*>(&prop);
340  if (p)
341  MsgStream::enableCountInactive(p->value());
342 #endif
343  }
344 }

◆ setupLimits()

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

Definition at line 245 of file LoggedMessageSvc.cxx.

245  {
246 
247  //int ic = 0;
248  if (prop.name() == "fatalLimit") {
249  //ic = MSG::FATAL;
250  } else if (prop.name() == "errorLimit") {
251  //ic = MSG::ERROR;
252  } else if (prop.name() == "warningLimit") {
253  //ic = MSG::WARNING;
254  } else if (prop.name() == "infoLimit") {
255  //ic = MSG::INFO;
256  } else if (prop.name() == "debugLimit") {
257  //ic = MSG::DEBUG;
258  } else if (prop.name() == "verboseLimit") {
259  //ic = MSG::VERBOSE;
260  } else if (prop.name() == "alwaysLimit") {
261  IntegerProperty *p = dynamic_cast<IntegerProperty*>(&prop);
262  if (p && p->value() != 0) {
263  cout << "LoggedMessageSvc ERROR: cannot suppress ALWAYS messages" << endl;
264  p->setValue(0);
265  }
266  //ic = MSG::ALWAYS;
267  } else if (prop.name() == "defaultLimit") {
268  for (int i = MSG::VERBOSE; i< MSG::NUM_LEVELS; ++i) {
269  if (i != MSG::ALWAYS) {
270  m_msgLimit[i] = m_msgLimit[MSG::NIL].value();
271  }
272  }
273  } else {
274  cout << "LoggedMessageSvc ERROR: Unknown message limit parameter: "
275  << prop.name() << endl;
276  return;
277  }
278 
279 }

◆ setupLogStreams()

void LoggedMessageSvc::setupLogStreams ( )
private

Definition at line 888 of file LoggedMessageSvc.cxx.

889 {
890  // reset state
891  for ( LoggedStreamsMap_t::iterator iLog = m_loggedStreams.begin();
892  iLog != m_loggedStreams.end();
893  ++iLog ) {
894  delete iLog->second;
895  }
896  m_loggedStreams.clear();
897 
898  typedef std::map<std::string,std::string> StreamMap_t;
899  const StreamMap_t& streamMap = m_loggedStreamsName;
900  typedef StreamMap_t::const_iterator StreamMapIter;
901 
902  for ( StreamMapIter iProp = streamMap.begin(), iEnd = streamMap.end();
903  iProp != iEnd;
904  ++iProp ) {
905 
906  const std::string sourceName = iProp->first;
907  const std::string outFileName = iProp->second;
908 
909  std::set<std::string> outFileNames;
910  for ( StreamMapIter jProp = streamMap.begin();
911  jProp != iEnd;
912  ++jProp ) {
913  if ( jProp->first != iProp->first ) {
914  outFileNames.insert( jProp->second );
915  }
916  }
917 
918  tee( sourceName, outFileName, outFileNames );
919 
920  }//> loop over property entries
921 
922  return;
923 }

◆ setupThreshold()

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

Definition at line 282 of file LoggedMessageSvc.cxx.

282  {
283 
284  int ic = 0;
285  if (prop.name() == "setFatal") {
286  ic = MSG::FATAL;
287  } else if (prop.name() == "setError") {
288  ic = MSG::ERROR;
289  } else if (prop.name() == "setWarning") {
290  ic = MSG::WARNING;
291  } else if (prop.name() == "setInfo") {
292  ic = MSG::INFO;
293  } else if (prop.name() == "setDebug") {
294  ic = MSG::DEBUG;
295  } else if (prop.name() == "setVerbose") {
296  ic = MSG::VERBOSE;
297  } else if (prop.name() == "setAlways") {
298  ic = MSG::ALWAYS;
299  } else if (prop.name() == "loggingLevel") {
300  IntegerProperty *iap = dynamic_cast<IntegerProperty*>( &prop );
301  if (iap)
302  m_logLevel = iap->value();
303  return;
304  } else if (prop.name() == "keywords") {
305  StringArrayProperty *sap = dynamic_cast<StringArrayProperty*>( &prop );
306  if (sap!= nullptr && sap->value().size() > 0) {
307  m_keysUsed = true;
308  } else {
309  m_keysUsed = false;
310  }
311  return;
312  } else {
313  cerr << "LoggedMessageSvc ERROR: Unknown message theshold parameter: "
314  << prop.name() << endl;
315  return;
316  }
317 
318  StringArrayProperty *sap = dynamic_cast<StringArrayProperty*>( &prop);
319  if (sap == nullptr) {
320  std::cerr << "could not dcast " << prop.name()
321  << " to a StringArrayProperty (which it should be!)" << endl;
322  return;
323  } else {
324  std::vector<std::string>::const_iterator itr;
325  for ( itr = sap->value().begin();
326  itr != sap->value().end();
327  ++itr) {
328  setOutputLevel( *itr, ic );
329  }
330  }
331 
332 }

◆ tee()

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

Definition at line 926 of file LoggedMessageSvc.cxx.

929 {
930  const std::ios_base::openmode openMode = std::ios_base::out |
931  std::ios_base::trunc;
932 
933  LoggedStreamsMap_t::iterator iEnd = m_loggedStreams.end();
934  LoggedStreamsMap_t::iterator iStream = m_loggedStreams.find( sourceName );
935  if ( iStream != iEnd ) {
936  delete iStream->second;
937  iStream->second = nullptr;
938  m_loggedStreams.erase( iStream );
939  }
940 
941  // before creating a new ofstream, make sure there is no already existing
942  // one with the same file name...
943  iEnd = m_loggedStreams.end();
944  for ( iStream = m_loggedStreams.begin(); iStream != iEnd; ++iStream ) {
945  if ( outFileNames.find( outFileName ) != outFileNames.end() ) {
946  m_loggedStreams[sourceName] = m_loggedStreams[iStream->first];
947  return;
948  }
949  }
950 
951  std::ofstream * out = new std::ofstream( outFileName.c_str(), openMode );
952 
953  if ( !out->good() ) {
954  out->close();
955  delete out;
956  return;
957  }
958 
959  m_loggedStreams[sourceName] = out;
960 
961  return;
962 }

◆ useColor()

virtual bool LoggedMessageSvc::useColor ( ) const
inlineoverridevirtual

Definition at line 124 of file LoggedMessageSvc.h.

124 { return m_color; }

Member Data Documentation

◆ m_colMap

ColorMap LoggedMessageSvc::m_colMap
private

Definition at line 172 of file LoggedMessageSvc.h.

◆ m_color

BooleanProperty LoggedMessageSvc::m_color
private

Definition at line 149 of file LoggedMessageSvc.h.

◆ m_defaultFormat

std::string LoggedMessageSvc::m_defaultFormat
private

Default format for the messages.

Definition at line 146 of file LoggedMessageSvc.h.

◆ m_defaultMessage

Message LoggedMessageSvc::m_defaultMessage
private

Default Message.

Definition at line 142 of file LoggedMessageSvc.h.

◆ m_defaultStream

std::ostream* LoggedMessageSvc::m_defaultStream
private

Pointer to the output stream.

Definition at line 141 of file LoggedMessageSvc.h.

◆ m_defaultTimeFormat

std::string LoggedMessageSvc::m_defaultTimeFormat
private

Default format for timestamps in the messages.

Definition at line 147 of file LoggedMessageSvc.h.

◆ m_inactCount

BooleanProperty LoggedMessageSvc::m_inactCount
private

Definition at line 168 of file LoggedMessageSvc.h.

◆ m_inactiveMap

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

Definition at line 167 of file LoggedMessageSvc.h.

◆ m_keysUsed

bool LoggedMessageSvc::m_keysUsed
private

Definition at line 203 of file LoggedMessageSvc.h.

◆ m_keywords

StringArrayProperty LoggedMessageSvc::m_keywords
private

Definition at line 155 of file LoggedMessageSvc.h.

◆ m_logColorCodes

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

Definition at line 157 of file LoggedMessageSvc.h.

◆ m_logColors

StringArrayProperty LoggedMessageSvc::m_logColors[MSG::NUM_LEVELS]
private

Definition at line 152 of file LoggedMessageSvc.h.

◆ m_loggedStreams

LoggedStreamsMap_t LoggedMessageSvc::m_loggedStreams
private

Definition at line 178 of file LoggedMessageSvc.h.

◆ m_loggedStreamsName

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

Definition at line 176 of file LoggedMessageSvc.h.

◆ m_logLevel

IntegerProperty LoggedMessageSvc::m_logLevel
private

Definition at line 154 of file LoggedMessageSvc.h.

◆ m_messageMap

MessageMap LoggedMessageSvc::m_messageMap
private

Message map.

Definition at line 144 of file LoggedMessageSvc.h.

◆ m_messageMapMutex

std::recursive_mutex LoggedMessageSvc::m_messageMapMutex
mutableprivate

Mutex to synchronize multiple access to m_messageMap.

Definition at line 195 of file LoggedMessageSvc.h.

◆ m_msgCount

int LoggedMessageSvc::m_msgCount[MSG::NUM_LEVELS]
private

Definition at line 174 of file LoggedMessageSvc.h.

◆ m_msgKeyLog

std::vector< LoggedMessage > LoggedMessageSvc::m_msgKeyLog
private

Definition at line 202 of file LoggedMessageSvc.h.

◆ m_msgLimit

IntegerProperty LoggedMessageSvc::m_msgLimit[MSG::NUM_LEVELS]
private

Definition at line 153 of file LoggedMessageSvc.h.

◆ m_msgLog

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

Definition at line 201 of file LoggedMessageSvc.h.

◆ m_reportMutex

std::mutex LoggedMessageSvc::m_reportMutex
mutableprivate

Mutex to synchronize multiple threads printing.

Definition at line 192 of file LoggedMessageSvc.h.

◆ m_sourceMap

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

Definition at line 167 of file LoggedMessageSvc.h.

◆ m_statLevel

UnsignedIntegerProperty LoggedMessageSvc::m_statLevel
private

Definition at line 151 of file LoggedMessageSvc.h.

◆ m_stats

BooleanProperty LoggedMessageSvc::m_stats
private

Definition at line 150 of file LoggedMessageSvc.h.

◆ m_streamMap

StreamMap LoggedMessageSvc::m_streamMap
private

Stream map.

Definition at line 143 of file LoggedMessageSvc.h.

◆ m_suppress

BooleanProperty LoggedMessageSvc::m_suppress
private

Definition at line 168 of file LoggedMessageSvc.h.

◆ m_thresholdMap

ThresholdMap LoggedMessageSvc::m_thresholdMap
private

Output level threshold map.

Definition at line 145 of file LoggedMessageSvc.h.

◆ m_thresholdMapMutex

std::mutex LoggedMessageSvc::m_thresholdMapMutex
mutableprivate

Mutex to synchronize multiple access to m_thresholdMap (.

See also
MsgStream::doOutput).

Definition at line 199 of file LoggedMessageSvc.h.

◆ m_thresholdProp

StringArrayProperty LoggedMessageSvc::m_thresholdProp[MSG::NUM_LEVELS]
private

Properties controling.

Definition at line 148 of file LoggedMessageSvc.h.

The documentation for this class was generated from the following files:
xAOD::iterator
JetConstituentVector::iterator iterator
Definition: JetConstituentVector.cxx:68
LoggedMessageSvc::m_logColors
StringArrayProperty m_logColors[MSG::NUM_LEVELS]
Definition: LoggedMessageSvc.h:152
LoggedMessageSvc::m_msgKeyLog
std::vector< LoggedMessage > m_msgKeyLog
Definition: LoggedMessageSvc.h:202
python.PerfMonSerializer.p
def p
Definition: PerfMonSerializer.py:743
python.consts.BLACK
BLACK
Definition: consts.py:3
python.Constants.FATAL
int FATAL
Definition: Control/AthenaCommon/python/Constants.py:19
FullCPAlgorithmsTest_eljob.flush
flush
Definition: FullCPAlgorithmsTest_eljob.py:168
LoggedMessageSvc::m_colMap
ColorMap m_colMap
Definition: LoggedMessageSvc.h:172
LoggedMessageSvc::m_color
BooleanProperty m_color
Definition: LoggedMessageSvc.h:149
LoggedMessageSvc::m_keysUsed
bool m_keysUsed
Definition: LoggedMessageSvc.h:203
LoggedMessageSvc::m_msgLog
std::vector< std::pair< std::string, std::string > > m_msgLog[MSG::NUM_LEVELS]
Definition: LoggedMessageSvc.h:201
LoggedMessageSvc::m_defaultMessage
Message m_defaultMessage
Default Message.
Definition: LoggedMessageSvc.h:142
initialize
void initialize()
Definition: run_EoverP.cxx:894
python.TrigPSCPythonDbSetup.logLevel
logLevel
If HLT PSK is set on command line read it from DB instead of COOL (ATR-25974)
Definition: TrigPSCPythonDbSetup.py:27
skel.it
it
Definition: skel.GENtoEVGEN.py:423
LoggedMessageSvc::initColors
void initColors(Gaudi::Details::PropertyBase &prop)
Definition: LoggedMessageSvc.cxx:151
python.AthDsoLogger.out
out
Definition: AthDsoLogger.py:71
LoggedMessageSvc::outputLevel
virtual int outputLevel() const override
Definition: LoggedMessageSvc.cxx:825
athena.value
value
Definition: athena.py:122
ILoggedMessageSvc
Definition: ILoggedMessageSvc.h:25
LoggedMessageSvc::m_loggedStreams
LoggedStreamsMap_t m_loggedStreams
Definition: LoggedMessageSvc.h:178
ReweightUtils.message
message
Definition: ReweightUtils.py:15
LoggedMessageSvc::m_stats
BooleanProperty m_stats
Definition: LoggedMessageSvc.h:150
AthenaPoolTestWrite.stream
string stream
Definition: AthenaPoolTestWrite.py:12
atlasStyleMacro.icol
int icol
Definition: atlasStyleMacro.py:13
AthenaPoolTestRead.sc
sc
Definition: AthenaPoolTestRead.py:27
python.iconfTool.models.loaders.level
level
Definition: loaders.py:20
LoggedMessageSvc::m_inactiveMap
std::map< std::string, MsgAry, std::less<> > m_inactiveMap
Definition: LoggedMessageSvc.h:167
dqt_zlumi_alleff_HIST.A
A
Definition: dqt_zlumi_alleff_HIST.py:110
LoggedMessageSvc::m_thresholdMapMutex
std::mutex m_thresholdMapMutex
Mutex to synchronize multiple access to m_thresholdMap (.
Definition: LoggedMessageSvc.h:199
LoggedMessageSvc::m_msgCount
int m_msgCount[MSG::NUM_LEVELS]
Definition: LoggedMessageSvc.h:174
python.setupRTTAlg.size
int size
Definition: setupRTTAlg.py:39
DumpGeoConfig.outFileName
string outFileName
Definition: DumpGeoConfig.py:238
LoggedMessageSvc::initialize
virtual StatusCode initialize() override
Initialize Service.
Definition: LoggedMessageSvc.cxx:109
LoggedMessageSvc::setupLogStreams
void setupLogStreams()
Definition: LoggedMessageSvc.cxx:888
StdJOSetup.msgSvc
msgSvc
Provide convenience handles for various services.
Definition: StdJOSetup.py:36
TrigConf::MSGTC::ALWAYS
@ ALWAYS
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:29
lumiFormat.i
int i
Definition: lumiFormat.py:92
LoggedMessageSvc::m_logLevel
IntegerProperty m_logLevel
Definition: LoggedMessageSvc.h:154
EL::StatusCode
::StatusCode StatusCode
StatusCode definition for legacy code.
Definition: PhysicsAnalysis/D3PDTools/EventLoop/EventLoop/StatusCode.h:22
LoggedMessageSvc::m_messageMapMutex
std::recursive_mutex m_messageMapMutex
Mutex to synchronize multiple access to m_messageMap.
Definition: LoggedMessageSvc.h:195
LoggedMessageSvc::tee
void tee(const std::string &sourceName, const std::string &logFileName, const std::set< std::string > &declaredOutFileNames)
Definition: LoggedMessageSvc.cxx:926
CaloGetLC_CL_W_OOC_Config.defaultLimit
defaultLimit
Definition: CaloGetLC_CL_W_OOC_Config.py:80
LoggedMessageSvc::m_msgLimit
IntegerProperty m_msgLimit[MSG::NUM_LEVELS]
Definition: LoggedMessageSvc.h:153
LoggedMessageSvc::m_suppress
BooleanProperty m_suppress
Definition: LoggedMessageSvc.h:168
LoggedMessageSvc::colTrans
std::string colTrans(const std::string &, int)
Definition: LoggedMessageSvc.cxx:476
ILoggedMessageSvc::interfaceID
static const InterfaceID & interfaceID()
Retrieve interface ID.
Definition: ILoggedMessageSvc.h:29
LoggedMessageSvc::NamedStream
std::pair< std::string, std::ostream * > NamedStream
Definition: LoggedMessageSvc.h:41
LoggedMessageSvc::m_inactCount
BooleanProperty m_inactCount
Definition: LoggedMessageSvc.h:168
LoggedMessageSvc::m_sourceMap
std::map< std::string, MsgAry, std::less<> > m_sourceMap
Definition: LoggedMessageSvc.h:167
LoggedMessageSvc::setOutputLevel
virtual void setOutputLevel(int new_level) override
Definition: LoggedMessageSvc.cxx:839
ReadFromCoolCompare.os
os
Definition: ReadFromCoolCompare.py:231
grepfile.ic
int ic
Definition: grepfile.py:33
LoggedMessageSvc::m_thresholdMap
ThresholdMap m_thresholdMap
Output level threshold map.
Definition: LoggedMessageSvc.h:145
GetAllXsec.entry
list entry
Definition: GetAllXsec.py:132
LoggedMessageSvc::m_loggedStreamsName
std::map< std::string, std::string > m_loggedStreamsName
Definition: LoggedMessageSvc.h:176
ReadFromCoolCompare.os2
os2
Definition: ReadFromCoolCompare.py:249
pmontree.code
code
Definition: pmontree.py:443
TrigConf::MSGTC::NUM_LEVELS
@ NUM_LEVELS
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:30
name
std::string name
Definition: Control/AthContainers/Root/debug.cxx:195
ActsTrk::to_string
std::string to_string(const DetectorType &type)
Definition: GeometryDefs.h:34
query_example.col
col
Definition: query_example.py:7
python.consts.RED
RED
Definition: consts.py:3
LoggedMessageSvc::setupThreshold
void setupThreshold(Gaudi::Details::PropertyBase &prop)
Definition: LoggedMessageSvc.cxx:282
LoggedMessageSvc::m_defaultTimeFormat
std::string m_defaultTimeFormat
Default format for timestamps in the messages.
Definition: LoggedMessageSvc.h:147
python.consts.YELLOW
YELLOW
Definition: consts.py:3
python.consts.GREEN
GREEN
Definition: consts.py:3
LoggedMessageSvc::m_thresholdProp
StringArrayProperty m_thresholdProp[MSG::NUM_LEVELS]
Properties controling.
Definition: LoggedMessageSvc.h:148
LoggedMessageSvc::setupLimits
void setupLimits(Gaudi::Details::PropertyBase &prop)
Definition: LoggedMessageSvc.cxx:245
CondAlgsOpts.found
int found
Definition: CondAlgsOpts.py:101
LoggedMessageSvc::m_reportMutex
std::mutex m_reportMutex
Mutex to synchronize multiple threads printing.
Definition: LoggedMessageSvc.h:192
python.CaloScaleNoiseConfig.type
type
Definition: CaloScaleNoiseConfig.py:78
DeMoScan.first
bool first
Definition: DeMoScan.py:534
DEBUG
#define DEBUG
Definition: page_access.h:11
convertTimingResiduals.offset
offset
Definition: convertTimingResiduals.py:71
LoggedMessageSvc::m_defaultStream
std::ostream * m_defaultStream
Pointer to the output stream.
Definition: LoggedMessageSvc.h:141
declareProperty
#define declareProperty(n, p, h)
Definition: BaseFakeBkgTool.cxx:15
LoggedMessageSvc::reportMessage
virtual void reportMessage(const Message &message) override
Definition: LoggedMessageSvc.cxx:596
str
Definition: BTagTrackIpAccessor.cxx:11
LoggedMessageSvc::m_logColorCodes
std::string m_logColorCodes[MSG::NUM_LEVELS]
Definition: LoggedMessageSvc.h:157
LoggedMessageSvc::m_keywords
StringArrayProperty m_keywords
Definition: LoggedMessageSvc.h:155
ATLAS_THREAD_SAFE
#define ATLAS_THREAD_SAFE
Definition: checker_macros.h:211
python.Constants.VERBOSE
int VERBOSE
Definition: Control/AthenaCommon/python/Constants.py:14
TrigConf::MSGTC::NIL
@ NIL
Definition: Trigger/TrigConfiguration/TrigConfBase/TrigConfBase/MsgStream.h:22
LoggedMessageSvc::m_streamMap
StreamMap m_streamMap
Stream map.
Definition: LoggedMessageSvc.h:143
value_type
Definition: EDM_MasterSearch.h:11
LoggedMessageSvc::setupInactCount
void setupInactCount(Gaudi::Details::PropertyBase &prop)
Definition: LoggedMessageSvc.cxx:336
python.AutoConfigFlags.msg
msg
Definition: AutoConfigFlags.py:7
LoggedMessageSvc::m_statLevel
UnsignedIntegerProperty m_statLevel
Definition: LoggedMessageSvc.h:151
python.consts.WHITE
WHITE
Definition: consts.py:3
LoggedMessageSvc::setupColors
void setupColors(Gaudi::Details::PropertyBase &prop)
Definition: LoggedMessageSvc.cxx:193
run.Message
Message
Definition: run.py:57
LoggedMessageSvc::m_messageMap
MessageMap m_messageMap
Message map.
Definition: LoggedMessageSvc.h:144
python.logger.BLUE
BLUE
Definition: DataQuality/DQUtils/python/logger.py:15
LoggedMessageSvc::m_defaultFormat
std::string m_defaultFormat
Default format for the messages.
Definition: LoggedMessageSvc.h:146
mapkey::key
key
Definition: TElectronEfficiencyCorrectionTool.cxx:37
Generated on Fri Jul 5 2024 21:52:16 for ATLAS Offline Software by   doxygen 1.8.18