1 // Copyright (C) 2017 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 "StatsLogProcessor.h"
16
17 #include <android-base/stringprintf.h>
18 #include <android-modules-utils/sdk_level.h>
19 #include <gmock/gmock.h>
20 #include <gtest/gtest.h>
21 #include <stdio.h>
22
23 #include "StatsService.h"
24 #include "config/ConfigKey.h"
25 #include "guardrail/StatsdStats.h"
26 #include "logd/LogEvent.h"
27 #include "packages/UidMap.h"
28 #include "src/stats_log.pb.h"
29 #include "src/statsd_config.pb.h"
30 #include "state/StateManager.h"
31 #include "statslog_statsdtest.h"
32 #include "storage/StorageManager.h"
33 #include "tests/statsd_test_util.h"
34 #include "utils/DbUtils.h"
35
36 using namespace android;
37 using namespace testing;
38 using ::ndk::SharedRefBase;
39 using std::shared_ptr;
40
41 namespace android {
42 namespace os {
43 namespace statsd {
44
45 using android::base::StringPrintf;
46 using android::modules::sdklevel::IsAtLeastU;
47 using android::util::ProtoOutputStream;
48
49 using ::testing::Expectation;
50
51 #ifdef __ANDROID__
52 #define STATS_DATA_DIR "/data/misc/stats-data"
53
54 /**
55 * Mock MetricsManager (ByteSize() is called).
56 */
57 class MockMetricsManager : public MetricsManager {
58 public:
MockMetricsManager(ConfigKey configKey=ConfigKey (1,12345))59 MockMetricsManager(ConfigKey configKey = ConfigKey(1, 12345))
60 : MetricsManager(configKey, StatsdConfig(), 1000, 1000, new UidMap(),
61 new StatsPullerManager(),
62 new AlarmMonitor(
63 10, [](const shared_ptr<IStatsCompanionService>&, int64_t) {},
__anon700ef3810202(const shared_ptr<IStatsCompanionService>&) 64 [](const shared_ptr<IStatsCompanionService>&) {}),
65 new AlarmMonitor(
__anon700ef3810302(const shared_ptr<IStatsCompanionService>&, int64_t) 66 10, [](const shared_ptr<IStatsCompanionService>&, int64_t) {},
__anon700ef3810402(const shared_ptr<IStatsCompanionService>&) 67 [](const shared_ptr<IStatsCompanionService>&) {})) {
68 }
69
70 MOCK_METHOD0(byteSize, size_t());
71
72 MOCK_METHOD1(dropData, void(const int64_t dropTimeNs));
73
74 MOCK_METHOD(void, onLogEvent, (const LogEvent& event), (override));
75
76 MOCK_METHOD(void, onDumpReport,
77 (const int64_t dumpTimeNs, const int64_t wallClockNs,
78 const bool include_current_partial_bucket, const bool erase_data,
79 const DumpLatency dumpLatency, std::set<string>* str_set,
80 android::util::ProtoOutputStream* protoOutput),
81 (override));
82 };
83
TEST(StatsLogProcessorTest,TestRateLimitByteSize)84 TEST(StatsLogProcessorTest, TestRateLimitByteSize) {
85 sp<UidMap> m = new UidMap();
86 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
87 sp<AlarmMonitor> anomalyAlarmMonitor;
88 sp<AlarmMonitor> periodicAlarmMonitor;
89 // Construct the processor with a no-op sendBroadcast function that does nothing.
90 StatsLogProcessor p(
91 m, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, 0,
92 [](const ConfigKey& key) { return true; },
93 [](const int&, const vector<int64_t>&) { return true; },
94 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, nullptr);
95
96 MockMetricsManager mockMetricsManager;
97
98 ConfigKey key(100, 12345);
99 // Expect only the first flush to trigger a check for byte size since the last two are
100 // rate-limited.
101 EXPECT_CALL(mockMetricsManager, byteSize()).Times(1);
102 p.flushIfNecessaryLocked(key, mockMetricsManager);
103 p.flushIfNecessaryLocked(key, mockMetricsManager);
104 p.flushIfNecessaryLocked(key, mockMetricsManager);
105 }
106
TEST(StatsLogProcessorTest,TestRateLimitBroadcast)107 TEST(StatsLogProcessorTest, TestRateLimitBroadcast) {
108 sp<UidMap> m = new UidMap();
109 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
110 sp<AlarmMonitor> anomalyAlarmMonitor;
111 sp<AlarmMonitor> subscriberAlarmMonitor;
112 int broadcastCount = 0;
113 StatsLogProcessor p(
114 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
115 [&broadcastCount](const ConfigKey& key) {
116 broadcastCount++;
117 return true;
118 },
119 [](const int&, const vector<int64_t>&) { return true; },
120 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, nullptr);
121
122 MockMetricsManager mockMetricsManager;
123
124 ConfigKey key(100, 12345);
125 EXPECT_CALL(mockMetricsManager, byteSize())
126 .Times(1)
127 .WillRepeatedly(::testing::Return(int(
128 StatsdStats::kMaxMetricsBytesPerConfig * .95)));
129
130 // Expect only one broadcast despite always returning a size that should trigger broadcast.
131 p.flushIfNecessaryLocked(key, mockMetricsManager);
132 EXPECT_EQ(1, broadcastCount);
133
134 // b/73089712
135 // This next call to flush should not trigger a broadcast.
136 // p.mLastByteSizeTimes.clear(); // Force another check for byte size.
137 // p.flushIfNecessaryLocked(2, key, mockMetricsManager);
138 // EXPECT_EQ(1, broadcastCount);
139 }
140
TEST(StatsLogProcessorTest,TestDropWhenByteSizeTooLarge)141 TEST(StatsLogProcessorTest, TestDropWhenByteSizeTooLarge) {
142 sp<UidMap> m = new UidMap();
143 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
144 sp<AlarmMonitor> anomalyAlarmMonitor;
145 sp<AlarmMonitor> subscriberAlarmMonitor;
146 int broadcastCount = 0;
147 StatsLogProcessor p(
148 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
149 [&broadcastCount](const ConfigKey& key) {
150 broadcastCount++;
151 return true;
152 },
153 [](const int&, const vector<int64_t>&) { return true; },
154 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, nullptr);
155
156 MockMetricsManager mockMetricsManager;
157
158 ConfigKey key(100, 12345);
159 EXPECT_CALL(mockMetricsManager, byteSize())
160 .Times(1)
161 .WillRepeatedly(::testing::Return(int(StatsdStats::kMaxMetricsBytesPerConfig * 1.2)));
162
163 EXPECT_CALL(mockMetricsManager, dropData(_)).Times(1);
164
165 // Expect to call the onDumpReport and skip the broadcast.
166 p.flushIfNecessaryLocked(key, mockMetricsManager);
167 EXPECT_EQ(0, broadcastCount);
168 }
169
MakeConfig(bool includeMetric)170 StatsdConfig MakeConfig(bool includeMetric) {
171 StatsdConfig config;
172 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
173
174 if (includeMetric) {
175 auto appCrashMatcher = CreateProcessCrashAtomMatcher();
176 *config.add_atom_matcher() = appCrashMatcher;
177 auto countMetric = config.add_count_metric();
178 countMetric->set_id(StringToId("AppCrashes"));
179 countMetric->set_what(appCrashMatcher.id());
180 countMetric->set_bucket(FIVE_MINUTES);
181 }
182 return config;
183 }
184
makeRestrictedConfig(bool includeMetric=false)185 StatsdConfig makeRestrictedConfig(bool includeMetric = false) {
186 StatsdConfig config;
187 config.add_allowed_log_source("AID_ROOT");
188 config.set_restricted_metrics_delegate_package_name("delegate");
189
190 if (includeMetric) {
191 auto appCrashMatcher = CreateProcessCrashAtomMatcher();
192 *config.add_atom_matcher() = appCrashMatcher;
193 auto eventMetric = config.add_event_metric();
194 eventMetric->set_id(StringToId("EventAppCrashes"));
195 eventMetric->set_what(appCrashMatcher.id());
196 }
197 return config;
198 }
199
200 class MockRestrictedMetricsManager : public MetricsManager {
201 public:
MockRestrictedMetricsManager(ConfigKey configKey=ConfigKey (1,12345))202 MockRestrictedMetricsManager(ConfigKey configKey = ConfigKey(1, 12345))
203 : MetricsManager(configKey, makeRestrictedConfig(), 1000, 1000, new UidMap(),
204 new StatsPullerManager(),
205 new AlarmMonitor(
206 10, [](const shared_ptr<IStatsCompanionService>&, int64_t) {},
__anon700ef3810f02(const shared_ptr<IStatsCompanionService>&) 207 [](const shared_ptr<IStatsCompanionService>&) {}),
208 new AlarmMonitor(
__anon700ef3811002(const shared_ptr<IStatsCompanionService>&, int64_t) 209 10, [](const shared_ptr<IStatsCompanionService>&, int64_t) {},
__anon700ef3811102(const shared_ptr<IStatsCompanionService>&) 210 [](const shared_ptr<IStatsCompanionService>&) {})) {
211 }
212
213 MOCK_METHOD(void, onLogEvent, (const LogEvent& event), (override));
214 MOCK_METHOD(void, onDumpReport,
215 (const int64_t dumpTimeNs, const int64_t wallClockNs,
216 const bool include_current_partial_bucket, const bool erase_data,
217 const DumpLatency dumpLatency, std::set<string>* str_set,
218 android::util::ProtoOutputStream* protoOutput),
219 (override));
220 MOCK_METHOD(size_t, byteSize, (), (override));
221 MOCK_METHOD(void, flushRestrictedData, (), (override));
222 };
223
TEST(StatsLogProcessorTest,TestUidMapHasSnapshot)224 TEST(StatsLogProcessorTest, TestUidMapHasSnapshot) {
225 ConfigKey key(3, 4);
226 StatsdConfig config = MakeConfig(true);
227
228 sp<UidMap> m = new UidMap();
229 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
230 m->updateMap(1, {1, 2}, {1, 2}, {String16("v1"), String16("v2")},
231 {String16("p1"), String16("p2")}, {String16(""), String16("")},
232 /* certificateHash */ {{}, {}});
233 sp<AlarmMonitor> anomalyAlarmMonitor;
234 sp<AlarmMonitor> subscriberAlarmMonitor;
235 int broadcastCount = 0;
236 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
237 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
238 .Times(1);
239 StatsLogProcessor p(
240 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
241 [&broadcastCount](const ConfigKey& key) {
242 broadcastCount++;
243 return true;
244 },
245 [](const int&, const vector<int64_t>&) { return true; },
246 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
247
248 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
249 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &p)).Times(1);
250
251 p.OnConfigUpdated(0, key, config);
252
253 // Expect to get no metrics, but snapshot specified above in uidmap.
254 vector<uint8_t> bytes;
255 p.onDumpReport(key, 1, false, true, ADB_DUMP, FAST, &bytes);
256
257 ConfigMetricsReportList output;
258 output.ParseFromArray(bytes.data(), bytes.size());
259 EXPECT_TRUE(output.reports_size() > 0);
260 auto uidmap = output.reports(0).uid_map();
261 EXPECT_TRUE(uidmap.snapshots_size() > 0);
262 ASSERT_EQ(2, uidmap.snapshots(0).package_info_size());
263 }
264
TEST(StatsLogProcessorTest,TestEmptyConfigHasNoUidMap)265 TEST(StatsLogProcessorTest, TestEmptyConfigHasNoUidMap) {
266 // Setup simple config key corresponding to empty config.
267 ConfigKey key(3, 4);
268 StatsdConfig config = MakeConfig(false);
269
270 sp<UidMap> m = new UidMap();
271 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
272 m->updateMap(1, {1, 2}, {1, 2}, {String16("v1"), String16("v2")},
273 {String16("p1"), String16("p2")}, {String16(""), String16("")},
274 /* certificateHash */ {{}, {}});
275 sp<AlarmMonitor> anomalyAlarmMonitor;
276 sp<AlarmMonitor> subscriberAlarmMonitor;
277 int broadcastCount = 0;
278 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
279 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
280 .Times(1);
281 StatsLogProcessor p(
282 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
283 [&broadcastCount](const ConfigKey& key) {
284 broadcastCount++;
285 return true;
286 },
287 [](const int&, const vector<int64_t>&) { return true; },
288 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
289
290 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
291 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &p)).Times(1);
292
293 p.OnConfigUpdated(0, key, config);
294
295 // Expect to get no metrics, but snapshot specified above in uidmap.
296 vector<uint8_t> bytes;
297 p.onDumpReport(key, 1, false, true, ADB_DUMP, FAST, &bytes);
298
299 ConfigMetricsReportList output;
300 output.ParseFromArray(bytes.data(), bytes.size());
301 EXPECT_TRUE(output.reports_size() > 0);
302 EXPECT_FALSE(output.reports(0).has_uid_map());
303 }
304
TEST(StatsLogProcessorTest,TestReportIncludesSubConfig)305 TEST(StatsLogProcessorTest, TestReportIncludesSubConfig) {
306 // Setup simple config key corresponding to empty config.
307 ConfigKey key(3, 4);
308 StatsdConfig config;
309 auto annotation = config.add_annotation();
310 annotation->set_field_int64(1);
311 annotation->set_field_int32(2);
312 config.add_allowed_log_source("AID_ROOT");
313
314 sp<UidMap> m = new UidMap();
315 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
316 sp<AlarmMonitor> anomalyAlarmMonitor;
317 sp<AlarmMonitor> subscriberAlarmMonitor;
318 int broadcastCount = 0;
319 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
320 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
321 .Times(1);
322 StatsLogProcessor p(
323 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
324 [&broadcastCount](const ConfigKey& key) {
325 broadcastCount++;
326 return true;
327 },
328 [](const int&, const vector<int64_t>&) { return true; },
329 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
330
331 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
332 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &p)).Times(1);
333
334 p.OnConfigUpdated(1, key, config);
335
336 // Expect to get no metrics, but snapshot specified above in uidmap.
337 vector<uint8_t> bytes;
338 p.onDumpReport(key, 1, false, true, ADB_DUMP, FAST, &bytes);
339
340 ConfigMetricsReportList output;
341 output.ParseFromArray(bytes.data(), bytes.size());
342 EXPECT_TRUE(output.reports_size() > 0);
343 auto report = output.reports(0);
344 ASSERT_EQ(1, report.annotation_size());
345 EXPECT_EQ(1, report.annotation(0).field_int64());
346 EXPECT_EQ(2, report.annotation(0).field_int32());
347 }
348
TEST(StatsLogProcessorTest,TestOnDumpReportEraseData)349 TEST(StatsLogProcessorTest, TestOnDumpReportEraseData) {
350 // Setup a simple config.
351 StatsdConfig config;
352 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
353 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher();
354 *config.add_atom_matcher() = wakelockAcquireMatcher;
355
356 auto countMetric = config.add_count_metric();
357 countMetric->set_id(123456);
358 countMetric->set_what(wakelockAcquireMatcher.id());
359 countMetric->set_bucket(FIVE_MINUTES);
360
361 ConfigKey cfgKey;
362 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(1, 1, config, cfgKey);
363
364 std::vector<int> attributionUids = {111};
365 std::vector<string> attributionTags = {"App1"};
366 std::unique_ptr<LogEvent> event =
367 CreateAcquireWakelockEvent(2 /*timestamp*/, attributionUids, attributionTags, "wl1");
368 processor->OnLogEvent(event.get());
369
370 vector<uint8_t> bytes;
371 ConfigMetricsReportList output;
372
373 // Dump report WITHOUT erasing data.
374 processor->onDumpReport(cfgKey, 3, true, false /* Do NOT erase data. */, ADB_DUMP, FAST,
375 &bytes);
376 output.ParseFromArray(bytes.data(), bytes.size());
377 ASSERT_EQ(output.reports_size(), 1);
378 ASSERT_EQ(output.reports(0).metrics_size(), 1);
379 ASSERT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1);
380
381 // Dump report WITH erasing data. There should be data since we didn't previously erase it.
382 processor->onDumpReport(cfgKey, 4, true, true /* DO erase data. */, ADB_DUMP, FAST, &bytes);
383 output.ParseFromArray(bytes.data(), bytes.size());
384 ASSERT_EQ(output.reports_size(), 1);
385 ASSERT_EQ(output.reports(0).metrics_size(), 1);
386 ASSERT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1);
387
388 // Dump report again. There should be no data since we erased it.
389 processor->onDumpReport(cfgKey, 5, true, true /* DO erase data. */, ADB_DUMP, FAST, &bytes);
390 output.ParseFromArray(bytes.data(), bytes.size());
391 // We don't care whether statsd has a report, as long as it has no count metrics in it.
392 bool noData = output.reports_size() == 0 || output.reports(0).metrics_size() == 0 ||
393 output.reports(0).metrics(0).count_metrics().data_size() == 0;
394 EXPECT_TRUE(noData);
395 }
396
TEST(StatsLogProcessorTest,TestPullUidProviderSetOnConfigUpdate)397 TEST(StatsLogProcessorTest, TestPullUidProviderSetOnConfigUpdate) {
398 // Setup simple config key corresponding to empty config.
399 ConfigKey key(3, 4);
400 StatsdConfig config = MakeConfig(false);
401
402 sp<UidMap> m = new UidMap();
403 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
404 sp<AlarmMonitor> anomalyAlarmMonitor;
405 sp<AlarmMonitor> subscriberAlarmMonitor;
406 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
407 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
408 .Times(1);
409 StatsLogProcessor p(
410 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
411 [](const ConfigKey& key) { return true; },
412 [](const int&, const vector<int64_t>&) { return true; },
413 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
414
415 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
416 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &p)).Times(3);
417
418 p.OnConfigUpdated(0, key, config);
419 EXPECT_NE(pullerManager->mPullUidProviders.find(key), pullerManager->mPullUidProviders.end());
420
421 config.add_default_pull_packages("AID_STATSD");
422 p.OnConfigUpdated(5, key, config);
423 EXPECT_NE(pullerManager->mPullUidProviders.find(key), pullerManager->mPullUidProviders.end());
424
425 p.OnConfigRemoved(key);
426 EXPECT_EQ(pullerManager->mPullUidProviders.find(key), pullerManager->mPullUidProviders.end());
427 }
428
TEST(StatsLogProcessorTest,InvalidConfigRemoved)429 TEST(StatsLogProcessorTest, InvalidConfigRemoved) {
430 ConfigKey key(3, 4);
431 StatsdConfig config = MakeConfig(true);
432
433 sp<UidMap> m = new UidMap();
434 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
435 m->updateMap(1, {1, 2}, {1, 2}, {String16("v1"), String16("v2")},
436 {String16("p1"), String16("p2")}, {String16(""), String16("")},
437 /* certificateHash */ {{}, {}});
438 sp<AlarmMonitor> anomalyAlarmMonitor;
439 sp<AlarmMonitor> subscriberAlarmMonitor;
440 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
441 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
442 .Times(1);
443 StatsLogProcessor p(
444 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
445 [](const ConfigKey& key) { return true; },
446 [](const int&, const vector<int64_t>&) { return true; },
447 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
448
449 EXPECT_CALL(*mockLogEventFilter, setAtomIds(CreateAtomIdSetDefault(), &p)).Times(1);
450 // atom used by matcher defined in MakeConfig() API
451 Expectation exp =
452 EXPECT_CALL(*mockLogEventFilter, setAtomIds(CreateAtomIdSetFromConfig(config), &p))
453 .Times(1);
454 EXPECT_CALL(*mockLogEventFilter, setAtomIds(CreateAtomIdSetDefault(), &p)).Times(1).After(exp);
455
456 // Remove the config mConfigStats so that the Icebox starts at 0 configs.
457 p.OnConfigRemoved(key);
458 StatsdStats::getInstance().reset();
459 p.OnConfigUpdated(0, key, config);
460 EXPECT_EQ(1, p.mMetricsManagers.size());
461 EXPECT_NE(p.mMetricsManagers.find(key), p.mMetricsManagers.end());
462 // Cannot assert the size of mConfigStats since it is static and does not get cleared on reset.
463 EXPECT_NE(StatsdStats::getInstance().mConfigStats.end(),
464 StatsdStats::getInstance().mConfigStats.find(key));
465 EXPECT_EQ(0, StatsdStats::getInstance().mIceBox.size());
466
467 StatsdConfig invalidConfig = MakeConfig(true);
468 invalidConfig.clear_allowed_log_source();
469 p.OnConfigUpdated(0, key, invalidConfig);
470 EXPECT_EQ(0, p.mMetricsManagers.size());
471 // The current configs should not contain the invalid config.
472 EXPECT_EQ(StatsdStats::getInstance().mConfigStats.end(),
473 StatsdStats::getInstance().mConfigStats.find(key));
474 // Both "config" and "invalidConfig" should be in the icebox.
475 EXPECT_EQ(2, StatsdStats::getInstance().mIceBox.size());
476 string suffix = StringPrintf("%d_%lld", key.GetUid(), (long long)key.GetId());
477 StorageManager::deleteSuffixedFiles(STATS_DATA_DIR, suffix.c_str());
478 }
479
TEST(StatsLogProcessorTest,TestActiveConfigMetricDiskWriteRead)480 TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) {
481 int uid = 1111;
482
483 // Setup a simple config, no activation
484 StatsdConfig config1;
485 int64_t cfgId1 = 12341;
486 config1.set_id(cfgId1);
487 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
488 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher();
489 *config1.add_atom_matcher() = wakelockAcquireMatcher;
490
491 long metricId1 = 1234561;
492 long metricId2 = 1234562;
493 auto countMetric1 = config1.add_count_metric();
494 countMetric1->set_id(metricId1);
495 countMetric1->set_what(wakelockAcquireMatcher.id());
496 countMetric1->set_bucket(FIVE_MINUTES);
497
498 auto countMetric2 = config1.add_count_metric();
499 countMetric2->set_id(metricId2);
500 countMetric2->set_what(wakelockAcquireMatcher.id());
501 countMetric2->set_bucket(FIVE_MINUTES);
502
503 ConfigKey cfgKey1(uid, cfgId1);
504
505 // Add another config, with two metrics, one with activation
506 StatsdConfig config2;
507 int64_t cfgId2 = 12342;
508 config2.set_id(cfgId2);
509 config2.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
510 *config2.add_atom_matcher() = wakelockAcquireMatcher;
511
512 long metricId3 = 1234561;
513 long metricId4 = 1234562;
514
515 auto countMetric3 = config2.add_count_metric();
516 countMetric3->set_id(metricId3);
517 countMetric3->set_what(wakelockAcquireMatcher.id());
518 countMetric3->set_bucket(FIVE_MINUTES);
519
520 auto countMetric4 = config2.add_count_metric();
521 countMetric4->set_id(metricId4);
522 countMetric4->set_what(wakelockAcquireMatcher.id());
523 countMetric4->set_bucket(FIVE_MINUTES);
524
525 auto metric3Activation = config2.add_metric_activation();
526 metric3Activation->set_metric_id(metricId3);
527 metric3Activation->set_activation_type(ACTIVATE_IMMEDIATELY);
528 auto metric3ActivationTrigger = metric3Activation->add_event_activation();
529 metric3ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id());
530 metric3ActivationTrigger->set_ttl_seconds(100);
531
532 ConfigKey cfgKey2(uid, cfgId2);
533
534 // Add another config, with two metrics, both with activations
535 StatsdConfig config3;
536 int64_t cfgId3 = 12343;
537 config3.set_id(cfgId3);
538 config3.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
539 *config3.add_atom_matcher() = wakelockAcquireMatcher;
540
541 long metricId5 = 1234565;
542 long metricId6 = 1234566;
543 auto countMetric5 = config3.add_count_metric();
544 countMetric5->set_id(metricId5);
545 countMetric5->set_what(wakelockAcquireMatcher.id());
546 countMetric5->set_bucket(FIVE_MINUTES);
547
548 auto countMetric6 = config3.add_count_metric();
549 countMetric6->set_id(metricId6);
550 countMetric6->set_what(wakelockAcquireMatcher.id());
551 countMetric6->set_bucket(FIVE_MINUTES);
552
553 auto metric5Activation = config3.add_metric_activation();
554 metric5Activation->set_metric_id(metricId5);
555 metric5Activation->set_activation_type(ACTIVATE_IMMEDIATELY);
556 auto metric5ActivationTrigger = metric5Activation->add_event_activation();
557 metric5ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id());
558 metric5ActivationTrigger->set_ttl_seconds(100);
559
560 auto metric6Activation = config3.add_metric_activation();
561 metric6Activation->set_metric_id(metricId6);
562 metric6Activation->set_activation_type(ACTIVATE_IMMEDIATELY);
563 auto metric6ActivationTrigger = metric6Activation->add_event_activation();
564 metric6ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id());
565 metric6ActivationTrigger->set_ttl_seconds(200);
566
567 ConfigKey cfgKey3(uid, cfgId3);
568
569 sp<UidMap> m = new UidMap();
570 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
571 sp<AlarmMonitor> anomalyAlarmMonitor;
572 sp<AlarmMonitor> subscriberAlarmMonitor;
573 vector<int64_t> activeConfigsBroadcast;
574
575 long timeBase1 = 1;
576 int broadcastCount = 0;
577 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
578 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
579 .Times(1);
580 StatsLogProcessor processor(
581 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, timeBase1,
582 [](const ConfigKey& key) { return true; },
583 [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,
584 const vector<int64_t>& activeConfigs) {
585 broadcastCount++;
586 EXPECT_EQ(broadcastUid, uid);
587 activeConfigsBroadcast.clear();
588 activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), activeConfigs.begin(),
589 activeConfigs.end());
590 return true;
591 },
592 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
593
594 // config1,config2,config3 use the same atom
595 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config1);
596 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &processor)).Times(3);
597
598 processor.OnConfigUpdated(1, cfgKey1, config1);
599 processor.OnConfigUpdated(2, cfgKey2, config2);
600 processor.OnConfigUpdated(3, cfgKey3, config3);
601
602 ASSERT_EQ(3, processor.mMetricsManagers.size());
603
604 // Expect the first config and both metrics in it to be active.
605 auto it = processor.mMetricsManagers.find(cfgKey1);
606 EXPECT_TRUE(it != processor.mMetricsManagers.end());
607 auto& metricsManager1 = it->second;
608 EXPECT_TRUE(metricsManager1->isActive());
609
610 auto metricIt = metricsManager1->mAllMetricProducers.begin();
611 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {
612 if ((*metricIt)->getMetricId() == metricId1) {
613 break;
614 }
615 }
616 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());
617 auto& metricProducer1 = *metricIt;
618 EXPECT_TRUE(metricProducer1->isActive());
619
620 metricIt = metricsManager1->mAllMetricProducers.begin();
621 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {
622 if ((*metricIt)->getMetricId() == metricId2) {
623 break;
624 }
625 }
626 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());
627 auto& metricProducer2 = *metricIt;
628 EXPECT_TRUE(metricProducer2->isActive());
629
630 // Expect config 2 to be active. Metric 3 shouldn't be active, metric 4 should be active.
631 it = processor.mMetricsManagers.find(cfgKey2);
632 EXPECT_TRUE(it != processor.mMetricsManagers.end());
633 auto& metricsManager2 = it->second;
634 EXPECT_TRUE(metricsManager2->isActive());
635
636 metricIt = metricsManager2->mAllMetricProducers.begin();
637 for (; metricIt != metricsManager2->mAllMetricProducers.end(); metricIt++) {
638 if ((*metricIt)->getMetricId() == metricId3) {
639 break;
640 }
641 }
642 EXPECT_TRUE(metricIt != metricsManager2->mAllMetricProducers.end());
643 auto& metricProducer3 = *metricIt;
644 EXPECT_FALSE(metricProducer3->isActive());
645
646 metricIt = metricsManager2->mAllMetricProducers.begin();
647 for (; metricIt != metricsManager2->mAllMetricProducers.end(); metricIt++) {
648 if ((*metricIt)->getMetricId() == metricId4) {
649 break;
650 }
651 }
652 EXPECT_TRUE(metricIt != metricsManager2->mAllMetricProducers.end());
653 auto& metricProducer4 = *metricIt;
654 EXPECT_TRUE(metricProducer4->isActive());
655
656 // Expect the third config and both metrics in it to be inactive.
657 it = processor.mMetricsManagers.find(cfgKey3);
658 EXPECT_TRUE(it != processor.mMetricsManagers.end());
659 auto& metricsManager3 = it->second;
660 EXPECT_FALSE(metricsManager3->isActive());
661
662 metricIt = metricsManager3->mAllMetricProducers.begin();
663 for (; metricIt != metricsManager2->mAllMetricProducers.end(); metricIt++) {
664 if ((*metricIt)->getMetricId() == metricId5) {
665 break;
666 }
667 }
668 EXPECT_TRUE(metricIt != metricsManager3->mAllMetricProducers.end());
669 auto& metricProducer5 = *metricIt;
670 EXPECT_FALSE(metricProducer5->isActive());
671
672 metricIt = metricsManager3->mAllMetricProducers.begin();
673 for (; metricIt != metricsManager3->mAllMetricProducers.end(); metricIt++) {
674 if ((*metricIt)->getMetricId() == metricId6) {
675 break;
676 }
677 }
678 EXPECT_TRUE(metricIt != metricsManager3->mAllMetricProducers.end());
679 auto& metricProducer6 = *metricIt;
680 EXPECT_FALSE(metricProducer6->isActive());
681
682 // No broadcast for active configs should have happened yet.
683 EXPECT_EQ(broadcastCount, 0);
684
685 // Activate all 3 metrics that were not active.
686 std::vector<int> attributionUids = {111};
687 std::vector<string> attributionTags = {"App1"};
688 std::unique_ptr<LogEvent> event =
689 CreateAcquireWakelockEvent(timeBase1 + 100, attributionUids, attributionTags, "wl1");
690 processor.OnLogEvent(event.get());
691
692 // Assert that all 3 configs are active.
693 EXPECT_TRUE(metricsManager1->isActive());
694 EXPECT_TRUE(metricsManager2->isActive());
695 EXPECT_TRUE(metricsManager3->isActive());
696
697 // A broadcast should have happened, and all 3 configs should be active in the broadcast.
698 EXPECT_EQ(broadcastCount, 1);
699 ASSERT_EQ(activeConfigsBroadcast.size(), 3);
700 EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId1) !=
701 activeConfigsBroadcast.end());
702 EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId2) !=
703 activeConfigsBroadcast.end());
704 EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId3) !=
705 activeConfigsBroadcast.end());
706
707 // When we shut down, metrics 3 & 5 have 100ns remaining, metric 6 has 100s + 100ns.
708 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC;
709 processor.SaveActiveConfigsToDisk(shutDownTime);
710 const int64_t ttl3 = event->GetElapsedTimestampNs() +
711 metric3ActivationTrigger->ttl_seconds() * NS_PER_SEC - shutDownTime;
712 const int64_t ttl5 = event->GetElapsedTimestampNs() +
713 metric5ActivationTrigger->ttl_seconds() * NS_PER_SEC - shutDownTime;
714 const int64_t ttl6 = event->GetElapsedTimestampNs() +
715 metric6ActivationTrigger->ttl_seconds() * NS_PER_SEC - shutDownTime;
716
717 // Create a second StatsLogProcessor and push the same 3 configs.
718 long timeBase2 = 1000;
719 sp<StatsLogProcessor> processor2 =
720 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1);
721 processor2->OnConfigUpdated(timeBase2, cfgKey2, config2);
722 processor2->OnConfigUpdated(timeBase2, cfgKey3, config3);
723
724 ASSERT_EQ(3, processor2->mMetricsManagers.size());
725
726 // First config and both metrics are active.
727 it = processor2->mMetricsManagers.find(cfgKey1);
728 EXPECT_TRUE(it != processor2->mMetricsManagers.end());
729 auto& metricsManager1001 = it->second;
730 EXPECT_TRUE(metricsManager1001->isActive());
731
732 metricIt = metricsManager1001->mAllMetricProducers.begin();
733 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {
734 if ((*metricIt)->getMetricId() == metricId1) {
735 break;
736 }
737 }
738 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());
739 auto& metricProducer1001 = *metricIt;
740 EXPECT_TRUE(metricProducer1001->isActive());
741
742 metricIt = metricsManager1001->mAllMetricProducers.begin();
743 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {
744 if ((*metricIt)->getMetricId() == metricId2) {
745 break;
746 }
747 }
748 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());
749 auto& metricProducer1002 = *metricIt;
750 EXPECT_TRUE(metricProducer1002->isActive());
751
752 // Second config is active. Metric 3 is inactive, metric 4 is active.
753 it = processor2->mMetricsManagers.find(cfgKey2);
754 EXPECT_TRUE(it != processor2->mMetricsManagers.end());
755 auto& metricsManager1002 = it->second;
756 EXPECT_TRUE(metricsManager1002->isActive());
757
758 metricIt = metricsManager1002->mAllMetricProducers.begin();
759 for (; metricIt != metricsManager1002->mAllMetricProducers.end(); metricIt++) {
760 if ((*metricIt)->getMetricId() == metricId3) {
761 break;
762 }
763 }
764 EXPECT_TRUE(metricIt != metricsManager1002->mAllMetricProducers.end());
765 auto& metricProducer1003 = *metricIt;
766 EXPECT_FALSE(metricProducer1003->isActive());
767
768 metricIt = metricsManager1002->mAllMetricProducers.begin();
769 for (; metricIt != metricsManager1002->mAllMetricProducers.end(); metricIt++) {
770 if ((*metricIt)->getMetricId() == metricId4) {
771 break;
772 }
773 }
774 EXPECT_TRUE(metricIt != metricsManager1002->mAllMetricProducers.end());
775 auto& metricProducer1004 = *metricIt;
776 EXPECT_TRUE(metricProducer1004->isActive());
777
778 // Config 3 is inactive. both metrics are inactive.
779 it = processor2->mMetricsManagers.find(cfgKey3);
780 EXPECT_TRUE(it != processor2->mMetricsManagers.end());
781 auto& metricsManager1003 = it->second;
782 EXPECT_FALSE(metricsManager1003->isActive());
783 ASSERT_EQ(2, metricsManager1003->mAllMetricProducers.size());
784
785 metricIt = metricsManager1003->mAllMetricProducers.begin();
786 for (; metricIt != metricsManager1002->mAllMetricProducers.end(); metricIt++) {
787 if ((*metricIt)->getMetricId() == metricId5) {
788 break;
789 }
790 }
791 EXPECT_TRUE(metricIt != metricsManager1003->mAllMetricProducers.end());
792 auto& metricProducer1005 = *metricIt;
793 EXPECT_FALSE(metricProducer1005->isActive());
794
795 metricIt = metricsManager1003->mAllMetricProducers.begin();
796 for (; metricIt != metricsManager1003->mAllMetricProducers.end(); metricIt++) {
797 if ((*metricIt)->getMetricId() == metricId6) {
798 break;
799 }
800 }
801 EXPECT_TRUE(metricIt != metricsManager1003->mAllMetricProducers.end());
802 auto& metricProducer1006 = *metricIt;
803 EXPECT_FALSE(metricProducer1006->isActive());
804
805 // Assert that all 3 metrics with activation are inactive and that the ttls were properly set.
806 EXPECT_FALSE(metricProducer1003->isActive());
807 const auto& activation1003 = metricProducer1003->mEventActivationMap.begin()->second;
808 EXPECT_EQ(100 * NS_PER_SEC, activation1003->ttl_ns);
809 EXPECT_EQ(0, activation1003->start_ns);
810 EXPECT_FALSE(metricProducer1005->isActive());
811 const auto& activation1005 = metricProducer1005->mEventActivationMap.begin()->second;
812 EXPECT_EQ(100 * NS_PER_SEC, activation1005->ttl_ns);
813 EXPECT_EQ(0, activation1005->start_ns);
814 EXPECT_FALSE(metricProducer1006->isActive());
815 const auto& activation1006 = metricProducer1006->mEventActivationMap.begin()->second;
816 EXPECT_EQ(200 * NS_PER_SEC, activation1006->ttl_ns);
817 EXPECT_EQ(0, activation1006->start_ns);
818
819 processor2->LoadActiveConfigsFromDisk();
820
821 // After loading activations from disk, assert that all 3 metrics are active.
822 EXPECT_TRUE(metricProducer1003->isActive());
823 EXPECT_EQ(timeBase2 + ttl3 - activation1003->ttl_ns, activation1003->start_ns);
824 EXPECT_TRUE(metricProducer1005->isActive());
825 EXPECT_EQ(timeBase2 + ttl5 - activation1005->ttl_ns, activation1005->start_ns);
826 EXPECT_TRUE(metricProducer1006->isActive());
827 EXPECT_EQ(timeBase2 + ttl6 - activation1006->ttl_ns, activation1003->start_ns);
828
829 // Make sure no more broadcasts have happened.
830 EXPECT_EQ(broadcastCount, 1);
831 }
832
TEST(StatsLogProcessorTest,TestActivationOnBoot)833 TEST(StatsLogProcessorTest, TestActivationOnBoot) {
834 int uid = 1111;
835
836 StatsdConfig config1;
837 config1.set_id(12341);
838 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
839 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher();
840 *config1.add_atom_matcher() = wakelockAcquireMatcher;
841
842 long metricId1 = 1234561;
843 long metricId2 = 1234562;
844 auto countMetric1 = config1.add_count_metric();
845 countMetric1->set_id(metricId1);
846 countMetric1->set_what(wakelockAcquireMatcher.id());
847 countMetric1->set_bucket(FIVE_MINUTES);
848
849 auto countMetric2 = config1.add_count_metric();
850 countMetric2->set_id(metricId2);
851 countMetric2->set_what(wakelockAcquireMatcher.id());
852 countMetric2->set_bucket(FIVE_MINUTES);
853
854 auto metric1Activation = config1.add_metric_activation();
855 metric1Activation->set_metric_id(metricId1);
856 metric1Activation->set_activation_type(ACTIVATE_ON_BOOT);
857 auto metric1ActivationTrigger = metric1Activation->add_event_activation();
858 metric1ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id());
859 metric1ActivationTrigger->set_ttl_seconds(100);
860
861 ConfigKey cfgKey1(uid, 12341);
862 long timeBase1 = 1;
863 sp<StatsLogProcessor> processor =
864 CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1);
865
866 ASSERT_EQ(1, processor->mMetricsManagers.size());
867 auto it = processor->mMetricsManagers.find(cfgKey1);
868 EXPECT_TRUE(it != processor->mMetricsManagers.end());
869 auto& metricsManager1 = it->second;
870 EXPECT_TRUE(metricsManager1->isActive());
871
872 auto metricIt = metricsManager1->mAllMetricProducers.begin();
873 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {
874 if ((*metricIt)->getMetricId() == metricId1) {
875 break;
876 }
877 }
878 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());
879 auto& metricProducer1 = *metricIt;
880 EXPECT_FALSE(metricProducer1->isActive());
881
882 metricIt = metricsManager1->mAllMetricProducers.begin();
883 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {
884 if ((*metricIt)->getMetricId() == metricId2) {
885 break;
886 }
887 }
888 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());
889 auto& metricProducer2 = *metricIt;
890 EXPECT_TRUE(metricProducer2->isActive());
891
892 const auto& activation1 = metricProducer1->mEventActivationMap.begin()->second;
893 EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns);
894 EXPECT_EQ(0, activation1->start_ns);
895 EXPECT_EQ(kNotActive, activation1->state);
896
897 std::vector<int> attributionUids = {111};
898 std::vector<string> attributionTags = {"App1"};
899 std::unique_ptr<LogEvent> event =
900 CreateAcquireWakelockEvent(timeBase1 + 100, attributionUids, attributionTags, "wl1");
901 processor->OnLogEvent(event.get());
902
903 EXPECT_FALSE(metricProducer1->isActive());
904 EXPECT_EQ(0, activation1->start_ns);
905 EXPECT_EQ(kActiveOnBoot, activation1->state);
906
907 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC;
908 processor->SaveActiveConfigsToDisk(shutDownTime);
909 EXPECT_FALSE(metricProducer1->isActive());
910 const int64_t ttl1 = metric1ActivationTrigger->ttl_seconds() * NS_PER_SEC;
911
912 long timeBase2 = 1000;
913 sp<StatsLogProcessor> processor2 =
914 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1);
915
916 ASSERT_EQ(1, processor2->mMetricsManagers.size());
917 it = processor2->mMetricsManagers.find(cfgKey1);
918 EXPECT_TRUE(it != processor2->mMetricsManagers.end());
919 auto& metricsManager1001 = it->second;
920 EXPECT_TRUE(metricsManager1001->isActive());
921
922 metricIt = metricsManager1001->mAllMetricProducers.begin();
923 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {
924 if ((*metricIt)->getMetricId() == metricId1) {
925 break;
926 }
927 }
928 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());
929 auto& metricProducer1001 = *metricIt;
930 EXPECT_FALSE(metricProducer1001->isActive());
931
932 metricIt = metricsManager1001->mAllMetricProducers.begin();
933 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {
934 if ((*metricIt)->getMetricId() == metricId2) {
935 break;
936 }
937 }
938 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());
939 auto& metricProducer1002 = *metricIt;
940 EXPECT_TRUE(metricProducer1002->isActive());
941
942 const auto& activation1001 = metricProducer1001->mEventActivationMap.begin()->second;
943 EXPECT_EQ(100 * NS_PER_SEC, activation1001->ttl_ns);
944 EXPECT_EQ(0, activation1001->start_ns);
945 EXPECT_EQ(kNotActive, activation1001->state);
946
947 processor2->LoadActiveConfigsFromDisk();
948
949 EXPECT_TRUE(metricProducer1001->isActive());
950 EXPECT_EQ(timeBase2 + ttl1 - activation1001->ttl_ns, activation1001->start_ns);
951 EXPECT_EQ(kActive, activation1001->state);
952 }
953
TEST(StatsLogProcessorTest,TestActivationOnBootMultipleActivations)954 TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) {
955 int uid = 1111;
956
957 // Create config with 2 metrics:
958 // Metric 1: Activate on boot with 2 activations
959 // Metric 2: Always active
960 StatsdConfig config1;
961 config1.set_id(12341);
962 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
963 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher();
964 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
965 *config1.add_atom_matcher() = wakelockAcquireMatcher;
966 *config1.add_atom_matcher() = screenOnMatcher;
967
968 long metricId1 = 1234561;
969 long metricId2 = 1234562;
970
971 auto countMetric1 = config1.add_count_metric();
972 countMetric1->set_id(metricId1);
973 countMetric1->set_what(wakelockAcquireMatcher.id());
974 countMetric1->set_bucket(FIVE_MINUTES);
975
976 auto countMetric2 = config1.add_count_metric();
977 countMetric2->set_id(metricId2);
978 countMetric2->set_what(wakelockAcquireMatcher.id());
979 countMetric2->set_bucket(FIVE_MINUTES);
980
981 auto metric1Activation = config1.add_metric_activation();
982 metric1Activation->set_metric_id(metricId1);
983 metric1Activation->set_activation_type(ACTIVATE_ON_BOOT);
984 auto metric1ActivationTrigger1 = metric1Activation->add_event_activation();
985 metric1ActivationTrigger1->set_atom_matcher_id(wakelockAcquireMatcher.id());
986 metric1ActivationTrigger1->set_ttl_seconds(100);
987 auto metric1ActivationTrigger2 = metric1Activation->add_event_activation();
988 metric1ActivationTrigger2->set_atom_matcher_id(screenOnMatcher.id());
989 metric1ActivationTrigger2->set_ttl_seconds(200);
990
991 ConfigKey cfgKey1(uid, 12341);
992 long timeBase1 = 1;
993 sp<StatsLogProcessor> processor =
994 CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1);
995
996 // Metric 1 is not active.
997 // Metric 2 is active.
998 // {{{---------------------------------------------------------------------------
999 ASSERT_EQ(1, processor->mMetricsManagers.size());
1000 auto it = processor->mMetricsManagers.find(cfgKey1);
1001 EXPECT_TRUE(it != processor->mMetricsManagers.end());
1002 auto& metricsManager1 = it->second;
1003 EXPECT_TRUE(metricsManager1->isActive());
1004
1005 auto metricIt = metricsManager1->mAllMetricProducers.begin();
1006 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {
1007 if ((*metricIt)->getMetricId() == metricId1) {
1008 break;
1009 }
1010 }
1011 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());
1012 auto& metricProducer1 = *metricIt;
1013 EXPECT_FALSE(metricProducer1->isActive());
1014
1015 metricIt = metricsManager1->mAllMetricProducers.begin();
1016 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) {
1017 if ((*metricIt)->getMetricId() == metricId2) {
1018 break;
1019 }
1020 }
1021 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end());
1022 auto& metricProducer2 = *metricIt;
1023 EXPECT_TRUE(metricProducer2->isActive());
1024
1025 int i = 0;
1026 for (; i < metricsManager1->mAllAtomMatchingTrackers.size(); i++) {
1027 if (metricsManager1->mAllAtomMatchingTrackers[i]->getId() ==
1028 metric1ActivationTrigger1->atom_matcher_id()) {
1029 break;
1030 }
1031 }
1032 const auto& activation1 = metricProducer1->mEventActivationMap.at(i);
1033 EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns);
1034 EXPECT_EQ(0, activation1->start_ns);
1035 EXPECT_EQ(kNotActive, activation1->state);
1036
1037 i = 0;
1038 for (; i < metricsManager1->mAllAtomMatchingTrackers.size(); i++) {
1039 if (metricsManager1->mAllAtomMatchingTrackers[i]->getId() ==
1040 metric1ActivationTrigger2->atom_matcher_id()) {
1041 break;
1042 }
1043 }
1044 const auto& activation2 = metricProducer1->mEventActivationMap.at(i);
1045 EXPECT_EQ(200 * NS_PER_SEC, activation2->ttl_ns);
1046 EXPECT_EQ(0, activation2->start_ns);
1047 EXPECT_EQ(kNotActive, activation2->state);
1048 // }}}------------------------------------------------------------------------------
1049
1050 // Trigger Activation 1 for Metric 1
1051 std::vector<int> attributionUids = {111};
1052 std::vector<string> attributionTags = {"App1"};
1053 std::unique_ptr<LogEvent> event =
1054 CreateAcquireWakelockEvent(timeBase1 + 100, attributionUids, attributionTags, "wl1");
1055 processor->OnLogEvent(event.get());
1056
1057 // Metric 1 is not active; Activation 1 set to kActiveOnBoot
1058 // Metric 2 is active.
1059 // {{{---------------------------------------------------------------------------
1060 EXPECT_FALSE(metricProducer1->isActive());
1061 EXPECT_EQ(0, activation1->start_ns);
1062 EXPECT_EQ(kActiveOnBoot, activation1->state);
1063 EXPECT_EQ(0, activation2->start_ns);
1064 EXPECT_EQ(kNotActive, activation2->state);
1065
1066 EXPECT_TRUE(metricProducer2->isActive());
1067 // }}}-----------------------------------------------------------------------------
1068
1069 // Simulate shutdown by saving state to disk
1070 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC;
1071 processor->SaveActiveConfigsToDisk(shutDownTime);
1072 EXPECT_FALSE(metricProducer1->isActive());
1073 int64_t ttl1 = metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC;
1074
1075 // Simulate device restarted state by creating new instance of StatsLogProcessor with the
1076 // same config.
1077 long timeBase2 = 1000;
1078 sp<StatsLogProcessor> processor2 =
1079 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1);
1080
1081 // Metric 1 is not active.
1082 // Metric 2 is active.
1083 // {{{---------------------------------------------------------------------------
1084 ASSERT_EQ(1, processor2->mMetricsManagers.size());
1085 it = processor2->mMetricsManagers.find(cfgKey1);
1086 EXPECT_TRUE(it != processor2->mMetricsManagers.end());
1087 auto& metricsManager1001 = it->second;
1088 EXPECT_TRUE(metricsManager1001->isActive());
1089
1090 metricIt = metricsManager1001->mAllMetricProducers.begin();
1091 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {
1092 if ((*metricIt)->getMetricId() == metricId1) {
1093 break;
1094 }
1095 }
1096 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());
1097 auto& metricProducer1001 = *metricIt;
1098 EXPECT_FALSE(metricProducer1001->isActive());
1099
1100 metricIt = metricsManager1001->mAllMetricProducers.begin();
1101 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) {
1102 if ((*metricIt)->getMetricId() == metricId2) {
1103 break;
1104 }
1105 }
1106 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end());
1107 auto& metricProducer1002 = *metricIt;
1108 EXPECT_TRUE(metricProducer1002->isActive());
1109
1110 i = 0;
1111 for (; i < metricsManager1001->mAllAtomMatchingTrackers.size(); i++) {
1112 if (metricsManager1001->mAllAtomMatchingTrackers[i]->getId() ==
1113 metric1ActivationTrigger1->atom_matcher_id()) {
1114 break;
1115 }
1116 }
1117 const auto& activation1001_1 = metricProducer1001->mEventActivationMap.at(i);
1118 EXPECT_EQ(100 * NS_PER_SEC, activation1001_1->ttl_ns);
1119 EXPECT_EQ(0, activation1001_1->start_ns);
1120 EXPECT_EQ(kNotActive, activation1001_1->state);
1121
1122 i = 0;
1123 for (; i < metricsManager1001->mAllAtomMatchingTrackers.size(); i++) {
1124 if (metricsManager1001->mAllAtomMatchingTrackers[i]->getId() ==
1125 metric1ActivationTrigger2->atom_matcher_id()) {
1126 break;
1127 }
1128 }
1129
1130 const auto& activation1001_2 = metricProducer1001->mEventActivationMap.at(i);
1131 EXPECT_EQ(200 * NS_PER_SEC, activation1001_2->ttl_ns);
1132 EXPECT_EQ(0, activation1001_2->start_ns);
1133 EXPECT_EQ(kNotActive, activation1001_2->state);
1134 // }}}-----------------------------------------------------------------------------------
1135
1136 // Load saved state from disk.
1137 processor2->LoadActiveConfigsFromDisk();
1138
1139 // Metric 1 active; Activation 1 is active, Activation 2 is not active
1140 // Metric 2 is active.
1141 // {{{---------------------------------------------------------------------------
1142 EXPECT_TRUE(metricProducer1001->isActive());
1143 EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns);
1144 EXPECT_EQ(kActive, activation1001_1->state);
1145 EXPECT_EQ(0, activation1001_2->start_ns);
1146 EXPECT_EQ(kNotActive, activation1001_2->state);
1147
1148 EXPECT_TRUE(metricProducer1002->isActive());
1149 // }}}--------------------------------------------------------------------------------
1150
1151 // Trigger Activation 2 for Metric 1.
1152 auto screenOnEvent =
1153 CreateScreenStateChangedEvent(timeBase2 + 200, android::view::DISPLAY_STATE_ON);
1154 processor2->OnLogEvent(screenOnEvent.get());
1155
1156 // Metric 1 active; Activation 1 is active, Activation 2 is set to kActiveOnBoot
1157 // Metric 2 is active.
1158 // {{{---------------------------------------------------------------------------
1159 EXPECT_TRUE(metricProducer1001->isActive());
1160 EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns);
1161 EXPECT_EQ(kActive, activation1001_1->state);
1162 EXPECT_EQ(0, activation1001_2->start_ns);
1163 EXPECT_EQ(kActiveOnBoot, activation1001_2->state);
1164
1165 EXPECT_TRUE(metricProducer1002->isActive());
1166 // }}}---------------------------------------------------------------------------
1167
1168 // Simulate shutdown by saving state to disk
1169 shutDownTime = timeBase2 + 50 * NS_PER_SEC;
1170 processor2->SaveActiveConfigsToDisk(shutDownTime);
1171 EXPECT_TRUE(metricProducer1001->isActive());
1172 EXPECT_TRUE(metricProducer1002->isActive());
1173 ttl1 = timeBase2 + metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC - shutDownTime;
1174 int64_t ttl2 = metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC;
1175
1176 // Simulate device restarted state by creating new instance of StatsLogProcessor with the
1177 // same config.
1178 long timeBase3 = timeBase2 + 120 * NS_PER_SEC;
1179 sp<StatsLogProcessor> processor3 =
1180 CreateStatsLogProcessor(timeBase3, timeBase3, config1, cfgKey1);
1181
1182 // Metric 1 is not active.
1183 // Metric 2 is active.
1184 // {{{---------------------------------------------------------------------------
1185 ASSERT_EQ(1, processor3->mMetricsManagers.size());
1186 it = processor3->mMetricsManagers.find(cfgKey1);
1187 EXPECT_TRUE(it != processor3->mMetricsManagers.end());
1188 auto& metricsManagerTimeBase3 = it->second;
1189 EXPECT_TRUE(metricsManagerTimeBase3->isActive());
1190
1191 metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin();
1192 for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) {
1193 if ((*metricIt)->getMetricId() == metricId1) {
1194 break;
1195 }
1196 }
1197 EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end());
1198 auto& metricProducerTimeBase3_1 = *metricIt;
1199 EXPECT_FALSE(metricProducerTimeBase3_1->isActive());
1200
1201 metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin();
1202 for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) {
1203 if ((*metricIt)->getMetricId() == metricId2) {
1204 break;
1205 }
1206 }
1207 EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end());
1208 auto& metricProducerTimeBase3_2 = *metricIt;
1209 EXPECT_TRUE(metricProducerTimeBase3_2->isActive());
1210
1211 i = 0;
1212 for (; i < metricsManagerTimeBase3->mAllAtomMatchingTrackers.size(); i++) {
1213 if (metricsManagerTimeBase3->mAllAtomMatchingTrackers[i]->getId() ==
1214 metric1ActivationTrigger1->atom_matcher_id()) {
1215 break;
1216 }
1217 }
1218 const auto& activationTimeBase3_1 = metricProducerTimeBase3_1->mEventActivationMap.at(i);
1219 EXPECT_EQ(100 * NS_PER_SEC, activationTimeBase3_1->ttl_ns);
1220 EXPECT_EQ(0, activationTimeBase3_1->start_ns);
1221 EXPECT_EQ(kNotActive, activationTimeBase3_1->state);
1222
1223 i = 0;
1224 for (; i < metricsManagerTimeBase3->mAllAtomMatchingTrackers.size(); i++) {
1225 if (metricsManagerTimeBase3->mAllAtomMatchingTrackers[i]->getId() ==
1226 metric1ActivationTrigger2->atom_matcher_id()) {
1227 break;
1228 }
1229 }
1230
1231 const auto& activationTimeBase3_2 = metricProducerTimeBase3_1->mEventActivationMap.at(i);
1232 EXPECT_EQ(200 * NS_PER_SEC, activationTimeBase3_2->ttl_ns);
1233 EXPECT_EQ(0, activationTimeBase3_2->start_ns);
1234 EXPECT_EQ(kNotActive, activationTimeBase3_2->state);
1235
1236 EXPECT_TRUE(metricProducerTimeBase3_2->isActive());
1237 // }}}----------------------------------------------------------------------------------
1238
1239 // Load saved state from disk.
1240 processor3->LoadActiveConfigsFromDisk();
1241
1242 // Metric 1 active: Activation 1 is active, Activation 2 is active
1243 // Metric 2 is active.
1244 // {{{---------------------------------------------------------------------------
1245 EXPECT_TRUE(metricProducerTimeBase3_1->isActive());
1246 EXPECT_EQ(timeBase3 + ttl1 - activationTimeBase3_1->ttl_ns, activationTimeBase3_1->start_ns);
1247 EXPECT_EQ(kActive, activationTimeBase3_1->state);
1248 EXPECT_EQ(timeBase3 + ttl2 - activationTimeBase3_2->ttl_ns, activationTimeBase3_2->start_ns);
1249 EXPECT_EQ(kActive, activationTimeBase3_2->state);
1250
1251 EXPECT_TRUE(metricProducerTimeBase3_2->isActive());
1252 // }}}-------------------------------------------------------------------------------
1253
1254 // Trigger Activation 2 for Metric 1 again.
1255 screenOnEvent = CreateScreenStateChangedEvent(timeBase3 + 100 * NS_PER_SEC,
1256 android::view::DISPLAY_STATE_ON);
1257 processor3->OnLogEvent(screenOnEvent.get());
1258
1259 // Metric 1 active; Activation 1 is not active, Activation 2 is set to active
1260 // Metric 2 is active.
1261 // {{{---------------------------------------------------------------------------
1262 EXPECT_TRUE(metricProducerTimeBase3_1->isActive());
1263 EXPECT_EQ(kNotActive, activationTimeBase3_1->state);
1264 EXPECT_EQ(timeBase3 + ttl2 - activationTimeBase3_2->ttl_ns, activationTimeBase3_2->start_ns);
1265 EXPECT_EQ(kActive, activationTimeBase3_2->state);
1266
1267 EXPECT_TRUE(metricProducerTimeBase3_2->isActive());
1268 // }}}---------------------------------------------------------------------------
1269
1270 // Simulate shutdown by saving state to disk.
1271 shutDownTime = timeBase3 + 500 * NS_PER_SEC;
1272 processor3->SaveActiveConfigsToDisk(shutDownTime);
1273 EXPECT_TRUE(metricProducer1001->isActive());
1274 EXPECT_TRUE(metricProducer1002->isActive());
1275 ttl1 = timeBase3 + ttl1 - shutDownTime;
1276 ttl2 = timeBase3 + metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC - shutDownTime;
1277
1278 // Simulate device restarted state by creating new instance of StatsLogProcessor with the
1279 // same config.
1280 long timeBase4 = timeBase3 + 600 * NS_PER_SEC;
1281 sp<StatsLogProcessor> processor4 =
1282 CreateStatsLogProcessor(timeBase4, timeBase4, config1, cfgKey1);
1283
1284 // Metric 1 is not active.
1285 // Metric 2 is active.
1286 // {{{---------------------------------------------------------------------------
1287 ASSERT_EQ(1, processor4->mMetricsManagers.size());
1288 it = processor4->mMetricsManagers.find(cfgKey1);
1289 EXPECT_TRUE(it != processor4->mMetricsManagers.end());
1290 auto& metricsManagerTimeBase4 = it->second;
1291 EXPECT_TRUE(metricsManagerTimeBase4->isActive());
1292
1293 metricIt = metricsManagerTimeBase4->mAllMetricProducers.begin();
1294 for (; metricIt != metricsManagerTimeBase4->mAllMetricProducers.end(); metricIt++) {
1295 if ((*metricIt)->getMetricId() == metricId1) {
1296 break;
1297 }
1298 }
1299 EXPECT_TRUE(metricIt != metricsManagerTimeBase4->mAllMetricProducers.end());
1300 auto& metricProducerTimeBase4_1 = *metricIt;
1301 EXPECT_FALSE(metricProducerTimeBase4_1->isActive());
1302
1303 metricIt = metricsManagerTimeBase4->mAllMetricProducers.begin();
1304 for (; metricIt != metricsManagerTimeBase4->mAllMetricProducers.end(); metricIt++) {
1305 if ((*metricIt)->getMetricId() == metricId2) {
1306 break;
1307 }
1308 }
1309 EXPECT_TRUE(metricIt != metricsManagerTimeBase4->mAllMetricProducers.end());
1310 auto& metricProducerTimeBase4_2 = *metricIt;
1311 EXPECT_TRUE(metricProducerTimeBase4_2->isActive());
1312
1313 i = 0;
1314 for (; i < metricsManagerTimeBase4->mAllAtomMatchingTrackers.size(); i++) {
1315 if (metricsManagerTimeBase4->mAllAtomMatchingTrackers[i]->getId() ==
1316 metric1ActivationTrigger1->atom_matcher_id()) {
1317 break;
1318 }
1319 }
1320 const auto& activationTimeBase4_1 = metricProducerTimeBase4_1->mEventActivationMap.at(i);
1321 EXPECT_EQ(100 * NS_PER_SEC, activationTimeBase4_1->ttl_ns);
1322 EXPECT_EQ(0, activationTimeBase4_1->start_ns);
1323 EXPECT_EQ(kNotActive, activationTimeBase4_1->state);
1324
1325 i = 0;
1326 for (; i < metricsManagerTimeBase4->mAllAtomMatchingTrackers.size(); i++) {
1327 if (metricsManagerTimeBase4->mAllAtomMatchingTrackers[i]->getId() ==
1328 metric1ActivationTrigger2->atom_matcher_id()) {
1329 break;
1330 }
1331 }
1332
1333 const auto& activationTimeBase4_2 = metricProducerTimeBase4_1->mEventActivationMap.at(i);
1334 EXPECT_EQ(200 * NS_PER_SEC, activationTimeBase4_2->ttl_ns);
1335 EXPECT_EQ(0, activationTimeBase4_2->start_ns);
1336 EXPECT_EQ(kNotActive, activationTimeBase4_2->state);
1337
1338 EXPECT_TRUE(metricProducerTimeBase4_2->isActive());
1339 // }}}----------------------------------------------------------------------------------
1340
1341 // Load saved state from disk.
1342 processor4->LoadActiveConfigsFromDisk();
1343
1344 // Metric 1 active: Activation 1 is not active, Activation 2 is not active
1345 // Metric 2 is active.
1346 // {{{---------------------------------------------------------------------------
1347 EXPECT_FALSE(metricProducerTimeBase4_1->isActive());
1348 EXPECT_EQ(kNotActive, activationTimeBase4_1->state);
1349 EXPECT_EQ(kNotActive, activationTimeBase4_2->state);
1350
1351 EXPECT_TRUE(metricProducerTimeBase4_2->isActive());
1352 // }}}-------------------------------------------------------------------------------
1353 }
1354
TEST(StatsLogProcessorTest,TestActivationOnBootMultipleActivationsDifferentActivationTypes)1355 TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActivationTypes) {
1356 int uid = 1111;
1357
1358 // Create config with 2 metrics:
1359 // Metric 1: Activate on boot with 2 activations
1360 // Metric 2: Always active
1361 StatsdConfig config1;
1362 config1.set_id(12341);
1363 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
1364 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher();
1365 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
1366 *config1.add_atom_matcher() = wakelockAcquireMatcher;
1367 *config1.add_atom_matcher() = screenOnMatcher;
1368
1369 long metricId1 = 1234561;
1370 long metricId2 = 1234562;
1371
1372 auto countMetric1 = config1.add_count_metric();
1373 countMetric1->set_id(metricId1);
1374 countMetric1->set_what(wakelockAcquireMatcher.id());
1375 countMetric1->set_bucket(FIVE_MINUTES);
1376
1377 auto countMetric2 = config1.add_count_metric();
1378 countMetric2->set_id(metricId2);
1379 countMetric2->set_what(wakelockAcquireMatcher.id());
1380 countMetric2->set_bucket(FIVE_MINUTES);
1381
1382 auto metric1Activation = config1.add_metric_activation();
1383 metric1Activation->set_metric_id(metricId1);
1384 metric1Activation->set_activation_type(ACTIVATE_ON_BOOT);
1385 auto metric1ActivationTrigger1 = metric1Activation->add_event_activation();
1386 metric1ActivationTrigger1->set_atom_matcher_id(wakelockAcquireMatcher.id());
1387 metric1ActivationTrigger1->set_ttl_seconds(100);
1388 auto metric1ActivationTrigger2 = metric1Activation->add_event_activation();
1389 metric1ActivationTrigger2->set_atom_matcher_id(screenOnMatcher.id());
1390 metric1ActivationTrigger2->set_ttl_seconds(200);
1391 metric1ActivationTrigger2->set_activation_type(ACTIVATE_IMMEDIATELY);
1392
1393 ConfigKey cfgKey1(uid, 12341);
1394 long timeBase1 = 1;
1395 sp<StatsLogProcessor> processor1 =
1396 CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1);
1397
1398 // Metric 1 is not active.
1399 // Metric 2 is active.
1400 // {{{---------------------------------------------------------------------------
1401 ASSERT_EQ(1, processor1->mMetricsManagers.size());
1402 auto it = processor1->mMetricsManagers.find(cfgKey1);
1403 EXPECT_TRUE(it != processor1->mMetricsManagers.end());
1404 auto& metricsManager1 = it->second;
1405 EXPECT_TRUE(metricsManager1->isActive());
1406
1407 ASSERT_EQ(metricsManager1->mAllMetricProducers.size(), 2);
1408 // We assume that the index of a MetricProducer within the mAllMetricProducers
1409 // array follows the order in which metrics are added to the config.
1410 auto& metricProducer1_1 = metricsManager1->mAllMetricProducers[0];
1411 EXPECT_EQ(metricProducer1_1->getMetricId(), metricId1);
1412 EXPECT_FALSE(metricProducer1_1->isActive()); // inactive due to associated MetricActivation
1413
1414 auto& metricProducer1_2 = metricsManager1->mAllMetricProducers[1];
1415 EXPECT_EQ(metricProducer1_2->getMetricId(), metricId2);
1416 EXPECT_TRUE(metricProducer1_2->isActive());
1417
1418 ASSERT_EQ(metricProducer1_1->mEventActivationMap.size(), 2);
1419 // The key in mEventActivationMap is the index of the associated atom matcher. We assume
1420 // that matchers are indexed in the order that they are added to the config.
1421 const auto& activation1_1_1 = metricProducer1_1->mEventActivationMap.at(0);
1422 EXPECT_EQ(100 * NS_PER_SEC, activation1_1_1->ttl_ns);
1423 EXPECT_EQ(0, activation1_1_1->start_ns);
1424 EXPECT_EQ(kNotActive, activation1_1_1->state);
1425 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1_1_1->activationType);
1426
1427 const auto& activation1_1_2 = metricProducer1_1->mEventActivationMap.at(1);
1428 EXPECT_EQ(200 * NS_PER_SEC, activation1_1_2->ttl_ns);
1429 EXPECT_EQ(0, activation1_1_2->start_ns);
1430 EXPECT_EQ(kNotActive, activation1_1_2->state);
1431 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1_1_2->activationType);
1432 // }}}------------------------------------------------------------------------------
1433
1434 // Trigger Activation 1 for Metric 1
1435 std::vector<int> attributionUids = {111};
1436 std::vector<string> attributionTags = {"App1"};
1437 std::unique_ptr<LogEvent> event =
1438 CreateAcquireWakelockEvent(timeBase1 + 100, attributionUids, attributionTags, "wl1");
1439 processor1->OnLogEvent(event.get());
1440
1441 // Metric 1 is not active; Activation 1 set to kActiveOnBoot
1442 // Metric 2 is active.
1443 // {{{---------------------------------------------------------------------------
1444 EXPECT_FALSE(metricProducer1_1->isActive());
1445 EXPECT_EQ(0, activation1_1_1->start_ns);
1446 EXPECT_EQ(kActiveOnBoot, activation1_1_1->state);
1447 EXPECT_EQ(0, activation1_1_2->start_ns);
1448 EXPECT_EQ(kNotActive, activation1_1_2->state);
1449
1450 EXPECT_TRUE(metricProducer1_2->isActive());
1451 // }}}-----------------------------------------------------------------------------
1452
1453 // Simulate shutdown by saving state to disk
1454 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC;
1455 processor1->SaveActiveConfigsToDisk(shutDownTime);
1456 EXPECT_FALSE(metricProducer1_1->isActive());
1457
1458 // Simulate device restarted state by creating new instance of StatsLogProcessor with the
1459 // same config.
1460 long timeBase2 = 1000;
1461 sp<StatsLogProcessor> processor2 =
1462 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1);
1463
1464 // Metric 1 is not active.
1465 // Metric 2 is active.
1466 // {{{---------------------------------------------------------------------------
1467 ASSERT_EQ(1, processor2->mMetricsManagers.size());
1468 it = processor2->mMetricsManagers.find(cfgKey1);
1469 EXPECT_TRUE(it != processor2->mMetricsManagers.end());
1470 auto& metricsManager2 = it->second;
1471 EXPECT_TRUE(metricsManager2->isActive());
1472
1473 ASSERT_EQ(metricsManager2->mAllMetricProducers.size(), 2);
1474 // We assume that the index of a MetricProducer within the mAllMetricProducers
1475 // array follows the order in which metrics are added to the config.
1476 auto& metricProducer2_1 = metricsManager2->mAllMetricProducers[0];
1477 EXPECT_EQ(metricProducer2_1->getMetricId(), metricId1);
1478 EXPECT_FALSE(metricProducer2_1->isActive());
1479
1480 auto& metricProducer2_2 = metricsManager2->mAllMetricProducers[1];
1481 EXPECT_EQ(metricProducer2_2->getMetricId(), metricId2);
1482 EXPECT_TRUE(metricProducer2_2->isActive());
1483
1484 ASSERT_EQ(metricProducer2_1->mEventActivationMap.size(), 2);
1485 // The key in mEventActivationMap is the index of the associated atom matcher. We assume
1486 // that matchers are indexed in the order that they are added to the config.
1487 const auto& activation2_1_1 = metricProducer2_1->mEventActivationMap.at(0);
1488 EXPECT_EQ(100 * NS_PER_SEC, activation2_1_1->ttl_ns);
1489 EXPECT_EQ(0, activation2_1_1->start_ns);
1490 EXPECT_EQ(kNotActive, activation2_1_1->state);
1491 EXPECT_EQ(ACTIVATE_ON_BOOT, activation2_1_1->activationType);
1492
1493 const auto& activation2_1_2 = metricProducer2_1->mEventActivationMap.at(1);
1494 EXPECT_EQ(200 * NS_PER_SEC, activation2_1_2->ttl_ns);
1495 EXPECT_EQ(0, activation2_1_2->start_ns);
1496 EXPECT_EQ(kNotActive, activation2_1_2->state);
1497 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation2_1_2->activationType);
1498 // }}}-----------------------------------------------------------------------------------
1499
1500 // Load saved state from disk.
1501 processor2->LoadActiveConfigsFromDisk();
1502
1503 // Metric 1 active; Activation 1 is active, Activation 2 is not active
1504 // Metric 2 is active.
1505 // {{{---------------------------------------------------------------------------
1506 EXPECT_TRUE(metricProducer2_1->isActive());
1507 int64_t ttl1 = metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC;
1508 EXPECT_EQ(timeBase2 + ttl1 - activation2_1_1->ttl_ns, activation2_1_1->start_ns);
1509 EXPECT_EQ(kActive, activation2_1_1->state);
1510 EXPECT_EQ(0, activation2_1_2->start_ns);
1511 EXPECT_EQ(kNotActive, activation2_1_2->state);
1512
1513 EXPECT_TRUE(metricProducer2_2->isActive());
1514 // }}}--------------------------------------------------------------------------------
1515
1516 // Trigger Activation 2 for Metric 1.
1517 auto screenOnEvent =
1518 CreateScreenStateChangedEvent(timeBase2 + 200, android::view::DISPLAY_STATE_ON);
1519 processor2->OnLogEvent(screenOnEvent.get());
1520
1521 // Metric 1 active; Activation 1 is active, Activation 2 is active
1522 // Metric 2 is active.
1523 // {{{---------------------------------------------------------------------------
1524 EXPECT_TRUE(metricProducer2_1->isActive());
1525 EXPECT_EQ(timeBase2 + ttl1 - activation2_1_1->ttl_ns, activation2_1_1->start_ns);
1526 EXPECT_EQ(kActive, activation2_1_1->state);
1527 EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activation2_1_2->start_ns);
1528 EXPECT_EQ(kActive, activation2_1_2->state);
1529
1530 EXPECT_TRUE(metricProducer2_2->isActive());
1531 // }}}---------------------------------------------------------------------------
1532
1533 // Simulate shutdown by saving state to disk
1534 shutDownTime = timeBase2 + 50 * NS_PER_SEC;
1535 processor2->SaveActiveConfigsToDisk(shutDownTime);
1536 EXPECT_TRUE(metricProducer2_1->isActive());
1537 EXPECT_TRUE(metricProducer2_2->isActive());
1538 ttl1 -= shutDownTime - timeBase2;
1539 int64_t ttl2 = metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC -
1540 (shutDownTime - screenOnEvent->GetElapsedTimestampNs());
1541
1542 // Simulate device restarted state by creating new instance of StatsLogProcessor with the
1543 // same config.
1544 long timeBase3 = timeBase2 + 120 * NS_PER_SEC;
1545 sp<StatsLogProcessor> processor3 =
1546 CreateStatsLogProcessor(timeBase3, timeBase3, config1, cfgKey1);
1547
1548 // Metric 1 is not active.
1549 // Metric 2 is active.
1550 // {{{---------------------------------------------------------------------------
1551 ASSERT_EQ(1, processor3->mMetricsManagers.size());
1552 it = processor3->mMetricsManagers.find(cfgKey1);
1553 EXPECT_TRUE(it != processor3->mMetricsManagers.end());
1554 auto& metricsManager3 = it->second;
1555 EXPECT_TRUE(metricsManager3->isActive());
1556
1557 ASSERT_EQ(metricsManager3->mAllMetricProducers.size(), 2);
1558 // We assume that the index of a MetricProducer within the mAllMetricProducers
1559 // array follows the order in which metrics are added to the config.
1560 auto& metricProducer3_1 = metricsManager3->mAllMetricProducers[0];
1561 EXPECT_EQ(metricProducer3_1->getMetricId(), metricId1);
1562 EXPECT_FALSE(metricProducer3_1->isActive());
1563
1564 auto& metricProducer3_2 = metricsManager3->mAllMetricProducers[1];
1565 EXPECT_EQ(metricProducer3_2->getMetricId(), metricId2);
1566 EXPECT_TRUE(metricProducer3_2->isActive());
1567
1568 ASSERT_EQ(metricProducer3_1->mEventActivationMap.size(), 2);
1569 // The key in mEventActivationMap is the index of the associated atom matcher. We assume
1570 // that matchers are indexed in the order that they are added to the config.
1571 const auto& activation3_1_1 = metricProducer3_1->mEventActivationMap.at(0);
1572 EXPECT_EQ(100 * NS_PER_SEC, activation3_1_1->ttl_ns);
1573 EXPECT_EQ(0, activation3_1_1->start_ns);
1574 EXPECT_EQ(kNotActive, activation3_1_1->state);
1575 EXPECT_EQ(ACTIVATE_ON_BOOT, activation3_1_1->activationType);
1576
1577 const auto& activation3_1_2 = metricProducer3_1->mEventActivationMap.at(1);
1578 EXPECT_EQ(200 * NS_PER_SEC, activation3_1_2->ttl_ns);
1579 EXPECT_EQ(0, activation3_1_2->start_ns);
1580 EXPECT_EQ(kNotActive, activation3_1_2->state);
1581 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation3_1_2->activationType);
1582 // }}}----------------------------------------------------------------------------------
1583
1584 // Load saved state from disk.
1585 processor3->LoadActiveConfigsFromDisk();
1586
1587 // Metric 1 active: Activation 1 is active, Activation 2 is active
1588 // Metric 2 is active.
1589 // {{{---------------------------------------------------------------------------
1590 EXPECT_TRUE(metricProducer3_1->isActive());
1591 EXPECT_EQ(timeBase3 + ttl1 - activation3_1_1->ttl_ns, activation3_1_1->start_ns);
1592 EXPECT_EQ(kActive, activation3_1_1->state);
1593 EXPECT_EQ(timeBase3 + ttl2 - activation3_1_2->ttl_ns, activation3_1_2->start_ns);
1594 EXPECT_EQ(kActive, activation3_1_2->state);
1595
1596 EXPECT_TRUE(metricProducer3_2->isActive());
1597 // }}}-------------------------------------------------------------------------------
1598
1599 // Trigger Activation 2 for Metric 1 again.
1600 screenOnEvent = CreateScreenStateChangedEvent(timeBase3 + 100 * NS_PER_SEC,
1601 android::view::DISPLAY_STATE_ON);
1602 processor3->OnLogEvent(screenOnEvent.get());
1603
1604 // Metric 1 active; Activation 1 is inactive (above screenOnEvent causes ttl1 to expire),
1605 // Activation 2 is set to active
1606 // Metric 2 is active.
1607 // {{{---------------------------------------------------------------------------
1608 EXPECT_TRUE(metricProducer3_1->isActive());
1609 EXPECT_EQ(kNotActive, activation3_1_1->state);
1610 EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activation3_1_2->start_ns);
1611 EXPECT_EQ(kActive, activation3_1_2->state);
1612
1613 EXPECT_TRUE(metricProducer3_2->isActive());
1614 // }}}---------------------------------------------------------------------------
1615 }
1616
TEST(StatsLogProcessorTest,TestActivationsPersistAcrossSystemServerRestart)1617 TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) {
1618 int uid = 9876;
1619 long configId = 12341;
1620
1621 // Create config with 3 metrics:
1622 // Metric 1: Activate on 2 activations, 1 on boot, 1 immediate.
1623 // Metric 2: Activate on 2 activations, 1 on boot, 1 immediate.
1624 // Metric 3: Always active
1625 StatsdConfig config1;
1626 config1.set_id(configId);
1627 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
1628 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher();
1629 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
1630 auto jobStartMatcher = CreateStartScheduledJobAtomMatcher();
1631 auto jobFinishMatcher = CreateFinishScheduledJobAtomMatcher();
1632 *config1.add_atom_matcher() = wakelockAcquireMatcher;
1633 *config1.add_atom_matcher() = screenOnMatcher;
1634 *config1.add_atom_matcher() = jobStartMatcher;
1635 *config1.add_atom_matcher() = jobFinishMatcher;
1636
1637 long metricId1 = 1234561;
1638 long metricId2 = 1234562;
1639 long metricId3 = 1234563;
1640
1641 auto countMetric1 = config1.add_count_metric();
1642 countMetric1->set_id(metricId1);
1643 countMetric1->set_what(wakelockAcquireMatcher.id());
1644 countMetric1->set_bucket(FIVE_MINUTES);
1645
1646 auto countMetric2 = config1.add_count_metric();
1647 countMetric2->set_id(metricId2);
1648 countMetric2->set_what(wakelockAcquireMatcher.id());
1649 countMetric2->set_bucket(FIVE_MINUTES);
1650
1651 auto countMetric3 = config1.add_count_metric();
1652 countMetric3->set_id(metricId3);
1653 countMetric3->set_what(wakelockAcquireMatcher.id());
1654 countMetric3->set_bucket(FIVE_MINUTES);
1655
1656 // Metric 1 activates on boot for wakelock acquire, immediately for screen on.
1657 auto metric1Activation = config1.add_metric_activation();
1658 metric1Activation->set_metric_id(metricId1);
1659 auto metric1ActivationTrigger1 = metric1Activation->add_event_activation();
1660 metric1ActivationTrigger1->set_atom_matcher_id(wakelockAcquireMatcher.id());
1661 metric1ActivationTrigger1->set_ttl_seconds(100);
1662 metric1ActivationTrigger1->set_activation_type(ACTIVATE_ON_BOOT);
1663 auto metric1ActivationTrigger2 = metric1Activation->add_event_activation();
1664 metric1ActivationTrigger2->set_atom_matcher_id(screenOnMatcher.id());
1665 metric1ActivationTrigger2->set_ttl_seconds(200);
1666 metric1ActivationTrigger2->set_activation_type(ACTIVATE_IMMEDIATELY);
1667
1668 // Metric 2 activates on boot for scheduled job start, immediately for scheduled job finish.
1669 auto metric2Activation = config1.add_metric_activation();
1670 metric2Activation->set_metric_id(metricId2);
1671 auto metric2ActivationTrigger1 = metric2Activation->add_event_activation();
1672 metric2ActivationTrigger1->set_atom_matcher_id(jobStartMatcher.id());
1673 metric2ActivationTrigger1->set_ttl_seconds(100);
1674 metric2ActivationTrigger1->set_activation_type(ACTIVATE_ON_BOOT);
1675 auto metric2ActivationTrigger2 = metric2Activation->add_event_activation();
1676 metric2ActivationTrigger2->set_atom_matcher_id(jobFinishMatcher.id());
1677 metric2ActivationTrigger2->set_ttl_seconds(200);
1678 metric2ActivationTrigger2->set_activation_type(ACTIVATE_IMMEDIATELY);
1679
1680 // Send the config.
1681 const sp<UidMap> uidMap = new UidMap();
1682 const shared_ptr<StatsService> service =
1683 SharedRefBase::make<StatsService>(uidMap, /* queue */ nullptr, nullptr);
1684 string serialized = config1.SerializeAsString();
1685 service->addConfigurationChecked(uid, configId, {serialized.begin(), serialized.end()});
1686
1687 // Make sure the config is stored on disk. Otherwise, we will not reset on system server death.
1688 StatsdConfig tmpConfig;
1689 ConfigKey cfgKey1(uid, configId);
1690 EXPECT_TRUE(StorageManager::readConfigFromDisk(cfgKey1, &tmpConfig));
1691
1692 // Metric 1 is not active.
1693 // Metric 2 is not active.
1694 // Metric 3 is active.
1695 // {{{---------------------------------------------------------------------------
1696 sp<StatsLogProcessor> processor = service->mProcessor;
1697 ASSERT_EQ(1, processor->mMetricsManagers.size());
1698 auto it = processor->mMetricsManagers.find(cfgKey1);
1699 EXPECT_TRUE(it != processor->mMetricsManagers.end());
1700 auto& metricsManager1 = it->second;
1701 EXPECT_TRUE(metricsManager1->isActive());
1702 ASSERT_EQ(3, metricsManager1->mAllMetricProducers.size());
1703
1704 auto& metricProducer1 = metricsManager1->mAllMetricProducers[0];
1705 EXPECT_EQ(metricId1, metricProducer1->getMetricId());
1706 EXPECT_FALSE(metricProducer1->isActive());
1707
1708 auto& metricProducer2 = metricsManager1->mAllMetricProducers[1];
1709 EXPECT_EQ(metricId2, metricProducer2->getMetricId());
1710 EXPECT_FALSE(metricProducer2->isActive());
1711
1712 auto& metricProducer3 = metricsManager1->mAllMetricProducers[2];
1713 EXPECT_EQ(metricId3, metricProducer3->getMetricId());
1714 EXPECT_TRUE(metricProducer3->isActive());
1715
1716 // Check event activations.
1717 ASSERT_EQ(metricsManager1->mAllAtomMatchingTrackers.size(), 4);
1718 EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[0]->getId(),
1719 metric1ActivationTrigger1->atom_matcher_id());
1720 const auto& activation1 = metricProducer1->mEventActivationMap.at(0);
1721 EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns);
1722 EXPECT_EQ(0, activation1->start_ns);
1723 EXPECT_EQ(kNotActive, activation1->state);
1724 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1->activationType);
1725
1726 EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[1]->getId(),
1727 metric1ActivationTrigger2->atom_matcher_id());
1728 const auto& activation2 = metricProducer1->mEventActivationMap.at(1);
1729 EXPECT_EQ(200 * NS_PER_SEC, activation2->ttl_ns);
1730 EXPECT_EQ(0, activation2->start_ns);
1731 EXPECT_EQ(kNotActive, activation2->state);
1732 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation2->activationType);
1733
1734 EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[2]->getId(),
1735 metric2ActivationTrigger1->atom_matcher_id());
1736 const auto& activation3 = metricProducer2->mEventActivationMap.at(2);
1737 EXPECT_EQ(100 * NS_PER_SEC, activation3->ttl_ns);
1738 EXPECT_EQ(0, activation3->start_ns);
1739 EXPECT_EQ(kNotActive, activation3->state);
1740 EXPECT_EQ(ACTIVATE_ON_BOOT, activation3->activationType);
1741
1742 EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[3]->getId(),
1743 metric2ActivationTrigger2->atom_matcher_id());
1744 const auto& activation4 = metricProducer2->mEventActivationMap.at(3);
1745 EXPECT_EQ(200 * NS_PER_SEC, activation4->ttl_ns);
1746 EXPECT_EQ(0, activation4->start_ns);
1747 EXPECT_EQ(kNotActive, activation4->state);
1748 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation4->activationType);
1749 // }}}------------------------------------------------------------------------------
1750
1751 // Trigger Activation 1 for Metric 1. Should activate on boot.
1752 // Trigger Activation 4 for Metric 2. Should activate immediately.
1753 int64_t configAddedTimeNs = metricsManager1->mLastReportTimeNs;
1754 std::vector<int> attributionUids = {111};
1755 std::vector<string> attributionTags = {"App1"};
1756 std::unique_ptr<LogEvent> event1 = CreateAcquireWakelockEvent(
1757 1 + configAddedTimeNs, attributionUids, attributionTags, "wl1");
1758 processor->OnLogEvent(event1.get());
1759
1760 std::unique_ptr<LogEvent> event2 = CreateFinishScheduledJobEvent(
1761 2 + configAddedTimeNs, attributionUids, attributionTags, "finish1");
1762 processor->OnLogEvent(event2.get());
1763
1764 // Metric 1 is not active; Activation 1 set to kActiveOnBoot
1765 // Metric 2 is active. Activation 4 set to kActive
1766 // Metric 3 is active.
1767 // {{{---------------------------------------------------------------------------
1768 EXPECT_FALSE(metricProducer1->isActive());
1769 EXPECT_EQ(0, activation1->start_ns);
1770 EXPECT_EQ(kActiveOnBoot, activation1->state);
1771 EXPECT_EQ(0, activation2->start_ns);
1772 EXPECT_EQ(kNotActive, activation2->state);
1773
1774 EXPECT_TRUE(metricProducer2->isActive());
1775 EXPECT_EQ(0, activation3->start_ns);
1776 EXPECT_EQ(kNotActive, activation3->state);
1777 EXPECT_EQ(2 + configAddedTimeNs, activation4->start_ns);
1778 EXPECT_EQ(kActive, activation4->state);
1779
1780 EXPECT_TRUE(metricProducer3->isActive());
1781 // }}}-----------------------------------------------------------------------------
1782
1783 // Can't fake time with StatsService.
1784 // Lets get a time close to the system server death time and make sure it's sane.
1785 int64_t approximateSystemServerDeath = getElapsedRealtimeNs();
1786 EXPECT_TRUE(approximateSystemServerDeath > 2 + configAddedTimeNs);
1787 EXPECT_TRUE(approximateSystemServerDeath < NS_PER_SEC + configAddedTimeNs);
1788
1789 // System server dies.
1790 service->statsCompanionServiceDiedImpl();
1791
1792 // We should have a new metrics manager. Lets get it and ensure activation status is restored.
1793 // {{{---------------------------------------------------------------------------
1794 ASSERT_EQ(1, processor->mMetricsManagers.size());
1795 it = processor->mMetricsManagers.find(cfgKey1);
1796 EXPECT_TRUE(it != processor->mMetricsManagers.end());
1797 auto& metricsManager2 = it->second;
1798 EXPECT_TRUE(metricsManager2->isActive());
1799 ASSERT_EQ(3, metricsManager2->mAllMetricProducers.size());
1800
1801 auto& metricProducer1001 = metricsManager2->mAllMetricProducers[0];
1802 EXPECT_EQ(metricId1, metricProducer1001->getMetricId());
1803 EXPECT_FALSE(metricProducer1001->isActive());
1804
1805 auto& metricProducer1002 = metricsManager2->mAllMetricProducers[1];
1806 EXPECT_EQ(metricId2, metricProducer1002->getMetricId());
1807 EXPECT_TRUE(metricProducer1002->isActive());
1808
1809 auto& metricProducer1003 = metricsManager2->mAllMetricProducers[2];
1810 EXPECT_EQ(metricId3, metricProducer1003->getMetricId());
1811 EXPECT_TRUE(metricProducer1003->isActive());
1812
1813 // Check event activations.
1814 // Activation 1 is kActiveOnBoot.
1815 // Activation 2 and 3 are not active.
1816 // Activation 4 is active.
1817 ASSERT_EQ(metricsManager2->mAllAtomMatchingTrackers.size(), 4);
1818 EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[0]->getId(),
1819 metric1ActivationTrigger1->atom_matcher_id());
1820 const auto& activation1001 = metricProducer1001->mEventActivationMap.at(0);
1821 EXPECT_EQ(100 * NS_PER_SEC, activation1001->ttl_ns);
1822 EXPECT_EQ(0, activation1001->start_ns);
1823 EXPECT_EQ(kActiveOnBoot, activation1001->state);
1824 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1001->activationType);
1825
1826 EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[1]->getId(),
1827 metric1ActivationTrigger2->atom_matcher_id());
1828 const auto& activation1002 = metricProducer1001->mEventActivationMap.at(1);
1829 EXPECT_EQ(200 * NS_PER_SEC, activation1002->ttl_ns);
1830 EXPECT_EQ(0, activation1002->start_ns);
1831 EXPECT_EQ(kNotActive, activation1002->state);
1832 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1002->activationType);
1833
1834 EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[2]->getId(),
1835 metric2ActivationTrigger1->atom_matcher_id());
1836 const auto& activation1003 = metricProducer1002->mEventActivationMap.at(2);
1837 EXPECT_EQ(100 * NS_PER_SEC, activation1003->ttl_ns);
1838 EXPECT_EQ(0, activation1003->start_ns);
1839 EXPECT_EQ(kNotActive, activation1003->state);
1840 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1003->activationType);
1841
1842 EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[3]->getId(),
1843 metric2ActivationTrigger2->atom_matcher_id());
1844 const auto& activation1004 = metricProducer1002->mEventActivationMap.at(3);
1845 EXPECT_EQ(200 * NS_PER_SEC, activation1004->ttl_ns);
1846 EXPECT_EQ(2 + configAddedTimeNs, activation1004->start_ns);
1847 EXPECT_EQ(kActive, activation1004->state);
1848 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1004->activationType);
1849 // }}}------------------------------------------------------------------------------
1850
1851 // Clear the data stored on disk as a result of the system server death.
1852 vector<uint8_t> buffer;
1853 processor->onDumpReport(cfgKey1, configAddedTimeNs + NS_PER_SEC, false, true, ADB_DUMP, FAST,
1854 &buffer);
1855
1856 service->removeConfiguration(configId, uid);
1857 service->mProcessor->onDumpReport(cfgKey1, getElapsedRealtimeNs(),
1858 false /* include_current_bucket*/, true /* erase_data */,
1859 ADB_DUMP, NO_TIME_CONSTRAINTS, nullptr);
1860 }
1861
TEST(StatsLogProcessorTest,LogEventFilterOnSetPrintLogs)1862 TEST(StatsLogProcessorTest, LogEventFilterOnSetPrintLogs) {
1863 sp<UidMap> m = new UidMap();
1864 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
1865 sp<AlarmMonitor> anomalyAlarmMonitor;
1866 sp<AlarmMonitor> periodicAlarmMonitor;
1867
1868 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
1869 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
1870 .Times(1);
1871 StatsLogProcessor p(
1872 m, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, 0,
1873 [](const ConfigKey& key) { return true; },
1874 [](const int&, const vector<int64_t>&) { return true; },
1875 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
1876
1877 Expectation filterSetFalse =
1878 EXPECT_CALL(*mockLogEventFilter, setFilteringEnabled(false)).Times(1);
1879 EXPECT_CALL(*mockLogEventFilter, setFilteringEnabled(true)).Times(1).After(filterSetFalse);
1880
1881 p.setPrintLogs(true);
1882 p.setPrintLogs(false);
1883 }
1884
TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid,LogHostUid)1885 TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogHostUid) {
1886 int hostUid = 20;
1887 int isolatedUid = 30;
1888 uint64_t eventTimeNs = 12355;
1889 int atomId = 89;
1890 int field1 = 90;
1891 int field2 = 28;
1892 sp<MockUidMap> mockUidMap = makeMockUidMapForHosts({{hostUid, {isolatedUid}}});
1893
1894 ConfigKey cfgKey;
1895 StatsdConfig config = MakeConfig(false);
1896 sp<StatsLogProcessor> processor =
1897 CreateStatsLogProcessor(1, 1, config, cfgKey, nullptr, 0, mockUidMap);
1898
1899 shared_ptr<LogEvent> logEvent = makeUidLogEvent(atomId, eventTimeNs, hostUid, field1, field2);
1900
1901 processor->OnLogEvent(logEvent.get());
1902
1903 const vector<FieldValue>* actualFieldValues = &logEvent->getValues();
1904 ASSERT_EQ(3, actualFieldValues->size());
1905 EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
1906 EXPECT_EQ(field1, actualFieldValues->at(1).mValue.int_value);
1907 EXPECT_EQ(field2, actualFieldValues->at(2).mValue.int_value);
1908 }
1909
TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid,LogIsolatedUid)1910 TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogIsolatedUid) {
1911 int hostUid = 20;
1912 int isolatedUid = 30;
1913 uint64_t eventTimeNs = 12355;
1914 int atomId = 89;
1915 int field1 = 90;
1916 int field2 = 28;
1917 sp<MockUidMap> mockUidMap = makeMockUidMapForHosts({{hostUid, {isolatedUid}}});
1918
1919 ConfigKey cfgKey;
1920 StatsdConfig config = MakeConfig(false);
1921 sp<StatsLogProcessor> processor =
1922 CreateStatsLogProcessor(1, 1, config, cfgKey, nullptr, 0, mockUidMap);
1923
1924 shared_ptr<LogEvent> logEvent =
1925 makeUidLogEvent(atomId, eventTimeNs, isolatedUid, field1, field2);
1926
1927 processor->OnLogEvent(logEvent.get());
1928
1929 const vector<FieldValue>* actualFieldValues = &logEvent->getValues();
1930 ASSERT_EQ(3, actualFieldValues->size());
1931 EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
1932 EXPECT_EQ(field1, actualFieldValues->at(1).mValue.int_value);
1933 EXPECT_EQ(field2, actualFieldValues->at(2).mValue.int_value);
1934 }
1935
TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid,LogThreeIsolatedUids)1936 TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogThreeIsolatedUids) {
1937 int hostUid = 20;
1938 int isolatedUid = 30;
1939 int hostUid2 = 200;
1940 int isolatedUid2 = 300;
1941 int hostUid3 = 2000;
1942 int isolatedUid3 = 3000;
1943 uint64_t eventTimeNs = 12355;
1944 int atomId = 89;
1945 int field1 = 90;
1946 int field2 = 28;
1947 sp<MockUidMap> mockUidMap = makeMockUidMapForHosts(
1948 {{hostUid, {isolatedUid}}, {hostUid2, {isolatedUid2}}, {hostUid3, {isolatedUid3}}});
1949 ConfigKey cfgKey;
1950 StatsdConfig config = MakeConfig(false);
1951 sp<StatsLogProcessor> processor =
1952 CreateStatsLogProcessor(1, 1, config, cfgKey, nullptr, 0, mockUidMap);
1953
1954 shared_ptr<LogEvent> logEvent = makeExtraUidsLogEvent(atomId, eventTimeNs, isolatedUid, field1,
1955 field2, {isolatedUid2, isolatedUid3});
1956
1957 processor->OnLogEvent(logEvent.get());
1958
1959 const vector<FieldValue>* actualFieldValues = &logEvent->getValues();
1960 ASSERT_EQ(5, actualFieldValues->size());
1961 EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
1962 EXPECT_EQ(field1, actualFieldValues->at(1).mValue.int_value);
1963 EXPECT_EQ(field2, actualFieldValues->at(2).mValue.int_value);
1964 EXPECT_EQ(hostUid2, actualFieldValues->at(3).mValue.int_value);
1965 EXPECT_EQ(hostUid3, actualFieldValues->at(4).mValue.int_value);
1966 }
1967
TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid,LogHostUidAttributionChain)1968 TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogHostUidAttributionChain) {
1969 int hostUid = 20;
1970 int isolatedUid = 30;
1971 uint64_t eventTimeNs = 12355;
1972 int atomId = 89;
1973 int field1 = 90;
1974 int field2 = 28;
1975 sp<MockUidMap> mockUidMap = makeMockUidMapForHosts({{hostUid, {isolatedUid}}});
1976
1977 ConfigKey cfgKey;
1978 StatsdConfig config = MakeConfig(false);
1979 sp<StatsLogProcessor> processor =
1980 CreateStatsLogProcessor(1, 1, config, cfgKey, nullptr, 0, mockUidMap);
1981
1982 shared_ptr<LogEvent> logEvent = makeAttributionLogEvent(atomId, eventTimeNs, {hostUid, 200},
1983 {"tag1", "tag2"}, field1, field2);
1984
1985 processor->OnLogEvent(logEvent.get());
1986
1987 const vector<FieldValue>* actualFieldValues = &logEvent->getValues();
1988 ASSERT_EQ(6, actualFieldValues->size());
1989 EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
1990 EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
1991 EXPECT_EQ(200, actualFieldValues->at(2).mValue.int_value);
1992 EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
1993 EXPECT_EQ(field1, actualFieldValues->at(4).mValue.int_value);
1994 EXPECT_EQ(field2, actualFieldValues->at(5).mValue.int_value);
1995 }
1996
TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid,LogIsolatedUidAttributionChain)1997 TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogIsolatedUidAttributionChain) {
1998 int hostUid = 20;
1999 int isolatedUid = 30;
2000 uint64_t eventTimeNs = 12355;
2001 int atomId = 89;
2002 int field1 = 90;
2003 int field2 = 28;
2004 sp<MockUidMap> mockUidMap = makeMockUidMapForHosts({{hostUid, {isolatedUid}}});
2005 ConfigKey cfgKey;
2006 StatsdConfig config = MakeConfig(false);
2007 sp<StatsLogProcessor> processor =
2008 CreateStatsLogProcessor(1, 1, config, cfgKey, nullptr, 0, mockUidMap);
2009
2010 shared_ptr<LogEvent> logEvent = makeAttributionLogEvent(atomId, eventTimeNs, {isolatedUid, 200},
2011 {"tag1", "tag2"}, field1, field2);
2012
2013 processor->OnLogEvent(logEvent.get());
2014
2015 const vector<FieldValue>* actualFieldValues = &logEvent->getValues();
2016 ASSERT_EQ(6, actualFieldValues->size());
2017 EXPECT_EQ(hostUid, actualFieldValues->at(0).mValue.int_value);
2018 EXPECT_EQ("tag1", actualFieldValues->at(1).mValue.str_value);
2019 EXPECT_EQ(200, actualFieldValues->at(2).mValue.int_value);
2020 EXPECT_EQ("tag2", actualFieldValues->at(3).mValue.str_value);
2021 EXPECT_EQ(field1, actualFieldValues->at(4).mValue.int_value);
2022 EXPECT_EQ(field2, actualFieldValues->at(5).mValue.int_value);
2023 }
2024
2025 /* *
2026 * Test cases for repeated uid fields:
2027 * - empty field
2028 * - single host uid
2029 * - single isolated uid
2030 * - multiple host uids
2031 * - multiple isolated uids
2032 * - multiple host and isolated uids
2033 */
TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid,LogRepeatedUidField)2034 TEST(StatsLogProcessorTest_mapIsolatedUidToHostUid, LogRepeatedUidField) {
2035 int hostUid1 = 21;
2036 int hostUid2 = 22;
2037 int isolatedUid1 = 31;
2038 int isolatedUid2 = 32;
2039 uint64_t eventTimeNs = 12355;
2040 int atomId = 89;
2041 int field1 = 90;
2042 int field2 = 28;
2043 sp<MockUidMap> mockUidMap =
2044 makeMockUidMapForHosts({{hostUid1, {isolatedUid1}}, {hostUid2, {isolatedUid2}}});
2045
2046 ConfigKey cfgKey;
2047 StatsdConfig config = MakeConfig(false);
2048 sp<StatsLogProcessor> processor =
2049 CreateStatsLogProcessor(1, 1, config, cfgKey, nullptr, 0, mockUidMap);
2050
2051 // Empty repeated uid field.
2052 shared_ptr<LogEvent> logEvent = makeRepeatedUidLogEvent(atomId, eventTimeNs, {});
2053 processor->OnLogEvent(logEvent.get());
2054
2055 const vector<FieldValue>* actualFieldValues = &logEvent->getValues();
2056 ASSERT_EQ(0, actualFieldValues->size());
2057
2058 // Single host uid.
2059 logEvent = makeRepeatedUidLogEvent(atomId, eventTimeNs, {hostUid1});
2060 processor->OnLogEvent(logEvent.get());
2061
2062 actualFieldValues = &logEvent->getValues();
2063 ASSERT_EQ(1, actualFieldValues->size());
2064 EXPECT_EQ(hostUid1, actualFieldValues->at(0).mValue.int_value);
2065
2066 // Single isolated uid.
2067 logEvent = makeRepeatedUidLogEvent(atomId, eventTimeNs, {isolatedUid1});
2068 processor->OnLogEvent(logEvent.get());
2069
2070 actualFieldValues = &logEvent->getValues();
2071 ASSERT_EQ(1, actualFieldValues->size());
2072 EXPECT_EQ(hostUid1, actualFieldValues->at(0).mValue.int_value);
2073
2074 // Multiple host uids.
2075 logEvent = makeRepeatedUidLogEvent(atomId, eventTimeNs, {hostUid1, hostUid2});
2076 processor->OnLogEvent(logEvent.get());
2077
2078 actualFieldValues = &logEvent->getValues();
2079 ASSERT_EQ(2, actualFieldValues->size());
2080 EXPECT_EQ(hostUid1, actualFieldValues->at(0).mValue.int_value);
2081 EXPECT_EQ(hostUid2, actualFieldValues->at(1).mValue.int_value);
2082
2083 // Multiple isolated uids.
2084 logEvent = makeRepeatedUidLogEvent(atomId, eventTimeNs, {isolatedUid1, isolatedUid2});
2085 processor->OnLogEvent(logEvent.get());
2086
2087 actualFieldValues = &logEvent->getValues();
2088 ASSERT_EQ(2, actualFieldValues->size());
2089 EXPECT_EQ(hostUid1, actualFieldValues->at(0).mValue.int_value);
2090 EXPECT_EQ(hostUid2, actualFieldValues->at(1).mValue.int_value);
2091
2092 // Multiple host and isolated uids.
2093 logEvent = makeRepeatedUidLogEvent(atomId, eventTimeNs,
2094 {isolatedUid1, hostUid2, isolatedUid2, hostUid1});
2095 processor->OnLogEvent(logEvent.get());
2096
2097 actualFieldValues = &logEvent->getValues();
2098 ASSERT_EQ(4, actualFieldValues->size());
2099 EXPECT_EQ(hostUid1, actualFieldValues->at(0).mValue.int_value);
2100 EXPECT_EQ(hostUid2, actualFieldValues->at(1).mValue.int_value);
2101 EXPECT_EQ(hostUid2, actualFieldValues->at(2).mValue.int_value);
2102 EXPECT_EQ(hostUid1, actualFieldValues->at(3).mValue.int_value);
2103 }
2104
TEST(StatsLogProcessorTest,TestDumpReportWithoutErasingDataDoesNotUpdateTimestamp)2105 TEST(StatsLogProcessorTest, TestDumpReportWithoutErasingDataDoesNotUpdateTimestamp) {
2106 int hostUid = 20;
2107 int isolatedUid = 30;
2108 sp<MockUidMap> mockUidMap = makeMockUidMapForHosts({{hostUid, {isolatedUid}}});
2109 ConfigKey key(3, 4);
2110
2111 // TODO: All tests should not persist state on disk. This removes any reports that were present.
2112 ProtoOutputStream proto;
2113 StorageManager::appendConfigMetricsReport(key, &proto, /*erase data=*/true, /*isAdb=*/false);
2114
2115 StatsdConfig config = MakeConfig(false);
2116 sp<StatsLogProcessor> processor =
2117 CreateStatsLogProcessor(1, 1, config, key, nullptr, 0, mockUidMap);
2118 vector<uint8_t> bytes;
2119
2120 int64_t dumpTime1Ns = 1 * NS_PER_SEC;
2121 processor->onDumpReport(key, dumpTime1Ns, false /* include_current_bucket */,
2122 true /* erase_data */, ADB_DUMP, FAST, &bytes);
2123
2124 ConfigMetricsReportList output;
2125 output.ParseFromArray(bytes.data(), bytes.size());
2126 EXPECT_EQ(output.reports_size(), 1);
2127 EXPECT_EQ(output.reports(0).current_report_elapsed_nanos(), dumpTime1Ns);
2128
2129 int64_t dumpTime2Ns = 5 * NS_PER_SEC;
2130 processor->onDumpReport(key, dumpTime2Ns, false /* include_current_bucket */,
2131 false /* erase_data */, ADB_DUMP, FAST, &bytes);
2132
2133 // Check that the dump report without clearing data is successful.
2134 output.ParseFromArray(bytes.data(), bytes.size());
2135 EXPECT_EQ(output.reports_size(), 1);
2136 EXPECT_EQ(output.reports(0).current_report_elapsed_nanos(), dumpTime2Ns);
2137 EXPECT_EQ(output.reports(0).last_report_elapsed_nanos(), dumpTime1Ns);
2138
2139 int64_t dumpTime3Ns = 10 * NS_PER_SEC;
2140 processor->onDumpReport(key, dumpTime3Ns, false /* include_current_bucket */,
2141 true /* erase_data */, ADB_DUMP, FAST, &bytes);
2142
2143 // Check that the previous dump report that didn't clear data did not overwrite the first dump's
2144 // timestamps.
2145 output.ParseFromArray(bytes.data(), bytes.size());
2146 EXPECT_EQ(output.reports_size(), 1);
2147 EXPECT_EQ(output.reports(0).current_report_elapsed_nanos(), dumpTime3Ns);
2148 EXPECT_EQ(output.reports(0).last_report_elapsed_nanos(), dumpTime1Ns);
2149 }
2150
2151 class StatsLogProcessorTestRestricted : public Test {
2152 protected:
2153 const ConfigKey mConfigKey = ConfigKey(1, 12345);
SetUp()2154 void SetUp() override {
2155 if (!IsAtLeastU()) {
2156 GTEST_SKIP();
2157 }
2158 }
TearDown()2159 void TearDown() override {
2160 if (!IsAtLeastU()) {
2161 GTEST_SKIP();
2162 }
2163 FlagProvider::getInstance().resetOverrides();
2164 StorageManager::deleteAllFiles(STATS_DATA_DIR);
2165 dbutils::deleteDb(mConfigKey);
2166 }
2167 };
2168
TEST_F(StatsLogProcessorTestRestricted,TestInconsistentRestrictedMetricsConfigUpdate)2169 TEST_F(StatsLogProcessorTestRestricted, TestInconsistentRestrictedMetricsConfigUpdate) {
2170 ConfigKey key(3, 4);
2171 StatsdConfig config = makeRestrictedConfig(true);
2172 config.set_restricted_metrics_delegate_package_name("rm_package");
2173
2174 sp<UidMap> m = new UidMap();
2175 sp<StatsPullerManager> pullerManager = new StatsPullerManager();
2176 m->updateMap(1, {1, 2}, {1, 2}, {String16("v1"), String16("v2")},
2177 {String16("p1"), String16("p2")}, {String16(""), String16("")},
2178 /* certificateHash */ {{}, {}});
2179 sp<AlarmMonitor> anomalyAlarmMonitor;
2180 sp<AlarmMonitor> subscriberAlarmMonitor;
2181 std::shared_ptr<MockLogEventFilter> mockLogEventFilter = std::make_shared<MockLogEventFilter>();
2182 EXPECT_CALL(*mockLogEventFilter, setAtomIds(StatsLogProcessor::getDefaultAtomIdSet(), _))
2183 .Times(1);
2184 StatsLogProcessor p(
2185 m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0,
2186 [](const ConfigKey& key) { return true; },
2187 [](const int&, const vector<int64_t>&) { return true; },
2188 [](const ConfigKey&, const string&, const vector<int64_t>&) {}, mockLogEventFilter);
2189
2190 // new newConfig will be the same as config
2191 const LogEventFilter::AtomIdSet atomIdsList = CreateAtomIdSetFromConfig(config);
2192 EXPECT_CALL(*mockLogEventFilter, setAtomIds(atomIdsList, &p)).Times(2);
2193
2194 p.OnConfigUpdated(0, key, config);
2195
2196 EXPECT_EQ(1, p.mMetricsManagers.size());
2197 EXPECT_NE(p.mMetricsManagers.find(key), p.mMetricsManagers.end());
2198 sp<MetricsManager> oldMetricsManager = p.mMetricsManagers.find(key)->second;
2199
2200 StatsdConfig newConfig = makeRestrictedConfig(true);
2201 newConfig.clear_restricted_metrics_delegate_package_name();
2202 p.OnConfigUpdated(/*timestampNs=*/0, key, newConfig);
2203
2204 ASSERT_NE(p.mMetricsManagers.find(key)->second, oldMetricsManager);
2205 }
2206
TEST_F(StatsLogProcessorTestRestricted,TestRestrictedLogEventNotPassed)2207 TEST_F(StatsLogProcessorTestRestricted, TestRestrictedLogEventNotPassed) {
2208 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2209 /*timeBaseNs=*/1, /*currentTimeNs=*/1, StatsdConfig(), mConfigKey);
2210 ConfigKey key(3, 4);
2211 sp<MockMetricsManager> metricsManager = new MockMetricsManager(mConfigKey);
2212 EXPECT_CALL(*metricsManager, onLogEvent).Times(0);
2213
2214 processor->mMetricsManagers[mConfigKey] = metricsManager;
2215 EXPECT_FALSE(processor->mMetricsManagers[mConfigKey]->hasRestrictedMetricsDelegate());
2216
2217 unique_ptr<LogEvent> event = CreateRestrictedLogEvent(123);
2218 EXPECT_TRUE(event->isValid());
2219 EXPECT_TRUE(event->isRestricted());
2220 processor->OnLogEvent(event.get());
2221 }
2222
TEST_F(StatsLogProcessorTestRestricted,TestRestrictedLogEventPassed)2223 TEST_F(StatsLogProcessorTestRestricted, TestRestrictedLogEventPassed) {
2224 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2225 /*timeBaseNs=*/1, /*currentTimeNs=*/1, StatsdConfig(), mConfigKey);
2226 sp<MockRestrictedMetricsManager> metricsManager = new MockRestrictedMetricsManager(mConfigKey);
2227 EXPECT_CALL(*metricsManager, onLogEvent).Times(1);
2228
2229 processor->mMetricsManagers[mConfigKey] = metricsManager;
2230 EXPECT_TRUE(processor->mMetricsManagers[mConfigKey]->hasRestrictedMetricsDelegate());
2231
2232 unique_ptr<LogEvent> event = CreateRestrictedLogEvent(123);
2233 EXPECT_TRUE(event->isValid());
2234 EXPECT_TRUE(event->isRestricted());
2235 processor->OnLogEvent(event.get());
2236 }
2237
TEST_F(StatsLogProcessorTestRestricted,RestrictedMetricsManagerOnDumpReportNotCalled)2238 TEST_F(StatsLogProcessorTestRestricted, RestrictedMetricsManagerOnDumpReportNotCalled) {
2239 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2240 /*timeBaseNs=*/1, /*currentTimeNs=*/1, makeRestrictedConfig(/*includeMetric=*/true),
2241 mConfigKey);
2242 sp<MockRestrictedMetricsManager> metricsManager = new MockRestrictedMetricsManager(mConfigKey);
2243 EXPECT_CALL(*metricsManager, onDumpReport).Times(0);
2244
2245 processor->mMetricsManagers[mConfigKey] = metricsManager;
2246 EXPECT_TRUE(processor->mMetricsManagers[mConfigKey]->hasRestrictedMetricsDelegate());
2247
2248 vector<uint8_t> buffer;
2249 processor->onConfigMetricsReportLocked(mConfigKey, /*dumpTimeStampNs=*/1, /*wallClockNs=*/0,
2250 /*include_current_partial_bucket=*/true,
2251 /*erase_data=*/true, GET_DATA_CALLED, FAST,
2252 /*dataSavedToDisk=*/true, &buffer);
2253 }
2254
TEST_F(StatsLogProcessorTestRestricted,RestrictedMetricFlushIfReachMemoryLimit)2255 TEST_F(StatsLogProcessorTestRestricted, RestrictedMetricFlushIfReachMemoryLimit) {
2256 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2257 /*timeBaseNs=*/1, /*currentTimeNs=*/1, makeRestrictedConfig(/*includeMetric=*/true),
2258 mConfigKey);
2259 sp<MockRestrictedMetricsManager> metricsManager = new MockRestrictedMetricsManager(mConfigKey);
2260 EXPECT_CALL(*metricsManager, flushRestrictedData).Times(1);
2261 EXPECT_CALL(*metricsManager, byteSize)
2262 .Times(1)
2263 .WillOnce(Return(StatsdStats::kBytesPerRestrictedConfigTriggerFlush + 1));
2264
2265 processor->mMetricsManagers[mConfigKey] = metricsManager;
2266 EXPECT_TRUE(processor->mMetricsManagers[mConfigKey]->hasRestrictedMetricsDelegate());
2267
2268 processor->flushIfNecessaryLocked(mConfigKey, *metricsManager);
2269 }
2270
TEST_F(StatsLogProcessorTestRestricted,RestrictedMetricNotFlushIfNotReachMemoryLimit)2271 TEST_F(StatsLogProcessorTestRestricted, RestrictedMetricNotFlushIfNotReachMemoryLimit) {
2272 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2273 /*timeBaseNs=*/1, /*currentTimeNs=*/1, makeRestrictedConfig(/*includeMetric=*/true),
2274 mConfigKey);
2275 sp<MockRestrictedMetricsManager> metricsManager = new MockRestrictedMetricsManager(mConfigKey);
2276 EXPECT_CALL(*metricsManager, flushRestrictedData).Times(0);
2277 EXPECT_CALL(*metricsManager, byteSize)
2278 .Times(1)
2279 .WillOnce(Return(StatsdStats::kBytesPerRestrictedConfigTriggerFlush - 1));
2280
2281 processor->mMetricsManagers[mConfigKey] = metricsManager;
2282 EXPECT_TRUE(processor->mMetricsManagers[mConfigKey]->hasRestrictedMetricsDelegate());
2283
2284 processor->flushIfNecessaryLocked(mConfigKey, *metricsManager);
2285 }
2286
TEST_F(StatsLogProcessorTestRestricted,NonRestrictedMetricsManagerOnDumpReportCalled)2287 TEST_F(StatsLogProcessorTestRestricted, NonRestrictedMetricsManagerOnDumpReportCalled) {
2288 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2289 /*timeBaseNs=*/1, /*currentTimeNs=*/1, MakeConfig(/*includeMetric=*/true), mConfigKey);
2290 sp<MockMetricsManager> metricsManager = new MockMetricsManager(mConfigKey);
2291 EXPECT_CALL(*metricsManager, onDumpReport).Times(1);
2292
2293 processor->mMetricsManagers[mConfigKey] = metricsManager;
2294 EXPECT_FALSE(processor->mMetricsManagers[mConfigKey]->hasRestrictedMetricsDelegate());
2295
2296 vector<uint8_t> buffer;
2297 processor->onConfigMetricsReportLocked(mConfigKey, /*dumpTimeStampNs=*/1, /*wallClockNs=*/0,
2298 /*include_current_partial_bucket=*/true,
2299 /*erase_data=*/true, GET_DATA_CALLED, FAST,
2300 /*dataSavedToDisk=*/true, &buffer);
2301 }
2302
TEST_F(StatsLogProcessorTestRestricted,RestrictedMetricOnDumpReportEmpty)2303 TEST_F(StatsLogProcessorTestRestricted, RestrictedMetricOnDumpReportEmpty) {
2304 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2305 /*timeBaseNs=*/1, /*currentTimeNs=*/1, makeRestrictedConfig(/*includeMetric=*/true),
2306 mConfigKey);
2307 ProtoOutputStream proto;
2308 processor->onDumpReport(mConfigKey, /*dumpTimeStampNs=*/1, /*wallClockNs=*/2,
2309 /*include_current_partial_bucket=*/true, /*erase_data=*/true,
2310 DEVICE_SHUTDOWN, FAST, &proto);
2311 ASSERT_EQ(proto.size(), 0);
2312 }
2313
TEST_F(StatsLogProcessorTestRestricted,NonRestrictedMetricOnDumpReportNotEmpty)2314 TEST_F(StatsLogProcessorTestRestricted, NonRestrictedMetricOnDumpReportNotEmpty) {
2315 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2316 /*timeBaseNs=*/1, /*currentTimeNs=*/1, MakeConfig(/*includeMetric=*/true), mConfigKey);
2317
2318 ProtoOutputStream proto;
2319 processor->onDumpReport(mConfigKey, /*dumpTimeStampNs=*/1, /*wallClockNs=*/2,
2320 /*include_current_partial_bucket=*/true, /*erase_data=*/true,
2321 DEVICE_SHUTDOWN, FAST, &proto);
2322 ASSERT_NE(proto.size(), 0);
2323 }
2324
TEST_F(StatsLogProcessorTestRestricted,RestrictedMetricNotWriteToDisk)2325 TEST_F(StatsLogProcessorTestRestricted, RestrictedMetricNotWriteToDisk) {
2326 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2327 /*timeBaseNs=*/1, /*currentTimeNs=*/1, makeRestrictedConfig(/*includeMetric=*/true),
2328 mConfigKey);
2329
2330 processor->WriteDataToDiskLocked(mConfigKey, /*timestampNs=*/0, /*wallClockNs=*/0,
2331 CONFIG_UPDATED, FAST);
2332
2333 ASSERT_FALSE(StorageManager::hasConfigMetricsReport(mConfigKey));
2334 }
2335
TEST_F(StatsLogProcessorTestRestricted,NonRestrictedMetricWriteToDisk)2336 TEST_F(StatsLogProcessorTestRestricted, NonRestrictedMetricWriteToDisk) {
2337 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(
2338 /*timeBaseNs=*/1, /*currentTimeNs=*/1, MakeConfig(true), mConfigKey);
2339
2340 processor->WriteDataToDiskLocked(mConfigKey, /*timestampNs=*/0, /*wallClockNs=*/0,
2341 CONFIG_UPDATED, FAST);
2342
2343 ASSERT_TRUE(StorageManager::hasConfigMetricsReport(mConfigKey));
2344 }
2345
2346 #else
2347 GTEST_LOG_(INFO) << "This test does nothing.\n";
2348 #endif
2349
2350 } // namespace statsd
2351 } // namespace os
2352 } // namespace android
2353