#include <MessageLoggerScribe.h>

Inheritance diagram for mf::service::MessageLoggerScribe:

Public Member Functions
	~MessageLoggerScribe ()

	MessageLoggerScribe (std::string const &applicationName)

	MessageLoggerScribe (MessageLoggerScribe const &)=delete

MessageLoggerScribe &	operator= (MessageLoggerScribe const &)=delete

void	runCommand (OpCode opcode, void *operand) override

void	setApplication (std::string const &application) override

void	setHostName (std::string const &hostName) override

void	setHostAddr (std::string const &hostAddr) override

void	setPID (long pid) override

Public Member Functions inherited from mf::service::AbstractMLscribe
	AbstractMLscribe ()=default

virtual	~AbstractMLscribe () noexcept=default

	AbstractMLscribe (AbstractMLscribe const &)=delete

AbstractMLscribe &	operator= (AbstractMLscribe const &)=delete

virtual void	setApplication (std::string const &application[[gnu::unused]])

virtual void	setHostName (std::string const &hostName[[gnu::unused]])

virtual void	setHostAddr (std::string const &hostAddr[[gnu::unused]])

virtual void	setPID (long pid[[gnu::unused]])

Private Member Functions
void	log (ErrorObj *errorobj_p)

void	triggerStatisticsSummaries ()

void	configure_errorlog (std::unique_ptr< MessageLoggerQ::Config > &&dests_config)

void	fetchDestinations (std::unique_ptr< MessageLoggerQ::Config > dests_config)

void	makeDestinations (fhicl::ParameterSet const &dests, ELdestConfig::dest_config const config)

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

std::string	createId (std::set< std::string > &existing_ids, std::string const &type, std::string const &filename, fhicl::ParameterSet const &pset={}, bool const should_throw=true)

bool	duplicateDestination (std::string const &output_id, ELdestConfig::dest_config const config, bool const should_throw)

std::unique_ptr< ELdestination >	makePlugin_ (cet::BasicPluginFactory &pluginFactory, std::string const &libspec, std::string const &psetname, fhicl::ParameterSet const &pset)

Private Attributes
ELadministrator	admin_

cet::BasicPluginFactory	pluginFactory_ {"mfPlugin"}

cet::BasicPluginFactory	pluginStatsFactory_ {"mfStatsPlugin"}

ELdestination &	earlyDest_

bool	cleanSlateConfiguration_ {true}

bool	active_ {true}

std::atomic< bool >	purgeMode_ {false}

std::atomic< int >	count_ {0}

std::atomic< bool >	messageBeingSent_ {false}

tbb::concurrent_queue< ErrorObj * >	waitingMessages_ {}

Detailed Description

Definition at line 25 of file MessageLoggerScribe.h.

Constructor & Destructor Documentation

mf::service::MessageLoggerScribe::~MessageLoggerScribe ( )

Definition at line 79 of file MessageLoggerScribe.cc.

     {
       // If there are any waiting message, finish them off
       ErrorObj* errorobj_p = nullptr;
       while (waitingMessages_.try_pop(errorobj_p)) {
         if (!purgeMode_) {
           for (auto const& cat : parseCategories(errorobj_p->xid().id())) {
             errorobj_p->setID(cat);
             admin_.log(*errorobj_p); // route the message text
           }
         }
         delete errorobj_p;
       }
       admin_.finish();
     }

mf::service::MessageLoggerScribe::MessageLoggerScribe ( std::string const & applicationName )

Definition at line 60 of file MessageLoggerScribe.cc.

                                             : admin_ {
       applicationName
     }
     , earlyDest_{admin_.attach("cerr_early",
                                makePlugin_(pluginFactory_,
                                            "cerr",
                                            "cerr_early",
                                            default_destination_config()))}
     {}
     catch (fhicl::detail::validationException const& e)
     {
       std::string msg{"\nConfiguration error for destination: " +
                       detail::bold_fontify("cerr_early") + "\n\n"};
       msg += e.what();
       throw Exception(errors::Configuration) << msg;
     }

