#include <MessageLoggerScribe.h>

Inheritance diagram for edm::service::MessageLoggerScribe:

Public Member Functions
	MessageLoggerScribe (std::shared_ptr< ThreadQueue > queue)
	— If queue is NULL, this sets singleThread true More...

virtual void	run ()

virtual void	runCommand (MessageLoggerQ::OpCode opcode, void *operand)

virtual	~MessageLoggerScribe ()

Public Member Functions inherited from edm::service::AbstractMLscribe
	AbstractMLscribe ()

virtual	~AbstractMLscribe ()

Private Types
typedef ParameterSet	PSet

typedef std::string	String

typedef std::vector< String >	vString

Private Member Functions
void	configure_dest (ELdestControl &dest_ctrl, String const &filename)

void	configure_errorlog ()

void	configure_external_dests ()

void	configure_ordinary_destinations ()

void	configure_statistics ()

template<class T >
T	getAparameter (PSet const &p, std::string const &id, T const &def)

void	log (ErrorObj *errorobj_p)

void	parseCategories (std::string const &s, std::vector< std::string > &cats)

void	triggerFJRmessageSummary (std::map< std::string, double > &sm)

void	triggerStatisticsSummaries ()

Private Attributes
bool	active

edm::propagate_const< std::shared_ptr< ELadministrator > >	admin_p

bool	clean_slate_configuration

int	count

bool	done

ELdestControl	early_dest

std::vector< NamedDestination * >	extern_dests

std::vector< edm::propagate_const< std::shared_ptr< std::ofstream > > >	file_ps

edm::propagate_const< std::shared_ptr< PSet > >	job_pset_p

edm::propagate_const< std::shared_ptr< ThreadQueue > >	m_queue

value_ptr< MessageLoggerDefaults >	messageLoggerDefaults

std::vector< String >	ordinary_destination_filenames

bool	purge_mode

bool	singleThread

std::vector< ELdestControl >	statisticsDestControls

std::vector< bool >	statisticsResets

std::map< String, edm::propagate_const< std::ostream * > >	stream_ps

Detailed Description

Definition at line 85 of file MessageLoggerScribe.h.

Member Typedef Documentation

typedef ParameterSet edm::service::MessageLoggerScribe::PSet

private

Definition at line 107 of file MessageLoggerScribe.h.

typedef std::string edm::service::MessageLoggerScribe::String

private

Definition at line 105 of file MessageLoggerScribe.h.

typedef std::vector<String> edm::service::MessageLoggerScribe::vString

private

Definition at line 106 of file MessageLoggerScribe.h.

Constructor & Destructor Documentation

edm::service::MessageLoggerScribe::MessageLoggerScribe ( std::shared_ptr< ThreadQueue > queue )

explicit

— If queue is NULL, this sets singleThread true

Definition at line 214 of file MessageLoggerScribe.cc.

 : admin_p   ( new ELadministrator() )
 , early_dest( admin_p->attach(ELoutput(std::cerr, false)) )
 , file_ps   ( )
 , job_pset_p( )
 , extern_dests( )
 , clean_slate_configuration( true )
 , active( true )
 , singleThread (queue.get() == 0)               // changeLog 36
 , done (false)                          // changeLog 32
 , purge_mode (false)                        // changeLog 32
 , count (false)                         // changeLog 32
 , m_queue(queue)                        // changeLog 36
 {
 }

edm::service::MessageLoggerScribe::~MessageLoggerScribe ( )

virtual

Definition at line 230 of file MessageLoggerScribe.cc.

References admin_p, and extern_dests.

 {
   admin_p->finish();
   assert( extern_dests.empty() );  // nothing to do
 }

Member Function Documentation

void edm::service::MessageLoggerScribe::configure_dest	(	ELdestControl &	dest_ctrl,
		String const &	filename
	)

private

Definition at line 489 of file MessageLoggerScribe.cc.

References myMessageLogger_cff::categories, python.rootplot.argparse::category, edm::copy_all(), edm::MessageDrop::debugAlwaysSuppressed, edm::ELseverityLevel::ELsev_info, edm::ELseverityLevel::ELsev_success, edm::ELseverityLevel::ELsev_warning, corrVsCorr::filename, edm::MessageDrop::infoAlwaysSuppressed, job_pset_p, MessageLogger_cfi::limit, messageLoggerDefaults, MessageLogger_cfi::noLineBreaks, edm::service::ELdestControl::setInterval(), edm::service::ELdestControl::setLimit(), edm::service::ELdestControl::setLineLength(), edm::service::ELdestControl::setThreshold(), edm::service::ELdestControl::setTimespan(), ErrorSummaryFilter_cfi::severity, AlCaHLTBitMon_QueryRunRegistry::string, edm::service::ELdestControl::suppressTime(), and edm::MessageDrop::warningAlwaysSuppressed.

