MessageLoggerScribe.cc

Go to the documentation of this file.

// ----------------------------------------------------------------------
//
// MessageLoggerScribe.cc
//
// Changes:
//
//   1 - 3/22/06  mf  - in configure_dest() 
//  Repaired the fact that destination limits for categories
//  were not being effective:
//  a) use values from the destination specific default PSet
//     rather than the overall default PSet to set these
//  b) when an explicit value has been set - either by overall default or 
//     by a destination specific default PSet - set that limit or
//     timespan for that dest_ctrl via a "*" msgId.
// 
//   2 - 3/22/06  mf  - in configure_dest() 
//  Enabled the use of -1 in the .cfg file to mean infinite limit
//  or timespan.  This is done by:
//  a) replacing the default value of -1 (by which we recognize 
//  never-specified values) by NO_VALUE_SET = -45654
//  b) checking for values of -1 and substituting a very large integer  
//
//   3 - 4/28/06  mf  - in configure_dest()
//  Mods to help deal with the fact that checking for an empty PSet is
//  unwise when untracked parameters are involved:  The PSet will appear
//  to be empty and if skipped, will result in limits not being applied.
//  a) Replaced default values directly in getAparameter with variables
//  which can be examined all in one place.
//  b) Carefully checked that we are never comparing to the empty PSet
//  
//   4 - 4/28/06  mf  - in configure_dest()
//  If a destination name does not have an extension, append .log 
//  (or in the case of a FwkJobReport, .xml).
//  [note for this change - the filename kept as an index to stream_ps
//  can be kept as its original name; it is just a tool for assigning
//  the right shared stream to statistics destinations]
//
//   5 - 4/28/06  mf  - in configure_dest()
//  Provision for an overall default affecting all categories, for 
//  example, establishing a limit for all a specific category for
//  every destination. 
//
//   6 - 5/18/06 mf  - in configure_dest()
//  Implement establishing intervals between reacting to message of
//  some type.
//
//   7 - 5/24/06 mf  - in configure_dest()
//  Corrected algorithm for estabolishing limits and intervals, avoiding
//      interference between setting the one and getting the default for the 
//      other.
//
//   8 - 5/31/06 wmtan  - in configure_errorlog()
//  The presence of the framework job report should not affect the output
//      to the early destination (cerr).
//
//   9 - 6/6/06 mf  - in configure_dest()
//  Support for placeholder PSet without actually creating the destination.
//  Useful in a .cfi file, in conjunction with potential replace commands.
//
//  10 - 6/6/06 mf  - in configure_dest()
//  Changed cfg keyword interval to reportEvery
//
//  11 - 6/12/06 mf  - in configure_errorlog()
//  Check for placeholder before attaching a destination that may not be
//  wanted.
//
//  12 - 6/14/06 mf  - in configure_external_dests()
//  Clear the list of external dests needing configuration, if there
//  is no configuration file available.
//
//  13 - 8/7/06 mf  - in configure_external_dests()
//  Undo change 12: the list of external dests needing configuration
//      is left intact if there is no configuration file available, the
//      assumption being that at some later time there will be a file and
//      the message logger will be configured again.
//
//      Note: The change made in (12) and un-done here was necessary to
//            prevent segfault behavior when a job is done with external
//            destinations and no .cfg file under some circumstances.
//            D. Evans (who was being hit with that behavior due to an
//        accidental .cfg omission) asserts (8/16) that running with
//            no .cfg file is a sufficient anomoly that the current change
//            is acceptable. 
//
//  14 - 10/18/06 mf  - in configure_error_log()
//  Finer control of output file name for a given destination:
//  Accept a parameter extension, to specify some extension other than
//      .log without needing to place a dot in the Pset name.  Also accept
//  an explicit filename.
//
//  15 - 2/11/07 mf - at bottom
//  Declared static_errorlog_p
//
//  16 - 3/13/07 mf - in configure_errorlog() and addition of 3 functions
//   Break out the configuring of each type of destination, for sanity.
//
//  17 - 3/13/07 mf - in run(), at CONFIGURE case
//   Use the handshake to make this synchronous, and pass any throw
//   across to the other thread.
//
//  18 - 3/14/07 mf - in configure_ordinary_destinations() and 2 others
//   Use actual filename in a master ostream_ps list, and behave correctly
//   when duplicates are found (duplicate names both used leads to grim
//   file behavior when one file is opened as two streams).
//
//  19 - 3/15/07 mf - in configure_fwkJobReports()
//   "Deturdification" - default is to not produce a job reports; a
//   command-line option lets you produce them.
//
//  20 - 3/15/07 mf - in configure_statistics() and configure_fwkJobReports()
//   Handle the placeholder case 
//
//  21 - 3/15/07 mf - run()
//   Improve the behavior of catches of exceptions in non-synchronous 
//       command cases:  Unless the ConfigurationHandshake is used, re-throw
//   is not an option, but exit is also not very good.
//
//  22 - 4/18/07 mf - in configure_error_log and its called functions
//   Allow for duplicate file names if configuration happens twice.
//
//  23 - 6/13/07 mf - in configure_statistics 
//   Repared error of calling "cerr" "err", which would cause appended
//   statistics destinations going to cerr to instead come out in a file 
//   err.log
//
//  24 - 6/15/07 mf - in configure_errlog and its descendants
//   Major mods to hardwire defaults taken from the .cfi file 
//   To allow flexibility, this depends on MessageLoggerDefaults.h
//
//  25 - 7/24/07 mf - in run() 
//   A command SHUT_UP to deactivate, and in the LOG_A_MESSGE case, response to 
//   that command.  This allows supression of the generator info in case of a
//   completely .cfg-less cmsRun command.  
//
//  26 - 8/7/07 mf - in run()
//   A command FLUSH_LOG_Q to consume the entire queue, processing each 
//   message.  Actually, the key is that on the other side, it is used in
//       a synchronous manner (like CONFIGURE) so as soon as one gets up to 
//   the flush command, the queue has in fact been flushed!  
//
//  27 - 8/16/07 mf - in run()
//   A command GROUP_STATS to add a category to a list which ELstatistics 
//   will use to avoid separate per-module statistics for that category.
//
//  28 - 6/18/08 mf - in CONFIGURE case and FLUSH_LOG_Q case
//   Changed expectation of p from a ParameterSet* to a void*:
//   static cast it to the needed ParameterSet*
//
//  29 - 6/19/08 mf - in run() and a new function triggerFJRmessageSummary()
//   Implemented filling a map with summary info for the Job Report
//
//  30 - 6/20/08 mf - in run() 
//   Setting MessageLoggerScribeIsRunning
//
//  31 - 7/9/08  mf - in configure_ordinary_destinations()
//       and configure_statistics()
//   using hardwired default output filename if there is one
//
//  32 - 10/21/08 mf - in ctor and in run() and new runCommand()
//   split up run() to have ability to implement single-thread
//
//  33 - 10/22/08 mf
//   implementation of singleThread
//
//  34 - 5/13/09 mf
//   Allowing threshold to be set for default destination in default PSet
//
//  35 - 5/29/09 mf
//       Avoiding throw when duplicate destination names are used, to let the
//   validation report that and abort instead.
//
//  36 - 8/10/09 mf, cdj
//       Use ThreadQ in place of the singleton MessageLoggerQ to consume
//
//  37 - 9/24/10 mf
//       Establish values of debugAlwaysSuppressed, infoAlwaysSuppressed
//       and warningAlwaysSuppressed when setting up thresholds
//
//  38 - 9/29/10 mf, ql
//       Limit and timespan shuold be translated from -1 input to 
//   2000000000.  This was being done in all cases except the 
//   severity limits; omission rectified.
//
// ----------------------------------------------------------------------