mf::service::MessageLoggerScribe::MessageLoggerScribe ( MessageLoggerScribe const & )

delete

Member Function Documentation

void mf::service::MessageLoggerScribe::configure_errorlog ( std::unique_ptr< MessageLoggerQ::Config > && dests_config )

private

Definition at line 222 of file MessageLoggerScribe.cc.

     {
       if (admin_.destinations().size() > 1) {
         LogWarning("multiLogConfig")
           << "The message logger has been configured multiple times";
         cleanSlateConfiguration_ = false;
       }
 
       fetchDestinations(std::move(config));
     } // MessageLoggerScribe::configure_errorlog()

std::string mf::service::MessageLoggerScribe::createId	(	std::set< std::string > &	existing_ids,
		std::string const &	type,
		std::string const &	filename,
		fhicl::ParameterSet const &	pset = `{}`,
		bool const	should_throw = `true`
	)

private

Definition at line 391 of file MessageLoggerScribe.cc.

     {
       std::string output_id{type};
       if (!cet::search_all(std::vector<std::string>{"cout", "cerr", "syslog"},
                            type)) {
         output_id += ":" + pset.get<std::string>("filename", file_name);
       }
 
       // Emplace and check that output_id doesn't already exist
       if (!existing_ids.emplace(output_id).second) {
         // Current usage case is to NOT throw for ordinary
         // destinations, but to throw for statistics destinations.
         if (should_throw) {
           throw mf::Exception{mf::errors::Configuration}
             << "\n"
             << " Output identifier: \"" << output_id << "\""
             << " already specified within ordinary/statistics block in FHiCL "
                "file"
             << "\n";
         }
       }
 
       return output_id;
     }

bool mf::service::MessageLoggerScribe::duplicateDestination	(	std::string const &	output_id,
		ELdestConfig::dest_config const	config,
		bool const	should_throw
	)

private

Definition at line 422 of file MessageLoggerScribe.cc.

     {
       std::string config_str;
       switch (configuration) {
         case ELdestConfig::ORDINARY:
           config_str = "MessageLogger";
           break;
         case ELdestConfig::STATISTICS:
           config_str = "MessageLogger Statistics";
           break;
       }
 
       auto dest_pr = admin_.destinations().find(output_id);
       if (dest_pr == admin_.destinations().end())
         return false;
 
       // For duplicate destinations
       std::string const hrule{"\n=============================================="
                               "============================== \n"};
       std::ostringstream except_msg, orig_config_msg;
       except_msg << hrule << "\n    Duplicate name for a " << config_str
                  << " destination: \"" << output_id << "\"";
       orig_config_msg
         << "\n    Only original configuration instructions are used. \n"
         << hrule;
 
       //------------------------------------------------------------------
       // Handle statistics case where duplicate destinations are okay
       //------------------------------------------------------------------
 
       // If user specifies the destination twice and the configuration
       // is STATISTICS, then the ELdestination.userWantsStats_ flag
       // needs to be set to 'true' so that statistics are output.
 
       if (configuration == ELdestConfig::STATISTICS) {
         dest_pr->second->userWantsStats();
         return true; // don't emit warning for statistics
       }
 
       // Emit error message for everything else
       if (cleanSlateConfiguration_) {
 
         if (should_throw) {
           throw mf::Exception{mf::errors::Configuration} << "\n"
                                                          << except_msg.str();
         } else
           LogError("duplicateDestination")
             << except_msg.str() << orig_config_msg.str();
 
       } else { // !cleanSlateConfiguration_
         LogWarning("duplicateDestination")
           << except_msg.str() << orig_config_msg.str();
       }
 
       return true;
     }

void mf::service::MessageLoggerScribe::fetchDestinations ( std::unique_ptr< MessageLoggerQ::Config > dests_config )