Referenced by configure_external_dests(), configure_ordinary_destinations(), and configure_statistics().

 {
   static const int NO_VALUE_SET = -45654;           // change log 2
   vString  empty_vString;
   PSet     empty_PSet;
   String   empty_String;
 
   // Defaults:                          // change log 3a
   const std::string COMMON_DEFAULT_THRESHOLD = "INFO";
   const         int COMMON_DEFAULT_LIMIT     = NO_VALUE_SET; 
   const         int COMMON_DEFAULT_INTERVAL  = NO_VALUE_SET;    // change log 6
   const         int COMMON_DEFAULT_TIMESPAN  = NO_VALUE_SET; 
 
   char const*  severity_array[] = {"WARNING", "INFO", "ERROR", "DEBUG"};
   vString const  severities(severity_array+0, severity_array+4);
 
   // grab list of categories
   vString  categories
      = getAparameter<vString>(*job_pset_p, "categories", empty_vString);
 
   // grab list of messageIDs -- these are a synonym for categories
   // Note -- the use of messageIDs is deprecated in favor of categories
   {
     vString  messageIDs
       = getAparameter<vString>(*job_pset_p, "messageIDs", empty_vString);
 
   // combine the lists, not caring about possible duplicates (for now)
     copy_all( messageIDs, std::back_inserter(categories) );
   }  // no longer need messageIDs
 
   // grab list of hardwired categories (hardcats) -- these are to be added
   // to the list of categories -- change log 24
   {
     std::vector<std::string> hardcats = messageLoggerDefaults->categories;
   // combine the lists, not caring about possible duplicates (for now)
     copy_all( hardcats, std::back_inserter(categories) );
   }  // no longer need hardcats
 
   // grab default threshold common to all destinations
   String default_threshold
      = getAparameter<String>(*job_pset_p, "threshold", empty_String);
                             // change log 3a
                         // change log 24
 
   // grab default limit/interval/timespan common to all destinations/categories:
   PSet  default_pset
      = getAparameter<PSet>(*job_pset_p, "default", empty_PSet);
   int  default_limit
     = getAparameter<int>(default_pset, "limit", COMMON_DEFAULT_LIMIT);
   int  default_interval
     = getAparameter<int>(default_pset, "reportEvery", COMMON_DEFAULT_INTERVAL);
                             // change log 6, 10
   int  default_timespan
     = getAparameter<int>(default_pset, "timespan", COMMON_DEFAULT_TIMESPAN);
                         // change log 2a
                             // change log 3a
   String default_pset_threshold             
      = getAparameter<String>(default_pset, "threshold", default_threshold);
                             // change log 34
                     
   // grab all of this destination's parameters:
   PSet  dest_pset = getAparameter<PSet>(*job_pset_p, filename, empty_PSet);
 
   // See if this is just a placeholder          // change log 9
   bool is_placeholder 
       = getAparameter<bool>(dest_pset, "placeholder", false);
   if (is_placeholder) return;
   
   // grab this destination's default limit/interval/timespan:
   PSet  dest_default_pset
      = getAparameter<PSet>(dest_pset, "default", empty_PSet);
   int  dest_default_limit
     = getAparameter<int>(dest_default_pset, "limit", default_limit);
   int  dest_default_interval
     = getAparameter<int>(dest_default_pset, "reportEvery", default_interval);
                             // change log 6
   int  dest_default_timespan
     = getAparameter<int>(dest_default_pset, "timespan", default_timespan);
                             // change log 1a
   if ( dest_default_limit != NO_VALUE_SET ) {
     if ( dest_default_limit < 0 ) dest_default_limit = 2000000000;
     dest_ctrl.setLimit("*", dest_default_limit );
   }                         // change log 1b, 2a, 2b
   if ( dest_default_interval != NO_VALUE_SET ) {  // change log 6
     dest_ctrl.setInterval("*", dest_default_interval );
   }                         
   if ( dest_default_timespan != NO_VALUE_SET ) {
     if ( dest_default_timespan < 0 ) dest_default_timespan = 2000000000;
     dest_ctrl.setTimespan("*", dest_default_timespan );
   }                         // change log 1b, 2a, 2b
                               
   // establish this destination's threshold:
   String dest_threshold
      = getAparameter<String>(dest_pset, "threshold", default_threshold);
   if (dest_threshold == empty_String) {  
     dest_threshold = default_threshold;
   }
   if (dest_threshold == empty_String) {         // change log 34
       dest_threshold = default_pset_threshold;
   }
   if (dest_threshold == empty_String) {
     dest_threshold = messageLoggerDefaults->threshold(filename);
   }
   if (dest_threshold == empty_String) dest_threshold = COMMON_DEFAULT_THRESHOLD;
   ELseverityLevel  threshold_sev(dest_threshold);
   dest_ctrl.setThreshold(threshold_sev);
   // change log 37
   if (threshold_sev <= ELseverityLevel::ELsev_success) 
     { edm::MessageDrop::debugAlwaysSuppressed = false; }
   if (threshold_sev <= ELseverityLevel::ELsev_info) 
     { edm::MessageDrop::infoAlwaysSuppressed = false; }
   if (threshold_sev <= ELseverityLevel::ELsev_warning) 
     { edm::MessageDrop::warningAlwaysSuppressed = false; }
 
   // establish this destination's limit/interval/timespan for each category:
   for( vString::const_iterator id_it = categories.begin()
      ; id_it != categories.end()
      ; ++id_it
      )
   {
     String  msgID = *id_it;
     PSet default_category_pset 
        = getAparameter<PSet>(default_pset, msgID, empty_PSet);  // change log 5
     PSet  category_pset
        = getAparameter<PSet>(dest_pset, msgID, default_category_pset);
 
     int  category_default_limit 
        = getAparameter<int>(default_category_pset, "limit", NO_VALUE_SET);
     int  limit
       = getAparameter<int>(category_pset, "limit", category_default_limit);
     if (limit == NO_VALUE_SET) limit = dest_default_limit;
                                     // change log 7 
     int  category_default_interval 
        = getAparameter<int>(default_category_pset, "reportEvery", NO_VALUE_SET);
     int  interval
       = getAparameter<int>(category_pset, "reportEvery",category_default_interval);
     if (interval == NO_VALUE_SET) interval = dest_default_interval;
                             // change log 6  and then 7
     int  category_default_timespan 
        = getAparameter<int>(default_category_pset, "timespan", NO_VALUE_SET);
     int  timespan
       = getAparameter<int>(category_pset, "timespan", category_default_timespan);
     if (timespan == NO_VALUE_SET) timespan = dest_default_timespan;
                                     // change log 7 
 
     std::string category = msgID;
     if ( limit     == NO_VALUE_SET )  {             // change log 24
        limit = messageLoggerDefaults->limit(filename,category);
     }  
     if ( interval     == NO_VALUE_SET )  {          // change log 24
        interval = messageLoggerDefaults->reportEvery(filename,category);
     }  
     if ( timespan     == NO_VALUE_SET )  {          // change log 24
        timespan = messageLoggerDefaults->timespan(filename,category);
     }  
      
     if( limit     != NO_VALUE_SET )  {
       if ( limit < 0 ) limit = 2000000000;  
       dest_ctrl.setLimit(msgID, limit);
     }                       // change log 2a, 2b
     if( interval  != NO_VALUE_SET )  {
       dest_ctrl.setInterval(msgID, interval);
     }                       // change log 6
     if( timespan  != NO_VALUE_SET )  {
       if ( timespan < 0 ) timespan = 2000000000;  
       dest_ctrl.setTimespan(msgID, timespan);
     }                       // change log 2a, 2b
                         
   }  // for
 
   // establish this destination's limit for each severity:
   for( vString::const_iterator sev_it = severities.begin()
      ; sev_it != severities.end()
      ; ++sev_it
      )
   {
     String  sevID = *sev_it;
     ELseverityLevel  severity(sevID);
     PSet  default_sev_pset 
         = getAparameter<PSet>(default_pset, sevID, empty_PSet);
     PSet  sev_pset 
         = getAparameter<PSet>(dest_pset, sevID, default_sev_pset);
                         // change log 5
     int  limit     = getAparameter<int>(sev_pset, "limit", NO_VALUE_SET);
     if ( limit     == NO_VALUE_SET )  {             // change log 24
        limit = messageLoggerDefaults->sev_limit(filename,sevID);
     }  
     if( limit    != NO_VALUE_SET )  {
       if (limit < 0) limit = 2000000000;            // change log 38
       dest_ctrl.setLimit(severity, limit   );
     }
     int  interval  = getAparameter<int>(sev_pset, "reportEvery", NO_VALUE_SET);
     if ( interval     == NO_VALUE_SET )  {          // change log 24
        interval = messageLoggerDefaults->sev_reportEvery(filename,sevID);
     }  
     if( interval != NO_VALUE_SET )  dest_ctrl.setInterval(severity, interval);
                         // change log 2
     int  timespan  = getAparameter<int>(sev_pset, "timespan", NO_VALUE_SET);
     if ( timespan     == NO_VALUE_SET )  {          // change log 24
        timespan = messageLoggerDefaults->sev_timespan(filename,sevID);
     }  
     if( timespan    != NO_VALUE_SET )  {
       if (timespan < 0) timespan = 2000000000;          // change log 38
       dest_ctrl.setTimespan(severity, timespan   );
     }
   }  // for
 
   // establish this destination's linebreak policy:
   bool noLineBreaks_default 
     = getAparameter<bool> (default_pset, "noLineBreaks", false);
                         // change log 5
   bool noLineBreaks 
     = getAparameter<bool> (dest_pset, "noLineBreaks", noLineBreaks_default);
   if (noLineBreaks) {
     dest_ctrl.setLineLength(32000);
   }
   else {
     int  lenDef = 80;
     int  lineLen_default
          = getAparameter<int> (default_pset, "lineLength", lenDef);
                         // change log 5
     int  lineLen = getAparameter<int> (dest_pset, "lineLength", lineLen_default);
     if (lineLen != lenDef) {
       dest_ctrl.setLineLength(lineLen);
     }
   }
 
   // if indicated, suppress time stamps in this destination's output
   bool suppressTime_default 
     = getAparameter<bool> (default_pset, "noTimeStamps", false);
   bool suppressTime 
     = getAparameter<bool> (dest_pset, "noTimeStamps", suppressTime_default);
   if (suppressTime) {
     dest_ctrl.suppressTime();
   }
 
 }  // MessageLoggerScribe::configure_dest()

