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 #include "StatsService.h" 17 #include "config/ConfigKey.h" 18 #include "frameworks/base/cmds/statsd/src/stats_log.pb.h" 19 #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" 20 #include "guardrail/StatsdStats.h" 21 #include "logd/LogEvent.h" 22 #include "packages/UidMap.h" 23 #include "storage/StorageManager.h" 24 #include "statslog.h" 25 26 #include <gmock/gmock.h> 27 #include <gtest/gtest.h> 28 29 #include "tests/statsd_test_util.h" 30 31 #include <stdio.h> 32 33 using namespace android; 34 using namespace testing; 35 36 namespace android { 37 namespace os { 38 namespace statsd { 39 40 using android::util::ProtoOutputStream; 41 42 #ifdef __ANDROID__ 43 44 /** 45 * Mock MetricsManager (ByteSize() is called). 46 */ 47 class MockMetricsManager : public MetricsManager { 48 public: 49 MockMetricsManager() 50 : MetricsManager(ConfigKey(1, 12345), StatsdConfig(), 1000, 1000, new UidMap(), 51 new StatsPullerManager(), 52 new AlarmMonitor(10, [](const sp<IStatsCompanionService>&, int64_t) {}, 53 [](const sp<IStatsCompanionService>&) {}), 54 new AlarmMonitor(10, [](const sp<IStatsCompanionService>&, int64_t) {}, 55 [](const sp<IStatsCompanionService>&) {})) { 56 } 57 58 MOCK_METHOD0(byteSize, size_t()); 59 60 MOCK_METHOD1(dropData, void(const int64_t dropTimeNs)); 61 }; 62 63 TEST(StatsLogProcessorTest, TestRateLimitByteSize) { 64 sp<UidMap> m = new UidMap(); 65 sp<StatsPullerManager> pullerManager = new StatsPullerManager(); 66 sp<AlarmMonitor> anomalyAlarmMonitor; 67 sp<AlarmMonitor> periodicAlarmMonitor; 68 // Construct the processor with a dummy sendBroadcast function that does nothing. 69 StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, 0, 70 [](const ConfigKey& key) { return true; }, 71 [](const int&, const vector<int64_t>&) {return true;}); 72 73 MockMetricsManager mockMetricsManager; 74 75 ConfigKey key(100, 12345); 76 // Expect only the first flush to trigger a check for byte size since the last two are 77 // rate-limited. 78 EXPECT_CALL(mockMetricsManager, byteSize()).Times(1); 79 p.flushIfNecessaryLocked(99, key, mockMetricsManager); 80 p.flushIfNecessaryLocked(100, key, mockMetricsManager); 81 p.flushIfNecessaryLocked(101, key, mockMetricsManager); 82 } 83 84 TEST(StatsLogProcessorTest, TestRateLimitBroadcast) { 85 sp<UidMap> m = new UidMap(); 86 sp<StatsPullerManager> pullerManager = new StatsPullerManager(); 87 sp<AlarmMonitor> anomalyAlarmMonitor; 88 sp<AlarmMonitor> subscriberAlarmMonitor; 89 int broadcastCount = 0; 90 StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0, 91 [&broadcastCount](const ConfigKey& key) { 92 broadcastCount++; 93 return true; 94 }, 95 [](const int&, const vector<int64_t>&) {return true;}); 96 97 MockMetricsManager mockMetricsManager; 98 99 ConfigKey key(100, 12345); 100 EXPECT_CALL(mockMetricsManager, byteSize()) 101 .Times(1) 102 .WillRepeatedly(::testing::Return(int( 103 StatsdStats::kMaxMetricsBytesPerConfig * .95))); 104 105 // Expect only one broadcast despite always returning a size that should trigger broadcast. 106 p.flushIfNecessaryLocked(1, key, mockMetricsManager); 107 EXPECT_EQ(1, broadcastCount); 108 109 // b/73089712 110 // This next call to flush should not trigger a broadcast. 111 // p.mLastByteSizeTimes.clear(); // Force another check for byte size. 112 // p.flushIfNecessaryLocked(2, key, mockMetricsManager); 113 // EXPECT_EQ(1, broadcastCount); 114 } 115 116 TEST(StatsLogProcessorTest, TestDropWhenByteSizeTooLarge) { 117 sp<UidMap> m = new UidMap(); 118 sp<StatsPullerManager> pullerManager = new StatsPullerManager(); 119 sp<AlarmMonitor> anomalyAlarmMonitor; 120 sp<AlarmMonitor> subscriberAlarmMonitor; 121 int broadcastCount = 0; 122 StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0, 123 [&broadcastCount](const ConfigKey& key) { 124 broadcastCount++; 125 return true; 126 }, 127 [](const int&, const vector<int64_t>&) {return true;}); 128 129 MockMetricsManager mockMetricsManager; 130 131 ConfigKey key(100, 12345); 132 EXPECT_CALL(mockMetricsManager, byteSize()) 133 .Times(1) 134 .WillRepeatedly(::testing::Return(int(StatsdStats::kMaxMetricsBytesPerConfig * 1.2))); 135 136 EXPECT_CALL(mockMetricsManager, dropData(_)).Times(1); 137 138 // Expect to call the onDumpReport and skip the broadcast. 139 p.flushIfNecessaryLocked(1, key, mockMetricsManager); 140 EXPECT_EQ(0, broadcastCount); 141 } 142 143 StatsdConfig MakeConfig(bool includeMetric) { 144 StatsdConfig config; 145 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 146 147 if (includeMetric) { 148 auto appCrashMatcher = CreateProcessCrashAtomMatcher(); 149 *config.add_atom_matcher() = appCrashMatcher; 150 auto countMetric = config.add_count_metric(); 151 countMetric->set_id(StringToId("AppCrashes")); 152 countMetric->set_what(appCrashMatcher.id()); 153 countMetric->set_bucket(FIVE_MINUTES); 154 } 155 return config; 156 } 157 158 TEST(StatsLogProcessorTest, TestUidMapHasSnapshot) { 159 // Setup simple config key corresponding to empty config. 160 sp<UidMap> m = new UidMap(); 161 sp<StatsPullerManager> pullerManager = new StatsPullerManager(); 162 m->updateMap(1, {1, 2}, {1, 2}, {String16("v1"), String16("v2")}, 163 {String16("p1"), String16("p2")}, {String16(""), String16("")}); 164 sp<AlarmMonitor> anomalyAlarmMonitor; 165 sp<AlarmMonitor> subscriberAlarmMonitor; 166 int broadcastCount = 0; 167 StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0, 168 [&broadcastCount](const ConfigKey& key) { 169 broadcastCount++; 170 return true; 171 }, 172 [](const int&, const vector<int64_t>&) {return true;}); 173 ConfigKey key(3, 4); 174 StatsdConfig config = MakeConfig(true); 175 p.OnConfigUpdated(0, key, config); 176 177 // Expect to get no metrics, but snapshot specified above in uidmap. 178 vector<uint8_t> bytes; 179 p.onDumpReport(key, 1, false, true, ADB_DUMP, FAST, &bytes); 180 181 ConfigMetricsReportList output; 182 output.ParseFromArray(bytes.data(), bytes.size()); 183 EXPECT_TRUE(output.reports_size() > 0); 184 auto uidmap = output.reports(0).uid_map(); 185 EXPECT_TRUE(uidmap.snapshots_size() > 0); 186 EXPECT_EQ(2, uidmap.snapshots(0).package_info_size()); 187 } 188 189 TEST(StatsLogProcessorTest, TestEmptyConfigHasNoUidMap) { 190 // Setup simple config key corresponding to empty config. 191 sp<UidMap> m = new UidMap(); 192 sp<StatsPullerManager> pullerManager = new StatsPullerManager(); 193 m->updateMap(1, {1, 2}, {1, 2}, {String16("v1"), String16("v2")}, 194 {String16("p1"), String16("p2")}, {String16(""), String16("")}); 195 sp<AlarmMonitor> anomalyAlarmMonitor; 196 sp<AlarmMonitor> subscriberAlarmMonitor; 197 int broadcastCount = 0; 198 StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0, 199 [&broadcastCount](const ConfigKey& key) { 200 broadcastCount++; 201 return true; 202 }, 203 [](const int&, const vector<int64_t>&) {return true;}); 204 ConfigKey key(3, 4); 205 StatsdConfig config = MakeConfig(false); 206 p.OnConfigUpdated(0, key, config); 207 208 // Expect to get no metrics, but snapshot specified above in uidmap. 209 vector<uint8_t> bytes; 210 p.onDumpReport(key, 1, false, true, ADB_DUMP, FAST, &bytes); 211 212 ConfigMetricsReportList output; 213 output.ParseFromArray(bytes.data(), bytes.size()); 214 EXPECT_TRUE(output.reports_size() > 0); 215 EXPECT_FALSE(output.reports(0).has_uid_map()); 216 } 217 218 TEST(StatsLogProcessorTest, TestReportIncludesSubConfig) { 219 // Setup simple config key corresponding to empty config. 220 sp<UidMap> m = new UidMap(); 221 sp<StatsPullerManager> pullerManager = new StatsPullerManager(); 222 sp<AlarmMonitor> anomalyAlarmMonitor; 223 sp<AlarmMonitor> subscriberAlarmMonitor; 224 int broadcastCount = 0; 225 StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0, 226 [&broadcastCount](const ConfigKey& key) { 227 broadcastCount++; 228 return true; 229 }, 230 [](const int&, const vector<int64_t>&) {return true;}); 231 ConfigKey key(3, 4); 232 StatsdConfig config; 233 auto annotation = config.add_annotation(); 234 annotation->set_field_int64(1); 235 annotation->set_field_int32(2); 236 config.add_allowed_log_source("AID_ROOT"); 237 p.OnConfigUpdated(1, key, config); 238 239 // Expect to get no metrics, but snapshot specified above in uidmap. 240 vector<uint8_t> bytes; 241 p.onDumpReport(key, 1, false, true, ADB_DUMP, FAST, &bytes); 242 243 ConfigMetricsReportList output; 244 output.ParseFromArray(bytes.data(), bytes.size()); 245 EXPECT_TRUE(output.reports_size() > 0); 246 auto report = output.reports(0); 247 EXPECT_EQ(1, report.annotation_size()); 248 EXPECT_EQ(1, report.annotation(0).field_int64()); 249 EXPECT_EQ(2, report.annotation(0).field_int32()); 250 } 251 252 TEST(StatsLogProcessorTest, TestOnDumpReportEraseData) { 253 // Setup a simple config. 254 StatsdConfig config; 255 config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 256 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher(); 257 *config.add_atom_matcher() = wakelockAcquireMatcher; 258 259 auto countMetric = config.add_count_metric(); 260 countMetric->set_id(123456); 261 countMetric->set_what(wakelockAcquireMatcher.id()); 262 countMetric->set_bucket(FIVE_MINUTES); 263 264 ConfigKey cfgKey; 265 sp<StatsLogProcessor> processor = CreateStatsLogProcessor(1, 1, config, cfgKey); 266 267 std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; 268 auto event = CreateAcquireWakelockEvent(attributions1, "wl1", 2); 269 processor->OnLogEvent(event.get()); 270 271 vector<uint8_t> bytes; 272 ConfigMetricsReportList output; 273 274 // Dump report WITHOUT erasing data. 275 processor->onDumpReport(cfgKey, 3, true, false /* Do NOT erase data. */, ADB_DUMP, FAST, &bytes); 276 output.ParseFromArray(bytes.data(), bytes.size()); 277 EXPECT_EQ(output.reports_size(), 1); 278 EXPECT_EQ(output.reports(0).metrics_size(), 1); 279 EXPECT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1); 280 281 // Dump report WITH erasing data. There should be data since we didn't previously erase it. 282 processor->onDumpReport(cfgKey, 4, true, true /* DO erase data. */, ADB_DUMP, FAST, &bytes); 283 output.ParseFromArray(bytes.data(), bytes.size()); 284 EXPECT_EQ(output.reports_size(), 1); 285 EXPECT_EQ(output.reports(0).metrics_size(), 1); 286 EXPECT_EQ(output.reports(0).metrics(0).count_metrics().data_size(), 1); 287 288 // Dump report again. There should be no data since we erased it. 289 processor->onDumpReport(cfgKey, 5, true, true /* DO erase data. */, ADB_DUMP, FAST, &bytes); 290 output.ParseFromArray(bytes.data(), bytes.size()); 291 // We don't care whether statsd has a report, as long as it has no count metrics in it. 292 bool noData = output.reports_size() == 0 293 || output.reports(0).metrics_size() == 0 294 || output.reports(0).metrics(0).count_metrics().data_size() == 0; 295 EXPECT_TRUE(noData); 296 } 297 298 TEST(StatsLogProcessorTest, TestActiveConfigMetricDiskWriteRead) { 299 int uid = 1111; 300 301 // Setup a simple config, no activation 302 StatsdConfig config1; 303 int64_t cfgId1 = 12341; 304 config1.set_id(cfgId1); 305 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 306 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher(); 307 *config1.add_atom_matcher() = wakelockAcquireMatcher; 308 309 long metricId1 = 1234561; 310 long metricId2 = 1234562; 311 auto countMetric1 = config1.add_count_metric(); 312 countMetric1->set_id(metricId1); 313 countMetric1->set_what(wakelockAcquireMatcher.id()); 314 countMetric1->set_bucket(FIVE_MINUTES); 315 316 auto countMetric2 = config1.add_count_metric(); 317 countMetric2->set_id(metricId2); 318 countMetric2->set_what(wakelockAcquireMatcher.id()); 319 countMetric2->set_bucket(FIVE_MINUTES); 320 321 ConfigKey cfgKey1(uid, cfgId1); 322 323 // Add another config, with two metrics, one with activation 324 StatsdConfig config2; 325 int64_t cfgId2 = 12342; 326 config2.set_id(cfgId2); 327 config2.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 328 *config2.add_atom_matcher() = wakelockAcquireMatcher; 329 330 long metricId3 = 1234561; 331 long metricId4 = 1234562; 332 333 auto countMetric3 = config2.add_count_metric(); 334 countMetric3->set_id(metricId3); 335 countMetric3->set_what(wakelockAcquireMatcher.id()); 336 countMetric3->set_bucket(FIVE_MINUTES); 337 338 auto countMetric4 = config2.add_count_metric(); 339 countMetric4->set_id(metricId4); 340 countMetric4->set_what(wakelockAcquireMatcher.id()); 341 countMetric4->set_bucket(FIVE_MINUTES); 342 343 auto metric3Activation = config2.add_metric_activation(); 344 metric3Activation->set_metric_id(metricId3); 345 metric3Activation->set_activation_type(ACTIVATE_IMMEDIATELY); 346 auto metric3ActivationTrigger = metric3Activation->add_event_activation(); 347 metric3ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id()); 348 metric3ActivationTrigger->set_ttl_seconds(100); 349 350 ConfigKey cfgKey2(uid, cfgId2); 351 352 // Add another config, with two metrics, both with activations 353 StatsdConfig config3; 354 int64_t cfgId3 = 12343; 355 config3.set_id(cfgId3); 356 config3.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 357 *config3.add_atom_matcher() = wakelockAcquireMatcher; 358 359 long metricId5 = 1234565; 360 long metricId6 = 1234566; 361 auto countMetric5 = config3.add_count_metric(); 362 countMetric5->set_id(metricId5); 363 countMetric5->set_what(wakelockAcquireMatcher.id()); 364 countMetric5->set_bucket(FIVE_MINUTES); 365 366 auto countMetric6 = config3.add_count_metric(); 367 countMetric6->set_id(metricId6); 368 countMetric6->set_what(wakelockAcquireMatcher.id()); 369 countMetric6->set_bucket(FIVE_MINUTES); 370 371 auto metric5Activation = config3.add_metric_activation(); 372 metric5Activation->set_metric_id(metricId5); 373 metric5Activation->set_activation_type(ACTIVATE_IMMEDIATELY); 374 auto metric5ActivationTrigger = metric5Activation->add_event_activation(); 375 metric5ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id()); 376 metric5ActivationTrigger->set_ttl_seconds(100); 377 378 auto metric6Activation = config3.add_metric_activation(); 379 metric6Activation->set_metric_id(metricId6); 380 metric6Activation->set_activation_type(ACTIVATE_IMMEDIATELY); 381 auto metric6ActivationTrigger = metric6Activation->add_event_activation(); 382 metric6ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id()); 383 metric6ActivationTrigger->set_ttl_seconds(200); 384 385 ConfigKey cfgKey3(uid, cfgId3); 386 387 sp<UidMap> m = new UidMap(); 388 sp<StatsPullerManager> pullerManager = new StatsPullerManager(); 389 sp<AlarmMonitor> anomalyAlarmMonitor; 390 sp<AlarmMonitor> subscriberAlarmMonitor; 391 vector<int64_t> activeConfigsBroadcast; 392 393 long timeBase1 = 1; 394 int broadcastCount = 0; 395 StatsLogProcessor processor(m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 396 timeBase1, [](const ConfigKey& key) { return true; }, 397 [&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid, 398 const vector<int64_t>& activeConfigs) { 399 broadcastCount++; 400 EXPECT_EQ(broadcastUid, uid); 401 activeConfigsBroadcast.clear(); 402 activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), 403 activeConfigs.begin(), activeConfigs.end()); 404 return true; 405 }); 406 407 processor.OnConfigUpdated(1, cfgKey1, config1); 408 processor.OnConfigUpdated(2, cfgKey2, config2); 409 processor.OnConfigUpdated(3, cfgKey3, config3); 410 411 EXPECT_EQ(3, processor.mMetricsManagers.size()); 412 413 // Expect the first config and both metrics in it to be active. 414 auto it = processor.mMetricsManagers.find(cfgKey1); 415 EXPECT_TRUE(it != processor.mMetricsManagers.end()); 416 auto& metricsManager1 = it->second; 417 EXPECT_TRUE(metricsManager1->isActive()); 418 419 auto metricIt = metricsManager1->mAllMetricProducers.begin(); 420 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 421 if ((*metricIt)->getMetricId() == metricId1) { 422 break; 423 } 424 } 425 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 426 auto& metricProducer1 = *metricIt; 427 EXPECT_TRUE(metricProducer1->isActive()); 428 429 metricIt = metricsManager1->mAllMetricProducers.begin(); 430 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 431 if ((*metricIt)->getMetricId() == metricId2) { 432 break; 433 } 434 } 435 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 436 auto& metricProducer2 = *metricIt; 437 EXPECT_TRUE(metricProducer2->isActive()); 438 439 // Expect config 2 to be active. Metric 3 shouldn't be active, metric 4 should be active. 440 it = processor.mMetricsManagers.find(cfgKey2); 441 EXPECT_TRUE(it != processor.mMetricsManagers.end()); 442 auto& metricsManager2 = it->second; 443 EXPECT_TRUE(metricsManager2->isActive()); 444 445 metricIt = metricsManager2->mAllMetricProducers.begin(); 446 for (; metricIt != metricsManager2->mAllMetricProducers.end(); metricIt++) { 447 if ((*metricIt)->getMetricId() == metricId3) { 448 break; 449 } 450 } 451 EXPECT_TRUE(metricIt != metricsManager2->mAllMetricProducers.end()); 452 auto& metricProducer3 = *metricIt; 453 EXPECT_FALSE(metricProducer3->isActive()); 454 455 metricIt = metricsManager2->mAllMetricProducers.begin(); 456 for (; metricIt != metricsManager2->mAllMetricProducers.end(); metricIt++) { 457 if ((*metricIt)->getMetricId() == metricId4) { 458 break; 459 } 460 } 461 EXPECT_TRUE(metricIt != metricsManager2->mAllMetricProducers.end()); 462 auto& metricProducer4 = *metricIt; 463 EXPECT_TRUE(metricProducer4->isActive()); 464 465 // Expect the third config and both metrics in it to be inactive. 466 it = processor.mMetricsManagers.find(cfgKey3); 467 EXPECT_TRUE(it != processor.mMetricsManagers.end()); 468 auto& metricsManager3 = it->second; 469 EXPECT_FALSE(metricsManager3->isActive()); 470 471 metricIt = metricsManager3->mAllMetricProducers.begin(); 472 for (; metricIt != metricsManager2->mAllMetricProducers.end(); metricIt++) { 473 if ((*metricIt)->getMetricId() == metricId5) { 474 break; 475 } 476 } 477 EXPECT_TRUE(metricIt != metricsManager3->mAllMetricProducers.end()); 478 auto& metricProducer5 = *metricIt; 479 EXPECT_FALSE(metricProducer5->isActive()); 480 481 metricIt = metricsManager3->mAllMetricProducers.begin(); 482 for (; metricIt != metricsManager3->mAllMetricProducers.end(); metricIt++) { 483 if ((*metricIt)->getMetricId() == metricId6) { 484 break; 485 } 486 } 487 EXPECT_TRUE(metricIt != metricsManager3->mAllMetricProducers.end()); 488 auto& metricProducer6 = *metricIt; 489 EXPECT_FALSE(metricProducer6->isActive()); 490 491 // No broadcast for active configs should have happened yet. 492 EXPECT_EQ(broadcastCount, 0); 493 494 // Activate all 3 metrics that were not active. 495 std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; 496 auto event = CreateAcquireWakelockEvent(attributions1, "wl1", 100 + timeBase1); 497 processor.OnLogEvent(event.get()); 498 499 // Assert that all 3 configs are active. 500 EXPECT_TRUE(metricsManager1->isActive()); 501 EXPECT_TRUE(metricsManager2->isActive()); 502 EXPECT_TRUE(metricsManager3->isActive()); 503 504 // A broadcast should have happened, and all 3 configs should be active in the broadcast. 505 EXPECT_EQ(broadcastCount, 1); 506 EXPECT_EQ(activeConfigsBroadcast.size(), 3); 507 EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId1) 508 != activeConfigsBroadcast.end()); 509 EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId2) 510 != activeConfigsBroadcast.end()); 511 EXPECT_TRUE(std::find(activeConfigsBroadcast.begin(), activeConfigsBroadcast.end(), cfgId3) 512 != activeConfigsBroadcast.end()); 513 514 // When we shut down, metrics 3 & 5 have 100ns remaining, metric 6 has 100s + 100ns. 515 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC; 516 processor.SaveActiveConfigsToDisk(shutDownTime); 517 const int64_t ttl3 = event->GetElapsedTimestampNs() + 518 metric3ActivationTrigger->ttl_seconds() * NS_PER_SEC - shutDownTime; 519 const int64_t ttl5 = event->GetElapsedTimestampNs() + 520 metric5ActivationTrigger->ttl_seconds() * NS_PER_SEC - shutDownTime; 521 const int64_t ttl6 = event->GetElapsedTimestampNs() + 522 metric6ActivationTrigger->ttl_seconds() * NS_PER_SEC - shutDownTime; 523 524 // Create a second StatsLogProcessor and push the same 3 configs. 525 long timeBase2 = 1000; 526 sp<StatsLogProcessor> processor2 = 527 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1); 528 processor2->OnConfigUpdated(timeBase2, cfgKey2, config2); 529 processor2->OnConfigUpdated(timeBase2, cfgKey3, config3); 530 531 EXPECT_EQ(3, processor2->mMetricsManagers.size()); 532 533 // First config and both metrics are active. 534 it = processor2->mMetricsManagers.find(cfgKey1); 535 EXPECT_TRUE(it != processor2->mMetricsManagers.end()); 536 auto& metricsManager1001 = it->second; 537 EXPECT_TRUE(metricsManager1001->isActive()); 538 539 metricIt = metricsManager1001->mAllMetricProducers.begin(); 540 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 541 if ((*metricIt)->getMetricId() == metricId1) { 542 break; 543 } 544 } 545 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 546 auto& metricProducer1001 = *metricIt; 547 EXPECT_TRUE(metricProducer1001->isActive()); 548 549 metricIt = metricsManager1001->mAllMetricProducers.begin(); 550 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 551 if ((*metricIt)->getMetricId() == metricId2) { 552 break; 553 } 554 } 555 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 556 auto& metricProducer1002 = *metricIt; 557 EXPECT_TRUE(metricProducer1002->isActive()); 558 559 // Second config is active. Metric 3 is inactive, metric 4 is active. 560 it = processor2->mMetricsManagers.find(cfgKey2); 561 EXPECT_TRUE(it != processor2->mMetricsManagers.end()); 562 auto& metricsManager1002 = it->second; 563 EXPECT_TRUE(metricsManager1002->isActive()); 564 565 metricIt = metricsManager1002->mAllMetricProducers.begin(); 566 for (; metricIt != metricsManager1002->mAllMetricProducers.end(); metricIt++) { 567 if ((*metricIt)->getMetricId() == metricId3) { 568 break; 569 } 570 } 571 EXPECT_TRUE(metricIt != metricsManager1002->mAllMetricProducers.end()); 572 auto& metricProducer1003 = *metricIt; 573 EXPECT_FALSE(metricProducer1003->isActive()); 574 575 metricIt = metricsManager1002->mAllMetricProducers.begin(); 576 for (; metricIt != metricsManager1002->mAllMetricProducers.end(); metricIt++) { 577 if ((*metricIt)->getMetricId() == metricId4) { 578 break; 579 } 580 } 581 EXPECT_TRUE(metricIt != metricsManager1002->mAllMetricProducers.end()); 582 auto& metricProducer1004 = *metricIt; 583 EXPECT_TRUE(metricProducer1004->isActive()); 584 585 // Config 3 is inactive. both metrics are inactive. 586 it = processor2->mMetricsManagers.find(cfgKey3); 587 EXPECT_TRUE(it != processor2->mMetricsManagers.end()); 588 auto& metricsManager1003 = it->second; 589 EXPECT_FALSE(metricsManager1003->isActive()); 590 EXPECT_EQ(2, metricsManager1003->mAllMetricProducers.size()); 591 592 metricIt = metricsManager1003->mAllMetricProducers.begin(); 593 for (; metricIt != metricsManager1002->mAllMetricProducers.end(); metricIt++) { 594 if ((*metricIt)->getMetricId() == metricId5) { 595 break; 596 } 597 } 598 EXPECT_TRUE(metricIt != metricsManager1003->mAllMetricProducers.end()); 599 auto& metricProducer1005 = *metricIt; 600 EXPECT_FALSE(metricProducer1005->isActive()); 601 602 metricIt = metricsManager1003->mAllMetricProducers.begin(); 603 for (; metricIt != metricsManager1003->mAllMetricProducers.end(); metricIt++) { 604 if ((*metricIt)->getMetricId() == metricId6) { 605 break; 606 } 607 } 608 EXPECT_TRUE(metricIt != metricsManager1003->mAllMetricProducers.end()); 609 auto& metricProducer1006 = *metricIt; 610 EXPECT_FALSE(metricProducer1006->isActive()); 611 612 // Assert that all 3 metrics with activation are inactive and that the ttls were properly set. 613 EXPECT_FALSE(metricProducer1003->isActive()); 614 const auto& activation1003 = metricProducer1003->mEventActivationMap.begin()->second; 615 EXPECT_EQ(100 * NS_PER_SEC, activation1003->ttl_ns); 616 EXPECT_EQ(0, activation1003->start_ns); 617 EXPECT_FALSE(metricProducer1005->isActive()); 618 const auto& activation1005 = metricProducer1005->mEventActivationMap.begin()->second; 619 EXPECT_EQ(100 * NS_PER_SEC, activation1005->ttl_ns); 620 EXPECT_EQ(0, activation1005->start_ns); 621 EXPECT_FALSE(metricProducer1006->isActive()); 622 const auto& activation1006 = metricProducer1006->mEventActivationMap.begin()->second; 623 EXPECT_EQ(200 * NS_PER_SEC, activation1006->ttl_ns); 624 EXPECT_EQ(0, activation1006->start_ns); 625 626 processor2->LoadActiveConfigsFromDisk(); 627 628 // After loading activations from disk, assert that all 3 metrics are active. 629 EXPECT_TRUE(metricProducer1003->isActive()); 630 EXPECT_EQ(timeBase2 + ttl3 - activation1003->ttl_ns, activation1003->start_ns); 631 EXPECT_TRUE(metricProducer1005->isActive()); 632 EXPECT_EQ(timeBase2 + ttl5 - activation1005->ttl_ns, activation1005->start_ns); 633 EXPECT_TRUE(metricProducer1006->isActive()); 634 EXPECT_EQ(timeBase2 + ttl6 - activation1006->ttl_ns, activation1003->start_ns); 635 636 // Make sure no more broadcasts have happened. 637 EXPECT_EQ(broadcastCount, 1); 638 } 639 640 TEST(StatsLogProcessorTest, TestActivationOnBoot) { 641 int uid = 1111; 642 643 StatsdConfig config1; 644 config1.set_id(12341); 645 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 646 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher(); 647 *config1.add_atom_matcher() = wakelockAcquireMatcher; 648 649 long metricId1 = 1234561; 650 long metricId2 = 1234562; 651 auto countMetric1 = config1.add_count_metric(); 652 countMetric1->set_id(metricId1); 653 countMetric1->set_what(wakelockAcquireMatcher.id()); 654 countMetric1->set_bucket(FIVE_MINUTES); 655 656 auto countMetric2 = config1.add_count_metric(); 657 countMetric2->set_id(metricId2); 658 countMetric2->set_what(wakelockAcquireMatcher.id()); 659 countMetric2->set_bucket(FIVE_MINUTES); 660 661 auto metric1Activation = config1.add_metric_activation(); 662 metric1Activation->set_metric_id(metricId1); 663 metric1Activation->set_activation_type(ACTIVATE_ON_BOOT); 664 auto metric1ActivationTrigger = metric1Activation->add_event_activation(); 665 metric1ActivationTrigger->set_atom_matcher_id(wakelockAcquireMatcher.id()); 666 metric1ActivationTrigger->set_ttl_seconds(100); 667 668 ConfigKey cfgKey1(uid, 12341); 669 long timeBase1 = 1; 670 sp<StatsLogProcessor> processor = 671 CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1); 672 673 EXPECT_EQ(1, processor->mMetricsManagers.size()); 674 auto it = processor->mMetricsManagers.find(cfgKey1); 675 EXPECT_TRUE(it != processor->mMetricsManagers.end()); 676 auto& metricsManager1 = it->second; 677 EXPECT_TRUE(metricsManager1->isActive()); 678 679 auto metricIt = metricsManager1->mAllMetricProducers.begin(); 680 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 681 if ((*metricIt)->getMetricId() == metricId1) { 682 break; 683 } 684 } 685 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 686 auto& metricProducer1 = *metricIt; 687 EXPECT_FALSE(metricProducer1->isActive()); 688 689 metricIt = metricsManager1->mAllMetricProducers.begin(); 690 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 691 if ((*metricIt)->getMetricId() == metricId2) { 692 break; 693 } 694 } 695 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 696 auto& metricProducer2 = *metricIt; 697 EXPECT_TRUE(metricProducer2->isActive()); 698 699 const auto& activation1 = metricProducer1->mEventActivationMap.begin()->second; 700 EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns); 701 EXPECT_EQ(0, activation1->start_ns); 702 EXPECT_EQ(kNotActive, activation1->state); 703 704 std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; 705 auto event = CreateAcquireWakelockEvent(attributions1, "wl1", 100 + timeBase1); 706 processor->OnLogEvent(event.get()); 707 708 EXPECT_FALSE(metricProducer1->isActive()); 709 EXPECT_EQ(0, activation1->start_ns); 710 EXPECT_EQ(kActiveOnBoot, activation1->state); 711 712 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC; 713 processor->SaveActiveConfigsToDisk(shutDownTime); 714 EXPECT_FALSE(metricProducer1->isActive()); 715 const int64_t ttl1 = metric1ActivationTrigger->ttl_seconds() * NS_PER_SEC; 716 717 long timeBase2 = 1000; 718 sp<StatsLogProcessor> processor2 = 719 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1); 720 721 EXPECT_EQ(1, processor2->mMetricsManagers.size()); 722 it = processor2->mMetricsManagers.find(cfgKey1); 723 EXPECT_TRUE(it != processor2->mMetricsManagers.end()); 724 auto& metricsManager1001 = it->second; 725 EXPECT_TRUE(metricsManager1001->isActive()); 726 727 metricIt = metricsManager1001->mAllMetricProducers.begin(); 728 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 729 if ((*metricIt)->getMetricId() == metricId1) { 730 break; 731 } 732 } 733 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 734 auto& metricProducer1001 = *metricIt; 735 EXPECT_FALSE(metricProducer1001->isActive()); 736 737 metricIt = metricsManager1001->mAllMetricProducers.begin(); 738 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 739 if ((*metricIt)->getMetricId() == metricId2) { 740 break; 741 } 742 } 743 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 744 auto& metricProducer1002 = *metricIt; 745 EXPECT_TRUE(metricProducer1002->isActive()); 746 747 const auto& activation1001 = metricProducer1001->mEventActivationMap.begin()->second; 748 EXPECT_EQ(100 * NS_PER_SEC, activation1001->ttl_ns); 749 EXPECT_EQ(0, activation1001->start_ns); 750 EXPECT_EQ(kNotActive, activation1001->state); 751 752 processor2->LoadActiveConfigsFromDisk(); 753 754 EXPECT_TRUE(metricProducer1001->isActive()); 755 EXPECT_EQ(timeBase2 + ttl1 - activation1001->ttl_ns, activation1001->start_ns); 756 EXPECT_EQ(kActive, activation1001->state); 757 } 758 759 TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { 760 int uid = 1111; 761 762 // Create config with 2 metrics: 763 // Metric 1: Activate on boot with 2 activations 764 // Metric 2: Always active 765 StatsdConfig config1; 766 config1.set_id(12341); 767 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 768 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher(); 769 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher(); 770 *config1.add_atom_matcher() = wakelockAcquireMatcher; 771 *config1.add_atom_matcher() = screenOnMatcher; 772 773 long metricId1 = 1234561; 774 long metricId2 = 1234562; 775 776 auto countMetric1 = config1.add_count_metric(); 777 countMetric1->set_id(metricId1); 778 countMetric1->set_what(wakelockAcquireMatcher.id()); 779 countMetric1->set_bucket(FIVE_MINUTES); 780 781 auto countMetric2 = config1.add_count_metric(); 782 countMetric2->set_id(metricId2); 783 countMetric2->set_what(wakelockAcquireMatcher.id()); 784 countMetric2->set_bucket(FIVE_MINUTES); 785 786 auto metric1Activation = config1.add_metric_activation(); 787 metric1Activation->set_metric_id(metricId1); 788 metric1Activation->set_activation_type(ACTIVATE_ON_BOOT); 789 auto metric1ActivationTrigger1 = metric1Activation->add_event_activation(); 790 metric1ActivationTrigger1->set_atom_matcher_id(wakelockAcquireMatcher.id()); 791 metric1ActivationTrigger1->set_ttl_seconds(100); 792 auto metric1ActivationTrigger2 = metric1Activation->add_event_activation(); 793 metric1ActivationTrigger2->set_atom_matcher_id(screenOnMatcher.id()); 794 metric1ActivationTrigger2->set_ttl_seconds(200); 795 796 ConfigKey cfgKey1(uid, 12341); 797 long timeBase1 = 1; 798 sp<StatsLogProcessor> processor = 799 CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1); 800 801 // Metric 1 is not active. 802 // Metric 2 is active. 803 // {{{--------------------------------------------------------------------------- 804 EXPECT_EQ(1, processor->mMetricsManagers.size()); 805 auto it = processor->mMetricsManagers.find(cfgKey1); 806 EXPECT_TRUE(it != processor->mMetricsManagers.end()); 807 auto& metricsManager1 = it->second; 808 EXPECT_TRUE(metricsManager1->isActive()); 809 810 auto metricIt = metricsManager1->mAllMetricProducers.begin(); 811 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 812 if ((*metricIt)->getMetricId() == metricId1) { 813 break; 814 } 815 } 816 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 817 auto& metricProducer1 = *metricIt; 818 EXPECT_FALSE(metricProducer1->isActive()); 819 820 metricIt = metricsManager1->mAllMetricProducers.begin(); 821 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 822 if ((*metricIt)->getMetricId() == metricId2) { 823 break; 824 } 825 } 826 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 827 auto& metricProducer2 = *metricIt; 828 EXPECT_TRUE(metricProducer2->isActive()); 829 830 int i = 0; 831 for (; i < metricsManager1->mAllAtomMatchers.size(); i++) { 832 if (metricsManager1->mAllAtomMatchers[i]->getId() == 833 metric1ActivationTrigger1->atom_matcher_id()) { 834 break; 835 } 836 } 837 const auto& activation1 = metricProducer1->mEventActivationMap.at(i); 838 EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns); 839 EXPECT_EQ(0, activation1->start_ns); 840 EXPECT_EQ(kNotActive, activation1->state); 841 842 i = 0; 843 for (; i < metricsManager1->mAllAtomMatchers.size(); i++) { 844 if (metricsManager1->mAllAtomMatchers[i]->getId() == 845 metric1ActivationTrigger2->atom_matcher_id()) { 846 break; 847 } 848 } 849 const auto& activation2 = metricProducer1->mEventActivationMap.at(i); 850 EXPECT_EQ(200 * NS_PER_SEC, activation2->ttl_ns); 851 EXPECT_EQ(0, activation2->start_ns); 852 EXPECT_EQ(kNotActive, activation2->state); 853 // }}}------------------------------------------------------------------------------ 854 855 // Trigger Activation 1 for Metric 1 856 std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; 857 auto event = CreateAcquireWakelockEvent(attributions1, "wl1", 100 + timeBase1); 858 processor->OnLogEvent(event.get()); 859 860 // Metric 1 is not active; Activation 1 set to kActiveOnBoot 861 // Metric 2 is active. 862 // {{{--------------------------------------------------------------------------- 863 EXPECT_FALSE(metricProducer1->isActive()); 864 EXPECT_EQ(0, activation1->start_ns); 865 EXPECT_EQ(kActiveOnBoot, activation1->state); 866 EXPECT_EQ(0, activation2->start_ns); 867 EXPECT_EQ(kNotActive, activation2->state); 868 869 EXPECT_TRUE(metricProducer2->isActive()); 870 // }}}----------------------------------------------------------------------------- 871 872 // Simulate shutdown by saving state to disk 873 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC; 874 processor->SaveActiveConfigsToDisk(shutDownTime); 875 EXPECT_FALSE(metricProducer1->isActive()); 876 int64_t ttl1 = metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC; 877 878 // Simulate device restarted state by creating new instance of StatsLogProcessor with the 879 // same config. 880 long timeBase2 = 1000; 881 sp<StatsLogProcessor> processor2 = 882 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1); 883 884 // Metric 1 is not active. 885 // Metric 2 is active. 886 // {{{--------------------------------------------------------------------------- 887 EXPECT_EQ(1, processor2->mMetricsManagers.size()); 888 it = processor2->mMetricsManagers.find(cfgKey1); 889 EXPECT_TRUE(it != processor2->mMetricsManagers.end()); 890 auto& metricsManager1001 = it->second; 891 EXPECT_TRUE(metricsManager1001->isActive()); 892 893 metricIt = metricsManager1001->mAllMetricProducers.begin(); 894 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 895 if ((*metricIt)->getMetricId() == metricId1) { 896 break; 897 } 898 } 899 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 900 auto& metricProducer1001 = *metricIt; 901 EXPECT_FALSE(metricProducer1001->isActive()); 902 903 metricIt = metricsManager1001->mAllMetricProducers.begin(); 904 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 905 if ((*metricIt)->getMetricId() == metricId2) { 906 break; 907 } 908 } 909 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 910 auto& metricProducer1002 = *metricIt; 911 EXPECT_TRUE(metricProducer1002->isActive()); 912 913 i = 0; 914 for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) { 915 if (metricsManager1001->mAllAtomMatchers[i]->getId() == 916 metric1ActivationTrigger1->atom_matcher_id()) { 917 break; 918 } 919 } 920 const auto& activation1001_1 = metricProducer1001->mEventActivationMap.at(i); 921 EXPECT_EQ(100 * NS_PER_SEC, activation1001_1->ttl_ns); 922 EXPECT_EQ(0, activation1001_1->start_ns); 923 EXPECT_EQ(kNotActive, activation1001_1->state); 924 925 i = 0; 926 for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) { 927 if (metricsManager1001->mAllAtomMatchers[i]->getId() == 928 metric1ActivationTrigger2->atom_matcher_id()) { 929 break; 930 } 931 } 932 933 const auto& activation1001_2 = metricProducer1001->mEventActivationMap.at(i); 934 EXPECT_EQ(200 * NS_PER_SEC, activation1001_2->ttl_ns); 935 EXPECT_EQ(0, activation1001_2->start_ns); 936 EXPECT_EQ(kNotActive, activation1001_2->state); 937 // }}}----------------------------------------------------------------------------------- 938 939 // Load saved state from disk. 940 processor2->LoadActiveConfigsFromDisk(); 941 942 // Metric 1 active; Activation 1 is active, Activation 2 is not active 943 // Metric 2 is active. 944 // {{{--------------------------------------------------------------------------- 945 EXPECT_TRUE(metricProducer1001->isActive()); 946 EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns); 947 EXPECT_EQ(kActive, activation1001_1->state); 948 EXPECT_EQ(0, activation1001_2->start_ns); 949 EXPECT_EQ(kNotActive, activation1001_2->state); 950 951 EXPECT_TRUE(metricProducer1002->isActive()); 952 // }}}-------------------------------------------------------------------------------- 953 954 // Trigger Activation 2 for Metric 1. 955 auto screenOnEvent = CreateScreenStateChangedEvent( 956 android::view::DISPLAY_STATE_ON, 957 timeBase2 + 200 958 ); 959 processor2->OnLogEvent(screenOnEvent.get()); 960 961 // Metric 1 active; Activation 1 is active, Activation 2 is set to kActiveOnBoot 962 // Metric 2 is active. 963 // {{{--------------------------------------------------------------------------- 964 EXPECT_TRUE(metricProducer1001->isActive()); 965 EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns); 966 EXPECT_EQ(kActive, activation1001_1->state); 967 EXPECT_EQ(0, activation1001_2->start_ns); 968 EXPECT_EQ(kActiveOnBoot, activation1001_2->state); 969 970 EXPECT_TRUE(metricProducer1002->isActive()); 971 // }}}--------------------------------------------------------------------------- 972 973 // Simulate shutdown by saving state to disk 974 shutDownTime = timeBase2 + 50 * NS_PER_SEC; 975 processor2->SaveActiveConfigsToDisk(shutDownTime); 976 EXPECT_TRUE(metricProducer1001->isActive()); 977 EXPECT_TRUE(metricProducer1002->isActive()); 978 ttl1 = timeBase2 + metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC - shutDownTime; 979 int64_t ttl2 = metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC; 980 981 // Simulate device restarted state by creating new instance of StatsLogProcessor with the 982 // same config. 983 long timeBase3 = timeBase2 + 120 * NS_PER_SEC; 984 sp<StatsLogProcessor> processor3 = 985 CreateStatsLogProcessor(timeBase3, timeBase3, config1, cfgKey1); 986 987 // Metric 1 is not active. 988 // Metric 2 is active. 989 // {{{--------------------------------------------------------------------------- 990 EXPECT_EQ(1, processor3->mMetricsManagers.size()); 991 it = processor3->mMetricsManagers.find(cfgKey1); 992 EXPECT_TRUE(it != processor3->mMetricsManagers.end()); 993 auto& metricsManagerTimeBase3 = it->second; 994 EXPECT_TRUE(metricsManagerTimeBase3->isActive()); 995 996 metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin(); 997 for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) { 998 if ((*metricIt)->getMetricId() == metricId1) { 999 break; 1000 } 1001 } 1002 EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end()); 1003 auto& metricProducerTimeBase3_1 = *metricIt; 1004 EXPECT_FALSE(metricProducerTimeBase3_1->isActive()); 1005 1006 metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin(); 1007 for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) { 1008 if ((*metricIt)->getMetricId() == metricId2) { 1009 break; 1010 } 1011 } 1012 EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end()); 1013 auto& metricProducerTimeBase3_2 = *metricIt; 1014 EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); 1015 1016 i = 0; 1017 for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) { 1018 if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() == 1019 metric1ActivationTrigger1->atom_matcher_id()) { 1020 break; 1021 } 1022 } 1023 const auto& activationTimeBase3_1 = metricProducerTimeBase3_1->mEventActivationMap.at(i); 1024 EXPECT_EQ(100 * NS_PER_SEC, activationTimeBase3_1->ttl_ns); 1025 EXPECT_EQ(0, activationTimeBase3_1->start_ns); 1026 EXPECT_EQ(kNotActive, activationTimeBase3_1->state); 1027 1028 i = 0; 1029 for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) { 1030 if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() == 1031 metric1ActivationTrigger2->atom_matcher_id()) { 1032 break; 1033 } 1034 } 1035 1036 const auto& activationTimeBase3_2 = metricProducerTimeBase3_1->mEventActivationMap.at(i); 1037 EXPECT_EQ(200 * NS_PER_SEC, activationTimeBase3_2->ttl_ns); 1038 EXPECT_EQ(0, activationTimeBase3_2->start_ns); 1039 EXPECT_EQ(kNotActive, activationTimeBase3_2->state); 1040 1041 EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); 1042 // }}}---------------------------------------------------------------------------------- 1043 1044 // Load saved state from disk. 1045 processor3->LoadActiveConfigsFromDisk(); 1046 1047 // Metric 1 active: Activation 1 is active, Activation 2 is active 1048 // Metric 2 is active. 1049 // {{{--------------------------------------------------------------------------- 1050 EXPECT_TRUE(metricProducerTimeBase3_1->isActive()); 1051 EXPECT_EQ(timeBase3 + ttl1 - activationTimeBase3_1->ttl_ns, activationTimeBase3_1->start_ns); 1052 EXPECT_EQ(kActive, activationTimeBase3_1->state); 1053 EXPECT_EQ(timeBase3 + ttl2 - activationTimeBase3_2->ttl_ns, activationTimeBase3_2->start_ns); 1054 EXPECT_EQ(kActive, activationTimeBase3_2->state); 1055 1056 EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); 1057 // }}}------------------------------------------------------------------------------- 1058 1059 // Trigger Activation 2 for Metric 1 again. 1060 screenOnEvent = CreateScreenStateChangedEvent( 1061 android::view::DISPLAY_STATE_ON, 1062 timeBase3 + 100 * NS_PER_SEC 1063 ); 1064 processor3->OnLogEvent(screenOnEvent.get()); 1065 1066 // Metric 1 active; Activation 1 is not active, Activation 2 is set to active 1067 // Metric 2 is active. 1068 // {{{--------------------------------------------------------------------------- 1069 EXPECT_TRUE(metricProducerTimeBase3_1->isActive()); 1070 EXPECT_EQ(kNotActive, activationTimeBase3_1->state); 1071 EXPECT_EQ(timeBase3 + ttl2 - activationTimeBase3_2->ttl_ns, activationTimeBase3_2->start_ns); 1072 EXPECT_EQ(kActive, activationTimeBase3_2->state); 1073 1074 EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); 1075 // }}}--------------------------------------------------------------------------- 1076 1077 // Simulate shutdown by saving state to disk. 1078 shutDownTime = timeBase3 + 500 * NS_PER_SEC; 1079 processor3->SaveActiveConfigsToDisk(shutDownTime); 1080 EXPECT_TRUE(metricProducer1001->isActive()); 1081 EXPECT_TRUE(metricProducer1002->isActive()); 1082 ttl1 = timeBase3 + ttl1 - shutDownTime; 1083 ttl2 = timeBase3 + metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC - shutDownTime; 1084 1085 // Simulate device restarted state by creating new instance of StatsLogProcessor with the 1086 // same config. 1087 long timeBase4 = timeBase3 + 600 * NS_PER_SEC; 1088 sp<StatsLogProcessor> processor4 = 1089 CreateStatsLogProcessor(timeBase4, timeBase4, config1, cfgKey1); 1090 1091 // Metric 1 is not active. 1092 // Metric 2 is active. 1093 // {{{--------------------------------------------------------------------------- 1094 EXPECT_EQ(1, processor4->mMetricsManagers.size()); 1095 it = processor4->mMetricsManagers.find(cfgKey1); 1096 EXPECT_TRUE(it != processor4->mMetricsManagers.end()); 1097 auto& metricsManagerTimeBase4 = it->second; 1098 EXPECT_TRUE(metricsManagerTimeBase4->isActive()); 1099 1100 metricIt = metricsManagerTimeBase4->mAllMetricProducers.begin(); 1101 for (; metricIt != metricsManagerTimeBase4->mAllMetricProducers.end(); metricIt++) { 1102 if ((*metricIt)->getMetricId() == metricId1) { 1103 break; 1104 } 1105 } 1106 EXPECT_TRUE(metricIt != metricsManagerTimeBase4->mAllMetricProducers.end()); 1107 auto& metricProducerTimeBase4_1 = *metricIt; 1108 EXPECT_FALSE(metricProducerTimeBase4_1->isActive()); 1109 1110 metricIt = metricsManagerTimeBase4->mAllMetricProducers.begin(); 1111 for (; metricIt != metricsManagerTimeBase4->mAllMetricProducers.end(); metricIt++) { 1112 if ((*metricIt)->getMetricId() == metricId2) { 1113 break; 1114 } 1115 } 1116 EXPECT_TRUE(metricIt != metricsManagerTimeBase4->mAllMetricProducers.end()); 1117 auto& metricProducerTimeBase4_2 = *metricIt; 1118 EXPECT_TRUE(metricProducerTimeBase4_2->isActive()); 1119 1120 i = 0; 1121 for (; i < metricsManagerTimeBase4->mAllAtomMatchers.size(); i++) { 1122 if (metricsManagerTimeBase4->mAllAtomMatchers[i]->getId() == 1123 metric1ActivationTrigger1->atom_matcher_id()) { 1124 break; 1125 } 1126 } 1127 const auto& activationTimeBase4_1 = metricProducerTimeBase4_1->mEventActivationMap.at(i); 1128 EXPECT_EQ(100 * NS_PER_SEC, activationTimeBase4_1->ttl_ns); 1129 EXPECT_EQ(0, activationTimeBase4_1->start_ns); 1130 EXPECT_EQ(kNotActive, activationTimeBase4_1->state); 1131 1132 i = 0; 1133 for (; i < metricsManagerTimeBase4->mAllAtomMatchers.size(); i++) { 1134 if (metricsManagerTimeBase4->mAllAtomMatchers[i]->getId() == 1135 metric1ActivationTrigger2->atom_matcher_id()) { 1136 break; 1137 } 1138 } 1139 1140 const auto& activationTimeBase4_2 = metricProducerTimeBase4_1->mEventActivationMap.at(i); 1141 EXPECT_EQ(200 * NS_PER_SEC, activationTimeBase4_2->ttl_ns); 1142 EXPECT_EQ(0, activationTimeBase4_2->start_ns); 1143 EXPECT_EQ(kNotActive, activationTimeBase4_2->state); 1144 1145 EXPECT_TRUE(metricProducerTimeBase4_2->isActive()); 1146 // }}}---------------------------------------------------------------------------------- 1147 1148 // Load saved state from disk. 1149 processor4->LoadActiveConfigsFromDisk(); 1150 1151 // Metric 1 active: Activation 1 is not active, Activation 2 is not active 1152 // Metric 2 is active. 1153 // {{{--------------------------------------------------------------------------- 1154 EXPECT_FALSE(metricProducerTimeBase4_1->isActive()); 1155 EXPECT_EQ(kNotActive, activationTimeBase4_1->state); 1156 EXPECT_EQ(kNotActive, activationTimeBase4_2->state); 1157 1158 EXPECT_TRUE(metricProducerTimeBase4_2->isActive()); 1159 // }}}------------------------------------------------------------------------------- 1160 } 1161 1162 TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivationsDifferentActivationTypes) { 1163 int uid = 1111; 1164 1165 // Create config with 2 metrics: 1166 // Metric 1: Activate on boot with 2 activations 1167 // Metric 2: Always active 1168 StatsdConfig config1; 1169 config1.set_id(12341); 1170 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 1171 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher(); 1172 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher(); 1173 *config1.add_atom_matcher() = wakelockAcquireMatcher; 1174 *config1.add_atom_matcher() = screenOnMatcher; 1175 1176 long metricId1 = 1234561; 1177 long metricId2 = 1234562; 1178 1179 auto countMetric1 = config1.add_count_metric(); 1180 countMetric1->set_id(metricId1); 1181 countMetric1->set_what(wakelockAcquireMatcher.id()); 1182 countMetric1->set_bucket(FIVE_MINUTES); 1183 1184 auto countMetric2 = config1.add_count_metric(); 1185 countMetric2->set_id(metricId2); 1186 countMetric2->set_what(wakelockAcquireMatcher.id()); 1187 countMetric2->set_bucket(FIVE_MINUTES); 1188 1189 auto metric1Activation = config1.add_metric_activation(); 1190 metric1Activation->set_metric_id(metricId1); 1191 metric1Activation->set_activation_type(ACTIVATE_ON_BOOT); 1192 auto metric1ActivationTrigger1 = metric1Activation->add_event_activation(); 1193 metric1ActivationTrigger1->set_atom_matcher_id(wakelockAcquireMatcher.id()); 1194 metric1ActivationTrigger1->set_ttl_seconds(100); 1195 auto metric1ActivationTrigger2 = metric1Activation->add_event_activation(); 1196 metric1ActivationTrigger2->set_atom_matcher_id(screenOnMatcher.id()); 1197 metric1ActivationTrigger2->set_ttl_seconds(200); 1198 metric1ActivationTrigger2->set_activation_type(ACTIVATE_IMMEDIATELY); 1199 1200 ConfigKey cfgKey1(uid, 12341); 1201 long timeBase1 = 1; 1202 sp<StatsLogProcessor> processor = 1203 CreateStatsLogProcessor(timeBase1, timeBase1, config1, cfgKey1); 1204 1205 // Metric 1 is not active. 1206 // Metric 2 is active. 1207 // {{{--------------------------------------------------------------------------- 1208 EXPECT_EQ(1, processor->mMetricsManagers.size()); 1209 auto it = processor->mMetricsManagers.find(cfgKey1); 1210 EXPECT_TRUE(it != processor->mMetricsManagers.end()); 1211 auto& metricsManager1 = it->second; 1212 EXPECT_TRUE(metricsManager1->isActive()); 1213 1214 auto metricIt = metricsManager1->mAllMetricProducers.begin(); 1215 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 1216 if ((*metricIt)->getMetricId() == metricId1) { 1217 break; 1218 } 1219 } 1220 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 1221 auto& metricProducer1 = *metricIt; 1222 EXPECT_FALSE(metricProducer1->isActive()); 1223 1224 metricIt = metricsManager1->mAllMetricProducers.begin(); 1225 for (; metricIt != metricsManager1->mAllMetricProducers.end(); metricIt++) { 1226 if ((*metricIt)->getMetricId() == metricId2) { 1227 break; 1228 } 1229 } 1230 EXPECT_TRUE(metricIt != metricsManager1->mAllMetricProducers.end()); 1231 auto& metricProducer2 = *metricIt; 1232 EXPECT_TRUE(metricProducer2->isActive()); 1233 1234 int i = 0; 1235 for (; i < metricsManager1->mAllAtomMatchers.size(); i++) { 1236 if (metricsManager1->mAllAtomMatchers[i]->getId() == 1237 metric1ActivationTrigger1->atom_matcher_id()) { 1238 break; 1239 } 1240 } 1241 const auto& activation1 = metricProducer1->mEventActivationMap.at(i); 1242 EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns); 1243 EXPECT_EQ(0, activation1->start_ns); 1244 EXPECT_EQ(kNotActive, activation1->state); 1245 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1->activationType); 1246 1247 i = 0; 1248 for (; i < metricsManager1->mAllAtomMatchers.size(); i++) { 1249 if (metricsManager1->mAllAtomMatchers[i]->getId() == 1250 metric1ActivationTrigger2->atom_matcher_id()) { 1251 break; 1252 } 1253 } 1254 const auto& activation2 = metricProducer1->mEventActivationMap.at(i); 1255 EXPECT_EQ(200 * NS_PER_SEC, activation2->ttl_ns); 1256 EXPECT_EQ(0, activation2->start_ns); 1257 EXPECT_EQ(kNotActive, activation2->state); 1258 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation2->activationType); 1259 // }}}------------------------------------------------------------------------------ 1260 1261 // Trigger Activation 1 for Metric 1 1262 std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; 1263 auto event = CreateAcquireWakelockEvent(attributions1, "wl1", 100 + timeBase1); 1264 processor->OnLogEvent(event.get()); 1265 1266 // Metric 1 is not active; Activation 1 set to kActiveOnBoot 1267 // Metric 2 is active. 1268 // {{{--------------------------------------------------------------------------- 1269 EXPECT_FALSE(metricProducer1->isActive()); 1270 EXPECT_EQ(0, activation1->start_ns); 1271 EXPECT_EQ(kActiveOnBoot, activation1->state); 1272 EXPECT_EQ(0, activation2->start_ns); 1273 EXPECT_EQ(kNotActive, activation2->state); 1274 1275 EXPECT_TRUE(metricProducer2->isActive()); 1276 // }}}----------------------------------------------------------------------------- 1277 1278 // Simulate shutdown by saving state to disk 1279 int64_t shutDownTime = timeBase1 + 100 * NS_PER_SEC; 1280 processor->SaveActiveConfigsToDisk(shutDownTime); 1281 EXPECT_FALSE(metricProducer1->isActive()); 1282 int64_t ttl1 = metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC; 1283 1284 // Simulate device restarted state by creating new instance of StatsLogProcessor with the 1285 // same config. 1286 long timeBase2 = 1000; 1287 sp<StatsLogProcessor> processor2 = 1288 CreateStatsLogProcessor(timeBase2, timeBase2, config1, cfgKey1); 1289 1290 // Metric 1 is not active. 1291 // Metric 2 is active. 1292 // {{{--------------------------------------------------------------------------- 1293 EXPECT_EQ(1, processor2->mMetricsManagers.size()); 1294 it = processor2->mMetricsManagers.find(cfgKey1); 1295 EXPECT_TRUE(it != processor2->mMetricsManagers.end()); 1296 auto& metricsManager1001 = it->second; 1297 EXPECT_TRUE(metricsManager1001->isActive()); 1298 1299 metricIt = metricsManager1001->mAllMetricProducers.begin(); 1300 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 1301 if ((*metricIt)->getMetricId() == metricId1) { 1302 break; 1303 } 1304 } 1305 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 1306 auto& metricProducer1001 = *metricIt; 1307 EXPECT_FALSE(metricProducer1001->isActive()); 1308 1309 metricIt = metricsManager1001->mAllMetricProducers.begin(); 1310 for (; metricIt != metricsManager1001->mAllMetricProducers.end(); metricIt++) { 1311 if ((*metricIt)->getMetricId() == metricId2) { 1312 break; 1313 } 1314 } 1315 EXPECT_TRUE(metricIt != metricsManager1001->mAllMetricProducers.end()); 1316 auto& metricProducer1002 = *metricIt; 1317 EXPECT_TRUE(metricProducer1002->isActive()); 1318 1319 i = 0; 1320 for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) { 1321 if (metricsManager1001->mAllAtomMatchers[i]->getId() == 1322 metric1ActivationTrigger1->atom_matcher_id()) { 1323 break; 1324 } 1325 } 1326 const auto& activation1001_1 = metricProducer1001->mEventActivationMap.at(i); 1327 EXPECT_EQ(100 * NS_PER_SEC, activation1001_1->ttl_ns); 1328 EXPECT_EQ(0, activation1001_1->start_ns); 1329 EXPECT_EQ(kNotActive, activation1001_1->state); 1330 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1001_1->activationType); 1331 1332 i = 0; 1333 for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) { 1334 if (metricsManager1001->mAllAtomMatchers[i]->getId() == 1335 metric1ActivationTrigger2->atom_matcher_id()) { 1336 break; 1337 } 1338 } 1339 1340 const auto& activation1001_2 = metricProducer1001->mEventActivationMap.at(i); 1341 EXPECT_EQ(200 * NS_PER_SEC, activation1001_2->ttl_ns); 1342 EXPECT_EQ(0, activation1001_2->start_ns); 1343 EXPECT_EQ(kNotActive, activation1001_2->state); 1344 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1001_2->activationType); 1345 // }}}----------------------------------------------------------------------------------- 1346 1347 // Load saved state from disk. 1348 processor2->LoadActiveConfigsFromDisk(); 1349 1350 // Metric 1 active; Activation 1 is active, Activation 2 is not active 1351 // Metric 2 is active. 1352 // {{{--------------------------------------------------------------------------- 1353 EXPECT_TRUE(metricProducer1001->isActive()); 1354 EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns); 1355 EXPECT_EQ(kActive, activation1001_1->state); 1356 EXPECT_EQ(0, activation1001_2->start_ns); 1357 EXPECT_EQ(kNotActive, activation1001_2->state); 1358 1359 EXPECT_TRUE(metricProducer1002->isActive()); 1360 // }}}-------------------------------------------------------------------------------- 1361 1362 // Trigger Activation 2 for Metric 1. 1363 auto screenOnEvent = CreateScreenStateChangedEvent( 1364 android::view::DISPLAY_STATE_ON, 1365 timeBase2 + 200 1366 ); 1367 processor2->OnLogEvent(screenOnEvent.get()); 1368 1369 // Metric 1 active; Activation 1 is active, Activation 2 is active 1370 // Metric 2 is active. 1371 // {{{--------------------------------------------------------------------------- 1372 EXPECT_TRUE(metricProducer1001->isActive()); 1373 EXPECT_EQ(timeBase2 + ttl1 - activation1001_1->ttl_ns, activation1001_1->start_ns); 1374 EXPECT_EQ(kActive, activation1001_1->state); 1375 EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activation1001_2->start_ns); 1376 EXPECT_EQ(kActive, activation1001_2->state); 1377 1378 EXPECT_TRUE(metricProducer1002->isActive()); 1379 // }}}--------------------------------------------------------------------------- 1380 1381 // Simulate shutdown by saving state to disk 1382 shutDownTime = timeBase2 + 50 * NS_PER_SEC; 1383 processor2->SaveActiveConfigsToDisk(shutDownTime); 1384 EXPECT_TRUE(metricProducer1001->isActive()); 1385 EXPECT_TRUE(metricProducer1002->isActive()); 1386 ttl1 = timeBase2 + metric1ActivationTrigger1->ttl_seconds() * NS_PER_SEC - shutDownTime; 1387 int64_t ttl2 = screenOnEvent->GetElapsedTimestampNs() + 1388 metric1ActivationTrigger2->ttl_seconds() * NS_PER_SEC - shutDownTime; 1389 1390 // Simulate device restarted state by creating new instance of StatsLogProcessor with the 1391 // same config. 1392 long timeBase3 = timeBase2 + 120 * NS_PER_SEC; 1393 sp<StatsLogProcessor> processor3 = 1394 CreateStatsLogProcessor(timeBase3, timeBase3, config1, cfgKey1); 1395 1396 // Metric 1 is not active. 1397 // Metric 2 is active. 1398 // {{{--------------------------------------------------------------------------- 1399 EXPECT_EQ(1, processor3->mMetricsManagers.size()); 1400 it = processor3->mMetricsManagers.find(cfgKey1); 1401 EXPECT_TRUE(it != processor3->mMetricsManagers.end()); 1402 auto& metricsManagerTimeBase3 = it->second; 1403 EXPECT_TRUE(metricsManagerTimeBase3->isActive()); 1404 1405 metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin(); 1406 for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) { 1407 if ((*metricIt)->getMetricId() == metricId1) { 1408 break; 1409 } 1410 } 1411 EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end()); 1412 auto& metricProducerTimeBase3_1 = *metricIt; 1413 EXPECT_FALSE(metricProducerTimeBase3_1->isActive()); 1414 1415 metricIt = metricsManagerTimeBase3->mAllMetricProducers.begin(); 1416 for (; metricIt != metricsManagerTimeBase3->mAllMetricProducers.end(); metricIt++) { 1417 if ((*metricIt)->getMetricId() == metricId2) { 1418 break; 1419 } 1420 } 1421 EXPECT_TRUE(metricIt != metricsManagerTimeBase3->mAllMetricProducers.end()); 1422 auto& metricProducerTimeBase3_2 = *metricIt; 1423 EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); 1424 1425 i = 0; 1426 for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) { 1427 if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() == 1428 metric1ActivationTrigger1->atom_matcher_id()) { 1429 break; 1430 } 1431 } 1432 const auto& activationTimeBase3_1 = metricProducerTimeBase3_1->mEventActivationMap.at(i); 1433 EXPECT_EQ(100 * NS_PER_SEC, activationTimeBase3_1->ttl_ns); 1434 EXPECT_EQ(0, activationTimeBase3_1->start_ns); 1435 EXPECT_EQ(kNotActive, activationTimeBase3_1->state); 1436 EXPECT_EQ(ACTIVATE_ON_BOOT, activationTimeBase3_1->activationType); 1437 1438 i = 0; 1439 for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) { 1440 if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() == 1441 metric1ActivationTrigger2->atom_matcher_id()) { 1442 break; 1443 } 1444 } 1445 1446 const auto& activationTimeBase3_2 = metricProducerTimeBase3_1->mEventActivationMap.at(i); 1447 EXPECT_EQ(200 * NS_PER_SEC, activationTimeBase3_2->ttl_ns); 1448 EXPECT_EQ(0, activationTimeBase3_2->start_ns); 1449 EXPECT_EQ(kNotActive, activationTimeBase3_2->state); 1450 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activationTimeBase3_2->activationType); 1451 // }}}---------------------------------------------------------------------------------- 1452 1453 // Load saved state from disk. 1454 processor3->LoadActiveConfigsFromDisk(); 1455 1456 // Metric 1 active: Activation 1 is active, Activation 2 is active 1457 // Metric 2 is active. 1458 // {{{--------------------------------------------------------------------------- 1459 EXPECT_TRUE(metricProducerTimeBase3_1->isActive()); 1460 EXPECT_EQ(timeBase3 + ttl1 - activationTimeBase3_1->ttl_ns, activationTimeBase3_1->start_ns); 1461 EXPECT_EQ(kActive, activationTimeBase3_1->state); 1462 EXPECT_EQ(timeBase3 + ttl2 - activationTimeBase3_2->ttl_ns, activationTimeBase3_2->start_ns); 1463 EXPECT_EQ(kActive, activationTimeBase3_2->state); 1464 1465 EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); 1466 // }}}------------------------------------------------------------------------------- 1467 1468 1469 // Trigger Activation 2 for Metric 1 again. 1470 screenOnEvent = CreateScreenStateChangedEvent( 1471 android::view::DISPLAY_STATE_ON, 1472 timeBase3 + 100 * NS_PER_SEC 1473 ); 1474 processor3->OnLogEvent(screenOnEvent.get()); 1475 1476 // Metric 1 active; Activation 1 is not active, Activation 2 is set to active 1477 // Metric 2 is active. 1478 // {{{--------------------------------------------------------------------------- 1479 EXPECT_TRUE(metricProducerTimeBase3_1->isActive()); 1480 EXPECT_EQ(kNotActive, activationTimeBase3_1->state); 1481 EXPECT_EQ(screenOnEvent->GetElapsedTimestampNs(), activationTimeBase3_2->start_ns); 1482 EXPECT_EQ(kActive, activationTimeBase3_2->state); 1483 1484 EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); 1485 // }}}--------------------------------------------------------------------------- 1486 } 1487 1488 TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { 1489 int uid = 9876; 1490 long configId = 12341; 1491 1492 // Create config with 3 metrics: 1493 // Metric 1: Activate on 2 activations, 1 on boot, 1 immediate. 1494 // Metric 2: Activate on 2 activations, 1 on boot, 1 immediate. 1495 // Metric 3: Always active 1496 StatsdConfig config1; 1497 config1.set_id(configId); 1498 config1.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root. 1499 auto wakelockAcquireMatcher = CreateAcquireWakelockAtomMatcher(); 1500 auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher(); 1501 auto jobStartMatcher = CreateStartScheduledJobAtomMatcher(); 1502 auto jobFinishMatcher = CreateFinishScheduledJobAtomMatcher(); 1503 *config1.add_atom_matcher() = wakelockAcquireMatcher; 1504 *config1.add_atom_matcher() = screenOnMatcher; 1505 *config1.add_atom_matcher() = jobStartMatcher; 1506 *config1.add_atom_matcher() = jobFinishMatcher; 1507 1508 long metricId1 = 1234561; 1509 long metricId2 = 1234562; 1510 long metricId3 = 1234563; 1511 1512 auto countMetric1 = config1.add_count_metric(); 1513 countMetric1->set_id(metricId1); 1514 countMetric1->set_what(wakelockAcquireMatcher.id()); 1515 countMetric1->set_bucket(FIVE_MINUTES); 1516 1517 auto countMetric2 = config1.add_count_metric(); 1518 countMetric2->set_id(metricId2); 1519 countMetric2->set_what(wakelockAcquireMatcher.id()); 1520 countMetric2->set_bucket(FIVE_MINUTES); 1521 1522 auto countMetric3 = config1.add_count_metric(); 1523 countMetric3->set_id(metricId3); 1524 countMetric3->set_what(wakelockAcquireMatcher.id()); 1525 countMetric3->set_bucket(FIVE_MINUTES); 1526 1527 // Metric 1 activates on boot for wakelock acquire, immediately for screen on. 1528 auto metric1Activation = config1.add_metric_activation(); 1529 metric1Activation->set_metric_id(metricId1); 1530 auto metric1ActivationTrigger1 = metric1Activation->add_event_activation(); 1531 metric1ActivationTrigger1->set_atom_matcher_id(wakelockAcquireMatcher.id()); 1532 metric1ActivationTrigger1->set_ttl_seconds(100); 1533 metric1ActivationTrigger1->set_activation_type(ACTIVATE_ON_BOOT); 1534 auto metric1ActivationTrigger2 = metric1Activation->add_event_activation(); 1535 metric1ActivationTrigger2->set_atom_matcher_id(screenOnMatcher.id()); 1536 metric1ActivationTrigger2->set_ttl_seconds(200); 1537 metric1ActivationTrigger2->set_activation_type(ACTIVATE_IMMEDIATELY); 1538 1539 // Metric 2 activates on boot for scheduled job start, immediately for scheduled job finish. 1540 auto metric2Activation = config1.add_metric_activation(); 1541 metric2Activation->set_metric_id(metricId2); 1542 auto metric2ActivationTrigger1 = metric2Activation->add_event_activation(); 1543 metric2ActivationTrigger1->set_atom_matcher_id(jobStartMatcher.id()); 1544 metric2ActivationTrigger1->set_ttl_seconds(100); 1545 metric2ActivationTrigger1->set_activation_type(ACTIVATE_ON_BOOT); 1546 auto metric2ActivationTrigger2 = metric2Activation->add_event_activation(); 1547 metric2ActivationTrigger2->set_atom_matcher_id(jobFinishMatcher.id()); 1548 metric2ActivationTrigger2->set_ttl_seconds(200); 1549 metric2ActivationTrigger2->set_activation_type(ACTIVATE_IMMEDIATELY); 1550 1551 // Send the config. 1552 StatsService service(nullptr, nullptr); 1553 string serialized = config1.SerializeAsString(); 1554 service.addConfigurationChecked(uid, configId, {serialized.begin(), serialized.end()}); 1555 1556 // Make sure the config is stored on disk. Otherwise, we will not reset on system server death. 1557 StatsdConfig tmpConfig; 1558 ConfigKey cfgKey1(uid, configId); 1559 EXPECT_TRUE(StorageManager::readConfigFromDisk(cfgKey1, &tmpConfig)); 1560 1561 // Metric 1 is not active. 1562 // Metric 2 is not active. 1563 // Metric 3 is active. 1564 // {{{--------------------------------------------------------------------------- 1565 sp<StatsLogProcessor> processor = service.mProcessor; 1566 EXPECT_EQ(1, processor->mMetricsManagers.size()); 1567 auto it = processor->mMetricsManagers.find(cfgKey1); 1568 EXPECT_TRUE(it != processor->mMetricsManagers.end()); 1569 auto& metricsManager1 = it->second; 1570 EXPECT_TRUE(metricsManager1->isActive()); 1571 EXPECT_EQ(3, metricsManager1->mAllMetricProducers.size()); 1572 1573 auto& metricProducer1 = metricsManager1->mAllMetricProducers[0]; 1574 EXPECT_EQ(metricId1, metricProducer1->getMetricId()); 1575 EXPECT_FALSE(metricProducer1->isActive()); 1576 1577 auto& metricProducer2 = metricsManager1->mAllMetricProducers[1]; 1578 EXPECT_EQ(metricId2, metricProducer2->getMetricId()); 1579 EXPECT_FALSE(metricProducer2->isActive()); 1580 1581 auto& metricProducer3 = metricsManager1->mAllMetricProducers[2]; 1582 EXPECT_EQ(metricId3, metricProducer3->getMetricId()); 1583 EXPECT_TRUE(metricProducer3->isActive()); 1584 1585 // Check event activations. 1586 EXPECT_EQ(metricsManager1->mAllAtomMatchers.size(), 4); 1587 EXPECT_EQ(metricsManager1->mAllAtomMatchers[0]->getId(), 1588 metric1ActivationTrigger1->atom_matcher_id()); 1589 const auto& activation1 = metricProducer1->mEventActivationMap.at(0); 1590 EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns); 1591 EXPECT_EQ(0, activation1->start_ns); 1592 EXPECT_EQ(kNotActive, activation1->state); 1593 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1->activationType); 1594 1595 EXPECT_EQ(metricsManager1->mAllAtomMatchers[1]->getId(), 1596 metric1ActivationTrigger2->atom_matcher_id()); 1597 const auto& activation2 = metricProducer1->mEventActivationMap.at(1); 1598 EXPECT_EQ(200 * NS_PER_SEC, activation2->ttl_ns); 1599 EXPECT_EQ(0, activation2->start_ns); 1600 EXPECT_EQ(kNotActive, activation2->state); 1601 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation2->activationType); 1602 1603 EXPECT_EQ(metricsManager1->mAllAtomMatchers[2]->getId(), 1604 metric2ActivationTrigger1->atom_matcher_id()); 1605 const auto& activation3 = metricProducer2->mEventActivationMap.at(2); 1606 EXPECT_EQ(100 * NS_PER_SEC, activation3->ttl_ns); 1607 EXPECT_EQ(0, activation3->start_ns); 1608 EXPECT_EQ(kNotActive, activation3->state); 1609 EXPECT_EQ(ACTIVATE_ON_BOOT, activation3->activationType); 1610 1611 EXPECT_EQ(metricsManager1->mAllAtomMatchers[3]->getId(), 1612 metric2ActivationTrigger2->atom_matcher_id()); 1613 const auto& activation4 = metricProducer2->mEventActivationMap.at(3); 1614 EXPECT_EQ(200 * NS_PER_SEC, activation4->ttl_ns); 1615 EXPECT_EQ(0, activation4->start_ns); 1616 EXPECT_EQ(kNotActive, activation4->state); 1617 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation4->activationType); 1618 // }}}------------------------------------------------------------------------------ 1619 1620 // Trigger Activation 1 for Metric 1. Should activate on boot. 1621 // Trigger Activation 4 for Metric 2. Should activate immediately. 1622 long configAddedTimeNs = metricsManager1->mLastReportTimeNs; 1623 std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; 1624 auto event = CreateAcquireWakelockEvent(attributions1, "wl1", 1 + configAddedTimeNs); 1625 processor->OnLogEvent(event.get()); 1626 1627 event = CreateFinishScheduledJobEvent(attributions1, "finish1", 2 + configAddedTimeNs); 1628 processor->OnLogEvent(event.get()); 1629 1630 // Metric 1 is not active; Activation 1 set to kActiveOnBoot 1631 // Metric 2 is active. Activation 4 set to kActive 1632 // Metric 3 is active. 1633 // {{{--------------------------------------------------------------------------- 1634 EXPECT_FALSE(metricProducer1->isActive()); 1635 EXPECT_EQ(0, activation1->start_ns); 1636 EXPECT_EQ(kActiveOnBoot, activation1->state); 1637 EXPECT_EQ(0, activation2->start_ns); 1638 EXPECT_EQ(kNotActive, activation2->state); 1639 1640 EXPECT_TRUE(metricProducer2->isActive()); 1641 EXPECT_EQ(0, activation3->start_ns); 1642 EXPECT_EQ(kNotActive, activation3->state); 1643 EXPECT_EQ(2 + configAddedTimeNs, activation4->start_ns); 1644 EXPECT_EQ(kActive, activation4->state); 1645 1646 EXPECT_TRUE(metricProducer3->isActive()); 1647 // }}}----------------------------------------------------------------------------- 1648 1649 // Can't fake time with StatsService. 1650 // Lets get a time close to the system server death time and make sure it's sane. 1651 int64_t approximateSystemServerDeath = getElapsedRealtimeNs(); 1652 EXPECT_TRUE(approximateSystemServerDeath > 2 + configAddedTimeNs); 1653 EXPECT_TRUE(approximateSystemServerDeath < NS_PER_SEC + configAddedTimeNs); 1654 1655 // System server dies. 1656 service.binderDied(nullptr); 1657 1658 // We should have a new metrics manager. Lets get it and ensure activation status is restored. 1659 // {{{--------------------------------------------------------------------------- 1660 EXPECT_EQ(1, processor->mMetricsManagers.size()); 1661 it = processor->mMetricsManagers.find(cfgKey1); 1662 EXPECT_TRUE(it != processor->mMetricsManagers.end()); 1663 auto& metricsManager2 = it->second; 1664 EXPECT_TRUE(metricsManager2->isActive()); 1665 EXPECT_EQ(3, metricsManager2->mAllMetricProducers.size()); 1666 1667 auto& metricProducer1001 = metricsManager2->mAllMetricProducers[0]; 1668 EXPECT_EQ(metricId1, metricProducer1001->getMetricId()); 1669 EXPECT_FALSE(metricProducer1001->isActive()); 1670 1671 auto& metricProducer1002 = metricsManager2->mAllMetricProducers[1]; 1672 EXPECT_EQ(metricId2, metricProducer1002->getMetricId()); 1673 EXPECT_TRUE(metricProducer1002->isActive()); 1674 1675 auto& metricProducer1003 = metricsManager2->mAllMetricProducers[2]; 1676 EXPECT_EQ(metricId3, metricProducer1003->getMetricId()); 1677 EXPECT_TRUE(metricProducer1003->isActive()); 1678 1679 // Check event activations. 1680 // Activation 1 is kActiveOnBoot. 1681 // Activation 2 and 3 are not active. 1682 // Activation 4 is active. 1683 EXPECT_EQ(metricsManager2->mAllAtomMatchers.size(), 4); 1684 EXPECT_EQ(metricsManager2->mAllAtomMatchers[0]->getId(), 1685 metric1ActivationTrigger1->atom_matcher_id()); 1686 const auto& activation1001 = metricProducer1001->mEventActivationMap.at(0); 1687 EXPECT_EQ(100 * NS_PER_SEC, activation1001->ttl_ns); 1688 EXPECT_EQ(0, activation1001->start_ns); 1689 EXPECT_EQ(kActiveOnBoot, activation1001->state); 1690 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1001->activationType); 1691 1692 EXPECT_EQ(metricsManager2->mAllAtomMatchers[1]->getId(), 1693 metric1ActivationTrigger2->atom_matcher_id()); 1694 const auto& activation1002 = metricProducer1001->mEventActivationMap.at(1); 1695 EXPECT_EQ(200 * NS_PER_SEC, activation1002->ttl_ns); 1696 EXPECT_EQ(0, activation1002->start_ns); 1697 EXPECT_EQ(kNotActive, activation1002->state); 1698 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1002->activationType); 1699 1700 EXPECT_EQ(metricsManager2->mAllAtomMatchers[2]->getId(), 1701 metric2ActivationTrigger1->atom_matcher_id()); 1702 const auto& activation1003 = metricProducer1002->mEventActivationMap.at(2); 1703 EXPECT_EQ(100 * NS_PER_SEC, activation1003->ttl_ns); 1704 EXPECT_EQ(0, activation1003->start_ns); 1705 EXPECT_EQ(kNotActive, activation1003->state); 1706 EXPECT_EQ(ACTIVATE_ON_BOOT, activation1003->activationType); 1707 1708 EXPECT_EQ(metricsManager2->mAllAtomMatchers[3]->getId(), 1709 metric2ActivationTrigger2->atom_matcher_id()); 1710 const auto& activation1004 = metricProducer1002->mEventActivationMap.at(3); 1711 EXPECT_EQ(200 * NS_PER_SEC, activation1004->ttl_ns); 1712 EXPECT_EQ(2 + configAddedTimeNs, activation1004->start_ns); 1713 EXPECT_EQ(kActive, activation1004->state); 1714 EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1004->activationType); 1715 // }}}------------------------------------------------------------------------------ 1716 } 1717 1718 #else 1719 GTEST_LOG_(INFO) << "This test does nothing.\n"; 1720 #endif 1721 1722 } // namespace statsd 1723 } // namespace os 1724 } // namespace android 1725
