#include <ELdestination.h>

Inheritance diagram for mf::service::ELdestination:

Classes
struct	Category

struct	CategoryParams

struct	Config

class	MsgFormatSettings

class	MsgStatistics

struct	StatsCount

struct	XidLimiter

Public Types
enum	flag_enum { NO_LINE_BREAKS, TIMESTAMP, MILLISECOND, MODULE, SUBROUTINE, TEXT, SOME_CONTEXT, SERIAL, FULL_CONTEXT, TIME_SEPARATE, EPILOGUE_SEPARATE, NFLAGS }

Public Member Functions
virtual	~ELdestination () noexcept=default

	ELdestination (Config const &)

	ELdestination (ELdestination const &)=delete

	ELdestination (ELdestination &&)=delete

ELdestination &	operator= (ELdestination const &)=delete

ELdestination &	operator= (ELdestination &&)=delete

void	setThreshold (ELseverityLevel sv)

virtual void	log (mf::ErrorObj &)

virtual void	finish ()

virtual void	summary ()

Protected Member Functions
std::string	summarizeContext (std::string const &)

void	emitToken (std::ostream &os, std::string const &s, bool nl=false, bool preambleMode=false)

std::string	formSummary ()

bool	skipMsg (ELextendedID const &)

void	resetLimiters ()

void	resetMsgCounters ()

virtual void	fillPrefix (std::ostringstream &, mf::ErrorObj const &msg)

virtual void	fillUsrMsg (std::ostringstream &, mf::ErrorObj const &msg)

virtual void	fillSuffix (std::ostringstream &, mf::ErrorObj const &msg)

virtual void	routePayload (std::ostringstream const &, mf::ErrorObj const &msg)

virtual void	flush ()

Protected Attributes
ELseverityLevel	threshold_

MsgFormatSettings	format_

int	defaultLimit_

int	defaultReportEvery_

int	defaultTimespan_

std::map< std::string const, CategoryParams >	categoryParams_

std::map< ELextendedID const, XidLimiter >	xidLimiters_

std::map< ELextendedID const, StatsCount >	statsMap_

bool	outputStatistics_ {false}

bool	updatedStats_ {false}

bool	reset_ {false}

Private Attributes
std::size_t	charsOnLine_ {}

Detailed Description

Definition at line 24 of file ELdestination.h.

Member Enumeration Documentation

enum mf::service::ELdestination::flag_enum

Enumerator
NO_LINE_BREAKS
TIMESTAMP
MILLISECOND
MODULE
SUBROUTINE
TEXT
SOME_CONTEXT
SERIAL
FULL_CONTEXT
TIME_SEPARATE
EPILOGUE_SEPARATE
NFLAGS

Definition at line 26 of file ELdestination.h.

                    {
       NO_LINE_BREAKS,
       TIMESTAMP,
       MILLISECOND,
       MODULE,
       SUBROUTINE,
       TEXT,
       SOME_CONTEXT,
       SERIAL,
       FULL_CONTEXT,
       TIME_SEPARATE,
       EPILOGUE_SEPARATE,
       NFLAGS
     };

Constructor & Destructor Documentation

virtual mf::service::ELdestination::~ELdestination ( )

virtualdefaultnoexcept

mf::service::ELdestination::ELdestination ( Config const & pset )