void edm::service::MessageLoggerScribe::configure_errorlog ( )

private

Definition at line 445 of file MessageLoggerScribe.cc.

References clean_slate_configuration, configure_external_dests(), configure_ordinary_destinations(), configure_statistics(), early_dest, job_pset_p, log(), edm::MessageLoggerQ::LOG_A_MESSAGE, m_queue, singleThread, stream_ps, and edm::service::ELdestControl::suppressTime().

Referenced by runCommand().

 {
   vString  empty_vString;
   String   empty_String;
   PSet     empty_PSet;
   
   // The following is present to test pre-configuration message handling:
   String preconfiguration_message 
        = getAparameter<String>
         (*job_pset_p, "generate_preconfiguration_message", empty_String);
   if (preconfiguration_message != empty_String) {
     // To test a preconfiguration message without first going thru the 
     // configuration we are about to do, we issue the message (so it sits
     // on the queue), then copy the processing that the LOG_A_MESSAGE case
     // does.  We suppress the timestamp to allow for automated unit testing.
     early_dest.suppressTime();
     LogError ("preconfiguration") << preconfiguration_message;
     if (!singleThread) {
       MessageLoggerQ::OpCode  opcode;
       void *                  operand;
       m_queue->consume(opcode, operand);  // grab next work item from Q
       assert (opcode == MessageLoggerQ::LOG_A_MESSAGE);
       ErrorObj *  errorobj_p = static_cast<ErrorObj *>(operand);
       log (errorobj_p);        
       delete errorobj_p;  // dispose of the message text
     }
   }
 
   if ( !stream_ps.empty() ) {
     LogWarning ("multiLogConfig") 
         << "The message logger has been configured multiple times"; 
     clean_slate_configuration = false;              // Change Log 22
   }
   configure_ordinary_destinations();                // Change Log 16
   configure_statistics();                   // Change Log 16
 
   configure_external_dests();
 
 }  // MessageLoggerScribe::configure_errorlog()