private

Definition at line 236 of file MessageLoggerScribe.cc.

     {
       fhicl::ParameterSet dest_psets;
       fhicl::ParameterSet ordinaryDests;
       if (!config->destinations.get_if_present(dest_psets)) {
         dest_psets = default_destinations_config();
       }
       ordinaryDests = dest_psets;
       ordinaryDests.erase("statistics");
 
       // Dial down the early destination once the ordinary
       // destinations are filled.
       earlyDest_.setThreshold(ELhighestSeverity);
 
       auto statDests = dest_psets.get<fhicl::ParameterSet>(
         "statistics", default_statistics_config(ordinaryDests));
 
       // Initialize universal suppression variables
       MessageDrop::debugAlwaysSuppressed = true;
       MessageDrop::infoAlwaysSuppressed = true;
       MessageDrop::warningAlwaysSuppressed = true;
 
       makeDestinations(ordinaryDests, ELdestConfig::ORDINARY);
       makeDestinations(statDests, ELdestConfig::STATISTICS);
     }

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

private

Definition at line 194 of file MessageLoggerScribe.cc.

     {
       bool expected = false;
       std::unique_ptr<ErrorObj> obj(errorobj_p);
       if (messageBeingSent_.compare_exchange_strong(expected, true)) {
         // Process the current message.
         for (auto const& cat : parseCategories(errorobj_p->xid().id())) {
           errorobj_p->setID(cat);
           admin_.log(*errorobj_p); // route the message text
         }
         // process any waiting messages
         errorobj_p = nullptr;
         while (!purgeMode_ && waitingMessages_.try_pop(errorobj_p)) {
           obj.reset(errorobj_p);
           for (auto const& cat : parseCategories(errorobj_p->xid().id())) {
             errorobj_p->setID(cat);
             admin_.log(*errorobj_p); // route the message text
           }
         }
         messageBeingSent_.store(false);
       } else {
         obj.release();
         waitingMessages_.push(errorobj_p);
       }
     }

void mf::service::MessageLoggerScribe::makeDestinations	(	fhicl::ParameterSet const &	dests,
		ELdestConfig::dest_config const	config
	)

private

Definition at line 265 of file MessageLoggerScribe.cc.

     {
       std::set<std::string> ids;
 
       std::vector<std::string> config_errors;
       for (auto const& psetname : dests.get_pset_names()) {
 
         // Retrieve the destination pset object.
         auto dest_pset = dests.get<fhicl::ParameterSet>(psetname);
 
         // If the provided parameter set is empty, replace its
         // configuration with the default one.
         if (dest_pset.is_empty()) {
           dest_pset = default_destination_config();
         }
 
         // Grab the destination type and filename.
         // FIXME: This should only be part of the configuration
         // validation!
         std::string dest_type{};
         if (!dest_pset.get_if_present("type", dest_type)) {
           throw Exception(errors::Configuration)
             << "No 'type' specified for destination '" << psetname << "'.\n";
         }
         ELdestConfig::checkType(dest_type, configuration);
 
         bool const throw_on_duplicate_id =
           (configuration == ELdestConfig::STATISTICS);
         std::string const& outputId =
           createId(ids, dest_type, psetname, dest_pset, throw_on_duplicate_id);
 
         // Use previously defined configuration of duplicated destination
         if (duplicateDestination(
               outputId, configuration, no_throw_on_clean_slate))
           continue;
 
         std::string const& libspec = dest_type;
         auto& plugin_factory = configuration == ELdestConfig::STATISTICS ?
                                  pluginStatsFactory_ :
                                  pluginFactory_;
 
         // attach the current destination, keeping a control handle to it:
         try {
           ELdestination& dest = admin_.attach(
             outputId,
             makePlugin_(plugin_factory, libspec, psetname, dest_pset));
 
           // Suppress the desire to do an extra termination summary just because
           // of end-of-job info message for statistics jobs
           if (configuration == ELdestConfig::STATISTICS)
             dest.noTerminationSummary();
         }
         catch (fhicl::detail::validationException const& e) {
           std::string msg{"Configuration error for destination: " +
                           detail::bold_fontify(psetname) + "\n\n"};
           msg += e.what();
           config_errors.push_back(std::move(msg));
         }
       }
 
       if (!config_errors.empty()) {
         std::string msg{"\nThe following messagefacility destinations have "
                         "configuration errors:\n\n"};
         constexpr cet::HorizontalRule rule{60};
         msg += rule('=');
         msg += "\n\n";
         auto start = cbegin(config_errors);
         msg += *start;
         ++start;
         for (auto it = start, e = cend(config_errors); it != e; ++it) {
           msg += rule('-');
           msg += "\n\n";
           msg += *it;
         }
         msg += rule('=');
         msg += "\n\n";
         throw Exception(errors::Configuration) << msg;
       }
     } // make_destinations()