#include "FWCore/MessageService/interface/MessageLoggerScribe.h"
#include "FWCore/MessageService/interface/ELadministrator.h"
#include "FWCore/MessageService/interface/ELoutput.h"
#include "FWCore/MessageService/interface/ELstatistics.h"
#include "FWCore/MessageService/interface/ThreadQueue.h"

#include "FWCore/MessageLogger/interface/ErrorObj.h"
#include "FWCore/MessageLogger/interface/MessageLogger.h"
#include "FWCore/MessageLogger/interface/ConfigurationHandshake.h"
#include "FWCore/MessageLogger/interface/MessageDrop.h"     // change log 37
#include "FWCore/MessageLogger/interface/ELseverityLevel.h" // change log 37

#include "FWCore/Utilities/interface/EDMException.h"
#include "FWCore/Utilities/interface/Algorithms.h"

#include <algorithm>
#include <cassert>
#include <fstream>
#include <string>
#include <csignal>

using std::cerr;

namespace edm {
namespace service {


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

MessageLoggerScribe::~MessageLoggerScribe()
{
  admin_p->finish();
}


void
  MessageLoggerScribe::run()
{
  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
  MessageLoggerScribe::runCommand(              // changeLog 32
    MessageLoggerQ::OpCode  opcode, 
    void * operand)
{
  switch(opcode)  {  // interpret the work item
    default:  {
      assert(false);  // can't happen (we certainly hope!)
      break;
    }
    case MessageLoggerQ::END_THREAD:  {
      assert( operand == nullptr );
      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::SUMMARIZE: {
      assert( operand == nullptr );
      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 == nullptr );
      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 MessageLoggerScribe::log ( ErrorObj *  errorobj_p ) {
  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
  MessageLoggerScribe::configure_errorlog()
{
  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
}  // MessageLoggerScribe::configure_errorlog()




void
  MessageLoggerScribe::configure_dest( std::shared_ptr<ELdestination> dest_ctrl
                                     , String const &  filename
                     )
{
  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 

    const 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
  MessageLoggerScribe::configure_ordinary_destinations()    // Changelog 16
{
  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:
    std::shared_ptr<ELdestination> dest_ctrl;
    if( actual_filename == "cout" )  {
      dest_ctrl = std::make_shared<ELoutput>(std::cout);
      admin_p->attach( dest_ctrl );
      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 = std::make_shared<ELoutput>(*os_sp);
      admin_p->attach( dest_ctrl );
      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
  MessageLoggerScribe::configure_statistics()
{
  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;
    const 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:
      auto stat = std::make_shared<ELstatistics>(*os_p);
      admin_p->attach( stat );
      statisticsDestControls.push_back(stat);
      bool reset = getAparameter<bool>(stat_pset, "reset", false);
      statisticsResets.push_back(reset);
    
      // now configure this destination:
      configure_dest(stat, psetname);

      // and suppress the desire to do an extra termination summary just because
      // of end-of-job info messages
      stat->noTerminationSummary();
    }
     
  }  // for [it = statistics.begin() to end()]

} // configure_statistics

void
  MessageLoggerScribe::parseCategories (std::string const & s,
                        std::vector<std::string> & cats)
{
  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
  MessageLoggerScribe::triggerStatisticsSummaries() {
    assert (statisticsDestControls.size() == statisticsResets.size());
    for (unsigned int i = 0; i != statisticsDestControls.size(); ++i) {
      statisticsDestControls[i]->summary( 0 );
      if (statisticsResets[i]) statisticsDestControls[i]->wipe( );
    }
}

void
  MessageLoggerScribe::
  triggerFJRmessageSummary(std::map<std::string, double> & sm)  // ChangeLog 29
{
  if (statisticsDestControls.empty()) {
    sm["NoStatisticsDestinationsConfigured"] = 0.0;
  } else {
    statisticsDestControls[0]->summaryForJobReport(sm);
  }
}



} // end of namespace service  
} // end of namespace edm