1 #include "artdaq-utilities/Plugins/MetricManager.hh"
2 #include "artdaq-core/Utilities/TimeUtils.hh"
3 #include "artdaq-core/Utilities/configureMessageFacility.hh"
5 #define BOOST_TEST_MODULES MetricManager_t
6 #include "cetlib/quiet_unit_test.hpp"
7 #include "cetlib_except/exception.h"
8 #include "fhiclcpp/make_ParameterSet.h"
12 BOOST_AUTO_TEST_SUITE(MetricManager_test)
14 BOOST_AUTO_TEST_CASE(Construct)
16 artdaq::configureMessageFacility(
"MetricManager_t",
true,
true);
17 TLOG_DEBUG(
"MetricManager_t") <<
"BEGIN TEST Construct" << TLOG_ENDL;
18 artdaq::MetricManager mm;
19 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
20 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
21 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
22 BOOST_REQUIRE_EQUAL(mm.metricQueueEmpty(),
true);
23 BOOST_REQUIRE_EQUAL(mm.metricQueueSize(), 0);
24 TLOG_DEBUG(
"MetricManager_t") <<
"END TEST Construct" << TLOG_ENDL;
27 BOOST_AUTO_TEST_CASE(Initialize)
30 artdaq::configureMessageFacility(
"MetricManager_t",
true,
true);
31 TLOG_DEBUG(
"MetricManager_t") <<
"BEGIN TEST Initialize" << TLOG_ENDL;
32 artdaq::MetricManager mm;
33 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
34 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
35 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
36 BOOST_REQUIRE_EQUAL(mm.metricQueueEmpty(),
true);
37 BOOST_REQUIRE_EQUAL(mm.metricQueueSize(), 0);
39 std::string testConfig =
"msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
40 fhicl::ParameterSet pset;
41 fhicl::make_ParameterSet(testConfig, pset);
43 mm.initialize(pset,
"MetricManager_t");
44 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
45 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
46 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
50 BOOST_REQUIRE_EQUAL(mm.Running(),
true);
51 BOOST_REQUIRE_EQUAL(mm.Active(),
true);
52 TLOG_DEBUG(
"MetricManager_t") <<
"END TEST Initialize" << TLOG_ENDL;
55 BOOST_AUTO_TEST_CASE(Initialize_WithError)
58 artdaq::configureMessageFacility(
"MetricManager_t",
true,
true);
59 TLOG_DEBUG(
"MetricManager_t") <<
"BEGIN TEST Initialize_WithError" << TLOG_ENDL;
60 artdaq::MetricManager mm;
61 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
62 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
63 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
64 BOOST_REQUIRE_EQUAL(mm.metricQueueEmpty(),
true);
65 BOOST_REQUIRE_EQUAL(mm.metricQueueSize(), 0);
67 std::string testConfig =
"err: { level: 5 metricPluginType: nonExistentPluginType reporting_interval: 1.0}";
68 fhicl::ParameterSet pset;
69 fhicl::make_ParameterSet(testConfig, pset);
71 mm.initialize(pset,
"MetricManager_t");
72 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
73 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
76 BOOST_REQUIRE_EQUAL(mm.Running(),
true);
77 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
78 TLOG_DEBUG(
"MetricManager_t") <<
"END TEST Initialize_WithError" << TLOG_ENDL;
81 BOOST_AUTO_TEST_CASE(Shutdown)
83 artdaq::configureMessageFacility(
"MetricManager_t",
true,
true);
84 TLOG_DEBUG(
"MetricManager_t") <<
"BEGIN TEST Shutdown" << TLOG_ENDL;
85 artdaq::MetricManager mm;
86 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
87 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
88 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
89 BOOST_REQUIRE_EQUAL(mm.metricQueueEmpty(),
true);
90 BOOST_REQUIRE_EQUAL(mm.metricQueueSize(), 0);
92 std::string testConfig =
"msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
93 fhicl::ParameterSet pset;
94 fhicl::make_ParameterSet(testConfig, pset);
96 mm.initialize(pset,
"MetricManager_t");
97 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
98 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
99 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
103 BOOST_REQUIRE_EQUAL(mm.Running(),
true);
104 BOOST_REQUIRE_EQUAL(mm.Active(),
true);
107 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
108 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
111 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
112 TLOG_DEBUG(
"MetricManager_t") <<
"END TEST Shutdown" << TLOG_ENDL;
115 BOOST_AUTO_TEST_CASE(SendMetric_String)
118 artdaq::configureMessageFacility(
"MetricManager_t",
true,
true);
119 TLOG_DEBUG(
"MetricManager_t") <<
"BEGIN TEST SendMetric_String" << TLOG_ENDL;
120 artdaq::MetricManager mm;
121 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
122 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
123 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
124 BOOST_REQUIRE_EQUAL(mm.metricQueueEmpty(),
true);
125 BOOST_REQUIRE_EQUAL(mm.metricQueueSize(), 0);
127 std::string testConfig =
"msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
128 fhicl::ParameterSet pset;
129 fhicl::make_ParameterSet(testConfig, pset);
131 mm.initialize(pset,
"MetricManager_t");
132 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
133 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
134 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
138 BOOST_REQUIRE_EQUAL(mm.Running(),
true);
139 BOOST_REQUIRE_EQUAL(mm.Active(),
true);
142 mm.sendMetric(
"Test Metric",
"This is a test",
"Units", 2, artdaq::MetricMode::LastPoint);
146 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
147 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
150 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
151 TLOG_DEBUG(
"MetricManager_t") <<
"END TEST SendMetric_String" << TLOG_ENDL;
154 BOOST_AUTO_TEST_CASE(SendMetrics)
156 artdaq::configureMessageFacility(
"MetricManager_t",
true,
true);
157 TLOG_DEBUG(
"MetricManager_t") <<
"BEGIN TEST SendMetrics" << TLOG_ENDL;
158 artdaq::MetricManager mm;
159 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
160 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
161 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
162 BOOST_REQUIRE_EQUAL(mm.metricQueueEmpty(),
true);
163 BOOST_REQUIRE_EQUAL(mm.metricQueueSize(), 0);
165 std::string testConfig =
"msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
166 fhicl::ParameterSet pset;
167 fhicl::make_ParameterSet(testConfig, pset);
169 mm.initialize(pset,
"MetricManager_t");
170 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
171 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
172 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
176 BOOST_REQUIRE_EQUAL(mm.Running(),
true);
177 BOOST_REQUIRE_EQUAL(mm.Active(),
true);
180 mm.sendMetric(
"Test Metric LastPoint", 1,
"Units", 2, artdaq::MetricMode::LastPoint);
181 mm.sendMetric(
"Test Metric LastPoint", 5,
"Units", 2, artdaq::MetricMode::LastPoint);
182 TLOG_INFO(
"MetricManager_t") <<
"LastPoint Metric should have value 5" << TLOG_ENDL;
184 mm.sendMetric(
"Test Metric Accumulate", 4,
"Units", 2, artdaq::MetricMode::Accumulate);
185 mm.sendMetric(
"Test Metric Accumulate", 5,
"Units", 2, artdaq::MetricMode::Accumulate);
186 TLOG_INFO(
"MetricManager_t") <<
"Accumulate metric should have value 9" << TLOG_ENDL;
187 mm.sendMetric(
"Test Metric Average", 1,
"Units", 2, artdaq::MetricMode::Average);
188 mm.sendMetric(
"Test Metric Average", 3,
"Units", 2, artdaq::MetricMode::Average);
189 TLOG_INFO(
"MetricManager_t") <<
"Average metric should have value 2" << TLOG_ENDL;
194 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
195 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
198 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
199 TLOG_DEBUG(
"MetricManager_t") <<
"END TEST SendMetrics" << TLOG_ENDL;
202 BOOST_AUTO_TEST_CASE(MetricFlood)
205 artdaq::configureMessageFacility(
"MetricManager_t",
true,
true);
206 TLOG_DEBUG(
"MetricManager_t") <<
"BEGIN TEST MetricFlood" << TLOG_ENDL;
207 artdaq::MetricManager mm;
208 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
209 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
210 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
211 BOOST_REQUIRE_EQUAL(mm.metricQueueEmpty(),
true);
212 BOOST_REQUIRE_EQUAL(mm.metricQueueSize(), 0);
214 std::string testConfig =
"msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
215 fhicl::ParameterSet pset;
216 fhicl::make_ParameterSet(testConfig, pset);
218 mm.initialize(pset,
"MetricManager_t");
219 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
220 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
221 BOOST_REQUIRE_EQUAL(mm.Active(),
false);
225 BOOST_REQUIRE_EQUAL(mm.Running(),
true);
226 BOOST_REQUIRE_EQUAL(mm.Active(),
true);
228 auto beforeOne = std::chrono::steady_clock::now();
229 mm.sendMetric(
"Test Metric 1", 1,
"Units", 2, artdaq::MetricMode::Accumulate);
230 auto afterOne = std::chrono::steady_clock::now();
234 auto beforeTen = std::chrono::steady_clock::now();
235 for (
auto ii = 1; ii <= 10; ++ii)
237 mm.sendMetric(
"Test Metric 10", ii,
"Units", 2, artdaq::MetricMode::Accumulate);
239 auto afterTen = std::chrono::steady_clock::now();
243 auto beforeOneHundred = std::chrono::steady_clock::now();
244 for (
auto ii = 1; ii <= 100; ++ii)
246 mm.sendMetric(
"Test Metric 100", ii,
"Units", 2, artdaq::MetricMode::Accumulate);
248 auto afterOneHundred = std::chrono::steady_clock::now();
252 auto beforeOneThousand = std::chrono::steady_clock::now();
253 for (
auto ii = 1; ii <= 1000; ++ii)
255 mm.sendMetric(
"Test Metric 1000", ii,
"Units", 2, artdaq::MetricMode::Accumulate);
257 auto afterOneThousand = std::chrono::steady_clock::now();
261 auto beforeTenThousand = std::chrono::steady_clock::now();
262 for (
auto ii = 1; ii <= 10000; ++ii)
264 mm.sendMetric(
"Test Metric 10000", ii,
"Units", 2, artdaq::MetricMode::Accumulate);
266 auto afterTenThousand = std::chrono::steady_clock::now();
269 auto beforeStop = std::chrono::steady_clock::now();
271 BOOST_REQUIRE_EQUAL(mm.Running(),
false);
272 BOOST_REQUIRE_EQUAL(mm.Initialized(),
true);
273 auto afterStop = std::chrono::steady_clock::now();
275 TLOG_INFO(
"MetricManager_t") <<
"Time for One Metric: " << artdaq::TimeUtils::GetElapsedTime(beforeOne, afterOne) <<
" s." << TLOG_ENDL;
276 TLOG_INFO(
"MetricManager_t") <<
"Time for Ten Metrics: " << artdaq::TimeUtils::GetElapsedTime(beforeTen, afterTen) <<
" s." << TLOG_ENDL;
277 TLOG_INFO(
"MetricManager_t") <<
"Time for One Hundred Metrics: " << artdaq::TimeUtils::GetElapsedTime(beforeOneHundred, afterOneHundred) <<
" s." << TLOG_ENDL;
278 TLOG_INFO(
"MetricManager_t") <<
"Time for One Thousand Metrics: " << artdaq::TimeUtils::GetElapsedTime(beforeOneThousand, afterOneThousand) <<
" s." << TLOG_ENDL;
279 TLOG_INFO(
"MetricManager_t") <<
"Time for Ten Thousand Metrics: " << artdaq::TimeUtils::GetElapsedTime(beforeTenThousand, afterTenThousand) <<
" s." << TLOG_ENDL;
280 TLOG_INFO(
"MetricManager_t") <<
"Time for Stop Metrics: " << artdaq::TimeUtils::GetElapsedTime(beforeStop, afterStop) <<
" s." << TLOG_ENDL;
283 BOOST_REQUIRE_EQUAL(mm.Initialized(),
false);
284 TLOG_DEBUG(
"MetricManager_t") <<
"END TEST MetricFlood" << TLOG_ENDL;
287 BOOST_AUTO_TEST_SUITE_END()