Definition at line 272 of file ELdestination.cc.

     : threshold_{pset.threshold()}
     , format_{pset.format()}
     , defaultLimit_{numeric_limits<decltype(defaultLimit_)>::max()}
     , defaultReportEvery_{-1}
     , defaultTimespan_{numeric_limits<decltype(defaultTimespan_)>::max()}
     , categoryParams_{}
     , xidLimiters_{}
     , statsMap_{}
     , outputStatistics_{pset.outputStatistics()}
     , updatedStats_{false}
     , reset_{pset.msgStatistics().reset() ||
              pset.msgStatistics().resetStatistics()}
     , charsOnLine_{}
   {
     vector<string> configuration_errors;
     // Grab this destination's category configurations.
     fhicl::ParameterSet cats_pset{};
     pset.categories.get_if_present<fhicl::ParameterSet>(cats_pset);
     // Grab the list of categories, removing the default category
     // since it is handled specially.
     auto const default_category_name = "default"s;
     auto categories = cats_pset.get_pset_names();
     auto erase_from =
       remove_if(begin(categories), end(categories), [](auto const& category) {
         return category == "default"s;
       });
     categories.erase(erase_from, categories.cend());
     // Setup the default configuration for categories--this involves
     // resetting the limits table according to the user-specified
     // default configuration.
     auto const& default_pset =
       cats_pset.get<fhicl::ParameterSet>("default"s, {});
     try {
       fhicl::WrappedTable<Category::Config> default_params{default_pset};
       defaultLimit_ = (default_params().limit() < 0) ?
                         numeric_limits<decltype(defaultLimit_)>::max() :
                         default_params().limit();
       defaultReportEvery_ = default_params().reportEvery();
       defaultTimespan_ = (default_params().timespan() < 0) ?
                            numeric_limits<decltype(defaultTimespan_)>::max() :
                            default_params().timespan();
     }
     catch (fhicl::detail::validationException const& e) {
       string msg{"Category: "s + cet::bold_fontify("default"s) + "\n\n"s};
       msg += e.what();
       configuration_errors.push_back(move(msg));
     }
     // Now establish this destination's limit/reportEvery/timespan for
     // each category, using the values of the possibly-specified
     // default configuration when a given category is missing the
     // fields.
     for (auto const& category : categories) {
       fhicl::Table<Category::Config> category_params{fhicl::Name{category},
                                                      default_pset};
       try {
         category_params.validate(cats_pset.get<fhicl::ParameterSet>(category));
       }
       catch (fhicl::detail::validationException const& e) {
         string msg{"Category: " + cet::bold_fontify(category) + "\n\n"};
         msg += e.what();
         configuration_errors.push_back(move(msg));
       }
 
       if (category_params().limit() < 0) {
         categoryParams_[category].limit_ = numeric_limits<int>::max();
       } else {
         categoryParams_[category].limit_ = category_params().limit();
       }
       categoryParams_[category].reportEvery_ = category_params().reportEvery();
       if (category_params().timespan() < 0) {
         categoryParams_[category].timespan_ = numeric_limits<int>::max();
       } else {
         categoryParams_[category].timespan_ = category_params().timespan();
       }
     }
     if (!configuration_errors.empty()) {
       string msg{"The following categories were misconfigured:\n\n"};
       for (auto const& error : configuration_errors) {
         msg += error;
       }
       throw fhicl::detail::validationException{msg};
     }
   }

mf::service::ELdestination::ELdestination ( ELdestination const & )

delete

mf::service::ELdestination::ELdestination ( ELdestination && )

delete

Member Function Documentation

void mf::service::ELdestination::emitToken	(	std::ostream &	os,
		std::string const &	s,
		bool	nl = `false`,
		bool	preambleMode = `false`
	)

protected

Definition at line 388 of file ELdestination.cc.

   {
     string const indent(6, ' ');
     if (s.empty()) {
       if (nl) {
         os << '\n';
         charsOnLine_ = 0UL;
       }
       return;
     }
     if (!preambleMode) {
       os << s;
       return;
     }
     char const first = s[0];
     char const second = (s.length() < 2) ? '\0' : s[1];
     char const last = (s.length() < 2) ? '\0' : s[s.length() - 1];
     char const last2 = (s.length() < 3) ? '\0' : s[s.length() - 2];
     // checking -2 because the very last char is sometimes a ' '
     // inserted by ErrorLog::operator<<
     // Accounts for newline @ the beginning of the string
     if (first == '\n' || (charsOnLine_ + s.length()) > format_.lineLength) {
       charsOnLine_ = 0UL;
       if (second != ' ') {
         os << ' ';
         ++charsOnLine_;
       }
       if (first == '\n') {
         os << s.substr(1);
       } else {
         os << s;
       }
     } else {
       os << s;
     }
     if ((last == '\n') || (last2 == '\n')) {
       os << indent;
       if (last != ' ') {
         os << ' ';
       }
       charsOnLine_ = indent.length() + 1UL;
     }
     if (nl) {
       os << '\n';
       charsOnLine_ = 0UL;
     } else {
       charsOnLine_ += s.length();
     }
   }