void edm::service::MessageLoggerScribe::configure_external_dests ( )

private

Definition at line 1003 of file MessageLoggerScribe.cc.

References admin_p, configure_dest(), mps_fire::dest, extern_dests, and job_pset_p.

Referenced by configure_errorlog(), and runCommand().

 {
   if( ! job_pset_p )  
   {
 //  extern_dests.clear();               
 //  change log 12, removed by change log 13
     return;
   }
 
   for( auto& dest : extern_dests)
   {
     ELdestination *  dest_p = dest->dest_p().get();
     ELdestControl  dest_ctrl = admin_p->attach( *dest_p );
 
     // configure the newly-attached destination:
     configure_dest( dest_ctrl, dest->name() );
     delete dest;  // dispose of our (copy of the) NamedDestination
   }
   extern_dests.clear();
  
 }  // MessageLoggerScribe::configure_external_dests

void edm::service::MessageLoggerScribe::configure_ordinary_destinations ( )

private

Definition at line 730 of file MessageLoggerScribe.cc.

References admin_p, MessageLogger_cfi::cerr, clean_slate_configuration, configure_dest(), gather_cfg::cout, edm::MessageDrop::debugAlwaysSuppressed, myMessageLogger_cff::destinations, early_dest, edm::ELhighestSeverity, edm::ELzeroSeverity, file_ps, corrVsCorr::filename, edm::MessageDrop::infoAlwaysSuppressed, job_pset_p, messageLoggerDefaults, ordinary_destination_filenames, edm::service::ELdestControl::setThreshold(), stream_ps, AlCaHLTBitMon_QueryRunRegistry::string, and edm::MessageDrop::warningAlwaysSuppressed.

