| The Gaudi Framework v32r1 (f65d50dc)

MessageSvc.cpp
Go to the documentation of this file.
1 #ifdef _WIN32
2 // Avoid conflicts between windows and the message service.
3 # define NOMSG
4 # define NOGDI
5 #endif
6
7 #include "MessageSvc.h"
8 #include "GaudiKernel/IAppMgrUI.h"
9 #include "GaudiKernel/Kernel.h"
10 #include "GaudiKernel/Message.h"
11 #include "GaudiKernel/StatusCode.h"
12 #include "GaudiKernel/System.h"
13
14 #include <fstream>
15 #include <iostream>
16 #include <sstream>
17
18 namespace {
19
20 // erase_if functions for containers which do NOT invalidate iterators
21 // after the erase point, eg.std::{unordered_}{,multi}map, std::{forward_,}list.
22 // To be explicit: this does NOT work with std::vector.
23
24 // TODO: replace with std::experimental::erase_if (Libraries Fundamental TS v2)
25
26 template <typename Container, typename Iterator, typename Predicate>
27 void erase_if( Container& c, Iterator first, Iterator last, Predicate pred ) {
28 while ( first != last ) {
29 if ( pred( *first ) )
30 first = c.erase( first );
31 else
32 ++first;
33 }
34 }
35
36 template <typename Container, typename Predicate>
37 void erase_if( Container& c, Predicate pred ) {
38 return erase_if( c, std::begin( c ), std::end( c ), std::forward<Predicate>( pred ) );
39 }
40
41 template <typename Container, typename Iterator, typename Predicate>
42 void erase_if( Container& c, std::pair<Iterator, Iterator> range, Predicate pred ) {
43 return erase_if( c, std::move( range.first ), std::move( range.second ), std::forward<Predicate>( pred ) );
44 }
45
46 std::string colTrans( const std::string& col, int offset ) {
47 int icol = 0;
48 if ( col == "black" )
49 icol = MSG::BLACK;
50 else if ( col == "red" )
51 icol = MSG::RED;
52 else if ( col == "green" )
53 icol = MSG::GREEN;
54 else if ( col == "yellow" )
55 icol = MSG::YELLOW;
56 else if ( col == "blue" )
57 icol = MSG::BLUE;
58 else if ( col == "purple" )
59 icol = MSG::PURPLE;
60 else if ( col == "cyan" )
61 icol = MSG::CYAN;
62 else if ( col == "white" )
63 icol = MSG::WHITE;
64 else
65 icol = 8;
66 return std::to_string( icol + offset );
67 }
68 } // namespace
69
70 // Instantiation of a static factory class used by clients to create
71 // instances of this service
72 DECLARE_COMPONENT( MessageSvc )
73
74 static const std::string levelNames[MSG::NUM_LEVELS] = {"NIL", "VERBOSE", "DEBUG", "INFO",
75 "WARNING", "ERROR", "FATAL", "ALWAYS"};
76
77 // Constructor
78 MessageSvc::MessageSvc( const std::string& name, ISvcLocator* svcloc ) : base_class( name, svcloc ) {
79
80 m_outputLevel.declareUpdateHandler( [svcloc]( Gaudi::Details::PropertyBase& ) {
81 SmartIF<IAppMgrUI> app = svcloc;
82 if ( app ) app->outputLevelUpdate();
83 } );
84
85 #ifndef NDEBUG
86 // initialize the MsgStream static flag.
87 MsgStream::enableCountInactive( m_inactCount );
88 #endif
89
90 for ( int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
91 m_logColors[ic].declareUpdateHandler( &MessageSvc::setupColors, this );
92 m_msgLimit[ic].declareUpdateHandler( &MessageSvc::setupLimits, this );
93 m_thresholdProp[ic].declareUpdateHandler( &MessageSvc::setupThreshold, this );
94 }
95
96 m_logColors[MSG::FATAL].set( {"blue", "red"} );
97 m_logColors[MSG::ERROR].set( {"white", "red"} );
98 m_logColors[MSG::WARNING].set( {"yellow"} );
99
100 std::fill( std::begin( m_msgCount ), std::end( m_msgCount ), 0 );
101 }
102
103 //#############################################################################
104
106 StatusCode MessageSvc::initialize() {
107 StatusCode sc = Service::initialize();
108 if ( sc.isFailure() ) return sc;
109
110 #ifdef _WIN32
111 m_color = false;
112 #endif
113
114 // make sure the map of logged stream names is initialized
115 setupLogStreams();
116
117 return StatusCode::SUCCESS;
118 }
119
120 //#############################################################################
121
123 StatusCode MessageSvc::reinitialize() {
124 m_state = Gaudi::StateMachine::OFFLINE;
125 StatusCode sc = initialize();
126 if ( sc.isSuccess() ) m_state = Gaudi::StateMachine::INITIALIZED;
127
128 return sc;
129 }
130
131 //#############################################################################
132
133 void MessageSvc::setupColors( Gaudi::Details::PropertyBase& prop ) {
134 const std::string& pname = prop.name();
135 int level;
136 if ( pname == "fatalColorCode" )
137 level = MSG::FATAL;
138 else if ( pname == "errorColorCode" )
139 level = MSG::ERROR;
140 else if ( pname == "warningColorCode" )
141 level = MSG::WARNING;
142 else if ( pname == "infoColorCode" )
143 level = MSG::INFO;
144 else if ( pname == "debugColorCode" )
145 level = MSG::DEBUG;
146 else if ( pname == "verboseColorCode" )
147 level = MSG::VERBOSE;
148 else if ( pname == "alwaysColorCode" )
149 level = MSG::ALWAYS;
150 else {
151 throw GaudiException( "ERROR: Unknown message color parameter: " + pname, name(), StatusCode::FAILURE );
152 }
153
154 auto& code = m_logColorCodes[level];
155
156 const auto& col_desc = m_logColors[level].value();
157
158 if ( col_desc.size() == 1 ) {
159 const std::string& desc = col_desc[0];
160 if ( desc.empty() ) {
161 code = "";
162 } else if ( desc[0] == '[' ) {
163 code = "\033" + desc;
164 } else {
165 code = "\033[" + colTrans( desc, 90 ) + ";1m";
166 }
167 } else if ( col_desc.size() == 2 ) {
168 code = "\033[" + colTrans( col_desc[0], 90 ) + ";" + colTrans( col_desc[1], 100 ) + ";1m";
169 } else { // empty desc: no color
170 code = "";
171 }
172 }
173 //#############################################################################
174
175 void MessageSvc::setupLimits( Gaudi::Details::PropertyBase& prop ) {
176 // Just report problems in the settings of the limits and unknown limit parameters
177 if ( prop.name() == "alwaysLimit" ) {
178 Gaudi::Property<int>* p = dynamic_cast<Gaudi::Property<int>*>( &prop );
179 if ( p && p->value() != 0 ) {
180 std::cout << "MessageSvc ERROR: cannot suppress ALWAYS messages" << std::endl;
181 p->setValue( 0 );
182 }
183 } else if ( prop.name() == "defaultLimit" ) {
184 for ( int i = MSG::VERBOSE; i < MSG::NUM_LEVELS; ++i ) {
185 if ( i != MSG::ALWAYS ) { m_msgLimit[i] = m_msgLimit[MSG::NIL].value(); }
186 }
187 } else if ( prop.name() != "fatalLimit" && prop.name() != "errorLimit" && prop.name() != "warningLimit" &&
188 prop.name() == "infoLimit" && prop.name() == "debugLimit" && prop.name() == "verboseLimit" ) {
189 std::cout << "MessageSvc ERROR: Unknown message limit parameter: " << prop.name() << std::endl;
190 return;
191 }
192 }
193 //#############################################################################
194
195 void MessageSvc::setupThreshold( Gaudi::Details::PropertyBase& prop ) {
196
197 static const std::array<std::pair<const char*, MSG::Level>, 7> tbl{{{"setFatal", MSG::FATAL},
198 {"setError", MSG::ERROR},
199 {"setWarning", MSG::WARNING},
200 {"setInfo", MSG::INFO},
201 {"setDebug", MSG::DEBUG},
202 {"setVerbose", MSG::VERBOSE},
203 {"setAlways", MSG::ALWAYS}}};
204
205 auto i = std::find_if( std::begin( tbl ), std::end( tbl ),
206 [&]( const std::pair<const char*, MSG::Level>& t ) { return prop.name() == t.first; } );
207 if ( i == std::end( tbl ) ) {
208 std::cerr << "MessageSvc ERROR: Unknown message threshold parameter: " << prop.name() << std::endl;
209 return;
210 }
211 int ic = i->second;
212
213 Gaudi::Property<std::vector<std::string>>* sap = dynamic_cast<Gaudi::Property<std::vector<std::string>>*>( &prop );
214 if ( !sap ) {
215 std::cerr << "could not dcast " << prop.name()
216 << " to a Gaudi::Property<std::vector<std::string>> (which it should be!)" << std::endl;
217 } else {
218 for ( auto& i : sap->value() ) setOutputLevel( i, ic );
219 }
220 }
221
222 //#############################################################################
223
224 #ifdef NDEBUG
225 void MessageSvc::setupInactCount( Gaudi::Details::PropertyBase& ) {}
226 #else
227 void MessageSvc::setupInactCount( Gaudi::Details::PropertyBase& prop ) {
228 if ( prop.name() == "countInactive" ) {
229 Gaudi::Property<bool>* p = dynamic_cast<Gaudi::Property<bool>*>( &prop );
230 if ( p ) MsgStream::enableCountInactive( p->value() );
231 }
232 }
233 #endif
234
235 //#############################################################################
237 StatusCode MessageSvc::finalize() {
238
239 m_suppress = false;
240
241 {
242 std::ostringstream os;
243
244 if ( m_stats ) {
245 os << "Summarizing all message counts" << std::endl;
246 } else {
247 os << "Listing sources of suppressed message: " << std::endl;
248 }
249
250 os << "=====================================================" << std::endl;
251 os << " Message Source | Level | Count" << std::endl;
252 os << "-----------------------------+---------+-------------" << std::endl;
253
254 bool found( false );
255
256 for ( auto itr = m_sourceMap.begin(); itr != m_sourceMap.end(); ++itr ) {
257 for ( unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
258 if ( ( itr->second.msg[ic] >= m_msgLimit[ic] && m_msgLimit[ic] != 0 ) ||
259 ( m_stats && itr->second.msg[ic] > 0 && ic >= m_statLevel.value() ) ) {
260 os << " ";
261 os.width( 28 );
262 os.setf( std::ios_base::left, std::ios_base::adjustfield );
263 os << itr->first;
264 os << "|";
265
266 os.width( 8 );
267 os.setf( std::ios_base::right, std::ios_base::adjustfield );
268 os << levelNames[ic];
269 os << " |";
270
271 os.width( 9 );
272 os << itr->second.msg[ic];
273 os << std::endl;
274
275 found = true;
276 }
277 }
278 }
279 os << "=====================================================" << std::endl;
280 if ( found || m_stats ) std::cout << os.str();
281 }
282
283 #ifndef NDEBUG
284 if ( m_inactCount.value() ) {
285
286 std::ostringstream os;
287 os << "Listing sources of Unprotected and Unseen messages\n";
288
289 bool found( false );
290
291 unsigned int ml( 0 );
292 for ( const auto& itr : m_inactiveMap ) {
293 for ( unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
294 if ( itr.second.msg[ic] != 0 && itr.first.length() > ml ) { ml = itr.first.length(); }
295 }
296 }
297
298 for ( unsigned int i = 0; i < ml + 25; ++i ) os << "=";
299
300 os << std::endl << " ";
301 os.width( ml + 2 );
302 os.setf( std::ios_base::left, std::ios_base::adjustfield );
303 os << "Message Source";
304 os.width( 1 );
305 os << "| Level | Count" << std::endl;
306
307 for ( unsigned int i = 0; i < ml + 3; ++i ) os << "-";
308 os << "+---------+-----------" << std::endl;
309
310 for ( auto itr = m_inactiveMap.begin(); itr != m_inactiveMap.end(); ++itr ) {
311 for ( unsigned int ic = 0; ic < MSG::NUM_LEVELS; ++ic ) {
312 if ( itr->second.msg[ic] != 0 ) {
313 os << " ";
314 os.width( ml + 2 );
315 os.setf( std::ios_base::left, std::ios_base::adjustfield );
316 os << itr->first;
317
318 os << "|";
319
320 os.width( 8 );
321 os.setf( std::ios_base::right, std::ios_base::adjustfield );
322 os << levelNames[ic];
323
324 os << " |";
325
326 os.width( 9 );
327 os << itr->second.msg[ic];
328
329 os << std::endl;
330
331 found = true;
332 }
333 }
334 }
335 for ( unsigned int i = 0; i < ml + 25; ++i ) os << "=";
336 os << std::endl;
337
338 if ( found ) std::cout << os.str();
339 }
340 #endif
341
342 return StatusCode::SUCCESS;
343 }
344
345 //#############################################################################
346 // ---------------------------------------------------------------------------
347 // Routine: reportMessage
348 // Purpose: dispatches a message to the relevant streams.
349 // ---------------------------------------------------------------------------
350 //
351 void MessageSvc::reportMessage( const Message& msg, int outputLevel ) {
352 std::unique_lock<std::recursive_mutex> lock( m_reportMutex );
353 i_reportMessage( msg, outputLevel );
354 }
355
356 void MessageSvc::i_reportMessage( const Message& msg, int outputLevel ) {
357 int key = msg.getType();
358
359 ++m_msgCount[key];
360
361 const Message* cmsg = &msg;
362
363 // processing logged streams
364 if ( !m_loggedStreams.empty() ) {
365 auto iLog = m_loggedStreams.find( msg.getSource() );
366 if ( m_loggedStreams.end() != iLog ) { ( *iLog->second ) << *cmsg << std::endl; }
367 }
368
369 if ( m_suppress.value() || m_stats.value() ) {
370
371 // Increase the counter of 'key' type of messages for the source and
372 // get the new value.
373 const int nmsg = ++( m_sourceMap[msg.getSource()].msg[key] );
374
375 if ( m_suppress.value() && m_msgLimit[key] != 0 ) {
376 if ( nmsg > m_msgLimit[key] ) return;
377 if ( nmsg == m_msgLimit[key] ) {
378 std::string txt = levelNames[key] + " message limit (" + std::to_string( m_msgLimit[key].value() ) +
379 ") reached for " + msg.getSource() + ". Suppressing further output.";
380 cmsg = new Message( msg.getSource(), MSG::WARNING, std::move( txt ) );
381 cmsg->setFormat( msg.getFormat() );
382 }
383 }
384 }
385
386 auto range = m_streamMap.equal_range( key );
387 if ( range.first != m_streamMap.end() ) {
388 std::for_each( range.first, range.second,
389 [&]( StreamMap::const_reference sm ) { *sm.second.second << *cmsg << std::endl; } );
390 } else if ( key >= outputLevel ) {
391 msg.setFormat( m_defaultFormat );
392 msg.setTimeFormat( m_defaultTimeFormat );
393 if ( !m_color ) {
394 ( *m_defaultStream ) << *cmsg << std::endl << std::flush;
395 } else {
396 ( *m_defaultStream ) << m_logColorCodes[key] << *cmsg << "\033[m" << std::endl << std::flush;
397 }
398 }
399
400 if ( cmsg != &msg ) { delete cmsg; }
401 }
402
403 //#############################################################################
404 // ---------------------------------------------------------------------------
405 // Routine: reportMessage
406 // Purpose: dispatches a message to the relevant streams.
407 // ---------------------------------------------------------------------------
408 //
409 void MessageSvc::reportMessage( const Message& msg ) { reportMessage( msg, outputLevel( msg.getSource() ) ); }
410
411 //#############################################################################
412 // ---------------------------------------------------------------------------
413 // Routine: reportMessage
414 // Purpose: dispatches a message to the relevant streams.
415 // ---------------------------------------------------------------------------
416 //
417 void MessageSvc::reportMessage( const char* source, int type, const char* message ) {
418 reportMessage( Message{source, type, message} );
419 }
420
421 //#############################################################################
422 // ---------------------------------------------------------------------------
423 // Routine: reportMessage
424 // Purpose: dispatches a message to the relevant streams.
425 // ---------------------------------------------------------------------------
426 //
427 void MessageSvc::reportMessage( const std::string& source, int type, const std::string& message ) {
428 reportMessage( Message{source, type, message} );
429 }
430
431 //#############################################################################
432 // ---------------------------------------------------------------------------
433 // Routine: sendMessage
434 // Purpose: finds a message for a given status code and dispatches it.
435 // ---------------------------------------------------------------------------
436 //
437 void MessageSvc::reportMessage( const StatusCode& code, const std::string& source ) {
438 std::unique_lock<std::recursive_mutex> lock( m_messageMapMutex );
439 i_reportMessage( code, source );
440 }
441
442 void MessageSvc::i_reportMessage( const StatusCode& code, const std::string& source ) {
443 int level = outputLevel( source );
444 auto report = [&]( Message mesg ) {
445 mesg.setSource( source );
446 Message stat_code( source, mesg.getType(), "Status Code " + std::to_string( code.getCode() ) );
447 i_reportMessage( std::move( stat_code ), level );
448 i_reportMessage( std::move( mesg ), level );
449 };
450
451 auto range = m_messageMap.equal_range( code );
452 if ( range.first != m_messageMap.end() ) {
453 std::for_each( range.first, range.second, [&]( MessageMap::const_reference sm ) { report( sm.second ); } );
454 } else {
455 report( m_defaultMessage );
456 }
457 }
458
459 //#############################################################################
460 // ---------------------------------------------------------------------------
461 // Routine: insertStream
462 // Purpose: inserts a stream for a message type.
463 // ---------------------------------------------------------------------------
464 //
465
466 void MessageSvc::insertStream( int key, const std::string& name, std::ostream* stream ) {
467 m_streamMap.emplace( key, NamedStream( name, stream ) );
468 }
469
470 //#############################################################################
471 // ---------------------------------------------------------------------------
472 // Routine: eraseStream
473 // Purpose: erases all the streams for all the message types.
474 // ---------------------------------------------------------------------------
475 //
476
477 void MessageSvc::eraseStream() { m_streamMap.clear(); }
478
479 //#############################################################################
480 // ---------------------------------------------------------------------------
481 // Routine: eraseStream
482 // Purpose: erases all the streams for a message type.
483 // ---------------------------------------------------------------------------
484 //
485
486 void MessageSvc::eraseStream( int message_type ) { m_streamMap.erase( message_type ); }
487
488 //#############################################################################
489 // ---------------------------------------------------------------------------
490 // Routine: eraseStream
491 // Purpose: erases one stream for a message type.
492 // ---------------------------------------------------------------------------
493 //
494
495 void MessageSvc::eraseStream( int key, std::ostream* stream ) {
496 if ( stream ) {
497 erase_if( m_streamMap, m_streamMap.equal_range( key ),
498 [&]( StreamMap::const_reference j ) { return j.second.second == stream; } );
499 }
500 }
501
502 //#############################################################################
503 // ---------------------------------------------------------------------------
504 // Routine: eraseStream
505 // Purpose: erases one stream for all message types.
506 // ---------------------------------------------------------------------------
507 //
508
509 void MessageSvc::eraseStream( std::ostream* stream ) {
510 if ( stream ) {
511 erase_if( m_streamMap, [&]( StreamMap::const_reference j ) { return j.second.second == stream; } );
512 }
513 }
514
515 //#############################################################################
516 // ---------------------------------------------------------------------------
517 // Routine: insertMessage
518 // Purpose: inserts a message for a status code.
519 // ---------------------------------------------------------------------------
520 //
521
522 void MessageSvc::insertMessage( const StatusCode& key, const Message& msg ) {
523 std::unique_lock<std::recursive_mutex> lock( m_messageMapMutex );
524 m_messageMap.emplace( key, msg );
525 }
526
527 //#############################################################################
528 // ---------------------------------------------------------------------------
529 // Routine: eraseMessage
530 // Purpose: erases all the messages for all the status codes.
531 // ---------------------------------------------------------------------------
532 //
533
534 void MessageSvc::eraseMessage() {
535 std::unique_lock<std::recursive_mutex> lock( m_messageMapMutex );
536 m_messageMap.clear();
537 }
538
539 //#############################################################################
540 // ---------------------------------------------------------------------------
541 // Routine: eraseMessage
542 // Purpose: erases all the messages for a status code.
543 // ---------------------------------------------------------------------------
544 //
545
546 void MessageSvc::eraseMessage( const StatusCode& key ) {
547 std::unique_lock<std::recursive_mutex> lock( m_messageMapMutex );
548 m_messageMap.erase( key );
549 }
550
551 //#############################################################################
552 // ---------------------------------------------------------------------------
553 // Routine: eraseMessage
554 // Purpose: erases one message for a status code.
555 // ---------------------------------------------------------------------------
556 //
557
558 void MessageSvc::eraseMessage( const StatusCode& key, const Message& msg ) {
559 std::unique_lock<std::recursive_mutex> lock( m_messageMapMutex );
560
561 erase_if( m_messageMap, m_messageMap.equal_range( key ),
562 [&]( MessageMap::const_reference j ) { return j.second == msg; } );
563 }
564
565 // ---------------------------------------------------------------------------
566 int MessageSvc::outputLevel() const {
567 // ---------------------------------------------------------------------------
568 return m_outputLevel;
569 }
570
571 // ---------------------------------------------------------------------------
572 int MessageSvc::outputLevel( const std::string& source ) const {
573 // ---------------------------------------------------------------------------
574 std::unique_lock<std::recursive_mutex> lock( m_thresholdMapMutex );
575 auto it = m_thresholdMap.find( source );
576 return it != m_thresholdMap.end() ? it->second : m_outputLevel.value();
577 }
578
579 // ---------------------------------------------------------------------------
580 void MessageSvc::setOutputLevel( int new_level ) {
581 // ---------------------------------------------------------------------------
582 m_outputLevel = new_level;
583 }
584
585 // ---------------------------------------------------------------------------
586 void MessageSvc::setOutputLevel( const std::string& source, int level ) {
587 // ---------------------------------------------------------------------------
588 std::unique_lock<std::recursive_mutex> lock( m_thresholdMapMutex );
589
590 // only write if we really have to...
591 auto i = m_thresholdMap.find( source );
592 if ( i == m_thresholdMap.end() ) {
593 m_thresholdMap[source] = level;
594 } else if ( i->second != level ) {
595 i->second = level;
596 }
597 }
598
599 // ---------------------------------------------------------------------------
600 std::string MessageSvc::getLogColor( int logLevel ) const {
601 // ---------------------------------------------------------------------------
602 return ( logLevel < MSG::NUM_LEVELS ) ? m_logColorCodes[logLevel] : "";
603 }
604
605 // ---------------------------------------------------------------------------
606 int MessageSvc::messageCount( MSG::Level level ) const { return m_msgCount[level]; }
607
608 // ---------------------------------------------------------------------------
609 void MessageSvc::incrInactiveCount( MSG::Level level, const std::string& source ) {
610 ++( m_inactiveMap[source].msg[level] );
611
612 if ( std::find( begin( m_tracedInactiveSources ), end( m_tracedInactiveSources ), source ) !=
613 end( m_tracedInactiveSources ) ) {
614 std::cout << "== inactive message detected from " << source << " ==" << std::endl;
615 std::string t;
616 System::backTrace( t, 25, 0 );
617 std::cout << t << std::endl;
618 }
619 }
620
621 // ---------------------------------------------------------------------------
622 void MessageSvc::setupLogStreams() {
623 // reset state
624 m_loggedStreams.clear();
625
626 for ( auto& iProp : m_loggedStreamsName ) {
627
628 std::set<std::string> outFileNames;
629 for ( auto& jProp : m_loggedStreamsName ) {
630 if ( jProp.first != iProp.first ) { outFileNames.insert( jProp.second ); }
631 }
632 tee( iProp.first, iProp.second, outFileNames );
633
634 } //> loop over property entries
635 }
636
637 // ---------------------------------------------------------------------------
638 void MessageSvc::tee( const std::string& sourceName, const std::string& outFileName,
639 const std::set<std::string>& outFileNames ) {
640 const std::ios_base::openmode openMode = std::ios_base::out | std::ios_base::trunc;
641
642 auto iStream = m_loggedStreams.find( sourceName );
643 if ( iStream != std::end( m_loggedStreams ) ) { m_loggedStreams.erase( iStream ); }
644
645 // before creating a new ofstream, make sure there is no already existing
646 // one with the same file name...
647 for ( auto& iStream : m_loggedStreams ) {
648 if ( outFileNames.find( outFileName ) != outFileNames.end() ) {
649 m_loggedStreams[sourceName] = m_loggedStreams[iStream.first];
650 return;
651 }
652 }
653
654 auto out = std::make_shared<std::ofstream>( outFileName, openMode );
655 if ( out->good() ) m_loggedStreams[sourceName] = std::move( out );
656 }
Service::m_outputLevel
Gaudi::Property< int > m_outputLevel
Definition: Service.h:176
System.h
StatusCode::getCode
code_t getCode() const
Retrieve value ("checks" the StatusCode)
Definition: StatusCode.h:137
std::ostringstream::setf
T setf(T... args)
Service::initialize
StatusCode initialize() override
Definition: Service.cpp:60
Gaudi::StateMachine::INITIALIZED
Definition: StateMachine.h:15
SmartIF< IAppMgrUI >
Kernel.h
std::string::empty
T empty(T... args)
Gaudi::Property::setValue
bool setValue(const ValueType &v)
Definition: Property.h:528
GaudiException
Define general base for Gaudi exception.
Definition: GaudiException.h:21
ISvcLocator
The ISvcLocator is the interface implemented by the Service Factory in the Application Manager to loc...
Definition: ISvcLocator.h:25
gaudirun.c
c
Definition: gaudirun.py:487
Service::m_state
Gaudi::StateMachine::State m_state
Service state.
Definition: Service.h:153
gaudiComponentHelp.name
name
Definition: gaudiComponentHelp.py:41
MessageSvc::m_streamMap
StreamMap m_streamMap
Stream map.
Definition: MessageSvc.h:178
Gaudi::Property
Implementation of property with value of concrete type.
Definition: Property.h:352
Gaudi::Functional::details::zip::range
decltype(auto) range(Args &&... args)
Zips multiple containers together to form a single range.
Definition: FunctionalDetails.h:71
IAppMgrUI.h
MessageSvc::i_reportMessage
virtual void i_reportMessage(const Message &msg, int outputLevel)
Internal implementation of reportMessage(const Message&,int) without lock.
Definition: MessageSvc.cpp:356
MessageSvc::setupInactCount
void setupInactCount(Gaudi::Details::PropertyBase &prop)
Definition: MessageSvc.cpp:227
MessageSvc::m_sourceMap
std::map< std::string, MsgAry > m_sourceMap
Definition: MessageSvc.h:192
MSG::CYAN
Definition: IMessageSvc.h:16
MessageSvc::m_defaultMessage
Message m_defaultMessage
Default Message.
Definition: MessageSvc.h:177
MessageSvc::m_inactiveMap
std::map< std::string, MsgAry > m_inactiveMap
Definition: MessageSvc.h:192
MSG::GREEN
Definition: IMessageSvc.h:16
std::to_string
T to_string(T... args)
MSG::DEBUG
Definition: IMessageSvc.h:15
std::endl
T endl(T... args)
MessageSvc::m_messageMap
MessageMap m_messageMap
Message map.
Definition: MessageSvc.h:179
StatusCode::SUCCESS
constexpr static const auto SUCCESS
Definition: StatusCode.h:85
MessageSvc::setupLogStreams
void setupLogStreams()
Definition: MessageSvc.cpp:622
MessageSvc::m_defaultTimeFormat
Gaudi::Property< std::string > m_defaultTimeFormat
Definition: MessageSvc.h:131
MessageSvc::MessageSvc
MessageSvc(const std::string &name, ISvcLocator *svcloc)
Definition: MessageSvc.cpp:78
std::end
T end(T... args)
MessageSvc::m_messageMapMutex
std::recursive_mutex m_messageMapMutex
Mutex to synchronize multiple access to m_messageMap.
Definition: MessageSvc.h:212
Gaudi::Details::PropertyBase::name
const std::string name() const
property name
Definition: Property.h:36
MessageSvc::reinitialize
StatusCode reinitialize() override
Reinitialize Service.
Definition: MessageSvc.cpp:123
MSG::VERBOSE
Definition: IMessageSvc.h:15
MSG::WHITE
Definition: IMessageSvc.h:16
MessageSvc::eraseMessage
void eraseMessage() override
Definition: MessageSvc.cpp:534
MessageSvc::m_tracedInactiveSources
Gaudi::Property< std::vector< std::string > > m_tracedInactiveSources
Definition: MessageSvc.h:167
System::backTrace
GAUDI_API int backTrace(void **addresses, const int depth)
MessageSvc.h
MessageSvc::setupColors
void setupColors(Gaudi::Details::PropertyBase &prop)
Definition: MessageSvc.cpp:133
Message::setFormat
void setFormat(std::string msg) const
Set the format string.
Definition: Message.cpp:143
IAppMgrUI::outputLevelUpdate
virtual void outputLevelUpdate()=0
Function to call to update the outputLevel of the components (after a change in MessageSvc).
std::string
STL class.
MessageSvc::eraseStream
void eraseStream() override
Definition: MessageSvc.cpp:477
DECLARE_COMPONENT
#define DECLARE_COMPONENT(type)
Definition: PluginServiceV1.h:46
MessageSvc::incrInactiveCount
void incrInactiveCount(MSG::Level level, const std::string &src) override
Definition: MessageSvc.cpp:609
MessageSvc::m_loggedStreams
std::map< std::string, std::shared_ptr< std::ostream > > m_loggedStreams
Definition: MessageSvc.h:196
MSG::FATAL
Definition: IMessageSvc.h:15
MessageSvc::m_inactCount
Gaudi::Property< bool > m_inactCount
Definition: MessageSvc.h:165
Service::name
const std::string & name() const override
Retrieve name of the service.
Definition: Service.cpp:274
MSG::Level
Level
Definition: IMessageSvc.h:15
MessageSvc::m_logColors
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS > m_logColors
Definition: MessageSvc.h:146
MessageSvc::m_statLevel
Gaudi::Property< unsigned int > m_statLevel
Definition: MessageSvc.h:133
MessageSvc::getLogColor
std::string getLogColor(int logLevel) const override
Definition: MessageSvc.cpp:600
MessageSvc::setOutputLevel
void setOutputLevel(int new_level) override
Definition: MessageSvc.cpp:580
MSG::RED
Definition: IMessageSvc.h:16
MSG::BLUE
Definition: IMessageSvc.h:16
MessageSvc::initialize
StatusCode initialize() override
Initialize Service.
Definition: MessageSvc.cpp:106
MessageSvc::m_thresholdMap
ThresholdMap m_thresholdMap
Output level threshold map.
Definition: MessageSvc.h:180
StatusCode
This class is used for returning status codes from appropriate routines.
Definition: StatusCode.h:50
Gaudi::Property::value
const ValueType & value() const
Backward compatibility (.
Definition: Property.h:526
std::ostringstream
STL class.
gaudirun.type
type
Definition: gaudirun.py:142
MessageSvc::NamedStream
std::pair< std::string, std::ostream * > NamedStream
Definition: MessageSvc.h:32
std::multimap::erase
T erase(T... args)
MessageSvc::reportMessage
void reportMessage(const Message &message) override
Definition: MessageSvc.cpp:409
std::ostringstream::width
T width(T... args)
MessageSvc::m_color
Gaudi::Property< bool > m_color
Definition: MessageSvc.h:144
MSG::NIL
Definition: IMessageSvc.h:15
std::ostringstream::str
T str(T... args)
Gaudi::Details::PropertyBase
PropertyBase base class allowing PropertyBase* collections to be "homogeneous".
Definition: Property.h:32
IOTest.end
def end
Definition: IOTest.py:112
MessageSvc::m_defaultFormat
Gaudi::Property< std::string > m_defaultFormat
Definition: MessageSvc.h:130
MessageSvc::m_reportMutex
std::recursive_mutex m_reportMutex
Mutex to synchronize multiple threads printing.
Definition: MessageSvc.h:209
std::multimap::clear
T clear(T... args)
StatusCode::isSuccess
bool isSuccess() const
Definition: StatusCode.h:267
std::move
T move(T... args)
std::pair
std::flush
T flush(T... args)
std::set::insert
T insert(T... args)
std::find_if
T find_if(T... args)
std::set< std::string >
std::unique_lock
compareOutputFiles.pname
string pname
Definition: compareOutputFiles.py:470
CommonMessagingBase::msg
MsgStream & msg() const
shortcut for the method msgStream(MSG::INFO)
Definition: CommonMessaging.h:113
Message
The Message class.
Definition: Message.h:17
MessageSvc::finalize
StatusCode finalize() override
Finalize Service.
Definition: MessageSvc.cpp:237
Iterator
boost::spirit::classic::position_iterator2< ForwardIterator > Iterator
Definition: Iterator.h:18
std::begin
T begin(T... args)
MSG::NUM_LEVELS
Definition: IMessageSvc.h:15
MSG::BLACK
Definition: IMessageSvc.h:16
std::multimap::emplace
T emplace(T... args)
GaudiMP.FdsRegistry.msg
msg
Definition: FdsRegistry.py:8
std::array
STL class.
CommonMessaging
Definition: CommonMessaging.h:56
StatusCode::FAILURE
constexpr static const auto FAILURE
Definition: StatusCode.h:86
MSG::ERROR
Definition: IMessageSvc.h:15
MessageSvc::setupLimits
void setupLimits(Gaudi::Details::PropertyBase &prop)
Definition: MessageSvc.cpp:175
MSG::PURPLE
Definition: IMessageSvc.h:16
MessageSvc::setupThreshold
void setupThreshold(Gaudi::Details::PropertyBase &prop)
Definition: MessageSvc.cpp:195
MessageSvc::m_stats
Gaudi::Property< bool > m_stats
Definition: MessageSvc.h:132
MessageSvc::m_logColorCodes
std::string m_logColorCodes[MSG::NUM_LEVELS]
Definition: MessageSvc.h:182
MessageSvc::messageCount
int messageCount(MSG::Level logLevel) const override
Definition: MessageSvc.cpp:606
gaudirun.level
level
Definition: gaudirun.py:334
MessageSvc::m_msgCount
std::array< int, MSG::NUM_LEVELS > m_msgCount
Definition: MessageSvc.h:194
MessageSvc::m_thresholdProp
std::array< Gaudi::Property< std::vector< std::string > >, MSG::NUM_LEVELS > m_thresholdProp
Definition: MessageSvc.h:135
MSG::WARNING
Definition: IMessageSvc.h:15
StatusCode.h
StatusCode::isFailure
bool isFailure() const
Definition: StatusCode.h:130
std::fill
T fill(T... args)
Gaudi::Utils::begin
AttribStringParser::Iterator begin(const AttribStringParser &parser)
Definition: AttribStringParser.h:120
MessageSvc::m_msgLimit
std::array< Gaudi::Property< int >, MSG::NUM_LEVELS > m_msgLimit
Definition: MessageSvc.h:155
MessageSvc::outputLevel
int outputLevel() const override
Definition: MessageSvc.cpp:566
MessageSvc::tee
void tee(const std::string &sourceName, const std::string &logFileName, const std::set< std::string > &declaredOutFileNames)
Definition: MessageSvc.cpp:638
MSG::INFO
Definition: IMessageSvc.h:15
Gaudi::StateMachine::OFFLINE
Definition: StateMachine.h:13
std::for_each
T for_each(T... args)
MessageSvc::m_suppress
Gaudi::Property< bool > m_suppress
Definition: MessageSvc.h:164
MessageSvc::insertMessage
void insertMessage(const StatusCode &code, const Message &message) override
Definition: MessageSvc.cpp:522
MessageSvc
Definition: MessageSvc.h:30
MSG::YELLOW
Definition: IMessageSvc.h:16
MessageSvc::m_loggedStreamsName
Gaudi::Property< std::map< std::string, std::string > > m_loggedStreamsName
Definition: MessageSvc.h:173
std::cout
MsgStream::enableCountInactive
static GAUDI_API bool enableCountInactive(bool value=true)
Enable/disable the count of inactive messages.
Definition: MsgStream.cpp:31
MSG::ALWAYS
Definition: IMessageSvc.h:15
std::multimap::equal_range
T equal_range(T... args)
MessageSvc::insertStream
void insertStream(int message_type, const std::string &name, std::ostream *stream) override
Definition: MessageSvc.cpp:466
Message.h
MessageSvc::m_thresholdMapMutex
std::recursive_mutex m_thresholdMapMutex
Mutex to synchronize multiple access to m_thresholdMap (.
Definition: MessageSvc.h:216