void mf::service::ELdestination::fillPrefix	(	std::ostringstream &	oss,
		mf::ErrorObj const &	msg
	)

protectedvirtual

Reimplemented in mfplugins::ELsyslog.

Definition at line 442 of file ELdestination.cc.

   {
     if (msg.is_verbatim()) {
       return;
     }
     auto const& xid = msg.xid();
     charsOnLine_ = 0UL;
     emitToken(oss, "%MSG"s, false, true);
     emitToken(oss, xid.severity().getSymbol(), false, true);
     emitToken(oss, " ", false, true);
     emitToken(oss, xid.id(), false, true);
     emitToken(oss, msg.idOverflow(), false, true);
     emitToken(oss, ": ", false, true);
     if (format_.want(SERIAL)) {
       ostringstream s;
       s << msg.serial();
       emitToken(oss, "[serial #" + s.str() + "] ", false, true);
     }
     bool needAspace = true;
     if (format_.want(EPILOGUE_SEPARATE)) {
       if (xid.module().length() + xid.subroutine().length() > 0) {
         emitToken(oss, "\n", false, true);
         needAspace = false;
       } else if (format_.want(TIMESTAMP) && !format_.want(TIME_SEPARATE)) {
         emitToken(oss, "\n", false, true);
         needAspace = false;
       }
     }
     if (format_.want(MODULE) && (xid.module().length() > 0)) {
       if (needAspace) {
         emitToken(oss, " ", false, true);
         needAspace = false;
       }
       emitToken(oss, xid.module() + " ", false, true);
     }
     if (format_.want(SUBROUTINE) && (xid.subroutine().length() > 0)) {
       if (needAspace) {
         emitToken(oss, " ", false, true);
         needAspace = false;
       }
       emitToken(oss, xid.subroutine() + "() ", false, true);
     }
     if (format_.want(TIMESTAMP)) {
       if (format_.want(TIME_SEPARATE)) {
         emitToken(oss, "\n", false, true);
         needAspace = false;
       }
       if (needAspace) {
         emitToken(oss, " ", false, true);
         needAspace = false;
       }
       emitToken(oss, format_.timestamp(msg.timestamp()) + " ", false, true);
     }
     if (format_.want(SOME_CONTEXT)) {
       if (needAspace) {
         emitToken(oss, " ", false, true);
         needAspace = false;
       }
       emitToken(oss, msg.context(), false, true);
     }
   }

void mf::service::ELdestination::fillSuffix	(	std::ostringstream &	oss,
		mf::ErrorObj const &	msg
	)

protectedvirtual

Reimplemented in mfplugins::ELsyslog.

Definition at line 532 of file ELdestination.cc.

   {
     if (!msg.is_verbatim() && !format_.want(NO_LINE_BREAKS)) {
       emitToken(oss, "\n%MSG");
     }
     oss << '\n';
   }

void mf::service::ELdestination::fillUsrMsg	(	std::ostringstream &	oss,
		mf::ErrorObj const &	msg
	)

protectedvirtual

Reimplemented in mfplugins::ELsyslog.

Definition at line 505 of file ELdestination.cc.

   {
     if (!format_.want(TEXT)) {
       return;
     }
     // Determine if file and line should be included
     if (!msg.is_verbatim()) {
       if (!msg.filename().empty()) {
         emitToken(oss, " "s);
         emitToken(oss, msg.filename());
         emitToken(oss, ":"s);
         emitToken(oss, to_string(msg.lineNumber()));
       }
       // Check for user-requested line breaks
       if (format_.want(NO_LINE_BREAKS)) {
         emitToken(oss, " ==> ");
       } else {
         emitToken(oss, "", true);
       }
     }
     // Print the contents.
     for (auto const& val : msg.items()) {
       emitToken(oss, val);
     }
   }