Referenced by configure_errorlog().

 {
   vString  empty_vString;
   String   empty_String;
   PSet     empty_PSet;
 
   // Initialize unversal suppression variables
   MessageDrop::debugAlwaysSuppressed=true;      // change log 37
   MessageDrop::infoAlwaysSuppressed=true;       // change log 37
   MessageDrop::warningAlwaysSuppressed=true;        // change log 37
 
   // grab list of destinations:
   vString  destinations
      = getAparameter<vString>(*job_pset_p, "destinations", empty_vString);
 
   // Use the default list of destinations if and only if the grabbed list is
   // empty                          // change log 24
   if (destinations.empty()) {
     destinations = messageLoggerDefaults->destinations;
   }
   
   // dial down the early destination if other dest's are supplied:
   if( ! destinations.empty() )
     early_dest.setThreshold(ELhighestSeverity);
 
   // establish each destination:
   for( vString::const_iterator it = destinations.begin()
      ; it != destinations.end()
      ; ++it
      )
   {
     String filename = *it;
     String psetname = filename;
     
     // check that this destination is not just a placeholder // change log 11
     PSet  dest_pset = getAparameter<PSet>(*job_pset_p, psetname, empty_PSet);
     bool is_placeholder 
     = getAparameter<bool>(dest_pset, "placeholder", false);
     if (is_placeholder) continue;
 
     // Modify the file name if extension or name is explicitly specified
     // change log 14 
 
     // Although for an ordinary destination there is no output attribute
     // for the cfg (you can use filename instead) we provide output() for
     // uniformity with the statistics destinations.  The "right way" to
     // work this would have been to provide a filename() method, along with 
     // an extension() method.  We recognize the potential name confusion here
     // (filename(filename))!
     
     // Determine the destination file name to use if no explicit filename is
     // supplied in the cfg.
     String filename_default 
         = getAparameter<String>(dest_pset, "output", empty_String);
     if ( filename_default == empty_String ) {
       filename_default = messageLoggerDefaults->output(psetname); // change log 31
       if (filename_default  == empty_String) {
         filename_default  = filename;
       }        
     }
 
     String explicit_filename 
         = getAparameter<String>(dest_pset, "filename", filename_default);
     if (explicit_filename != empty_String) filename = explicit_filename;
     String explicit_extension 
         = getAparameter<String>(dest_pset, "extension", empty_String);
     if (explicit_extension != empty_String) {
       if (explicit_extension[0] == '.') {
     filename += explicit_extension;             
       } else {
     filename = filename + "." + explicit_extension;   
       }
     }
 
     // Attach a default extension of .log if there is no extension on a file
     // change log 18 - this had been done in concert with attaching destination
     
     std::string actual_filename = filename;         // change log 4
     if ( (filename != "cout") && (filename != "cerr") )  {
       const std::string::size_type npos = std::string::npos;
       if ( filename.find('.') == npos ) {
         actual_filename += ".log";
       }  
     }
 
      // Check that this is not a duplicate name         // change log 18
     if ( stream_ps.find(actual_filename)!=stream_ps.end() ) {        
       if (clean_slate_configuration) {              // change log 22
 //        throw edm::Exception ( edm::errors::Configuration )   
         LogError("duplicateDestination")            // change log 35
         <<"Duplicate name for a MessageLogger Destination: " 
         << actual_filename
         << "\n" << "Only the first configuration instructions are used";
     continue;
       } else {
         LogWarning("duplicateDestination")
         <<"Duplicate name for a MessageLogger Destination: " 
         << actual_filename
         << "\n" << "Only original configuration instructions are used";
         continue;
       }
     } 
     
     ordinary_destination_filenames.push_back(actual_filename);
 
     // attach the current destination, keeping a control handle to it:
     ELdestControl dest_ctrl;
     if( actual_filename == "cout" )  {
       dest_ctrl = admin_p->attach( ELoutput(std::cout) );
       stream_ps["cout"] = &std::cout;
     }
     else if( actual_filename == "cerr" )  {
       early_dest.setThreshold(ELzeroSeverity); 
       dest_ctrl = early_dest;
       stream_ps["cerr"] = &std::cerr;
     }
     else  {
       auto os_sp = std::make_shared<std::ofstream>(actual_filename.c_str());
       file_ps.push_back(os_sp);
       dest_ctrl = admin_p->attach( ELoutput(*os_sp) );
       stream_ps[actual_filename] = os_sp.get();
     }
 
     // now configure this destination:
     configure_dest(dest_ctrl, psetname);
 
   }  // for [it = destinations.begin() to end()]
 
 } // configure_ordinary_destinations

void edm::service::MessageLoggerScribe::configure_statistics ( )

private

Definition at line 862 of file MessageLoggerScribe.cc.

