1 // Copyright (C) 2018 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 // http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14
15 #include <gtest/gtest.h>
16
17 #include "src/StatsLogProcessor.h"
18 #include "src/stats_log_util.h"
19 #include "tests/statsd_test_util.h"
20
21 #include <vector>
22
23 namespace android {
24 namespace os {
25 namespace statsd {
26
27 #ifdef __ANDROID__
28
29 namespace {
30
CreateStatsdConfig()31 StatsdConfig CreateStatsdConfig() {
32 StatsdConfig config;
33 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
34 auto saverModeMatcher = CreateBatterySaverModeStartAtomMatcher();
35 auto crashMatcher = CreateProcessCrashAtomMatcher();
36 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
37
38 *config.add_atom_matcher() = saverModeMatcher;
39 *config.add_atom_matcher() = crashMatcher;
40 *config.add_atom_matcher() = screenOnMatcher;
41
42 int64_t metricId = 123456;
43 auto countMetric = config.add_count_metric();
44 countMetric->set_id(metricId);
45 countMetric->set_what(crashMatcher.id());
46 countMetric->set_bucket(FIVE_MINUTES);
47 countMetric->mutable_dimensions_in_what()->set_field(
48 util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
49 countMetric->mutable_dimensions_in_what()->add_child()->set_field(1); // uid field
50
51 auto metric_activation1 = config.add_metric_activation();
52 metric_activation1->set_metric_id(metricId);
53 auto event_activation1 = metric_activation1->add_event_activation();
54 event_activation1->set_atom_matcher_id(saverModeMatcher.id());
55 event_activation1->set_ttl_seconds(60 * 6); // 6 minutes
56 auto event_activation2 = metric_activation1->add_event_activation();
57 event_activation2->set_atom_matcher_id(screenOnMatcher.id());
58 event_activation2->set_ttl_seconds(60 * 2); // 2 minutes
59
60 return config;
61 }
62
CreateStatsdConfigWithOneDeactivation()63 StatsdConfig CreateStatsdConfigWithOneDeactivation() {
64 StatsdConfig config;
65 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
66 auto saverModeMatcher = CreateBatterySaverModeStartAtomMatcher();
67 auto crashMatcher = CreateProcessCrashAtomMatcher();
68 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
69 auto brightnessChangedMatcher = CreateScreenBrightnessChangedAtomMatcher();
70
71 *config.add_atom_matcher() = saverModeMatcher;
72 *config.add_atom_matcher() = crashMatcher;
73 *config.add_atom_matcher() = screenOnMatcher;
74 *config.add_atom_matcher() = brightnessChangedMatcher;
75
76 int64_t metricId = 123456;
77 auto countMetric = config.add_count_metric();
78 countMetric->set_id(metricId);
79 countMetric->set_what(crashMatcher.id());
80 countMetric->set_bucket(FIVE_MINUTES);
81 countMetric->mutable_dimensions_in_what()->set_field(
82 util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
83 countMetric->mutable_dimensions_in_what()->add_child()->set_field(1); // uid field
84
85 auto metric_activation1 = config.add_metric_activation();
86 metric_activation1->set_metric_id(metricId);
87 auto event_activation1 = metric_activation1->add_event_activation();
88 event_activation1->set_atom_matcher_id(saverModeMatcher.id());
89 event_activation1->set_ttl_seconds(60 * 6); // 6 minutes
90 event_activation1->set_deactivation_atom_matcher_id(brightnessChangedMatcher.id());
91 auto event_activation2 = metric_activation1->add_event_activation();
92 event_activation2->set_atom_matcher_id(screenOnMatcher.id());
93 event_activation2->set_ttl_seconds(60 * 2); // 2 minutes
94
95 return config;
96 }
97
CreateStatsdConfigWithTwoDeactivations()98 StatsdConfig CreateStatsdConfigWithTwoDeactivations() {
99 StatsdConfig config;
100 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
101 auto saverModeMatcher = CreateBatterySaverModeStartAtomMatcher();
102 auto crashMatcher = CreateProcessCrashAtomMatcher();
103 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
104 auto brightnessChangedMatcher = CreateScreenBrightnessChangedAtomMatcher();
105 auto brightnessChangedMatcher2 = CreateScreenBrightnessChangedAtomMatcher();
106 brightnessChangedMatcher2.set_id(StringToId("ScreenBrightnessChanged2"));
107
108 *config.add_atom_matcher() = saverModeMatcher;
109 *config.add_atom_matcher() = crashMatcher;
110 *config.add_atom_matcher() = screenOnMatcher;
111 *config.add_atom_matcher() = brightnessChangedMatcher;
112 *config.add_atom_matcher() = brightnessChangedMatcher2;
113
114 int64_t metricId = 123456;
115 auto countMetric = config.add_count_metric();
116 countMetric->set_id(metricId);
117 countMetric->set_what(crashMatcher.id());
118 countMetric->set_bucket(FIVE_MINUTES);
119 countMetric->mutable_dimensions_in_what()->set_field(
120 util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
121 countMetric->mutable_dimensions_in_what()->add_child()->set_field(1); // uid field
122
123 auto metric_activation1 = config.add_metric_activation();
124 metric_activation1->set_metric_id(metricId);
125 auto event_activation1 = metric_activation1->add_event_activation();
126 event_activation1->set_atom_matcher_id(saverModeMatcher.id());
127 event_activation1->set_ttl_seconds(60 * 6); // 6 minutes
128 event_activation1->set_deactivation_atom_matcher_id(brightnessChangedMatcher.id());
129 auto event_activation2 = metric_activation1->add_event_activation();
130 event_activation2->set_atom_matcher_id(screenOnMatcher.id());
131 event_activation2->set_ttl_seconds(60 * 2); // 2 minutes
132 event_activation2->set_deactivation_atom_matcher_id(brightnessChangedMatcher2.id());
133
134 return config;
135 }
136
CreateStatsdConfigWithSameDeactivations()137 StatsdConfig CreateStatsdConfigWithSameDeactivations() {
138 StatsdConfig config;
139 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
140 auto saverModeMatcher = CreateBatterySaverModeStartAtomMatcher();
141 auto crashMatcher = CreateProcessCrashAtomMatcher();
142 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
143 auto brightnessChangedMatcher = CreateScreenBrightnessChangedAtomMatcher();
144
145 *config.add_atom_matcher() = saverModeMatcher;
146 *config.add_atom_matcher() = crashMatcher;
147 *config.add_atom_matcher() = screenOnMatcher;
148 *config.add_atom_matcher() = brightnessChangedMatcher;
149
150 int64_t metricId = 123456;
151 auto countMetric = config.add_count_metric();
152 countMetric->set_id(metricId);
153 countMetric->set_what(crashMatcher.id());
154 countMetric->set_bucket(FIVE_MINUTES);
155 countMetric->mutable_dimensions_in_what()->set_field(
156 util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
157 countMetric->mutable_dimensions_in_what()->add_child()->set_field(1); // uid field
158
159 auto metric_activation1 = config.add_metric_activation();
160 metric_activation1->set_metric_id(metricId);
161 auto event_activation1 = metric_activation1->add_event_activation();
162 event_activation1->set_atom_matcher_id(saverModeMatcher.id());
163 event_activation1->set_ttl_seconds(60 * 6); // 6 minutes
164 event_activation1->set_deactivation_atom_matcher_id(brightnessChangedMatcher.id());
165 auto event_activation2 = metric_activation1->add_event_activation();
166 event_activation2->set_atom_matcher_id(screenOnMatcher.id());
167 event_activation2->set_ttl_seconds(60 * 2); // 2 minutes
168 event_activation2->set_deactivation_atom_matcher_id(brightnessChangedMatcher.id());
169
170 return config;
171 }
172
CreateStatsdConfigWithTwoMetricsTwoDeactivations()173 StatsdConfig CreateStatsdConfigWithTwoMetricsTwoDeactivations() {
174 StatsdConfig config;
175 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
176 auto saverModeMatcher = CreateBatterySaverModeStartAtomMatcher();
177 auto crashMatcher = CreateProcessCrashAtomMatcher();
178 auto foregroundMatcher = CreateMoveToForegroundAtomMatcher();
179 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
180 auto brightnessChangedMatcher = CreateScreenBrightnessChangedAtomMatcher();
181 auto brightnessChangedMatcher2 = CreateScreenBrightnessChangedAtomMatcher();
182 brightnessChangedMatcher2.set_id(StringToId("ScreenBrightnessChanged2"));
183
184 *config.add_atom_matcher() = saverModeMatcher;
185 *config.add_atom_matcher() = crashMatcher;
186 *config.add_atom_matcher() = screenOnMatcher;
187 *config.add_atom_matcher() = brightnessChangedMatcher;
188 *config.add_atom_matcher() = brightnessChangedMatcher2;
189 *config.add_atom_matcher() = foregroundMatcher;
190
191 int64_t metricId = 123456;
192 auto countMetric = config.add_count_metric();
193 countMetric->set_id(metricId);
194 countMetric->set_what(crashMatcher.id());
195 countMetric->set_bucket(FIVE_MINUTES);
196 countMetric->mutable_dimensions_in_what()->set_field(
197 util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
198 countMetric->mutable_dimensions_in_what()->add_child()->set_field(1); // uid field
199
200 int64_t metricId2 = 234567;
201 countMetric = config.add_count_metric();
202 countMetric->set_id(metricId2);
203 countMetric->set_what(foregroundMatcher.id());
204 countMetric->set_bucket(FIVE_MINUTES);
205 countMetric->mutable_dimensions_in_what()->set_field(
206 util::ACTIVITY_FOREGROUND_STATE_CHANGED);
207 countMetric->mutable_dimensions_in_what()->add_child()->set_field(1); // uid field
208
209 auto metric_activation1 = config.add_metric_activation();
210 metric_activation1->set_metric_id(metricId);
211 auto event_activation1 = metric_activation1->add_event_activation();
212 event_activation1->set_atom_matcher_id(saverModeMatcher.id());
213 event_activation1->set_ttl_seconds(60 * 6); // 6 minutes
214 event_activation1->set_deactivation_atom_matcher_id(brightnessChangedMatcher.id());
215 auto event_activation2 = metric_activation1->add_event_activation();
216 event_activation2->set_atom_matcher_id(screenOnMatcher.id());
217 event_activation2->set_ttl_seconds(60 * 2); // 2 minutes
218 event_activation2->set_deactivation_atom_matcher_id(brightnessChangedMatcher2.id());
219
220 metric_activation1 = config.add_metric_activation();
221 metric_activation1->set_metric_id(metricId2);
222 event_activation1 = metric_activation1->add_event_activation();
223 event_activation1->set_atom_matcher_id(saverModeMatcher.id());
224 event_activation1->set_ttl_seconds(60 * 6); // 6 minutes
225 event_activation1->set_deactivation_atom_matcher_id(brightnessChangedMatcher.id());
226 event_activation2 = metric_activation1->add_event_activation();
227 event_activation2->set_atom_matcher_id(screenOnMatcher.id());
228 event_activation2->set_ttl_seconds(60 * 2); // 2 minutes
229 event_activation2->set_deactivation_atom_matcher_id(brightnessChangedMatcher2.id());
230
231 return config;
232 }
233
234 } // namespace
235
TEST(MetricActivationE2eTest,TestCountMetric)236 TEST(MetricActivationE2eTest, TestCountMetric) {
237 auto config = CreateStatsdConfig();
238
239 int64_t bucketStartTimeNs = NS_PER_SEC * 10; // 10 secs
240 int64_t bucketSizeNs =
241 TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000LL * 1000LL;
242
243 int uid = 12345;
244 int64_t cfgId = 98765;
245 ConfigKey cfgKey(uid, cfgId);
246
247 sp<UidMap> m = new UidMap();
248 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
249 sp<AlarmMonitor> anomalyAlarmMonitor;
250 sp<AlarmMonitor> subscriberAlarmMonitor;
251 vector<int64_t> activeConfigsBroadcast;
252
253 long timeBase1 = 1;
254 int broadcastCount = 0;
255 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
256 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
257 .Times(1);
258 StatsLogProcessor processor(
259 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, bucketStartTimeNs,
260 [](const ConfigKey& key) { return true; },
261 [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,
262 const vector<int64_t>& activeConfigs) {
263 broadcastCount++;
264 EXPECT_EQ(broadcastUid, uid);
265 activeConfigsBroadcast.clear();
266 activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), activeConfigs.begin(),
267 activeConfigs.end());
268 return true;
269 },
270 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
271
272 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
273 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &processor)).Times(1);
274
275 processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config);
276
277 ASSERT_EQ(processor.mMetricsManagers.size(), 1u);
278 sp<MetricsManager> metricsManager = processor.mMetricsManagers.begin()->second;
279 EXPECT_TRUE(metricsManager->isConfigValid());
280 ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
281 sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
282 auto& eventActivationMap = metricProducer->mEventActivationMap;
283
284 EXPECT_FALSE(metricsManager->isActive());
285 EXPECT_FALSE(metricProducer->mIsActive);
286 // Two activations: one is triggered by battery saver mode (tracker index 0), the other is
287 // triggered by screen on event (tracker index 2).
288 ASSERT_EQ(eventActivationMap.size(), 2u);
289 EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end());
290 EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end());
291 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
292 EXPECT_EQ(eventActivationMap[0]->start_ns, 0);
293 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
294 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
295 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
296 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
297
298 std::unique_ptr<LogEvent> event;
299
300 event = CreateAppCrashEvent(bucketStartTimeNs + 5, 111);
301 processor.OnLogEvent(event.get(), bucketStartTimeNs + 5);
302 EXPECT_FALSE(metricsManager->isActive());
303 EXPECT_FALSE(metricProducer->mIsActive);
304 EXPECT_EQ(broadcastCount, 0);
305
306 // Activated by battery save mode.
307 event = CreateBatterySaverOnEvent(bucketStartTimeNs + 10);
308 processor.OnLogEvent(event.get(), bucketStartTimeNs + 10);
309 EXPECT_TRUE(metricsManager->isActive());
310 EXPECT_TRUE(metricProducer->mIsActive);
311 EXPECT_EQ(broadcastCount, 1);
312 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
313 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
314 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
315 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
316 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
317 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
318 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
319 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
320
321 // First processed event.
322 event = CreateAppCrashEvent(bucketStartTimeNs + 15, 222);
323 processor.OnLogEvent(event.get(), bucketStartTimeNs + 15);
324
325 // Activated by screen on event.
326 event = CreateScreenStateChangedEvent(bucketStartTimeNs + 20, android::view::DISPLAY_STATE_ON);
327 processor.OnLogEvent(event.get(), bucketStartTimeNs + 20);
328 EXPECT_TRUE(metricsManager->isActive());
329 EXPECT_TRUE(metricProducer->mIsActive);
330 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
331 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
332 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
333 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
334 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
335 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
336
337 // 2nd processed event.
338 // The activation by screen_on event expires, but the one by battery save mode is still active.
339 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25, 333);
340 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25);
341 EXPECT_TRUE(metricsManager->isActive());
342 EXPECT_TRUE(metricProducer->mIsActive);
343 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
344 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
345 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
346 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
347 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
348 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
349 // No new broadcast since the config should still be active.
350 EXPECT_EQ(broadcastCount, 1);
351
352 // 3rd processed event.
353 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25, 444);
354 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25);
355
356 // All activations expired.
357 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 8, 555);
358 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 8);
359 EXPECT_FALSE(metricsManager->isActive());
360 EXPECT_FALSE(metricProducer->mIsActive);
361 // New broadcast since the config is no longer active.
362 EXPECT_EQ(broadcastCount, 2);
363 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
364 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
365 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
366 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
367 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
368 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
369 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
370
371 // Re-activate metric via screen on.
372 event = CreateScreenStateChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10,
373 android::view::DISPLAY_STATE_ON);
374 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
375 EXPECT_TRUE(metricsManager->isActive());
376 EXPECT_TRUE(metricProducer->mIsActive);
377 EXPECT_EQ(broadcastCount, 3);
378 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
379 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
380 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
381 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
382 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
383 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
384 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
385 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
386
387 // 4th processed event.
388 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1, 666);
389 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1);
390
391 ConfigMetricsReportList reports;
392 vector<uint8_t> buffer;
393 processor.onDumpReport(cfgKey, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 1, false, true,
394 ADB_DUMP, FAST, &buffer);
395 EXPECT_TRUE(buffer.size() > 0);
396 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
397 backfillDimensionPath(&reports);
398 backfillStartEndTimestamp(&reports);
399 ASSERT_EQ(1, reports.reports_size());
400 ASSERT_EQ(1, reports.reports(0).metrics_size());
401
402 StatsLogReport::CountMetricDataWrapper countMetrics;
403 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics);
404 ASSERT_EQ(4, countMetrics.data_size());
405
406 auto data = countMetrics.data(0);
407 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
408 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
409 EXPECT_EQ(1 /* uid field */,
410 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
411 EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
412 ASSERT_EQ(1, data.bucket_info_size());
413 EXPECT_EQ(1, data.bucket_info(0).count());
414 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
415 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
416
417 data = countMetrics.data(1);
418 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
419 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
420 EXPECT_EQ(1 /* uid field */,
421 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
422 EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
423 ASSERT_EQ(1, data.bucket_info_size());
424 EXPECT_EQ(1, data.bucket_info(0).count());
425 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
426 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
427
428 data = countMetrics.data(2);
429 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
430 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
431 EXPECT_EQ(1 /* uid field */,
432 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
433 EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
434 ASSERT_EQ(1, data.bucket_info_size());
435 EXPECT_EQ(1, data.bucket_info(0).count());
436 // Partial bucket as metric is deactivated.
437 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
438 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 8,
439 data.bucket_info(0).end_bucket_elapsed_nanos());
440
441 data = countMetrics.data(3);
442 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
443 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
444 EXPECT_EQ(1 /* uid field */,
445 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
446 EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
447 ASSERT_EQ(1, data.bucket_info_size());
448 EXPECT_EQ(1, data.bucket_info(0).count());
449 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
450 data.bucket_info(0).start_bucket_elapsed_nanos());
451 EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
452 }
453
TEST(MetricActivationE2eTest,TestCountMetricWithOneDeactivation)454 TEST(MetricActivationE2eTest, TestCountMetricWithOneDeactivation) {
455 auto config = CreateStatsdConfigWithOneDeactivation();
456
457 int64_t bucketStartTimeNs = NS_PER_SEC * 10; // 10 secs
458 int64_t bucketSizeNs =
459 TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000LL * 1000LL;
460
461 int uid = 12345;
462 int64_t cfgId = 98765;
463 ConfigKey cfgKey(uid, cfgId);
464
465 sp<UidMap> m = new UidMap();
466 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
467 sp<AlarmMonitor> anomalyAlarmMonitor;
468 sp<AlarmMonitor> subscriberAlarmMonitor;
469 vector<int64_t> activeConfigsBroadcast;
470
471 long timeBase1 = 1;
472 int broadcastCount = 0;
473 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
474 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
475 .Times(1);
476 StatsLogProcessor processor(
477 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, bucketStartTimeNs,
478 [](const ConfigKey& key) { return true; },
479 [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,
480 const vector<int64_t>& activeConfigs) {
481 broadcastCount++;
482 EXPECT_EQ(broadcastUid, uid);
483 activeConfigsBroadcast.clear();
484 activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), activeConfigs.begin(),
485 activeConfigs.end());
486 return true;
487 },
488 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
489
490 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
491 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &processor)).Times(1);
492
493 processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config);
494
495 ASSERT_EQ(processor.mMetricsManagers.size(), 1u);
496 sp<MetricsManager> metricsManager = processor.mMetricsManagers.begin()->second;
497 EXPECT_TRUE(metricsManager->isConfigValid());
498 ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
499 sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
500 auto& eventActivationMap = metricProducer->mEventActivationMap;
501 auto& eventDeactivationMap = metricProducer->mEventDeactivationMap;
502
503 EXPECT_FALSE(metricsManager->isActive());
504 EXPECT_FALSE(metricProducer->mIsActive);
505 // Two activations: one is triggered by battery saver mode (tracker index 0), the other is
506 // triggered by screen on event (tracker index 2).
507 ASSERT_EQ(eventActivationMap.size(), 2u);
508 EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end());
509 EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end());
510 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
511 EXPECT_EQ(eventActivationMap[0]->start_ns, 0);
512 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
513 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
514 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
515 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
516 ASSERT_EQ(eventDeactivationMap.size(), 1u);
517 EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end());
518 ASSERT_EQ(eventDeactivationMap[3].size(), 1u);
519 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
520
521 std::unique_ptr<LogEvent> event;
522
523 event = CreateAppCrashEvent(bucketStartTimeNs + 5, 111);
524 processor.OnLogEvent(event.get(), bucketStartTimeNs + 5);
525 EXPECT_FALSE(metricsManager->isActive());
526 EXPECT_FALSE(metricProducer->mIsActive);
527 EXPECT_EQ(broadcastCount, 0);
528
529 // Activated by battery save mode.
530 event = CreateBatterySaverOnEvent(bucketStartTimeNs + 10);
531 processor.OnLogEvent(event.get(), bucketStartTimeNs + 10);
532 EXPECT_TRUE(metricsManager->isActive());
533 EXPECT_TRUE(metricProducer->mIsActive);
534 EXPECT_EQ(broadcastCount, 1);
535 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
536 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
537 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
538 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
539 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
540 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
541 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
542 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
543 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
544
545 // First processed event.
546 event = CreateAppCrashEvent(bucketStartTimeNs + 15, 222);
547 processor.OnLogEvent(event.get(), bucketStartTimeNs + 15);
548
549 // Activated by screen on event.
550 event = CreateScreenStateChangedEvent(bucketStartTimeNs + 20, android::view::DISPLAY_STATE_ON);
551 processor.OnLogEvent(event.get(), bucketStartTimeNs + 20);
552 EXPECT_TRUE(metricsManager->isActive());
553 EXPECT_TRUE(metricProducer->mIsActive);
554 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
555 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
556 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
557 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
558 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
559 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
560 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
561
562 // 2nd processed event.
563 // The activation by screen_on event expires, but the one by battery save mode is still active.
564 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25, 333);
565 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25);
566 EXPECT_TRUE(metricsManager->isActive());
567 EXPECT_TRUE(metricProducer->mIsActive);
568 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
569 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
570 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
571 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
572 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
573 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
574 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
575 // No new broadcast since the config should still be active.
576 EXPECT_EQ(broadcastCount, 1);
577
578 // 3rd processed event.
579 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25, 444);
580 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25);
581
582 // All activations expired.
583 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 8, 555);
584 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 8);
585 EXPECT_FALSE(metricsManager->isActive());
586 EXPECT_FALSE(metricProducer->mIsActive);
587 // New broadcast since the config is no longer active.
588 EXPECT_EQ(broadcastCount, 2);
589 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
590 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
591 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
592 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
593 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
594 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
595 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
596 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
597
598 // Re-activate metric via screen on.
599 event = CreateScreenStateChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10,
600 android::view::DISPLAY_STATE_ON);
601 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
602 EXPECT_TRUE(metricsManager->isActive());
603 EXPECT_TRUE(metricProducer->mIsActive);
604 EXPECT_EQ(broadcastCount, 3);
605 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
606 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
607 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
608 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
609 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
610 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
611 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
612 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
613 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
614
615 // 4th processed event.
616 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1, 666);
617 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1);
618
619 // Re-enable battery saver mode activation.
620 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
621 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
622 EXPECT_TRUE(metricsManager->isActive());
623 EXPECT_TRUE(metricProducer->mIsActive);
624 EXPECT_EQ(broadcastCount, 3);
625 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
626 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
627 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
628 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
629 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
630 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
631 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
632 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
633 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
634
635 // 5th processed event.
636 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40, 777);
637 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40);
638
639 // Cancel battery saver mode activation.
640 event = CreateScreenBrightnessChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 60, 64);
641 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 60);
642 EXPECT_TRUE(metricsManager->isActive());
643 EXPECT_TRUE(metricProducer->mIsActive);
644 EXPECT_EQ(broadcastCount, 3);
645 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
646 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
647 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
648 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
649 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
650 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
651 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
652 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
653 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
654
655 // Screen-on activation expired.
656 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 13, 888);
657 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 13);
658 EXPECT_FALSE(metricsManager->isActive());
659 EXPECT_FALSE(metricProducer->mIsActive);
660 // New broadcast since the config is no longer active.
661 EXPECT_EQ(broadcastCount, 4);
662 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
663 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
664 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
665 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
666 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
667 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
668 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
669 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
670
671 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1, 999);
672 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1);
673
674 // Re-enable battery saver mode activation.
675 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
676 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
677 EXPECT_TRUE(metricsManager->isActive());
678 EXPECT_TRUE(metricProducer->mIsActive);
679 EXPECT_EQ(broadcastCount, 5);
680 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
681 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
682 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
683 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
684 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
685 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
686 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
687 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
688 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
689
690 // Cancel battery saver mode activation.
691 event = CreateScreenBrightnessChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 16, 140);
692 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 16);
693 EXPECT_FALSE(metricsManager->isActive());
694 EXPECT_FALSE(metricProducer->mIsActive);
695 EXPECT_EQ(broadcastCount, 6);
696 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
697 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
698 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
699 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
700 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
701 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
702 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
703 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
704
705 ConfigMetricsReportList reports;
706 vector<uint8_t> buffer;
707 processor.onDumpReport(cfgKey, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 1, false, true,
708 ADB_DUMP, FAST, &buffer);
709 EXPECT_TRUE(buffer.size() > 0);
710 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
711 backfillDimensionPath(&reports);
712 backfillStartEndTimestamp(&reports);
713 ASSERT_EQ(1, reports.reports_size());
714 ASSERT_EQ(1, reports.reports(0).metrics_size());
715
716 StatsLogReport::CountMetricDataWrapper countMetrics;
717 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics);
718 ASSERT_EQ(5, countMetrics.data_size());
719
720 auto data = countMetrics.data(0);
721 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
722 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
723 EXPECT_EQ(1 /* uid field */,
724 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
725 EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
726 ASSERT_EQ(1, data.bucket_info_size());
727 EXPECT_EQ(1, data.bucket_info(0).count());
728 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
729 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
730
731 data = countMetrics.data(1);
732 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
733 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
734 EXPECT_EQ(1 /* uid field */,
735 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
736 EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
737 ASSERT_EQ(1, data.bucket_info_size());
738 EXPECT_EQ(1, data.bucket_info(0).count());
739 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
740 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
741
742 data = countMetrics.data(2);
743 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
744 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
745 EXPECT_EQ(1 /* uid field */,
746 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
747 EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
748 ASSERT_EQ(1, data.bucket_info_size());
749 EXPECT_EQ(1, data.bucket_info(0).count());
750 // Partial bucket as metric is deactivated.
751 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
752 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 8,
753 data.bucket_info(0).end_bucket_elapsed_nanos());
754
755 data = countMetrics.data(3);
756 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
757 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
758 EXPECT_EQ(1 /* uid field */,
759 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
760 EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
761 ASSERT_EQ(1, data.bucket_info_size());
762 EXPECT_EQ(1, data.bucket_info(0).count());
763 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
764 data.bucket_info(0).start_bucket_elapsed_nanos());
765 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 13,
766 data.bucket_info(0).end_bucket_elapsed_nanos());
767
768 data = countMetrics.data(4);
769 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
770 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
771 EXPECT_EQ(1 /* uid field */,
772 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
773 EXPECT_EQ(777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
774 ASSERT_EQ(1, data.bucket_info_size());
775 EXPECT_EQ(1, data.bucket_info(0).count());
776 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
777 data.bucket_info(0).start_bucket_elapsed_nanos());
778 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 13,
779 data.bucket_info(0).end_bucket_elapsed_nanos());
780 }
781
TEST(MetricActivationE2eTest,TestCountMetricWithTwoDeactivations)782 TEST(MetricActivationE2eTest, TestCountMetricWithTwoDeactivations) {
783 auto config = CreateStatsdConfigWithTwoDeactivations();
784
785 int64_t bucketStartTimeNs = NS_PER_SEC * 10; // 10 secs
786 int64_t bucketSizeNs =
787 TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000LL * 1000LL;
788
789 int uid = 12345;
790 int64_t cfgId = 98765;
791 ConfigKey cfgKey(uid, cfgId);
792
793 sp<UidMap> m = new UidMap();
794 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
795 sp<AlarmMonitor> anomalyAlarmMonitor;
796 sp<AlarmMonitor> subscriberAlarmMonitor;
797 vector<int64_t> activeConfigsBroadcast;
798
799 long timeBase1 = 1;
800 int broadcastCount = 0;
801 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
802 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
803 .Times(1);
804 StatsLogProcessor processor(
805 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, bucketStartTimeNs,
806 [](const ConfigKey& key) { return true; },
807 [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,
808 const vector<int64_t>& activeConfigs) {
809 broadcastCount++;
810 EXPECT_EQ(broadcastUid, uid);
811 activeConfigsBroadcast.clear();
812 activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), activeConfigs.begin(),
813 activeConfigs.end());
814 return true;
815 },
816 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
817
818 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
819 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &processor)).Times(1);
820
821 processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config);
822
823 ASSERT_EQ(processor.mMetricsManagers.size(), 1u);
824 sp<MetricsManager> metricsManager = processor.mMetricsManagers.begin()->second;
825 EXPECT_TRUE(metricsManager->isConfigValid());
826 ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
827 sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
828 auto& eventActivationMap = metricProducer->mEventActivationMap;
829 auto& eventDeactivationMap = metricProducer->mEventDeactivationMap;
830
831 EXPECT_FALSE(metricsManager->isActive());
832 EXPECT_FALSE(metricProducer->mIsActive);
833 // Two activations: one is triggered by battery saver mode (tracker index 0), the other is
834 // triggered by screen on event (tracker index 2).
835 ASSERT_EQ(eventActivationMap.size(), 2u);
836 EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end());
837 EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end());
838 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
839 EXPECT_EQ(eventActivationMap[0]->start_ns, 0);
840 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
841 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
842 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
843 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
844 ASSERT_EQ(eventDeactivationMap.size(), 2u);
845 EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end());
846 EXPECT_TRUE(eventDeactivationMap.find(4) != eventDeactivationMap.end());
847 ASSERT_EQ(eventDeactivationMap[3].size(), 1u);
848 ASSERT_EQ(eventDeactivationMap[4].size(), 1u);
849 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
850 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
851
852 std::unique_ptr<LogEvent> event;
853
854 event = CreateAppCrashEvent(bucketStartTimeNs + 5, 111);
855 processor.OnLogEvent(event.get(), bucketStartTimeNs + 5);
856 EXPECT_FALSE(metricsManager->isActive());
857 EXPECT_FALSE(metricProducer->mIsActive);
858 EXPECT_EQ(broadcastCount, 0);
859
860 // Activated by battery save mode.
861 event = CreateBatterySaverOnEvent(bucketStartTimeNs + 10);
862 processor.OnLogEvent(event.get(), bucketStartTimeNs + 10);
863 EXPECT_TRUE(metricsManager->isActive());
864 EXPECT_TRUE(metricProducer->mIsActive);
865 EXPECT_EQ(broadcastCount, 1);
866 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
867 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
868 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
869 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
870 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
871 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
872 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
873 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
874 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
875 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
876
877 // First processed event.
878 event = CreateAppCrashEvent(bucketStartTimeNs + 15, 222);
879 processor.OnLogEvent(event.get(), bucketStartTimeNs + 15);
880
881 // Activated by screen on event.
882 event = CreateScreenStateChangedEvent(bucketStartTimeNs + 20, android::view::DISPLAY_STATE_ON);
883 processor.OnLogEvent(event.get(), bucketStartTimeNs + 20);
884 EXPECT_TRUE(metricsManager->isActive());
885 EXPECT_TRUE(metricProducer->mIsActive);
886 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
887 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
888 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
889 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
890 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
891 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
892 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
893 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
894
895 // 2nd processed event.
896 // The activation by screen_on event expires, but the one by battery save mode is still active.
897 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25, 333);
898 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25);
899 EXPECT_TRUE(metricsManager->isActive());
900 EXPECT_TRUE(metricProducer->mIsActive);
901 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
902 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
903 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
904 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
905 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
906 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
907 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
908 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
909 // No new broadcast since the config should still be active.
910 EXPECT_EQ(broadcastCount, 1);
911
912 // 3rd processed event.
913 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25, 444);
914 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25);
915
916 // All activations expired.
917 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 8, 555);
918 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 8);
919 EXPECT_FALSE(metricsManager->isActive());
920 EXPECT_FALSE(metricProducer->mIsActive);
921 // New broadcast since the config is no longer active.
922 EXPECT_EQ(broadcastCount, 2);
923 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
924 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
925 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
926 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
927 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
928 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
929 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
930 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
931 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
932
933 // Re-activate metric via screen on.
934 event = CreateScreenStateChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10,
935 android::view::DISPLAY_STATE_ON);
936 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
937 EXPECT_TRUE(metricsManager->isActive());
938 EXPECT_TRUE(metricProducer->mIsActive);
939 EXPECT_EQ(broadcastCount, 3);
940 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
941 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
942 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
943 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
944 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
945 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
946 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
947 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
948 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
949 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
950
951 // 4th processed event.
952 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1, 666);
953 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1);
954
955 // Re-enable battery saver mode activation.
956 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
957 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
958 EXPECT_TRUE(metricsManager->isActive());
959 EXPECT_TRUE(metricProducer->mIsActive);
960 EXPECT_EQ(broadcastCount, 3);
961 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
962 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
963 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
964 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
965 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
966 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
967 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
968 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
969 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
970 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
971
972 // 5th processed event.
973 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40, 777);
974 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40);
975
976 // Cancel battery saver mode and screen on activation.
977 event = CreateScreenBrightnessChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 60, 64);
978 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 60);
979 EXPECT_FALSE(metricsManager->isActive());
980 EXPECT_FALSE(metricProducer->mIsActive);
981 // New broadcast since the config is no longer active.
982 EXPECT_EQ(broadcastCount, 4);
983 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
984 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
985 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
986 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
987 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
988 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
989 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
990 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
991 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
992
993 // Screen-on activation expired.
994 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 13, 888);
995 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 13);
996 EXPECT_FALSE(metricsManager->isActive());
997 EXPECT_FALSE(metricProducer->mIsActive);
998 EXPECT_EQ(broadcastCount, 4);
999 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1000 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1001 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1002 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1003 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1004 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1005 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1006 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1007 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1008
1009 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1, 999);
1010 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1);
1011
1012 // Re-enable battery saver mode activation.
1013 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1014 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1015 EXPECT_TRUE(metricsManager->isActive());
1016 EXPECT_TRUE(metricProducer->mIsActive);
1017 EXPECT_EQ(broadcastCount, 5);
1018 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
1019 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
1020 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1021 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1022 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1023 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1024 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1025 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1026 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1027 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1028
1029 // Cancel battery saver mode and screen on activation.
1030 event = CreateScreenBrightnessChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 16, 140);
1031 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 16);
1032 EXPECT_FALSE(metricsManager->isActive());
1033 EXPECT_FALSE(metricProducer->mIsActive);
1034 EXPECT_EQ(broadcastCount, 6);
1035 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1036 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1037 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1038 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1039 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1040 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1041 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1042 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1043 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1044
1045 ConfigMetricsReportList reports;
1046 vector<uint8_t> buffer;
1047 processor.onDumpReport(cfgKey, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 1, false, true,
1048 ADB_DUMP, FAST, &buffer);
1049 EXPECT_TRUE(buffer.size() > 0);
1050 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1051 backfillDimensionPath(&reports);
1052 backfillStartEndTimestamp(&reports);
1053 ASSERT_EQ(1, reports.reports_size());
1054 ASSERT_EQ(1, reports.reports(0).metrics_size());
1055
1056 StatsLogReport::CountMetricDataWrapper countMetrics;
1057 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics);
1058 ASSERT_EQ(5, countMetrics.data_size());
1059
1060 auto data = countMetrics.data(0);
1061 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1062 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1063 EXPECT_EQ(1 /* uid field */,
1064 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1065 EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1066 ASSERT_EQ(1, data.bucket_info_size());
1067 EXPECT_EQ(1, data.bucket_info(0).count());
1068 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1069 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
1070
1071 data = countMetrics.data(1);
1072 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1073 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1074 EXPECT_EQ(1 /* uid field */,
1075 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1076 EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1077 ASSERT_EQ(1, data.bucket_info_size());
1078 EXPECT_EQ(1, data.bucket_info(0).count());
1079 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1080 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
1081
1082 data = countMetrics.data(2);
1083 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1084 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1085 EXPECT_EQ(1 /* uid field */,
1086 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1087 EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1088 ASSERT_EQ(1, data.bucket_info_size());
1089 EXPECT_EQ(1, data.bucket_info(0).count());
1090 // Partial bucket as metric is deactivated.
1091 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1092 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 8,
1093 data.bucket_info(0).end_bucket_elapsed_nanos());
1094
1095 data = countMetrics.data(3);
1096 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1097 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1098 EXPECT_EQ(1 /* uid field */,
1099 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1100 EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1101 ASSERT_EQ(1, data.bucket_info_size());
1102 EXPECT_EQ(1, data.bucket_info(0).count());
1103 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
1104 data.bucket_info(0).start_bucket_elapsed_nanos());
1105 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 11,
1106 data.bucket_info(0).end_bucket_elapsed_nanos());
1107
1108 data = countMetrics.data(4);
1109 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1110 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1111 EXPECT_EQ(1 /* uid field */,
1112 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1113 EXPECT_EQ(777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1114 ASSERT_EQ(1, data.bucket_info_size());
1115 EXPECT_EQ(1, data.bucket_info(0).count());
1116 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
1117 data.bucket_info(0).start_bucket_elapsed_nanos());
1118 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 11,
1119 data.bucket_info(0).end_bucket_elapsed_nanos());
1120 }
1121
TEST(MetricActivationE2eTest,TestCountMetricWithSameDeactivation)1122 TEST(MetricActivationE2eTest, TestCountMetricWithSameDeactivation) {
1123 auto config = CreateStatsdConfigWithSameDeactivations();
1124
1125 int64_t bucketStartTimeNs = NS_PER_SEC * 10; // 10 secs
1126 int64_t bucketSizeNs =
1127 TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000LL * 1000LL;
1128
1129 int uid = 12345;
1130 int64_t cfgId = 98765;
1131 ConfigKey cfgKey(uid, cfgId);
1132
1133 sp<UidMap> m = new UidMap();
1134 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
1135 sp<AlarmMonitor> anomalyAlarmMonitor;
1136 sp<AlarmMonitor> subscriberAlarmMonitor;
1137 vector<int64_t> activeConfigsBroadcast;
1138
1139 long timeBase1 = 1;
1140 int broadcastCount = 0;
1141 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
1142 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
1143 .Times(1);
1144 StatsLogProcessor processor(
1145 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, bucketStartTimeNs,
1146 [](const ConfigKey& key) { return true; },
1147 [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,
1148 const vector<int64_t>& activeConfigs) {
1149 broadcastCount++;
1150 EXPECT_EQ(broadcastUid, uid);
1151 activeConfigsBroadcast.clear();
1152 activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), activeConfigs.begin(),
1153 activeConfigs.end());
1154 return true;
1155 },
1156 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
1157
1158 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
1159 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &processor)).Times(1);
1160
1161 processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config);
1162
1163 ASSERT_EQ(processor.mMetricsManagers.size(), 1u);
1164 sp<MetricsManager> metricsManager = processor.mMetricsManagers.begin()->second;
1165 EXPECT_TRUE(metricsManager->isConfigValid());
1166 ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
1167 sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
1168 auto& eventActivationMap = metricProducer->mEventActivationMap;
1169 auto& eventDeactivationMap = metricProducer->mEventDeactivationMap;
1170
1171 EXPECT_FALSE(metricsManager->isActive());
1172 EXPECT_FALSE(metricProducer->mIsActive);
1173 // Two activations: one is triggered by battery saver mode (tracker index 0), the other is
1174 // triggered by screen on event (tracker index 2).
1175 ASSERT_EQ(eventActivationMap.size(), 2u);
1176 EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end());
1177 EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end());
1178 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1179 EXPECT_EQ(eventActivationMap[0]->start_ns, 0);
1180 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1181 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1182 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
1183 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1184 ASSERT_EQ(eventDeactivationMap.size(), 1u);
1185 EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end());
1186 ASSERT_EQ(eventDeactivationMap[3].size(), 2u);
1187 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1188 EXPECT_EQ(eventDeactivationMap[3][1], eventActivationMap[2]);
1189 EXPECT_EQ(broadcastCount, 0);
1190
1191 std::unique_ptr<LogEvent> event;
1192
1193 // Event that should be ignored.
1194 event = CreateAppCrashEvent(bucketStartTimeNs + 1, 111);
1195 processor.OnLogEvent(event.get(), bucketStartTimeNs + 1);
1196
1197 // Activate metric via screen on for 2 minutes.
1198 event = CreateScreenStateChangedEvent(bucketStartTimeNs + 10, android::view::DISPLAY_STATE_ON);
1199 processor.OnLogEvent(event.get(), bucketStartTimeNs + 10);
1200 EXPECT_TRUE(metricsManager->isActive());
1201 EXPECT_TRUE(metricProducer->mIsActive);
1202 EXPECT_EQ(broadcastCount, 1);
1203 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
1204 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
1205 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1206 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
1207 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 10);
1208
1209 // 1st processed event.
1210 event = CreateAppCrashEvent(bucketStartTimeNs + 15, 222);
1211 processor.OnLogEvent(event.get(), bucketStartTimeNs + 15);
1212
1213 // Enable battery saver mode activation for 5 minutes.
1214 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 + 10);
1215 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 + 10);
1216 EXPECT_TRUE(metricsManager->isActive());
1217 EXPECT_TRUE(metricProducer->mIsActive);
1218 EXPECT_EQ(broadcastCount, 1);
1219 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1220 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 + 10);
1221 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
1222 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 10);
1223
1224 // 2nd processed event.
1225 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 + 40, 333);
1226 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 + 40);
1227
1228 // Cancel battery saver mode and screen on activation.
1229 int64_t firstDeactivation = bucketStartTimeNs + NS_PER_SEC * 61;
1230 event = CreateScreenBrightnessChangedEvent(firstDeactivation, 64);
1231 processor.OnLogEvent(event.get(), firstDeactivation);
1232 EXPECT_FALSE(metricsManager->isActive());
1233 EXPECT_FALSE(metricProducer->mIsActive);
1234 // New broadcast since the config is no longer active.
1235 EXPECT_EQ(broadcastCount, 2);
1236 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1237 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1238 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1239
1240 // Should be ignored
1241 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 61 + 80, 444);
1242 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 61 + 80);
1243
1244 // Re-enable battery saver mode activation.
1245 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 15);
1246 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 15);
1247 EXPECT_TRUE(metricsManager->isActive());
1248 EXPECT_TRUE(metricProducer->mIsActive);
1249 EXPECT_EQ(broadcastCount, 3);
1250 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
1251 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
1252 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1253 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 15);
1254 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1255
1256 // 3rd processed event.
1257 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 80, 555);
1258 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 80);
1259
1260 // Cancel battery saver mode activation.
1261 int64_t secondDeactivation = bucketStartTimeNs + NS_PER_SEC * 60 * 13;
1262 event = CreateScreenBrightnessChangedEvent(secondDeactivation, 140);
1263 processor.OnLogEvent(event.get(), secondDeactivation);
1264 EXPECT_FALSE(metricsManager->isActive());
1265 EXPECT_FALSE(metricProducer->mIsActive);
1266 EXPECT_EQ(broadcastCount, 4);
1267 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1268 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1269 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1270
1271 // Should be ignored.
1272 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 13 + 80, 666);
1273 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 13 + 80);
1274
1275 ConfigMetricsReportList reports;
1276 vector<uint8_t> buffer;
1277 processor.onDumpReport(cfgKey, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 1, false, true,
1278 ADB_DUMP, FAST, &buffer);
1279 EXPECT_TRUE(buffer.size() > 0);
1280 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1281 backfillDimensionPath(&reports);
1282 backfillStartEndTimestamp(&reports);
1283 ASSERT_EQ(1, reports.reports_size());
1284 ASSERT_EQ(1, reports.reports(0).metrics_size());
1285
1286 StatsLogReport::CountMetricDataWrapper countMetrics;
1287 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics);
1288 ASSERT_EQ(3, countMetrics.data_size());
1289
1290 auto data = countMetrics.data(0);
1291 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1292 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1293 EXPECT_EQ(1 /* uid field */,
1294 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1295 EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1296 ASSERT_EQ(1, data.bucket_info_size());
1297 EXPECT_EQ(1, data.bucket_info(0).count());
1298 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1299 EXPECT_EQ(firstDeactivation, data.bucket_info(0).end_bucket_elapsed_nanos());
1300
1301 data = countMetrics.data(1);
1302 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1303 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1304 EXPECT_EQ(1 /* uid field */,
1305 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1306 EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1307 ASSERT_EQ(1, data.bucket_info_size());
1308 EXPECT_EQ(1, data.bucket_info(0).count());
1309 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1310 EXPECT_EQ(firstDeactivation, data.bucket_info(0).end_bucket_elapsed_nanos());
1311
1312 data = countMetrics.data(2);
1313 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1314 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1315 EXPECT_EQ(1 /* uid field */,
1316 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1317 EXPECT_EQ(555, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1318 ASSERT_EQ(1, data.bucket_info_size());
1319 EXPECT_EQ(1, data.bucket_info(0).count());
1320 // Partial bucket as metric is deactivated.
1321 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
1322 data.bucket_info(0).start_bucket_elapsed_nanos());
1323 EXPECT_EQ(secondDeactivation, data.bucket_info(0).end_bucket_elapsed_nanos());
1324 }
1325
TEST(MetricActivationE2eTest,TestCountMetricWithTwoMetricsTwoDeactivations)1326 TEST(MetricActivationE2eTest, TestCountMetricWithTwoMetricsTwoDeactivations) {
1327 auto config = CreateStatsdConfigWithTwoMetricsTwoDeactivations();
1328
1329 int64_t bucketStartTimeNs = NS_PER_SEC * 10; // 10 secs
1330 int64_t bucketSizeNs =
1331 TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000LL * 1000LL;
1332
1333 int uid = 12345;
1334 int64_t cfgId = 98765;
1335 ConfigKey cfgKey(uid, cfgId);
1336
1337 sp<UidMap> m = new UidMap();
1338 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
1339 sp<AlarmMonitor> anomalyAlarmMonitor;
1340 sp<AlarmMonitor> subscriberAlarmMonitor;
1341 vector<int64_t> activeConfigsBroadcast;
1342
1343 long timeBase1 = 1;
1344 int broadcastCount = 0;
1345 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
1346 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
1347 .Times(1);
1348 StatsLogProcessor processor(
1349 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, bucketStartTimeNs,
1350 [](const ConfigKey& key) { return true; },
1351 [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,
1352 const vector<int64_t>& activeConfigs) {
1353 broadcastCount++;
1354 EXPECT_EQ(broadcastUid, uid);
1355 activeConfigsBroadcast.clear();
1356 activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), activeConfigs.begin(),
1357 activeConfigs.end());
1358 return true;
1359 },
1360 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
1361
1362 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
1363 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &processor)).Times(1);
1364
1365 processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config);
1366
1367 ASSERT_EQ(processor.mMetricsManagers.size(), 1u);
1368 sp<MetricsManager> metricsManager = processor.mMetricsManagers.begin()->second;
1369 EXPECT_TRUE(metricsManager->isConfigValid());
1370 ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 2);
1371 sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
1372 auto& eventActivationMap = metricProducer->mEventActivationMap;
1373 auto& eventDeactivationMap = metricProducer->mEventDeactivationMap;
1374 sp<MetricProducer> metricProducer2 = metricsManager->mAllMetricProducers[1];
1375 auto& eventActivationMap2 = metricProducer2->mEventActivationMap;
1376 auto& eventDeactivationMap2 = metricProducer2->mEventDeactivationMap;
1377
1378 EXPECT_FALSE(metricsManager->isActive());
1379 EXPECT_FALSE(metricProducer->mIsActive);
1380 EXPECT_FALSE(metricProducer2->mIsActive);
1381 // Two activations: one is triggered by battery saver mode (tracker index 0), the other is
1382 // triggered by screen on event (tracker index 2).
1383 ASSERT_EQ(eventActivationMap.size(), 2u);
1384 EXPECT_TRUE(eventActivationMap.find(0) != eventActivationMap.end());
1385 EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end());
1386 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1387 EXPECT_EQ(eventActivationMap[0]->start_ns, 0);
1388 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1389 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1390 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
1391 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1392 ASSERT_EQ(eventDeactivationMap.size(), 2u);
1393 EXPECT_TRUE(eventDeactivationMap.find(3) != eventDeactivationMap.end());
1394 EXPECT_TRUE(eventDeactivationMap.find(4) != eventDeactivationMap.end());
1395 ASSERT_EQ(eventDeactivationMap[3].size(), 1u);
1396 ASSERT_EQ(eventDeactivationMap[4].size(), 1u);
1397 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1398 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1399
1400 ASSERT_EQ(eventActivationMap2.size(), 2u);
1401 EXPECT_TRUE(eventActivationMap2.find(0) != eventActivationMap2.end());
1402 EXPECT_TRUE(eventActivationMap2.find(2) != eventActivationMap2.end());
1403 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kNotActive);
1404 EXPECT_EQ(eventActivationMap2[0]->start_ns, 0);
1405 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1406 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1407 EXPECT_EQ(eventActivationMap2[2]->start_ns, 0);
1408 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1409 ASSERT_EQ(eventDeactivationMap2.size(), 2u);
1410 EXPECT_TRUE(eventDeactivationMap2.find(3) != eventDeactivationMap2.end());
1411 EXPECT_TRUE(eventDeactivationMap2.find(4) != eventDeactivationMap2.end());
1412 ASSERT_EQ(eventDeactivationMap[3].size(), 1u);
1413 ASSERT_EQ(eventDeactivationMap[4].size(), 1u);
1414 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1415 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1416
1417 std::unique_ptr<LogEvent> event;
1418
1419 event = CreateAppCrashEvent(bucketStartTimeNs + 5, 111);
1420 processor.OnLogEvent(event.get(), bucketStartTimeNs + 5);
1421 event = CreateMoveToForegroundEvent(bucketStartTimeNs + 5, 1111);
1422 processor.OnLogEvent(event.get(), bucketStartTimeNs + 5);
1423 EXPECT_FALSE(metricsManager->isActive());
1424 EXPECT_FALSE(metricProducer->mIsActive);
1425 EXPECT_FALSE(metricProducer2->mIsActive);
1426 EXPECT_EQ(broadcastCount, 0);
1427
1428 // Activated by battery save mode.
1429 event = CreateBatterySaverOnEvent(bucketStartTimeNs + 10);
1430 processor.OnLogEvent(event.get(), bucketStartTimeNs + 10);
1431 EXPECT_TRUE(metricsManager->isActive());
1432 EXPECT_EQ(broadcastCount, 1);
1433 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
1434 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
1435 EXPECT_TRUE(metricProducer->mIsActive);
1436 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1437 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
1438 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1439 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1440 EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
1441 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1442 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1443 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1444 EXPECT_TRUE(metricProducer2->mIsActive);
1445 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kActive);
1446 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + 10);
1447 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1448 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1449 EXPECT_EQ(eventActivationMap2[2]->start_ns, 0);
1450 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1451 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1452 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1453
1454 // First processed event.
1455 event = CreateAppCrashEvent(bucketStartTimeNs + 15, 222);
1456 processor.OnLogEvent(event.get(), bucketStartTimeNs + 15);
1457 event = CreateMoveToForegroundEvent(bucketStartTimeNs + 15, 2222);
1458 processor.OnLogEvent(event.get(), bucketStartTimeNs + 15);
1459
1460 // Activated by screen on event.
1461 event = CreateScreenStateChangedEvent(bucketStartTimeNs + 20, android::view::DISPLAY_STATE_ON);
1462 processor.OnLogEvent(event.get(), bucketStartTimeNs + 20);
1463 EXPECT_TRUE(metricsManager->isActive());
1464 EXPECT_TRUE(metricProducer->mIsActive);
1465 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1466 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
1467 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1468 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
1469 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
1470 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1471 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1472 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1473 EXPECT_TRUE(metricProducer2->mIsActive);
1474 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kActive);
1475 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + 10);
1476 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1477 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kActive);
1478 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + 20);
1479 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1480 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1481 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1482
1483 // 2nd processed event.
1484 // The activation by screen_on event expires, but the one by battery save mode is still active.
1485 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25, 333);
1486 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25);
1487 event = CreateMoveToForegroundEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25, 3333);
1488 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 2 + 25);
1489 EXPECT_TRUE(metricsManager->isActive());
1490 EXPECT_TRUE(metricProducer->mIsActive);
1491 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1492 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
1493 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1494 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1495 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
1496 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1497 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1498 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1499 EXPECT_TRUE(metricProducer2->mIsActive);
1500 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kActive);
1501 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + 10);
1502 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1503 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1504 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + 20);
1505 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1506 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1507 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1508 // No new broadcast since the config should still be active.
1509 EXPECT_EQ(broadcastCount, 1);
1510
1511 // 3rd processed event.
1512 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25, 444);
1513 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25);
1514 event = CreateMoveToForegroundEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25, 4444);
1515 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 5 + 25);
1516
1517 // All activations expired.
1518 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 8, 555);
1519 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 8);
1520 event = CreateMoveToForegroundEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 8, 5555);
1521 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 8);
1522 EXPECT_FALSE(metricsManager->isActive());
1523 // New broadcast since the config is no longer active.
1524 EXPECT_EQ(broadcastCount, 2);
1525 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1526 EXPECT_FALSE(metricProducer->mIsActive);
1527 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1528 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
1529 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1530 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1531 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + 20);
1532 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1533 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1534 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1535 EXPECT_FALSE(metricProducer2->mIsActive);
1536 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kNotActive);
1537 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + 10);
1538 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1539 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1540 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + 20);
1541 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1542 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1543 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1544
1545 // Re-activate metric via screen on.
1546 event = CreateScreenStateChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10,
1547 android::view::DISPLAY_STATE_ON);
1548 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1549 EXPECT_TRUE(metricsManager->isActive());
1550 EXPECT_EQ(broadcastCount, 3);
1551 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
1552 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
1553 EXPECT_TRUE(metricProducer->mIsActive);
1554 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1555 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + 10);
1556 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1557 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
1558 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1559 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1560 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1561 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1562 EXPECT_TRUE(metricProducer2->mIsActive);
1563 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kNotActive);
1564 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + 10);
1565 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1566 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kActive);
1567 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1568 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1569 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1570 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1571
1572 // 4th processed event.
1573 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1, 666);
1574 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1);
1575 event = CreateMoveToForegroundEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1, 6666);
1576 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 1);
1577
1578 // Re-enable battery saver mode activation.
1579 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1580 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1581 EXPECT_TRUE(metricsManager->isActive());
1582 EXPECT_EQ(broadcastCount, 3);
1583 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
1584 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
1585 EXPECT_TRUE(metricProducer->mIsActive);
1586 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1587 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1588 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1589 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
1590 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1591 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1592 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1593 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1594 EXPECT_TRUE(metricProducer2->mIsActive);
1595 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kActive);
1596 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1597 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1598 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kActive);
1599 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1600 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1601 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1602 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1603
1604 // 5th processed event.
1605 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40, 777);
1606 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40);
1607 event = CreateMoveToForegroundEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40, 7777);
1608 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 40);
1609
1610 // Cancel battery saver mode and screen on activation.
1611 event = CreateScreenBrightnessChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 60, 64);
1612 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 60);
1613 EXPECT_FALSE(metricsManager->isActive());
1614 // New broadcast since the config is no longer active.
1615 EXPECT_EQ(broadcastCount, 4);
1616 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1617 EXPECT_FALSE(metricProducer->mIsActive);
1618 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1619 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1620 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1621 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1622 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1623 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1624 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1625 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1626 EXPECT_FALSE(metricProducer2->mIsActive);
1627 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kNotActive);
1628 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1629 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1630 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1631 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1632 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1633 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1634 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1635
1636 // Screen-on activation expired.
1637 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 13, 888);
1638 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 13);
1639 event = CreateMoveToForegroundEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 13, 8888);
1640 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 13);
1641 EXPECT_FALSE(metricsManager->isActive());
1642 EXPECT_EQ(broadcastCount, 4);
1643 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1644 EXPECT_FALSE(metricProducer->mIsActive);
1645 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1646 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1647 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1648 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1649 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1650 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1651 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1652 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1653 EXPECT_FALSE(metricProducer2->mIsActive);
1654 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kNotActive);
1655 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 11 + 15);
1656 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1657 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1658 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1659 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1660 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1661 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1662
1663 event = CreateAppCrashEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1, 999);
1664 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1);
1665 event = CreateMoveToForegroundEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1, 9999);
1666 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 14 + 1);
1667
1668 // Re-enable battery saver mode activation.
1669 event = CreateBatterySaverOnEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1670 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1671 EXPECT_TRUE(metricsManager->isActive());
1672 EXPECT_EQ(broadcastCount, 5);
1673 ASSERT_EQ(activeConfigsBroadcast.size(), 1);
1674 EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
1675 EXPECT_TRUE(metricProducer->mIsActive);
1676 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kActive);
1677 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1678 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1679 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1680 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1681 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1682 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1683 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1684 EXPECT_TRUE(metricProducer2->mIsActive);
1685 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kActive);
1686 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1687 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1688 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1689 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1690 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1691 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1692 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1693
1694 // Cancel battery saver mode and screen on activation.
1695 event = CreateScreenBrightnessChangedEvent(bucketStartTimeNs + NS_PER_SEC * 60 * 16, 140);
1696 processor.OnLogEvent(event.get(), bucketStartTimeNs + NS_PER_SEC * 60 * 16);
1697 EXPECT_FALSE(metricsManager->isActive());
1698 EXPECT_EQ(broadcastCount, 6);
1699 ASSERT_EQ(activeConfigsBroadcast.size(), 0);
1700 EXPECT_FALSE(metricProducer->mIsActive);
1701 EXPECT_EQ(eventActivationMap[0]->state, ActivationState::kNotActive);
1702 EXPECT_EQ(eventActivationMap[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1703 EXPECT_EQ(eventActivationMap[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1704 EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
1705 EXPECT_EQ(eventActivationMap[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1706 EXPECT_EQ(eventActivationMap[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1707 EXPECT_EQ(eventDeactivationMap[3][0], eventActivationMap[0]);
1708 EXPECT_EQ(eventDeactivationMap[4][0], eventActivationMap[2]);
1709 EXPECT_FALSE(metricProducer2->mIsActive);
1710 EXPECT_EQ(eventActivationMap2[0]->state, ActivationState::kNotActive);
1711 EXPECT_EQ(eventActivationMap2[0]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 15);
1712 EXPECT_EQ(eventActivationMap2[0]->ttl_ns, 60 * 6 * NS_PER_SEC);
1713 EXPECT_EQ(eventActivationMap2[2]->state, ActivationState::kNotActive);
1714 EXPECT_EQ(eventActivationMap2[2]->start_ns, bucketStartTimeNs + NS_PER_SEC * 60 * 10 + 10);
1715 EXPECT_EQ(eventActivationMap2[2]->ttl_ns, 60 * 2 * NS_PER_SEC);
1716 EXPECT_EQ(eventDeactivationMap2[3][0], eventActivationMap2[0]);
1717 EXPECT_EQ(eventDeactivationMap2[4][0], eventActivationMap2[2]);
1718
1719 ConfigMetricsReportList reports;
1720 vector<uint8_t> buffer;
1721 processor.onDumpReport(cfgKey, bucketStartTimeNs + NS_PER_SEC * 60 * 15 + 1, false, true,
1722 ADB_DUMP, FAST, &buffer);
1723 EXPECT_TRUE(buffer.size() > 0);
1724 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1725 backfillDimensionPath(&reports);
1726 backfillStartEndTimestamp(&reports);
1727 ASSERT_EQ(1, reports.reports_size());
1728 ASSERT_EQ(2, reports.reports(0).metrics_size());
1729
1730 StatsLogReport::CountMetricDataWrapper countMetrics;
1731
1732 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics);
1733 ASSERT_EQ(5, countMetrics.data_size());
1734
1735 auto data = countMetrics.data(0);
1736 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1737 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1738 EXPECT_EQ(1 /* uid field */,
1739 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1740 EXPECT_EQ(222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1741 ASSERT_EQ(1, data.bucket_info_size());
1742 EXPECT_EQ(1, data.bucket_info(0).count());
1743 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1744 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
1745
1746 data = countMetrics.data(1);
1747 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1748 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1749 EXPECT_EQ(1 /* uid field */,
1750 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1751 EXPECT_EQ(333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1752 ASSERT_EQ(1, data.bucket_info_size());
1753 EXPECT_EQ(1, data.bucket_info(0).count());
1754 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1755 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
1756
1757 data = countMetrics.data(2);
1758 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1759 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1760 EXPECT_EQ(1 /* uid field */,
1761 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1762 EXPECT_EQ(444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1763 ASSERT_EQ(1, data.bucket_info_size());
1764 EXPECT_EQ(1, data.bucket_info(0).count());
1765 // Partial bucket as metric is deactivated.
1766 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1767 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 8,
1768 data.bucket_info(0).end_bucket_elapsed_nanos());
1769
1770 data = countMetrics.data(3);
1771 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1772 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1773 EXPECT_EQ(1 /* uid field */,
1774 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1775 EXPECT_EQ(666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1776 ASSERT_EQ(1, data.bucket_info_size());
1777 EXPECT_EQ(1, data.bucket_info(0).count());
1778 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
1779 data.bucket_info(0).start_bucket_elapsed_nanos());
1780 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 11,
1781 data.bucket_info(0).end_bucket_elapsed_nanos());
1782
1783 data = countMetrics.data(4);
1784 EXPECT_EQ(util::PROCESS_LIFE_CYCLE_STATE_CHANGED, data.dimensions_in_what().field());
1785 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1786 EXPECT_EQ(1 /* uid field */,
1787 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1788 EXPECT_EQ(777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1789 ASSERT_EQ(1, data.bucket_info_size());
1790 EXPECT_EQ(1, data.bucket_info(0).count());
1791 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
1792 data.bucket_info(0).start_bucket_elapsed_nanos());
1793 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 11,
1794 data.bucket_info(0).end_bucket_elapsed_nanos());
1795
1796 countMetrics.clear_data();
1797 sortMetricDataByDimensionsValue(reports.reports(0).metrics(1).count_metrics(), &countMetrics);
1798 ASSERT_EQ(5, countMetrics.data_size());
1799
1800 data = countMetrics.data(0);
1801 EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field());
1802 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1803 EXPECT_EQ(1 /* uid field */,
1804 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1805 EXPECT_EQ(2222, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1806 ASSERT_EQ(1, data.bucket_info_size());
1807 EXPECT_EQ(1, data.bucket_info(0).count());
1808 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1809 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
1810
1811 data = countMetrics.data(1);
1812 EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field());
1813 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1814 EXPECT_EQ(1 /* uid field */,
1815 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1816 EXPECT_EQ(3333, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1817 ASSERT_EQ(1, data.bucket_info_size());
1818 EXPECT_EQ(1, data.bucket_info(0).count());
1819 EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1820 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
1821
1822 data = countMetrics.data(2);
1823 EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field());
1824 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1825 EXPECT_EQ(1 /* uid field */,
1826 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1827 EXPECT_EQ(4444, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1828 ASSERT_EQ(1, data.bucket_info_size());
1829 EXPECT_EQ(1, data.bucket_info(0).count());
1830 // Partial bucket as metric is deactivated.
1831 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
1832 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 8,
1833 data.bucket_info(0).end_bucket_elapsed_nanos());
1834
1835 data = countMetrics.data(3);
1836 EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field());
1837 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1838 EXPECT_EQ(1 /* uid field */,
1839 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1840 EXPECT_EQ(6666, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1841 ASSERT_EQ(1, data.bucket_info_size());
1842 EXPECT_EQ(1, data.bucket_info(0).count());
1843 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
1844 data.bucket_info(0).start_bucket_elapsed_nanos());
1845 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 11,
1846 data.bucket_info(0).end_bucket_elapsed_nanos());
1847
1848 data = countMetrics.data(4);
1849 EXPECT_EQ(util::ACTIVITY_FOREGROUND_STATE_CHANGED, data.dimensions_in_what().field());
1850 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1851 EXPECT_EQ(1 /* uid field */,
1852 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1853 EXPECT_EQ(7777, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
1854 ASSERT_EQ(1, data.bucket_info_size());
1855 EXPECT_EQ(1, data.bucket_info(0).count());
1856 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
1857 data.bucket_info(0).start_bucket_elapsed_nanos());
1858 EXPECT_EQ(bucketStartTimeNs + NS_PER_SEC * 60 * 11,
1859 data.bucket_info(0).end_bucket_elapsed_nanos());
1860 }
1861
1862 #else
1863 GTEST_LOG_(INFO) << "This test does nothing.\n";
1864 #endif
1865
1866 } // namespace statsd
1867 } // namespace os
1868 } // namespace android
1869