std::unique_ptr< ELdestination > mf::service::MessageLoggerScribe::makePlugin_	(	cet::BasicPluginFactory &	pluginFactory,
		std::string const &	libspec,
		std::string const &	psetname,
		fhicl::ParameterSet const &	pset
	)

private

Definition at line 484 of file MessageLoggerScribe.cc.

     {
       std::unique_ptr<ELdestination> result;
       try {
         auto const pluginType = plugin_factory.pluginType(libspec);
         if (pluginType == cet::PluginTypeDeducer<ELdestination>::value) {
           result = plugin_factory.makePlugin<std::unique_ptr<ELdestination>>(
             libspec, psetname, pset);
         } else {
           throw Exception(errors::Configuration, "MessageLoggerScribe: ")
             << "unrecognized plugin type " << pluginType << "for plugin "
             << libspec << ".\n";
         }
       }
       catch (cet::exception const& e) {
         throw Exception(errors::Configuration, "MessageLoggerScribe: ", e)
           << "Exception caught while processing plugin spec.\n";
       }
       return result;
     } //

MessageLoggerScribe& mf::service::MessageLoggerScribe::operator= ( MessageLoggerScribe const & )

delete

vstring mf::service::MessageLoggerScribe::parseCategories ( std::string const & s )

private

Definition at line 349 of file MessageLoggerScribe.cc.

     {
       vstring cats;
       using namespace std::string_literals;
       // Note:  This algorithm assigns, as desired, one null category if it
       //        encounters an empty categories string
 
       auto const npos = s.length();
       decltype(s.length()) i{};
 
       while (i <= npos) {
 
         if (i == npos) {
           cats.push_back(std::string());
           return cats;
         }
 
         auto const j = s.find('|', i);
         std::string cat = cet::trim_copy(s.substr(i, j - i), " \t\n"s);
         cats.push_back(cat);
         i = j;
         while ((i < npos) && (s[i] == '|'))
           ++i;
         // the above handles cases of || and also | at end of string
       }
       return cats;
     }

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

overridevirtual

Implements mf::service::AbstractMLscribe.