void mf::service::ELdestination::finish ( )

virtual

Definition at line 701 of file ELdestination.cc.

702 {}

void mf::service::ELdestination::flush ( )

protectedvirtual

Definition at line 713 of file ELdestination.cc.

   {
     ErrorObj msg{ELwarning, "ELdestination"s};
     msg << "Call to unimplemented flush()!";
     log(msg);
   }

string mf::service::ELdestination::formSummary ( )

protected

Definition at line 574 of file ELdestination.cc.

   {
     ostringstream s;
     int n{};
     // -----  Summary part I:
     //
     bool ftnote{false};
     struct part3 {
       long n{}, t{};
     } p3[ELseverityLevel::nLevels];
     for (auto const& [xid, count] : statsMap_) {
       auto const& cat = xid.id();
       // -----  Emit new part I header, if needed:
       //
       if (n == 0) {
         s << "\n";
         s << " type     category        sev    module        subroutine      "
              "  count    total\n"
           << " ---- -------------------- -- ---------------- "
              "----------------  -----    -----\n";
       }
       // -----  Emit detailed message information:
       //
       s
         // Type
         << right << setw(5) << ++n
         << ' '
         // Category
         << left << setw(20) << cat.substr(0, 20)
         << ' '
         // Severity
         << left << setw(2) << xid.severity().getSymbol()
         << ' '
         // Module
         << left << setw(16) << xid.module().substr(0, 16)
         << ' '
         // Subroutine
         << left << setw(16)
         << xid.subroutine().substr(0, 16)
         // Count
         << right << setw(7) << count.n_ << left << setw(1)
         << (count.ignoredFlag_ ? '*' : ' ')
         // Total Count
         << right << setw(8) << count.aggregateN_ << '\n';
       ftnote = ftnote || count.ignoredFlag_;
       // -----  Obtain information for Part III, below:
       //
       p3[xid.severity().getLevel()].n += count.n_;
       p3[xid.severity().getLevel()].t += count.aggregateN_;
     }
     // -----  Provide footnote to part I, if needed:
     //
     if (ftnote) {
       s << "\n* Some occurrences of this message were suppressed in all "
            "logs, due to limits.\n";
     }
     // -----  Summary part II:
     //
     n = 0;
     for (auto const& pr : statsMap_) {
       auto const& xid = pr.first;
       auto const& count = pr.second;
       string const& cat = xid.id();
       if (n == 0) {
         s << '\n'
           << " type    category    Examples: run/evt        run/evt          "
              "run/evt\n"
           << " ---- -------------------- ---------------- ---------------- "
              "----------------\n";
       }
       s
         // Type
         << right << setw(5) << ++n
         << ' '
         // Category
         << left << setw(20) << cat
         << ' '
         // Context1
         << left << setw(16) << count.context1_.c_str()
         << ' '
         // Context2
         << left << setw(16) << count.context2_.c_str()
         << ' '
         // ContextLast
         << count.contextLast_ << '\n';
     }
     // -----  Summary part III:
     //
     s << '\n'
       << "Severity    # Occurrences   Total Occurrences\n"
       << "--------    -------------   -----------------\n";
     for (int k = 0; k < ELseverityLevel::nLevels; ++k) {
       if (p3[k].n != 0 || p3[k].t != 0) {
         s
           // Severity
           << left << setw(8)
           << ELseverityLevel{ELseverityLevel::ELsev_(k)}.getName().c_str()
           // Occurrences
           << right << setw(17)
           << p3[k].n
           // Total Occurrences
           << right << setw(20) << p3[k].t << '\n';
       }
     }
     return s.str();
   }

void mf::service::ELdestination::log ( mf::ErrorObj & msg )

virtual

Reimplemented in mf::service::ELstatistics.