References admin_p, MessageLogger_cfi::cerr, clean_slate_configuration, edm::errors::Configuration, configure_dest(), gather_cfg::cout, myMessageLogger_cff::destinations, Exception, file_ps, corrVsCorr::filename, job_pset_p, messageLoggerDefaults, edm::service::ELdestControl::noTerminationSummary(), ordinary_destination_filenames, reset(), edm::search_all(), myMessageLogger_cff::statistics, statisticsDestControls, statisticsResets, stream_ps, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by configure_errorlog().

 {
   vString  empty_vString;
   String   empty_String;
   PSet     empty_PSet;
 
   // grab list of statistics destinations:
   vString  statistics 
      = getAparameter<vString>(*job_pset_p, "statistics", empty_vString);
   
   bool no_statistics_configured = statistics.empty();       // change log 24
   
   if ( no_statistics_configured ) {
     // Read the list of staistics destinations from hardwired defaults,
     // but only if there is also no list of ordinary destinations.
     // (If a cfg specifies destinations, and no statistics, assume that
     // is what the user wants.)
     vString  destinations
      = getAparameter<vString>(*job_pset_p, "destinations", empty_vString);
     if (destinations.empty()) { 
       statistics = messageLoggerDefaults->statistics;
       no_statistics_configured = statistics.empty();
     }
   }
 
    // establish each statistics destination:
   for( vString::const_iterator it = statistics.begin()
      ; it != statistics.end()
      ; ++it
      )
   {
     String statname = *it;
     String psetname = statname;
 
     // check that this destination is not just a placeholder // change log 20
     PSet  stat_pset = getAparameter<PSet>(*job_pset_p, psetname, empty_PSet);
     bool is_placeholder 
     = getAparameter<bool>(stat_pset, "placeholder", false);
     if (is_placeholder) continue;
 
     // Determine the destination file name
     String filename 
         = getAparameter<String>(stat_pset, "output", empty_String);
     if ( filename == empty_String ) {
       filename = messageLoggerDefaults->output(psetname);   // change log 31
       if (filename == empty_String) {
         filename = statname;
       }        
     }
 
     // Modify the file name if extension or name is explicitly specified
     // change log 14 -- probably suspenders and a belt, because ouput option
     // is present, but uniformity is nice.
                     
     String explicit_filename 
         = getAparameter<String>(stat_pset, "filename", filename);
     if (explicit_filename != empty_String) filename = explicit_filename;
     String explicit_extension 
         = getAparameter<String>(stat_pset, "extension", empty_String);
     if (explicit_extension != empty_String) {
       if (explicit_extension[0] == '.') {
     filename += explicit_extension;             
       } else {
     filename = filename + "." + explicit_extension;   
       }
     }
 
     // Attach a default extension of .log if there is no extension on a file
     // change log 18 - this had been done in concert with attaching destination
     
     std::string actual_filename = filename;         // change log 4
     if ( (filename != "cout") && (filename != "cerr") )  {  // change log 23
       const std::string::size_type npos = std::string::npos;
       if ( filename.find('.') == npos ) {
         actual_filename += ".log";
       }  
     }
 
     // Check that this is not a duplicate name - 
     // unless it is an ordinary destination (which stats can share)
     if ( !search_all(ordinary_destination_filenames, actual_filename) ) {
       if ( stream_ps.find(actual_filename)!=stream_ps.end() ) {        
         if (clean_slate_configuration) {            // change log 22
           throw edm::Exception ( edm::errors::Configuration ) 
           <<"Duplicate name for a MessageLogger Statistics Destination: " 
           << actual_filename
           << "\n";
         } else {
           LogWarning("duplicateDestination")
           <<"Duplicate name for a MessageLogger Statistics Destination: " 
           << actual_filename
           << "\n" << "Only original configuration instructions are used";
           continue;
         } 
       }
     }
     
     // create (if statistics file does not match any destination file name)
     // or note (if statistics file matches a destination file name) the ostream.
     // But if no statistics destinations were provided in the config, do not
     // create a new destination for this hardwired statistics - only act if
     // it is matches a destination.  (shange log 24)
     bool statistics_destination_is_real = !no_statistics_configured;
     std::ostream* os_p;
     if ( stream_ps.find(actual_filename) == stream_ps.end() ) {
       if ( actual_filename == "cout" ) {
         os_p = &std::cout;
       } else if ( actual_filename == "cerr" ) {
         os_p = &std::cerr;
       } else {
         auto os_sp = std::make_shared<std::ofstream>(actual_filename.c_str());
     file_ps.push_back(os_sp);
         os_p = os_sp.get();
       }
       stream_ps[actual_filename] = os_p;
     } else { 
       statistics_destination_is_real = true;            // change log 24
       os_p = stream_ps[actual_filename];
     }
        
     if (statistics_destination_is_real) {           // change log 24
       // attach the statistics destination, keeping a control handle to it:
       ELdestControl dest_ctrl;
       dest_ctrl = admin_p->attach( ELstatistics(*os_p) );
       statisticsDestControls.push_back(dest_ctrl);
       bool reset = getAparameter<bool>(stat_pset, "reset", false);
       statisticsResets.push_back(reset);
     
       // now configure this destination:
       configure_dest(dest_ctrl, psetname);
 
       // and suppress the desire to do an extra termination summary just because
       // of end-of-job info messages
       dest_ctrl.noTerminationSummary();
     }
      
   }  // for [it = statistics.begin() to end()]
 
 } // configure_statistics

template<class T >

T edm::service::MessageLoggerScribe::getAparameter	(	PSet const &	p,
		std::string const &	id,
		T const &	def
	)

inlineprivate

Definition at line 156 of file MessageLoggerScribe.h.

References MessageLogger_cfi::cerr, def, MillePedeFileConverter_cfg::e, hcalTTPDigis_cfi::id, parseCategories(), cms::Exception::raise(), alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, and lumiQTWidget::t.

   {
     T t = def;
     try { 
       t = p.template getUntrackedParameter<T>(id, def);
     } catch (...) {
       try {
         t = p.template getParameter<T>(id);
       } catch (...) {
         // Since PSetValidation will catch such errors, we simply proceed as
     // best we can in case we are setting up the logger just to contain the 
     // validation-caught error messages. 
       }
     }
     return t;
   }

void edm::service::MessageLoggerScribe::log ( ErrorObj * errorobj_p )

private

Definition at line 435 of file MessageLoggerScribe.cc.

References admin_p, myMessageLogger_cff::categories, edm::ELextendedID::id, parseCategories(), edm::ErrorObj::setID(), and edm::ErrorObj::xid().

