#include <ThreadSafeLogMessageLoggerScribe.h>

Inheritance diagram for edm::service::ThreadSafeLogMessageLoggerScribe:

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

	ThreadSafeLogMessageLoggerScribe ()
	— If queue is NULL, this sets singleThread true More...

virtual	~ThreadSafeLogMessageLoggerScribe ()

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

std::atomic< int >	count

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

std::atomic< bool >	m_messageBeingSent

tbb::concurrent_queue< ErrorObj * >	m_waitingMessages

value_ptr< MessageLoggerDefaults >	messageLoggerDefaults

std::vector< String >	ordinary_destination_filenames

std::atomic< bool >	purge_mode

std::vector< ELdestControl >	statisticsDestControls

std::vector< bool >	statisticsResets

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

Detailed Description

Definition at line 38 of file ThreadSafeLogMessageLoggerScribe.h.

Member Typedef Documentation

typedef ParameterSet edm::service::ThreadSafeLogMessageLoggerScribe::PSet

private

Definition at line 58 of file ThreadSafeLogMessageLoggerScribe.h.

typedef std::string edm::service::ThreadSafeLogMessageLoggerScribe::String

private

Definition at line 56 of file ThreadSafeLogMessageLoggerScribe.h.

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

private

Definition at line 57 of file ThreadSafeLogMessageLoggerScribe.h.

Constructor & Destructor Documentation

edm::service::ThreadSafeLogMessageLoggerScribe::ThreadSafeLogMessageLoggerScribe ( )

explicit

— If queue is NULL, this sets singleThread true

Definition at line 40 of file ThreadSafeLogMessageLoggerScribe.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 )
     , purge_mode (false)                        // changeLog 32
     , count (false)                         // changeLog 32
     , m_messageBeingSent(false)
     {
     }

edm::service::ThreadSafeLogMessageLoggerScribe::~ThreadSafeLogMessageLoggerScribe ( )

virtual

Definition at line 54 of file ThreadSafeLogMessageLoggerScribe.cc.

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

     {
       //if there are any waiting message, finish them off
       ErrorObj* errorobj_p=nullptr;
       std::vector<std::string> categories;
       while(m_waitingMessages.try_pop(errorobj_p)) {
         if(not purge_mode) {
           categories.clear();
           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
           }
         }
         delete errorobj_p;
       }
       
       admin_p->finish();
       assert( extern_dests.empty() );  // nothing to do
     }

Member Function Documentation

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

private

Definition at line 267 of file ThreadSafeLogMessageLoggerScribe.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, lut2db_cfg::filename, edm::MessageDrop::infoAlwaysSuppressed, MergeJob_cfg::interval, job_pset_p, MessageLogger_cff::limit, messageLoggerDefaults, dtDQMClient_cfg::noLineBreaks, edm::service::ELdestControl::setInterval(), edm::service::ELdestControl::setLimit(), edm::service::ELdestControl::setLineLength(), edm::service::ELdestControl::setThreshold(), edm::service::ELdestControl::setTimespan(), HLT_25ns10e33_v2_cff::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();
       }
       
     }  // ThreadSafeLogMessageLoggerScribe::configure_dest()

void edm::service::ThreadSafeLogMessageLoggerScribe::configure_errorlog ( )

private

Definition at line 232 of file ThreadSafeLogMessageLoggerScribe.cc.

References clean_slate_configuration, configure_external_dests(), configure_ordinary_destinations(), configure_statistics(), early_dest, job_pset_p, 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 ( !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();
       
     }  // ThreadSafeLogMessageLoggerScribe::configure_errorlog()

void edm::service::ThreadSafeLogMessageLoggerScribe::configure_external_dests ( )

private

Definition at line 781 of file ThreadSafeLogMessageLoggerScribe.cc.

References admin_p, configure_dest(), alignCSCRings::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();
       
     }  // ThreadSafeLogMessageLoggerScribe::configure_external_dests

void edm::service::ThreadSafeLogMessageLoggerScribe::configure_ordinary_destinations ( )

private

Definition at line 508 of file ThreadSafeLogMessageLoggerScribe.cc.

References admin_p, ecal_dqm_sourceclient-live_cfg::cerr, clean_slate_configuration, configure_dest(), gather_cfg::cout, edm::MessageDrop::debugAlwaysSuppressed, myMessageLogger_cff::destinations, early_dest, edm::ELhighestSeverity, edm::ELzeroSeverity, file_ps, lut2db_cfg::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::ThreadSafeLogMessageLoggerScribe::configure_statistics ( )