Definition at line 97 of file MessageLoggerScribe.cc.

     {
       switch (opcode) {
         default: {
           assert(false); // can't happen (we certainly hope!)
           break;
         }
         case END_THREAD: {
           break;
         }
         case LOG_A_MESSAGE: {
           auto errorobj_p = static_cast<ErrorObj*>(operand);
           try {
             if (active_ && !purgeMode_) {
               log(errorobj_p);
             }
           }
           catch (cet::exception const& e) {
             ++count_;
             std::cerr << "MessageLoggerScribe caught " << count_
                       << " cet::exceptions, text = \n"
                       << e.what() << "\n";
 
             if (count_ > 25) {
               std::cerr << "MessageLogger will no longer be processing "
                         << "messages due to errors (entering purge mode).\n";
               purgeMode_ = true;
             }
           }
           catch (...) {
             std::cerr << "MessageLoggerScribe caught an unknown exception and "
                       << "will no longer be processing "
                       << "messages. (entering purge mode)\n";
             purgeMode_ = true;
           }
           break;
         }
         case CONFIGURE: {
           auto config = std::unique_ptr<MessageLoggerQ::Config>(
             static_cast<MessageLoggerQ::Config*>(operand));
           configure_errorlog(std::move(config));
           break;
         }
         case SUMMARIZE: {
           assert(operand == nullptr);
           try {
             triggerStatisticsSummaries();
           }
           catch (cet::exception const& 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 SHUT_UP: {
           assert(operand == nullptr);
           active_ = false;
           break;
         }
         case FLUSH_LOG_Q: {
           break;
         }
       } // switch
 
     } // MessageLoggerScribe::runCommand(opcode, operand)

void mf::service::MessageLoggerScribe::setApplication ( std::string const & application )

override

Definition at line 169 of file MessageLoggerScribe.cc.

     {
       admin_.setApplication(application);
     }

void mf::service::MessageLoggerScribe::setHostAddr ( std::string const & hostAddr )

override

Definition at line 181 of file MessageLoggerScribe.cc.

     {
       admin_.hostaddr_ = hostAddr;
     }

void mf::service::MessageLoggerScribe::setHostName ( std::string const & hostName )

override

Definition at line 175 of file MessageLoggerScribe.cc.

     {
       admin_.hostname_ = hostName;
     }

void mf::service::MessageLoggerScribe::setPID ( long pid )

override

Definition at line 187 of file MessageLoggerScribe.cc.

     {
       admin_.pid_ = pid;
     }

void mf::service::MessageLoggerScribe::triggerStatisticsSummaries ( )

private

Definition at line 379 of file MessageLoggerScribe.cc.

     {
       for (auto& idDestPair : admin_.destinations()) {
         auto& dest = *idDestPair.second;
         dest.summary();
         if (dest.resetStats())
           dest.wipe();
       }
     }

Member Data Documentation

bool mf::service::MessageLoggerScribe::active_ {true}

private

Definition at line 67 of file MessageLoggerScribe.h.

ELadministrator mf::service::MessageLoggerScribe::admin_

private

Definition at line 62 of file MessageLoggerScribe.h.

bool mf::service::MessageLoggerScribe::cleanSlateConfiguration_ {true}

private

Definition at line 66 of file MessageLoggerScribe.h.

std::atomic<int> mf::service::MessageLoggerScribe::count_ {0}

private

Definition at line 69 of file MessageLoggerScribe.h.

ELdestination& mf::service::MessageLoggerScribe::earlyDest_

private

Definition at line 65 of file MessageLoggerScribe.h.

std::atomic<bool> mf::service::MessageLoggerScribe::messageBeingSent_ {false}

private

Definition at line 70 of file MessageLoggerScribe.h.

cet::BasicPluginFactory mf::service::MessageLoggerScribe::pluginFactory_ {"mfPlugin"}

private

Definition at line 63 of file MessageLoggerScribe.h.

cet::BasicPluginFactory mf::service::MessageLoggerScribe::pluginStatsFactory_ {"mfStatsPlugin"}

private

Definition at line 64 of file MessageLoggerScribe.h.

std::atomic<bool> mf::service::MessageLoggerScribe::purgeMode_ {false}

private

Definition at line 68 of file MessageLoggerScribe.h.

tbb::concurrent_queue<ErrorObj*> mf::service::MessageLoggerScribe::waitingMessages_ {}

private

Definition at line 71 of file MessageLoggerScribe.h.

The documentation for this class was generated from the following files:

messagefacility/messagefacility/MessageLogger/MessageLoggerScribe.h
messagefacility/messagefacility/MessageLogger/MessageLoggerScribe.cc

Public Member Functions

Private Member Functions

Private Attributes

Detailed Description

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation