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>
21 #include "fhiclcpp/ParameterSet.h"
22 #include "fhiclcpp/types/Atom.h"
23 #include "fhiclcpp/types/ConfigurationTable.h"
24 #include "fhiclcpp/types/Sequence.h"
26 #include "artdaq-utilities/Plugins/MetricData.hh"
27 #include "cetlib/compiler_macros.h"
29 #define FALLTHROUGH while (0)
46 fhicl::Atom<std::string>
metricPluginType{fhicl::Name{
"metricPluginType"}, fhicl::Comment{
"The name of the metric plugin to load (may have additional configuration parameters"}};
48 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};
50 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>()};
52 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"},
""};
54 fhicl::Atom<double>
reporting_interval{fhicl::Name{
"reporting_interval"}, fhicl::Comment{
"How often recorded metrics are sent to the underlying metric storage"}, 15.0};
56 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};
69 explicit MetricPlugin(fhicl::ParameterSet
const& ps, std::string
const& app_name)
76 if (
pset.has_key(
"level"))
78 for (
size_t ii = 0; ii <=
pset.get<
size_t>(
"level"); ++ii)
83 if (
pset.has_key(
"metric_levels"))
85 auto levels =
pset.get<std::vector<size_t>>(
"metric_levels");
86 for (
auto& l : levels)
91 if (
pset.has_key(
"level_string"))
93 auto string =
pset.get<std::string>(
"level_string");
94 std::stringstream ss(
string);
96 while (std::getline(ss, token,
','))
98 auto it = token.find(
"-");
99 if (it == 0 || it == token.size() - 1)
continue;
101 if (it != std::string::npos)
103 auto minStr = token.substr(0, it);
104 auto maxStr = token.substr(it + 1);
105 auto min = std::stoi(minStr);
106 auto max = std::stoi(maxStr);
108 if (min > max) std::swap(min, max);
109 if (min > 63) min = 63;
110 if (max > 63) max = 63;
112 for (
int ii = min; ii <= max; ++ii)
119 auto level = std::stoi(token);
126 throw cet::exception(
"Configuration Error") <<
"No levels were enabled for this plugin! Please specify at least one of the following Parameters: \"level\", \"metric_levels\", or \"level_string\"!";
156 virtual void sendMetric_(
const std::string& name,
const std::string& value,
const std::string& unit) = 0;
166 virtual void sendMetric_(
const std::string& name,
const int& value,
const std::string& unit) = 0;
176 virtual void sendMetric_(
const std::string& name,
const double& value,
const std::string& unit) = 0;
186 virtual void sendMetric_(
const std::string& name,
const float& value,
const std::string& unit) = 0;
196 virtual void sendMetric_(
const std::string& name,
const long unsigned int& value,
const std::string& unit) = 0;
224 TLOG(22) <<
"Adding metric data for name " << data->Name;
227 sendMetric_(data->Name, data->StringValue, data->Unit);
231 if (!metricRegistry_.count(data->Name))
233 metricRegistry_[data->Name] = *data;
235 metricData_[data->Name].push_back(*data);
236 TLOG(22) <<
"Current list size: " << metricData_[data->Name].size();
250 std::chrono::steady_clock::time_point interval_end = std::chrono::steady_clock::now())
252 TLOG(23) <<
"sendMetrics called" << std::endl;
253 for (
auto& metric : metricData_)
255 if (readyToSend_(metric.first) || forceSend)
257 TLOG(24) <<
"Sending metric " << metric.first;
258 if (metric.second.size() == 0 && metricRegistry_.count(metric.first))
260 TLOG(24) <<
"Sending zero";
261 sendZero_(metricRegistry_[metric.first]);
263 else if (metric.second.size() > 0)
265 TLOG(24) <<
"Aggregating " << metric.second.size() <<
" MetricData points";
267 auto it = ++(metric.second.begin());
268 while (it != metric.second.end())
271 it = metric.second.erase(it);
274 std::bitset<32> modeSet(static_cast<uint32_t>(data.
Mode));
275 bool useSuffix =
true;
276 if (modeSet.count() <= 1) useSuffix =
false;
288 double average = 0.0;
310 double duration = std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1>>>(
311 interval_end - interval_start_[metric.first])
317 rate = data.
Value.
d / duration;
320 rate = data.
Value.
f / duration;
323 rate = data.
Value.
i / duration;
326 rate = data.
Value.
u / duration;
342 TLOG(24) <<
"Clearing metric data list sz=" << metric.second.size();
343 metric.second.clear();
344 TLOG(24) <<
"Cleared metric data list sz=" << metricData_[metric.first].size();
346 interval_start_[metric.first] = interval_end;
349 TLOG(23) <<
"sendMetrics done" << std::endl;
365 for (
auto metric : metricRegistry_)
367 sendZero_(metric.second);
380 if (level > 63) level = 63;
381 if (level < 0)
return true;
391 for (
auto& metric : metricData_)
393 if (metric.second.size() > 0)
395 TLOG(TLVL_TRACE) <<
"Metric " << metric.first <<
" has " << metric.second.size() <<
" pending MetricData instances" << std::endl;
412 std::unordered_map<std::string, std::list<MetricData>> metricData_;
413 std::unordered_map<std::string, MetricData> metricRegistry_;
414 std::unordered_map<std::string, std::chrono::steady_clock::time_point> lastSendTime_;
415 std::unordered_map<std::string, std::chrono::steady_clock::time_point> interval_start_;
417 bool readyToSend_(std::string name)
419 auto now = std::chrono::steady_clock::now();
420 if (std::chrono::duration_cast<std::chrono::duration<
double, std::ratio<1>>>(now - lastSendTime_[name]).count() >=
accumulationTime_)
422 lastSendTime_[name] = now;
433 std::bitset<32> modeSet(static_cast<uint32_t>(data.
Mode));
434 bool useSuffix =
true;
435 if (modeSet.count() <= 1) useSuffix =
false;
483 void sendMetric_(std::string name, MetricData::MetricDataValue data, std::string unit,
MetricType type)
506 #ifdef TRACE_NAME_POP
507 #pragma pop_macro("TRACE_NAME")
508 #undef TRACE_NAME_POP
510 #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.
virtual void sendMetric_(const std::string &name, const std::string &value, const std::string &unit)=0
Send a metric to the underlying metric storage (file, Graphite, Ganglia, etc.)
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...
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.
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.
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...
long unsigned int u
Value of the metric, if it is a MetricType::UnsignedMetric.
fhicl::WrappedTable< Config > Parameters
Used for ParameterSet validation (if desired)
This union holds the values for all other metric types
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.
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...