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")
127 <<
"No levels were enabled for this plugin! Please specify at least one of the following Parameters: \"level\", \"metric_levels\", or \"level_string\"!";
157 virtual void sendMetric_(
const std::string& name,
const std::string& value,
const std::string& unit) = 0;
167 virtual void sendMetric_(
const std::string& name,
const int& value,
const std::string& unit) = 0;
177 virtual void sendMetric_(
const std::string& name,
const double& value,
const std::string& unit) = 0;
187 virtual void sendMetric_(
const std::string& name,
const float& value,
const std::string& unit) = 0;
197 virtual void sendMetric_(
const std::string& name,
const uint64_t& value,
const std::string& unit) = 0;
225 TLOG(22) <<
"Adding metric data for name " << data->Name;
228 sendMetric_(data->Name, data->StringValue, data->Unit);
232 if (metricRegistry_.count(data->Name) == 0)
234 metricRegistry_[data->Name] = *data;
236 metricData_[data->Name].push_back(*data);
237 TLOG(22) <<
"Current list size: " << metricData_[data->Name].size();
251 std::chrono::steady_clock::time_point interval_end = std::chrono::steady_clock::now())
253 TLOG(23) <<
"sendMetrics called" << std::endl;
254 for (
auto& metric : metricData_)
256 if (readyToSend_(metric.first) || forceSend)
258 TLOG(24) <<
"Sending metric " << metric.first;
259 if (metric.second.empty() && metricRegistry_.count(metric.first))
261 TLOG(24) <<
"Sending zero";
262 sendZero_(metricRegistry_[metric.first]);
264 else if (!metric.second.empty())
266 TLOG(24) <<
"Aggregating " << metric.second.size() <<
" MetricData points";
268 if ((metric.second.front().Mode &
MetricMode::Persist) != MetricMode::None && metric.second.size() > 1)
270 TLOG(24) <<
"Metric is in Persist mode and multiple instances are present. Removing the first entry.";
271 metric.second.erase(metric.second.begin());
276 auto it = ++(metric.second.begin());
277 while (it != metric.second.end())
280 it = metric.second.erase(it);
283 std::bitset<32> modeSet(static_cast<uint32_t>(data.
Mode));
284 bool useSuffix =
true;
285 if (modeSet.count() <= 1 || (modeSet.count() <= 2 && (data.
Mode &
MetricMode::Persist) != MetricMode::None)) useSuffix =
false;
297 double average = 0.0;
319 double duration = std::chrono::duration_cast<std::chrono::duration<double, std::ratio<1>>>(
320 interval_end - interval_start_[metric.first])
326 rate = data.
Value.
d / duration;
329 rate = data.
Value.
f / duration;
332 rate = data.
Value.
i / duration;
335 rate = data.
Value.
u / duration;
353 TLOG(24) <<
"Clearing metric data list sz=" << metric.second.size();
354 metric.second.clear();
355 TLOG(24) <<
"Cleared metric data list sz=" << metricData_[metric.first].size();
359 TLOG(24) <<
"Metric is Persisted, leaving " << metricData_[metric.first].size() <<
" entries (should be 1)";
362 interval_start_[metric.first] = interval_end;
365 TLOG(23) <<
"sendMetrics done" << std::endl;
381 for (
auto const& metric : metricRegistry_)
383 sendZero_(metric.second);
396 if (level > 63) level = 63;
397 if (level < 0)
return true;
407 for (
auto& metric : metricData_)
409 if (!metric.second.empty())
411 TLOG(TLVL_TRACE) <<
"Metric " << metric.first <<
" has " << metric.second.size() <<
" pending MetricData instances" << std::endl;
433 std::unordered_map<std::string, std::list<MetricData>> metricData_;
434 std::unordered_map<std::string, MetricData> metricRegistry_;
435 std::unordered_map<std::string, std::chrono::steady_clock::time_point> lastSendTime_;
436 std::unordered_map<std::string, std::chrono::steady_clock::time_point> interval_start_;
438 bool readyToSend_(std::string
const& name)
440 auto now = std::chrono::steady_clock::now();
441 if (std::chrono::duration_cast<std::chrono::duration<
double, std::ratio<1>>>(now - lastSendTime_[name]).count() >=
accumulationTime_)
443 lastSendTime_[name] = now;
454 std::bitset<32> modeSet(static_cast<uint32_t>(data.
Mode));
455 bool useSuffix =
true;
456 if (modeSet.count() <= 1) useSuffix =
false;
504 void sendMetric_(std::string
const& name, MetricData::MetricDataValue data, std::string
const& unit,
MetricType type)
527 #ifdef TRACE_NAME_POP
528 #pragma pop_macro("TRACE_NAME")
529 #undef TRACE_NAME_POP
531 #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...
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.
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)
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.
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...