private

Definition at line 640 of file ThreadSafeLogMessageLoggerScribe.cc.

References admin_p, ecal_dqm_sourceclient-live_cfg::cerr, clean_slate_configuration, edm::errors::Configuration, configure_dest(), gather_cfg::cout, myMessageLogger_cff::destinations, Exception, file_ps, lut2db_cfg::filename, job_pset_p, messageLoggerDefaults, edm::service::ELdestControl::noTerminationSummary(), ordinary_destination_filenames, reset(), edm::search_all(), benchmark_cfg::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::ThreadSafeLogMessageLoggerScribe::getAparameter	(	PSet const &	p,
		std::string const &	id,
		T const &	def
	)

inlineprivate

Definition at line 77 of file ThreadSafeLogMessageLoggerScribe.h.

References def, 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::ThreadSafeLogMessageLoggerScribe::log ( ErrorObj * errorobj_p )

private

Definition at line 203 of file ThreadSafeLogMessageLoggerScribe.cc.

References admin_p, myMessageLogger_cff::categories, edm::ErrorObj::clear(), edm::ELextendedID::id, m_messageBeingSent, m_waitingMessages, getGTfromDQMFile::obj, parseCategories(), purge_mode, edm::ErrorObj::setID(), and edm::ErrorObj::xid().

Referenced by runCommand().

                                                                         {
       bool expected = false;
       std::unique_ptr<ErrorObj> obj(errorobj_p);
       if(m_messageBeingSent.compare_exchange_strong(expected,true)) {
         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
         }
         //process any waiting messages
         errorobj_p=nullptr;
         while(not purge_mode and m_waitingMessages.try_pop(errorobj_p)) {
           obj.reset(errorobj_p);
           categories.clear();
           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
           }
         }
         m_messageBeingSent.store(false);
       } else {
         obj.release();
         m_waitingMessages.push(errorobj_p);
       }
     }

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

private

Definition at line 804 of file ThreadSafeLogMessageLoggerScribe.cc.

References i, and j.

Referenced by log(), and ~ThreadSafeLogMessageLoggerScribe().

     {
       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::ThreadSafeLogMessageLoggerScribe::runCommand	(	MessageLoggerQ::OpCode	opcode,
		void *	operand
	)

virtual

Reimplemented from edm::service::AbstractMLscribe.

Definition at line 76 of file ThreadSafeLogMessageLoggerScribe.cc.

     {
       switch(opcode)  {  // interpret the work item
         default:  {
           assert(false);  // can't happen (we certainly hope!)
           break;
         }
         case MessageLoggerQ::END_THREAD:  {
           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 << "ThreadSafeLogMessageLoggerScribe 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 << "ThreadSafeLogMessageLoggerScribe caught an unknown exception and "
             << "will no longer be processing "
             << "messages. (entering purge mode)\n";
             purge_mode = true;
           }
           break;
         }
         case MessageLoggerQ::CONFIGURE:  {          // changelog 17
           job_pset_p = std::shared_ptr<PSet>(static_cast<PSet*>(operand)); // propagate_const<T> has no reset() function
           configure_errorlog();
           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 << "ThreadSafeLogMessageLoggerScribe 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 << "ThreadSafeLogMessageLoggerScribe 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 << "ThreadSafeLogMessageLoggerScribe caught exception "
             << "during summarize:\n"
             << e.what() << "\n";
           }
           catch(...)
           {
             std::cerr << "ThreadSafeLogMessageLoggerScribe 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
           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
           std::map<std::string, double> * smp =
           static_cast<std::map<std::string, double> *>(operand);
           triggerFJRmessageSummary(*smp);
           break;
         }
       }  // switch
       
     }  // ThreadSafeLogMessageLoggerScribe::runCommand(opcode, operand)

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

private

Definition at line 831 of file ThreadSafeLogMessageLoggerScribe.cc.

References statisticsDestControls.

Referenced by runCommand().

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

void edm::service::ThreadSafeLogMessageLoggerScribe::triggerStatisticsSummaries ( )

private

Definition at line 821 of file ThreadSafeLogMessageLoggerScribe.cc.

References assert(), i, statisticsDestControls, and statisticsResets.

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