Definition at line 545 of file ELdestination.cc.

   {
     if (msg.xid().severity() < threshold_) {
       if (outputStatistics_) {
         statsMap_[msg.xid()].add(summarizeContext(msg.context()), false);
         updatedStats_ = true;
       }
       return;
     }
     if (skipMsg(msg.xid())) {
       if (outputStatistics_) {
         statsMap_[msg.xid()].add(summarizeContext(msg.context()), false);
         updatedStats_ = true;
       }
       return;
     }
     msg.setReactedTo(true);
     ostringstream payload;
     fillPrefix(payload, msg);
     fillUsrMsg(payload, msg);
     fillSuffix(payload, msg);
     routePayload(payload, msg);
     if (outputStatistics_) {
       statsMap_[msg.xid()].add(summarizeContext(msg.context()), true);
       updatedStats_ = true;
     }
   }

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

delete

ELdestination& mf::service::ELdestination::operator= ( ELdestination && )

delete

void mf::service::ELdestination::resetLimiters ( )

protected

Definition at line 817 of file ELdestination.cc.

   {
     xidLimiters_.clear();
   }

void mf::service::ELdestination::resetMsgCounters ( )

protected

Definition at line 811 of file ELdestination.cc.

   {
     statsMap_.clear();
   }

void mf::service::ELdestination::routePayload	(	std::ostringstream const &	,
		mf::ErrorObj const &	msg
	)

protectedvirtual

Reimplemented in mfplugins::ELsyslog, and mf::service::ELostreamOutput.

Definition at line 541 of file ELdestination.cc.

542 {}

void mf::service::ELdestination::setThreshold ( ELseverityLevel sv )

Definition at line 707 of file ELdestination.cc.

   {
     threshold_ = sv;
   }

bool mf::service::ELdestination::skipMsg ( ELextendedID const & xid )

protected

Definition at line 724 of file ELdestination.cc.

   {
     auto xl_iter = xidLimiters_.find(xid);
     if (xl_iter == xidLimiters_.end()) {
       // Need to create and initialize a limiter for this xid.
       int limit{defaultLimit_};
       int reportEvery{defaultReportEvery_};
       int timespan{defaultTimespan_};
       // Does the category of this xid have explicit limits?
       auto cp_iter = categoryParams_.find(xid.id());
       if (cp_iter != categoryParams_.end()) {
         // Category limits found, use them.
         auto const& cp = cp_iter->second;
         limit = (cp.limit_ < 0) ? defaultLimit_ : cp.limit_;
         reportEvery =
           (cp.reportEvery_ < 0) ? defaultReportEvery_ : cp.reportEvery_;
         timespan = (cp.timespan_ < 0) ? defaultTimespan_ : cp.timespan_;
       }
       XidLimiter& limiter = xidLimiters_[xid];
       limiter.previousTimestamp_ = time(0);
       limiter.msgCount_ = 0;
       limiter.skippedMsgCount_ =
         reportEvery - 1; // So that the FIRST of the prescaled messages emerges
       limiter.limit_ = limit;
       limiter.reportEvery_ = reportEvery;
       limiter.timespan_ = timespan;
       xl_iter = xidLimiters_.find(xid);
     }
     XidLimiter& limiter = xl_iter->second;
     time_t now = time(0);
     // Has it been so long that we should restart counting toward the limit?
     if ((limiter.timespan_ >= 0) &&
         (difftime(now, limiter.previousTimestamp_) >= limiter.timespan_)) {
       limiter.msgCount_ = 0;
       if (limiter.reportEvery_ > 0) {
         // So this message will be reacted to
         limiter.skippedMsgCount_ = limiter.reportEvery_ - 1;
       } else {
         limiter.skippedMsgCount_ = 0;
       }
     }
     limiter.previousTimestamp_ = now;
     ++limiter.msgCount_;
     ++limiter.skippedMsgCount_;
     if (limiter.skippedMsgCount_ < limiter.reportEvery_) {
       // Skip message.
       return true;
     }
     if (limiter.limit_ == 0) {
       // Zero limit - never react to this
       // Skip message.
       return true;
     }
     if ((limiter.limit_ < 0) || (limiter.msgCount_ <= limiter.limit_)) {
       limiter.skippedMsgCount_ = 0;
       // Accept message.
       return false;
     }
     // Now we are over the limit - have we exceeded limit by 2^N * limit?
     long diff = limiter.msgCount_ - limiter.limit_;
     long r = diff / limiter.limit_;
     if (r * limiter.limit_ != diff) {
       // Not a multiple of limit - don't react
       // Skip message.
       return true;
     }
     if (r == 1) {
       // Exactly twice limit - react
       limiter.skippedMsgCount_ = 0;
       // Accept message.
       return false;
     }
     while (r > 1) {
       if ((r & 1) != 0) {
         // Not 2**msgCount_ times limit - don't react
         // Skip message.
         return true;
       }
       r >>= 1;
     }
     // If you never get an odd number till one, r is 2**msgCount_ so react
     limiter.skippedMsgCount_ = 0;
     // Accept message.
     return false;
   }