Referenced by configure_errorlog(), and runCommand().

                                                        {
   std::vector<std::string> categories;
   parseCategories(errorobj_p->xid().id, categories);
   for (unsigned int icat = 0; icat < categories.size(); ++icat) {
     errorobj_p->setID(categories[icat]);
     admin_p->log( *errorobj_p );  // route the message text
   } 
 }

void edm::service::MessageLoggerScribe::parseCategories	(	std::string const &	s,
		std::vector< std::string > &	cats
	)

private

Definition at line 1026 of file MessageLoggerScribe.cc.

References mps_fire::i.

Referenced by getAparameter(), and log().

 {
   const std::string::size_type npos = std::string::npos;
         std::string::size_type i    = 0;
   while ( i != npos ) {    
     std::string::size_type j = s.find('|',i);   
     cats.push_back (s.substr(i,j-i));
     i = j;
     while ( (i != npos) && (s[i] == '|') ) ++i; 
     // the above handles cases of || and also | at end of string
   } 
   // Note:  This algorithm assigns, as desired, one null category if it
   //        encounters an empty categories string
 }

void edm::service::MessageLoggerScribe::run ( void )

virtual

Definition at line 238 of file MessageLoggerScribe.cc.

References done, edm::MessageDrop::instance(), m_queue, edm::MessageDrop::messageLoggerScribeIsRunning, edm::MLSCRIBE_RUNNING_INDICATOR, and runCommand().

Referenced by Types.EventID::cppID(), and Types.LuminosityBlockID::cppID().

 {
   MessageLoggerQ::OpCode  opcode;
   void *                  operand;
 
   MessageDrop::instance()->messageLoggerScribeIsRunning = 
                 MLSCRIBE_RUNNING_INDICATOR; // ChangeLog 30
 //  std::cerr << "MessageLoggerScribe::run(): \n";
 //  std::cerr << "messageLoggerScribeIsRunning = "
 //      << (int)MessageDrop::instance()->messageLoggerScribeIsRunning << "\n";
 
   do  {
     m_queue->consume(opcode, operand);  // grab next work item from Q 
                         // changeLog 36
     runCommand (opcode, operand);
   } while(! done);
 
 }  // MessageLoggerScribe::run()

void edm::service::MessageLoggerScribe::runCommand	(	MessageLoggerQ::OpCode	opcode,
		void *	operand
	)

virtual

Reimplemented from edm::service::AbstractMLscribe.

Definition at line 258 of file MessageLoggerScribe.cc.

