7 #ifndef __METRIC_INTERFACE__
8 #define __METRIC_INTERFACE__
11 #pragma push_macro("TRACE_NAME")
13 #define TRACE_NAME "MetricPlugin"
14 #define TRACE_NAME_POP 1
16 #include "TRACE/trace.h"
20 #include <unordered_map>
22 #include "fhiclcpp/ParameterSet.h"
23 #include "fhiclcpp/types/Atom.h"
24 #include "fhiclcpp/types/ConfigurationTable.h"
25 #include "fhiclcpp/types/Sequence.h"
27 #include "artdaq-utilities/Plugins/MetricData.hh"
28 #include "cetlib/compiler_macros.h"
30 #define FALLTHROUGH while (0)
47 fhicl::Atom<std::string>
metricPluginType{fhicl::Name{
"metricPluginType"}, fhicl::Comment{
"The name of the metric plugin to load (may have additional configuration parameters"}};
49 fhicl::Atom<size_t>
level{fhicl::Name{
"level"}, fhicl::Comment{
"The verbosity level threshold for this plugin. sendMetric calls with verbosity level greater than this will not be sent to the plugin. OPTIONAL"}, 0};
51 fhicl::Sequence<size_t>
metric_levels{fhicl::Name{
"metric_levels"}, fhicl::Comment{
"A list of levels that should be enabled for this plugin. OPTIONAL"}, std::vector<size_t>()};
53 fhicl::Atom<std::string>
level_string{fhicl::Name{
"level_string"}, fhicl::Comment{
"A string containing a comma-separated list of levels to enable. Ranges are supported. Example: \"1,2,4-10,11\" OPTIONAL"},
""};
55 fhicl::Atom<double>
reporting_interval{fhicl::Name{
"reporting_interval"}, fhicl::Comment{
"How often recorded metrics are sent to the underlying metric storage"}, 15.0};
57 fhicl::Atom<bool>
send_zeros{fhicl::Name{
"send_zeros"}, fhicl::Comment{
"Whether zeros should be sent to the metric back-end when metrics are not reported in an interval and during shutdown"},
true};
70 explicit MetricPlugin(fhicl::ParameterSet
const& ps, std::string
const& app_name)
77 if (
pset.has_key(
"level"))
79 for (
size_t ii = 0; ii <=
pset.get<
size_t>(
"level"); ++ii)
84 if (
pset.has_key(
"metric_levels"))
86 auto levels =
pset.get<std::vector<size_t>>(
"metric_levels");
87 for (
auto& l : levels)
92 if (
pset.has_key(
"level_string"))
94 auto string =
pset.get<std::string>(
"level_string");
95 std::stringstream ss(
string);
97 while (std::getline(ss, token,
','))
99 auto it = token.find(
"-");
100 if (it == 0 || it == token.size() - 1)
continue;
102 if (it != std::string::npos)
104 auto minStr = token.substr(0, it);
105 auto maxStr = token.substr(it + 1);
106 auto min = std::stoi(minStr);
107 auto max = std::stoi(maxStr);
109 if (min > max) std::swap(min, max);
110 if (min > 63) min = 63;
111 if (max > 63) max = 63;
113 for (
int ii = min; ii <= max; ++ii)
120 auto level = std::stoi(token);
127 throw cet::exception(
"Configuration Error")
128 <<
"No levels were enabled for this plugin! Please specify at least one of the following Parameters: \"level\", \"metric_levels\", or \"level_string\"!";
159 virtual void sendMetric_(
const std::string& name,
const std::string& value,
const std::string& unit,
const std::chrono::system_clock::time_point& interval_end) = 0;
170 virtual void sendMetric_(
const std::string& name,
const int& value,
const std::string& unit,
const std::chrono::system_clock::time_point& interval_end) = 0;
181 virtual void sendMetric_(
const std::string& name,
const double& value,
const std::string& unit,
const std::chrono::system_clock::time_point& interval_end) = 0;
192 virtual void sendMetric_(
const std::string& name,
const float& value,
const std::string& unit,
const std::chrono::system_clock::time_point& interval_end) = 0;
203 virtual void sendMetric_(
const std::string& name,
const uint64_t& value,
const std::string& unit,
const std::chrono::system_clock::time_point& interval_end) = 0;
231 TLOG(22) <<
"Adding metric data for name " << data->Name;
234 sendMetric_(data->Name, data->StringValue, data->Unit, std::chrono::system_clock::now());
238 if (metricRegistry_.count(data->Name) == 0)
240 metricRegistry_[data->Name] = *data;
242 metricData_[data->Name].push_back(*data);
243 TLOG(22) <<
"Current list size: " << metricData_[data->Name].size();
257 std::chrono::steady_clock::time_point interval_end = std::chrono::steady_clock::now())
259 TLOG(23) <<
"sendMetrics called" << std::endl;
260 for (
auto& metric : metricData_)
262 if (readyToSend_(metric.first) || forceSend)
264 TLOG(24) <<
"Sending metric " << metric.first;
265 if (metric.second.empty() && metricRegistry_.count(metric.first))
267 TLOG(24) <<
"Sending zero";
268 sendZero_(metricRegistry_[metric.first]);
270 else if (!metric.second.empty())
272 TLOG(24) <<
"Aggregating " << metric.second.size() <<
" MetricData points";
274 if ((metric.second.front().Mode &
MetricMode::Persist) != MetricMode::None && metric.second.size() > 1)
276 TLOG(24) <<
"Metric is in Persist mode and multiple instances are present. Removing the first entry.";
277 metric.second.erase(metric.second.begin());
282 auto it = ++(metric.second.begin());
283 while (it != metric.second.end())
286 it = metric.second.erase(it);
289 std::bitset<32> modeSet(static_cast<uint32_t>(data.
Mode));
290 bool useSuffix =
true;
291 if (modeSet.count() <= 1 || (modeSet.count() <= 2 && (data.
Mode &
MetricMode::Persist) != MetricMode::None)) useSuffix =
false;
303 double average = 0.0;
321 sendMetric_(data.
Name + (useSuffix ?
" - Average" :
""), average, data.
Unit, to_system_clock(lastSendTime_[data.
Name]));
325 double duration = std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1>>>(
326 interval_end - interval_start_[metric.first])
332 rate = data.
Value.
d / duration;
335 rate = data.
Value.
f / duration;
338 rate = data.
Value.
i / duration;
341 rate = data.
Value.
u / duration;
346 sendMetric_(data.
Name + (useSuffix ?
" - Rate" :
""), rate, data.
Unit +
"/s", to_system_clock(lastSendTime_[data.
Name]));
359 TLOG(24) <<
"Clearing metric data list sz=" << metric.second.size();
360 metric.second.clear();
361 TLOG(24) <<
"Cleared metric data list sz=" << metricData_[metric.first].size();
365 TLOG(24) <<
"Metric is Persisted, leaving " << metricData_[metric.first].size() <<
" entries (should be 1)";
368 interval_start_[metric.first] = interval_end;
371 TLOG(23) <<
"sendMetrics done" << std::endl;
387 for (
auto const& metric : metricRegistry_)
389 sendZero_(metric.second);
402 if (level > 63) level = 63;
403 if (level < 0)
return true;
413 for (
auto& metric : metricData_)
415 if (!metric.second.empty())
417 TLOG(TLVL_TRACE) <<
"Metric " << metric.first <<
" has " << metric.second.size() <<
" pending MetricData instances" << std::endl;
439 std::unordered_map<std::string, std::list<MetricData>> metricData_;
440 std::unordered_map<std::string, MetricData> metricRegistry_;
441 std::unordered_map<std::string, std::chrono::steady_clock::time_point> lastSendTime_;
442 std::unordered_map<std::string, std::chrono::steady_clock::time_point> interval_start_;
444 std::chrono::system_clock::time_point to_system_clock(std::chrono::steady_clock::time_point
const& t)
446 auto pt = std::chrono::system_clock::now() + (t - std::chrono::steady_clock::now());
447 return std::chrono::system_clock::time_point(std::chrono::duration_cast<std::chrono::system_clock::duration>(pt.time_since_epoch()));
450 bool readyToSend_(std::string
const& name)
452 auto now = std::chrono::steady_clock::now();
453 if (std::chrono::duration_cast<std::chrono::duration<
double, std::ratio<1>>>(now - lastSendTime_[name]).count() >=
accumulationTime_)
455 lastSendTime_[name] = now;
462 void sendZero_(MetricData data)
466 std::bitset<32> modeSet(static_cast<uint32_t>(data.Mode));
467 bool useSuffix =
true;
468 if (modeSet.count() <= 1) useSuffix =
false;
470 MetricData::MetricDataValue zero;
491 sendMetric_(data.Name + (useSuffix ?
" - Last" :
""), zero, data.Unit, data.Type, std::chrono::system_clock::now());
495 sendMetric_(data.Name + (useSuffix ?
" - Total" :
""), zero, data.Unit, data.Type, std::chrono::system_clock::now());
499 sendMetric_(data.Name + (useSuffix ?
" - Average" :
""), 0.0, data.Unit, std::chrono::system_clock::now());
503 sendMetric_(data.Name + (useSuffix ?
" - Rate" :
""), 0.0, data.Unit +
"/s", std::chrono::system_clock::now());
507 sendMetric_(data.Name + (useSuffix ?
" - Min" :
""), zero, data.Unit, data.Type, std::chrono::system_clock::now());
511 sendMetric_(data.Name + (useSuffix ?
" - Max" :
""), zero, data.Unit, data.Type, std::chrono::system_clock::now());
516 void sendMetric_(std::string
const& name, MetricData::MetricDataValue data, std::string
const& unit,
MetricType type, std::chrono::system_clock::time_point
const& interval_end)
539 #ifdef TRACE_NAME_POP
540 #pragma pop_macro("TRACE_NAME")
541 #undef TRACE_NAME_POP
543 #endif //End ifndef __METRIC_INTERFACE__
bool IsLevelEnabled(int level)
Determine if the given level is enabled for this MetricPlugin instance.
virtual void startMetrics_()=0
Perform any start-up actions necessary for the metric plugin.
The MetricPlugin class defines the interface that MetricManager uses to send metric data to the vario...
void startMetrics()
Perform startup actions. Simply calls the virtual startMetrics_ function.
size_t DataPointCount
Number of data points accumulated in this MetricData
Report the sum of all values. Use for counters to report accurate results.
fhicl::ParameterSet pset
The ParameterSet used to configure the MetricPlugin.
fhicl::Atom< std::string > metricPluginType
The name of the metric plugin to load (may have additional configuration parameters.
std::string Unit
Units of the metric
float f
Value of the metric, if it is a MetricType::FloatMetric.
Metric is a std::string (not in union)
std::string Name
Name of the metric
fhicl::Atom< double > reporting_interval
"reporting_interval" (Default: 15.0): The interval, in seconds, which the metric plugin will accumula...
MetricMode Mode
Accumulation mode of the metric
bool Add(MetricData other)
Add two MetricData instances together
MetricType
This enumeration is used to identify the type of the metric instance (which value should be extraced ...
MetricDataValue Max
Maximum recorded vaule of this MetricData.
void stopMetrics()
Perform shutdown actions. Zeroes out all accumulators, and sends zeros for each metric. Calls stopMetrics_() for any plugin-defined shutdown actions.
Reports the minimum value recorded.
std::string app_name_
Name of the application which is sending metrics to this plugin.
Metric is a long unsigned int.
void sendMetrics(bool forceSend=false, std::chrono::steady_clock::time_point interval_end=std::chrono::steady_clock::now())
For each known metric, determine whether the reporting interval has elapsed, and if so...
over. Use to create rates from counters.
MetricPlugin(fhicl::ParameterSet const &ps, std::string const &app_name)
MetricPlugin Constructor.
Report only the last value recorded. Useful for event counters, run numbers, etc. ...
Repots the maximum value recorded.
std::bitset< 64 > level_mask_
Bitset indicating for each possible metric level, whether this plugin will receive those metrics...
bool metricsPending()
Determine if metrics are waiting to be sent.
virtual std::string getLibName() const
Return the name of the current MetricPlugin instance.
virtual void sendMetric_(const std::string &name, const std::string &value, const std::string &unit, const std::chrono::system_clock::time_point &interval_end)=0
Send a metric to the underlying metric storage (file, Graphite, Ganglia, etc.)
MetricDataValue Value
Accumulated value of this MetricData
virtual void stopMetrics_()=0
Perform any shutdown actions necessary for the metric plugin.
int i
Value of the metric, if it is a MetricType::IntMetric.
Keep previous metric value in memory.
MetricType Type
Type of the metric
fhicl::Atom< std::string > level_string
"level_string" (OPTIONAL): A string containing a comma-separated list of levels to enable...
fhicl::Atom< bool > send_zeros
"send_zeros" (Default: true): Whether zeros should be sent to the metric back-end when metrics are no...
fhicl::WrappedTable< Config > Parameters
Used for ParameterSet validation (if desired)
MetricDataValue Last
Last value of this MetricData.
fhicl::Atom< size_t > level
"level" (OPTIONAL): The verbosity level threshold for this plugin. sendMetric calls with verbosity le...
double accumulationTime_
The amount of time to average metric values; except for accumulate=false metrics, will be the interva...
Small structure used to hold a metric data point before sending to the metric plugins ...
The Config struct defines the accepted configuration parameters for this class.
uint64_t u
Value of the metric, if it is a MetricType::UnsignedMetric.
Report the average of all values. Use for rates to report accurate results.
MetricDataValue Min
Minimum recorded value of this MetricData.
fhicl::Sequence< size_t > metric_levels
"metric_levels" (OPTIONAL): A list of levels that should be enabled for this plugin.
void addMetricData(std::unique_ptr< MetricData > const &data)
Send a metric value to the MetricPlugin.
bool sendZeros_
Whether zeros should be sent to this metric backend when metric instances are missing or at the end o...
virtual ~MetricPlugin()=default
Default virtual Desctructor.
double d
Value of the metric, if it is a MetricType::DoubleMetric.
bool inhibit_
Flag to indicate that the MetricPlugin is being stopped, and any metric back-ends which do not have a...