string mf::service::ELdestination::summarizeContext ( std::string const & )

protected

Definition at line 358 of file ELdestination.cc.

   {
     if (c.substr(0, 4) != "Run:") {
       return c;
     }
     istringstream is(c);
     string runWord;
     int run;
     is >> runWord >> run;
     if (!is) {
       return c;
     }
     if (runWord != "Run:") {
       return c;
     }
     string eventWord;
     int event;
     is >> eventWord >> event;
     if (!is) {
       return c;
     }
     if (eventWord != "Event:") {
       return c;
     }
     ostringstream os;
     os << run << "/" << event;
     return os.str();
   }

void mf::service::ELdestination::summary ( )

virtual

Reimplemented in mf::service::ELstatistics.

Definition at line 684 of file ELdestination.cc.

   {
     if (outputStatistics_ && updatedStats_) {
       ostringstream payload;
       payload << "\n=============================================\n\n"
               << "MessageLogger Summary\n"
               << formSummary();
       routePayload(payload, ErrorObj{ELzeroSeverity, "No ostream"s});
     }
     updatedStats_ = false;
     if (reset_) {
       resetMsgCounters();
       resetLimiters();
     }
   }

Member Data Documentation

std::map<std::string const, CategoryParams> mf::service::ELdestination::categoryParams_

protected

Definition at line 229 of file ELdestination.h.

std::size_t mf::service::ELdestination::charsOnLine_ {}

private

Definition at line 237 of file ELdestination.h.

int mf::service::ELdestination::defaultLimit_

protected

Definition at line 226 of file ELdestination.h.

int mf::service::ELdestination::defaultReportEvery_

protected

Definition at line 227 of file ELdestination.h.

int mf::service::ELdestination::defaultTimespan_

protected

Definition at line 228 of file ELdestination.h.

MsgFormatSettings mf::service::ELdestination::format_

protected

Definition at line 225 of file ELdestination.h.

bool mf::service::ELdestination::outputStatistics_ {false}

protected

Definition at line 232 of file ELdestination.h.

bool mf::service::ELdestination::reset_ {false}

protected

Definition at line 234 of file ELdestination.h.

std::map<ELextendedID const, StatsCount> mf::service::ELdestination::statsMap_

protected

Definition at line 231 of file ELdestination.h.

ELseverityLevel mf::service::ELdestination::threshold_

protected

Definition at line 224 of file ELdestination.h.

bool mf::service::ELdestination::updatedStats_ {false}

protected

Definition at line 233 of file ELdestination.h.

std::map<ELextendedID const, XidLimiter> mf::service::ELdestination::xidLimiters_

protected

Definition at line 230 of file ELdestination.h.

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

messagefacility/messagefacility/MessageService/ELdestination.h
messagefacility/messagefacility/MessageService/ELdestination.cc

Classes

Public Types

Public Member Functions

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Member Data Documentation