Referenced by run().

 {
   switch(opcode)  {  // interpret the work item
     default:  {
       assert(false);  // can't happen (we certainly hope!)
       break;
     }
     case MessageLoggerQ::END_THREAD:  {
       assert( operand == 0 );
       done = true;
       MessageDrop::instance()->messageLoggerScribeIsRunning = 
           (unsigned char) -1;               // ChangeLog 30
       break;
     }
     case MessageLoggerQ::LOG_A_MESSAGE:  {
       ErrorObj *  errorobj_p = static_cast<ErrorObj *>(operand);
       try {
     if(active && !purge_mode) log (errorobj_p);        
       }
       catch(cms::Exception& e)
       {
       ++count;
       std::cerr << "MessageLoggerScribe caught " << count
            << " cms::Exceptions, text = \n"
            << e.what() << "\n";
 
       if(count > 25)
         {
           cerr << "MessageLogger will no longer be processing "
            << "messages due to errors (entering purge mode).\n";
           purge_mode = true;
         }
       }
       catch(...)
       {
       std::cerr << "MessageLoggerScribe caught an unknown exception and "
            << "will no longer be processing "
            << "messages. (entering purge mode)\n";
       purge_mode = true;
       }
       delete errorobj_p;  // dispose of the message text
       break;
     }
     case MessageLoggerQ::CONFIGURE:  {          // changelog 17
       if (singleThread) {
         job_pset_p = std::shared_ptr<PSet>(static_cast<PSet*>(operand)); // propagate_const<T> has no reset() function
     configure_errorlog();
     break;
       } else {
     ConfigurationHandshake * h_p = 
         static_cast<ConfigurationHandshake *>(operand);
         job_pset_p = std::shared_ptr<PSet>(static_cast<PSet*>(h_p->p)); // propagate_const<T> has no reset() function
   std::lock_guard<std::mutex> sl(h_p->m);   // get lock
     try {
       configure_errorlog();
     }
     catch(edm::Exception& e)
       {
         Place_for_passing_exception_ptr epp = h_p->epp;
         if (!(*epp)) { 
           *epp = std::make_shared<edm::Exception>(e);
         } else {
           Pointer_to_new_exception_on_heap ep = *epp;
           (*ep) << "\n and another exception: \n" << e.what();
         }
       }
     // Note - since the configuring code has not made a new copy of the 
     // job parameter set, we must not delete job_pset_p (in contrast to
     // the case for errorobj_p).  On the other hand, if we instantiate
     // a new edm::Exception pointed to by *epp, it is the responsibility
     // of the MessageLoggerQ to delete it.
     h_p->c.notify_all();  // Signal to MessageLoggerQ that we are done
     // finally, release the scoped lock by letting it go out of scope 
     break;
       }
     }
     case MessageLoggerQ::EXTERN_DEST: {
       try {
     extern_dests.push_back( static_cast<NamedDestination *>(operand) );
     configure_external_dests();
       }
       catch(cms::Exception& e)              // change log 21
     {
       std::cerr << "MessageLoggerScribe caught a cms::Exception "
            << "during extern dest configuration:\n"
            << e.what() << "\n"
            << "This is a serious problem, and the extern dest " 
            << "will not be produced.\n"
            << "However, the rest of the logger continues to run.\n";
     }
       catch(...)                        // change log 21
     {
       std::cerr << "MessageLoggerScribe caught unkonwn exception type\n"
            << "during extern dest configuration. "
            << "This is a serious problem, and the extern dest " 
            << "will not be produced.\n"
            << "The rest of the logger will attempt to continue to run.\n";
     }
       break;
     }
     case MessageLoggerQ::SUMMARIZE: {
       assert( operand == 0 );
       try {
     triggerStatisticsSummaries();
       }
       catch(cms::Exception& e)
     {
       std::cerr << "MessageLoggerScribe caught exception "
            << "during summarize:\n"
            << e.what() << "\n";
     }
       catch(...)
     {
       std::cerr << "MessageLoggerScribe caught unkonwn exception type "
            << "during summarize. (Ignored)\n";
     }
       break;
     }
     case MessageLoggerQ::JOBMODE:  {            // change log 24
       std::string* jobMode_p =
           static_cast<std::string*>(operand);
       JobMode jm = MessageLoggerDefaults::mode(*jobMode_p);
       messageLoggerDefaults = 
     value_ptr<MessageLoggerDefaults>(new MessageLoggerDefaults(jm));
           // Note - since messageLoggerDefaults is a value_ptr, 
           //        there is no concern about deleting here.
       delete jobMode_p;  // dispose of the message text
                  // which will have been new-ed
              // in MessageLogger.cc (service version)
       break;
     }
     case MessageLoggerQ::SHUT_UP:  {
       assert( operand == 0 );
       active = false;
       break;
     }
     case MessageLoggerQ::FLUSH_LOG_Q:  {            // changelog 26
       if (singleThread) return;
       ConfigurationHandshake * h_p = 
           static_cast<ConfigurationHandshake *>(operand);
       job_pset_p = std::shared_ptr<PSet>(static_cast<PSet*>(h_p->p)); // propagate_const<T> has no reset() function
       std::lock_guard<std::mutex> sl(h_p->m);   // get lock
       h_p->c.notify_all();  // Signal to MessageLoggerQ that we are done
       // finally, release the scoped lock by letting it go out of scope 
       break;
     }
     case MessageLoggerQ::GROUP_STATS:  {            // change log 27
       std::string* cat_p =
           static_cast<std::string*>(operand);
       ELstatistics::noteGroupedCategory(*cat_p);
       delete cat_p;  // dispose of the message text
       break;
     }
     case MessageLoggerQ::FJR_SUMMARY:  {            // changelog 29
       if (singleThread) {
     std::map<std::string, double> * smp = 
         static_cast<std::map<std::string, double> *>(operand);
     triggerFJRmessageSummary(*smp);
     break;
       } else {
     ConfigurationHandshake * h_p = 
         static_cast<ConfigurationHandshake *>(operand);
     std::lock_guard<std::mutex> sl(h_p->m);   // get lock
     std::map<std::string, double> * smp = 
         static_cast<std::map<std::string, double> *>(h_p->p);
     triggerFJRmessageSummary(*smp);
     h_p->c.notify_all();  // Signal to MessageLoggerQ that we are done
     // finally, release the scoped lock by letting it go out of scope 
     break;
       }
     }
   }  // switch
 
 }  // MessageLoggerScribe::runCommand(opcode, operand)

void edm::service::MessageLoggerScribe::triggerFJRmessageSummary ( std::map< std::string, double > & sm )

private

Definition at line 1053 of file MessageLoggerScribe.cc.

References statisticsDestControls.

Referenced by runCommand(), and triggerStatisticsSummaries().

 {
   if (statisticsDestControls.empty()) {
     sm["NoStatisticsDestinationsConfigured"] = 0.0;
   } else {
     statisticsDestControls[0].summaryForJobReport(sm);
   }
 }

void edm::service::MessageLoggerScribe::triggerStatisticsSummaries ( )

private

Definition at line 1043 of file MessageLoggerScribe.cc.

References mps_fire::i, statisticsDestControls, statisticsResets, and triggerFJRmessageSummary().

Referenced by runCommand().

                                                   {
     assert (statisticsDestControls.size() == statisticsResets.size());
     for (unsigned int i = 0; i != statisticsDestControls.size(); ++i) {
       statisticsDestControls[i].summary( );
       if (statisticsResets[i]) statisticsDestControls[i].wipe( );
     }
 }