artdaq  v3_05_00
MetricManager_t.cc
1 #include "artdaq-utilities/Plugins/MetricManager.hh"
2 #include "artdaq-core/Utilities/TimeUtils.hh"
3 #include "artdaq-core/Utilities/configureMessageFacility.hh"
4 
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"
9 
10 #include "tracemf.h"
11 
12 BOOST_AUTO_TEST_SUITE(MetricManager_test)
13 
14 BOOST_AUTO_TEST_CASE(Construct)
15 {
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;
25 }
26 
27 BOOST_AUTO_TEST_CASE(Initialize)
28 {
29 
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);
38 
39  std::string testConfig = "msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
40  fhicl::ParameterSet pset;
41  fhicl::make_ParameterSet(testConfig, pset);
42 
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);
47 
48 
49  mm.do_start();
50  BOOST_REQUIRE_EQUAL(mm.Running(), true);
51  BOOST_REQUIRE_EQUAL(mm.Active(), true);
52  TLOG_DEBUG("MetricManager_t") << "END TEST Initialize" << TLOG_ENDL;
53 }
54 
55 BOOST_AUTO_TEST_CASE(Initialize_WithError)
56 {
57 
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);
66 
67  std::string testConfig = "err: { level: 5 metricPluginType: nonExistentPluginType reporting_interval: 1.0}";
68  fhicl::ParameterSet pset;
69  fhicl::make_ParameterSet(testConfig, pset);
70 
71  mm.initialize(pset, "MetricManager_t");
72  BOOST_REQUIRE_EQUAL(mm.Initialized(), true);
73  BOOST_REQUIRE_EQUAL(mm.Running(), false);
74 
75  mm.do_start();
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;
79 }
80 
81 BOOST_AUTO_TEST_CASE(Shutdown)
82 {
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);
91 
92  std::string testConfig = "msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
93  fhicl::ParameterSet pset;
94  fhicl::make_ParameterSet(testConfig, pset);
95 
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);
100 
101 
102  mm.do_start();
103  BOOST_REQUIRE_EQUAL(mm.Running(), true);
104  BOOST_REQUIRE_EQUAL(mm.Active(), true);
105 
106  mm.do_stop();
107  BOOST_REQUIRE_EQUAL(mm.Running(), false);
108  BOOST_REQUIRE_EQUAL(mm.Initialized(), true);
109 
110  mm.shutdown();
111  BOOST_REQUIRE_EQUAL(mm.Initialized(), false);
112  TLOG_DEBUG("MetricManager_t") << "END TEST Shutdown" << TLOG_ENDL;
113 }
114 
115 BOOST_AUTO_TEST_CASE(SendMetric_String)
116 {
117 
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);
126 
127  std::string testConfig = "msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
128  fhicl::ParameterSet pset;
129  fhicl::make_ParameterSet(testConfig, pset);
130 
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);
135 
136 
137  mm.do_start();
138  BOOST_REQUIRE_EQUAL(mm.Running(), true);
139  BOOST_REQUIRE_EQUAL(mm.Active(), true);
140 
141 
142  mm.sendMetric("Test Metric", "This is a test", "Units", 2, artdaq::MetricMode::LastPoint);
143 
144 
145  mm.do_stop();
146  BOOST_REQUIRE_EQUAL(mm.Running(), false);
147  BOOST_REQUIRE_EQUAL(mm.Initialized(), true);
148 
149  mm.shutdown();
150  BOOST_REQUIRE_EQUAL(mm.Initialized(), false);
151  TLOG_DEBUG("MetricManager_t") << "END TEST SendMetric_String" << TLOG_ENDL;
152 }
153 
154 BOOST_AUTO_TEST_CASE(SendMetrics)
155 {
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);
164 
165  std::string testConfig = "msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
166  fhicl::ParameterSet pset;
167  fhicl::make_ParameterSet(testConfig, pset);
168 
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);
173 
174 
175  mm.do_start();
176  BOOST_REQUIRE_EQUAL(mm.Running(), true);
177  BOOST_REQUIRE_EQUAL(mm.Active(), true);
178 
179 
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;
183 
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;
190 
191 
192 
193  mm.do_stop();
194  BOOST_REQUIRE_EQUAL(mm.Running(), false);
195  BOOST_REQUIRE_EQUAL(mm.Initialized(), true);
196 
197  mm.shutdown();
198  BOOST_REQUIRE_EQUAL(mm.Initialized(), false);
199  TLOG_DEBUG("MetricManager_t") << "END TEST SendMetrics" << TLOG_ENDL;
200 }
201 
202 BOOST_AUTO_TEST_CASE(MetricFlood)
203 {
204 
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);
213 
214  std::string testConfig = "msgFac: { level: 5 metricPluginType: msgFacility reporting_interval: 1.0}";
215  fhicl::ParameterSet pset;
216  fhicl::make_ParameterSet(testConfig, pset);
217 
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);
222 
223 
224  mm.do_start();
225  BOOST_REQUIRE_EQUAL(mm.Running(), true);
226  BOOST_REQUIRE_EQUAL(mm.Active(), true);
227 
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();
231 
232  sleep(2);
233 
234  auto beforeTen = std::chrono::steady_clock::now();
235  for (auto ii = 1; ii <= 10; ++ii)
236  {
237  mm.sendMetric("Test Metric 10", ii, "Units", 2, artdaq::MetricMode::Accumulate);
238  }
239  auto afterTen = std::chrono::steady_clock::now();
240 
241  sleep(2);
242 
243  auto beforeOneHundred = std::chrono::steady_clock::now();
244  for (auto ii = 1; ii <= 100; ++ii)
245  {
246  mm.sendMetric("Test Metric 100", ii, "Units", 2, artdaq::MetricMode::Accumulate);
247  }
248  auto afterOneHundred = std::chrono::steady_clock::now();
249 
250  sleep(2);
251 
252  auto beforeOneThousand = std::chrono::steady_clock::now();
253  for (auto ii = 1; ii <= 1000; ++ii)
254  {
255  mm.sendMetric("Test Metric 1000", ii, "Units", 2, artdaq::MetricMode::Accumulate);
256  }
257  auto afterOneThousand = std::chrono::steady_clock::now();
258 
259  sleep(2);
260 
261  auto beforeTenThousand = std::chrono::steady_clock::now();
262  for (auto ii = 1; ii <= 10000; ++ii)
263  {
264  mm.sendMetric("Test Metric 10000", ii, "Units", 2, artdaq::MetricMode::Accumulate);
265  }
266  auto afterTenThousand = std::chrono::steady_clock::now();
267 
268 
269  auto beforeStop = std::chrono::steady_clock::now();
270  mm.do_stop();
271  BOOST_REQUIRE_EQUAL(mm.Running(), false);
272  BOOST_REQUIRE_EQUAL(mm.Initialized(), true);
273  auto afterStop = std::chrono::steady_clock::now();
274 
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;
281 
282  mm.shutdown();
283  BOOST_REQUIRE_EQUAL(mm.Initialized(), false);
284  TLOG_DEBUG("MetricManager_t") << "END TEST MetricFlood" << TLOG_ENDL;
285 }
286 
287 BOOST_AUTO_TEST_SUITE_END()