Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "(Part 1) Use new socket schema with statsd tests" into rvc-dev

Browse Source
This commit is contained in:
TreeHugger Robot
2020-03-11 07:05:51 +00:00
committed by Android (Google) Code Review
parent 4857993641 7747d37c34
commit a8c6c8b1f6
22 changed files with 7290 additions and 7172 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
cmds/statsd/src/logd/LogEvent.h
View File

@@ -328,4 +328,3 @@ void writeExperimentIdsToProto(const std::vector<int64_t>& experimentIds, std::v
} // namespace statsd } // namespace statsd
} // namespace os } // namespace os
} // namespace android } // namespace android

489
cmds/statsd/tests/condition/SimpleConditionTracker_test.cpp
View File

@@ -137,7 +137,9 @@ TEST(SimpleConditionTrackerTest, TestNonSlicedCondition) {
simplePredicate, trackerNameIndexMap); simplePredicate, trackerNameIndexMap);
EXPECT_FALSE(conditionTracker.isSliced()); EXPECT_FALSE(conditionTracker.isSliced());
LogEvent event(1 /*tagId*/, 0 /*timestamp*/); // This event is not accessed in this test besides dimensions which is why this is okay.
// This is technically an invalid LogEvent because we do not call parseBuffer.
LogEvent event(/*uid=*/0, /*pid=*/0);
vector<MatchingState> matcherState; vector<MatchingState> matcherState;
matcherState.push_back(MatchingState::kNotMatched); matcherState.push_back(MatchingState::kNotMatched);
@@ -222,7 +224,9 @@ TEST(SimpleConditionTrackerTest, TestNonSlicedConditionNestCounting) {
trackerNameIndexMap); trackerNameIndexMap);
EXPECT_FALSE(conditionTracker.isSliced()); EXPECT_FALSE(conditionTracker.isSliced());
LogEvent event(1 /*tagId*/, 0 /*timestamp*/); // This event is not accessed in this test besides dimensions which is why this is okay.
// This is technically an invalid LogEvent because we do not call parseBuffer.
LogEvent event(/*uid=*/0, /*pid=*/0);
// one matched start // one matched start
vector<MatchingState> matcherState; vector<MatchingState> matcherState;
@@ -296,8 +300,8 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) {
std::vector<int> uids = {111, 222, 333}; std::vector<int> uids = {111, 222, 333};
LogEvent event(/*uid=*/-1, /*pid=*/-1); LogEvent event1(/*uid=*/0, /*pid=*/0);
makeWakeLockEvent(&event, /*atomId=*/1, /*timestamp=*/0, uids, "wl1", /*acquire=*/1); makeWakeLockEvent(&event1, /*atomId=*/1, /*timestamp=*/0, uids, "wl1", /*acquire=*/1);
// one matched start // one matched start
vector<MatchingState> matcherState; vector<MatchingState> matcherState;
@@ -308,7 +312,7 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) {
vector<ConditionState> conditionCache(1, ConditionState::kNotEvaluated); vector<ConditionState> conditionCache(1, ConditionState::kNotEvaluated);
vector<bool> changedCache(1, false); vector<bool> changedCache(1, false);
conditionTracker.evaluateCondition(event, matcherState, allPredicates, conditionCache, conditionTracker.evaluateCondition(event1, matcherState, allPredicates, conditionCache,
changedCache); changedCache);
if (position == Position::FIRST || position == Position::LAST) { if (position == Position::FIRST || position == Position::LAST) {
@@ -333,7 +337,7 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) {
EXPECT_EQ(ConditionState::kTrue, conditionCache[0]); EXPECT_EQ(ConditionState::kTrue, conditionCache[0]);
// another wake lock acquired by this uid // another wake lock acquired by this uid
LogEvent event2(/*uid=*/-1, /*pid=*/-1); LogEvent event2(/*uid=*/0, /*pid=*/0);
makeWakeLockEvent(&event2, /*atomId=*/1, /*timestamp=*/0, uids, "wl2", /*acquire=*/1); makeWakeLockEvent(&event2, /*atomId=*/1, /*timestamp=*/0, uids, "wl2", /*acquire=*/1);
matcherState.clear(); matcherState.clear();
matcherState.push_back(MatchingState::kMatched); matcherState.push_back(MatchingState::kMatched);
@@ -353,7 +357,7 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) {
// wake lock 1 release // wake lock 1 release
LogEvent event3(/*uid=*/-1, /*pid=*/-1); LogEvent event3(/*uid=*/0, /*pid=*/0);
makeWakeLockEvent(&event3, /*atomId=*/1, /*timestamp=*/0, uids, "wl1", /*acquire=*/0); makeWakeLockEvent(&event3, /*atomId=*/1, /*timestamp=*/0, uids, "wl1", /*acquire=*/0);
matcherState.clear(); matcherState.clear();
matcherState.push_back(MatchingState::kNotMatched); matcherState.push_back(MatchingState::kNotMatched);
@@ -372,7 +376,7 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) {
EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty()); EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty());
EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty());
LogEvent event4(/*uid=*/-1, /*pid=*/-1); LogEvent event4(/*uid=*/0, /*pid=*/0);
makeWakeLockEvent(&event4, /*atomId=*/1, /*timestamp=*/0, uids, "wl2", /*acquire=*/0); makeWakeLockEvent(&event4, /*atomId=*/1, /*timestamp=*/0, uids, "wl2", /*acquire=*/0);
matcherState.clear(); matcherState.clear();
matcherState.push_back(MatchingState::kNotMatched); matcherState.push_back(MatchingState::kNotMatched);
@@ -399,246 +403,235 @@ TEST(SimpleConditionTrackerTest, TestSlicedCondition) {
} }
//TEST(SimpleConditionTrackerTest, TestSlicedWithNoOutputDim) { TEST(SimpleConditionTrackerTest, TestSlicedWithNoOutputDim) {
// std::vector<sp<ConditionTracker>> allConditions; std::vector<sp<ConditionTracker>> allConditions;
//
// SimplePredicate simplePredicate = getWakeLockHeldCondition( SimplePredicate simplePredicate =
// true /*nesting*/, true /*default to false*/, false /*slice output by uid*/, getWakeLockHeldCondition(true /*nesting*/, true /*default to false*/,
// Position::ANY /* position */); false /*slice output by uid*/, Position::ANY /* position */);
// string conditionName = "WL_HELD"; string conditionName = "WL_HELD";
//
// unordered_map<int64_t, int> trackerNameIndexMap; unordered_map<int64_t, int> trackerNameIndexMap;
// trackerNameIndexMap[StringToId("WAKE_LOCK_ACQUIRE")] = 0; trackerNameIndexMap[StringToId("WAKE_LOCK_ACQUIRE")] = 0;
// trackerNameIndexMap[StringToId("WAKE_LOCK_RELEASE")] = 1; trackerNameIndexMap[StringToId("WAKE_LOCK_RELEASE")] = 1;
// trackerNameIndexMap[StringToId("RELEASE_ALL")] = 2; trackerNameIndexMap[StringToId("RELEASE_ALL")] = 2;
//
// SimpleConditionTracker conditionTracker(kConfigKey, StringToId(conditionName), SimpleConditionTracker conditionTracker(kConfigKey, StringToId(conditionName),
// 0 /*condition tracker index*/, simplePredicate, 0 /*condition tracker index*/, simplePredicate,
// trackerNameIndexMap); trackerNameIndexMap);
//
// EXPECT_FALSE(conditionTracker.isSliced()); EXPECT_FALSE(conditionTracker.isSliced());
//
// std::vector<int> uid_list1 = {111, 1111, 11111}; std::vector<int> uids1 = {111, 1111, 11111};
// string uid1_wl1 = "wl1_1"; string uid1_wl1 = "wl1_1";
// std::vector<int> uid_list2 = {222, 2222, 22222}; std::vector<int> uids2 = {222, 2222, 22222};
// string uid2_wl1 = "wl2_1"; string uid2_wl1 = "wl2_1";
//
// LogEvent event(1 /*tagId*/, 0 /*timestamp*/); LogEvent event1(/*uid=*/0, /*pid=*/0);
// makeWakeLockEvent(&event, uid_list1, uid1_wl1, 1); makeWakeLockEvent(&event1, /*atomId=*/1, /*timestamp=*/0, uids1, uid1_wl1, /*acquire=*/1);
//
// // one matched start for uid1 // one matched start for uid1
// vector<MatchingState> matcherState; vector<MatchingState> matcherState;
// matcherState.push_back(MatchingState::kMatched); matcherState.push_back(MatchingState::kMatched);
// matcherState.push_back(MatchingState::kNotMatched); matcherState.push_back(MatchingState::kNotMatched);
// matcherState.push_back(MatchingState::kNotMatched); matcherState.push_back(MatchingState::kNotMatched);
// vector<sp<ConditionTracker>> allPredicates; vector<sp<ConditionTracker>> allPredicates;
// vector<ConditionState> conditionCache(1, ConditionState::kNotEvaluated); vector<ConditionState> conditionCache(1, ConditionState::kNotEvaluated);
// vector<bool> changedCache(1, false); vector<bool> changedCache(1, false);
//
// conditionTracker.evaluateCondition(event, matcherState, allPredicates, conditionCache, conditionTracker.evaluateCondition(event1, matcherState, allPredicates, conditionCache,
// changedCache); changedCache);
//
// EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size());
// EXPECT_TRUE(changedCache[0]); EXPECT_TRUE(changedCache[0]);
//
// // Now test query // Now test query
// ConditionKey queryKey; ConditionKey queryKey;
// conditionCache[0] = ConditionState::kNotEvaluated; conditionCache[0] = ConditionState::kNotEvaluated;
//
// conditionTracker.isConditionMet(queryKey, allPredicates, conditionTracker.isConditionMet(queryKey, allPredicates, true, conditionCache);
// true, EXPECT_EQ(ConditionState::kTrue, conditionCache[0]);
// conditionCache);
// EXPECT_EQ(ConditionState::kTrue, conditionCache[0]); // another wake lock acquired by this uid
// LogEvent event2(/*uid=*/0, /*pid=*/0);
// // another wake lock acquired by this uid makeWakeLockEvent(&event2, /*atomId=*/1, /*timestamp=*/0, uids2, uid2_wl1, /*acquire=*/1);
// LogEvent event2(1 /*tagId*/, 0 /*timestamp*/);
// makeWakeLockEvent(&event2, uid_list2, uid2_wl1, 1); matcherState.clear();
// matcherState.clear(); matcherState.push_back(MatchingState::kMatched);
// matcherState.push_back(MatchingState::kMatched); matcherState.push_back(MatchingState::kNotMatched);
// matcherState.push_back(MatchingState::kNotMatched); conditionCache[0] = ConditionState::kNotEvaluated;
// conditionCache[0] = ConditionState::kNotEvaluated; changedCache[0] = false;
// changedCache[0] = false; conditionTracker.evaluateCondition(event2, matcherState, allPredicates, conditionCache,
// conditionTracker.evaluateCondition(event2, matcherState, allPredicates, conditionCache, changedCache);
// changedCache); EXPECT_FALSE(changedCache[0]);
// EXPECT_FALSE(changedCache[0]);
// // uid1 wake lock 1 release
// // uid1 wake lock 1 release LogEvent event3(/*uid=*/0, /*pid=*/0);
// LogEvent event3(1 /*tagId*/, 0 /*timestamp*/); makeWakeLockEvent(&event3, /*atomId=*/1, /*timestamp=*/0, uids1, uid1_wl1,
// makeWakeLockEvent(&event3, uid_list1, uid1_wl1, 0); // now release it. /*release=*/0); // now release it.
// matcherState.clear();
// matcherState.push_back(MatchingState::kNotMatched); matcherState.clear();
// matcherState.push_back(MatchingState::kMatched); matcherState.push_back(MatchingState::kNotMatched);
// conditionCache[0] = ConditionState::kNotEvaluated; matcherState.push_back(MatchingState::kMatched);
// changedCache[0] = false; conditionCache[0] = ConditionState::kNotEvaluated;
// conditionTracker.evaluateCondition(event3, matcherState, allPredicates, conditionCache, changedCache[0] = false;
// changedCache); conditionTracker.evaluateCondition(event3, matcherState, allPredicates, conditionCache,
// // nothing changes, because uid2 is still holding wl. changedCache);
// EXPECT_FALSE(changedCache[0]); // nothing changes, because uid2 is still holding wl.
// EXPECT_FALSE(changedCache[0]);
// LogEvent event4(1 /*tagId*/, 0 /*timestamp*/);
// makeWakeLockEvent(&event4, uid_list2, uid2_wl1, 0); // now release it. LogEvent event4(/*uid=*/0, /*pid=*/0);
// matcherState.clear(); makeWakeLockEvent(&event4, /*atomId=*/1, /*timestamp=*/0, uids2, uid2_wl1,
// matcherState.push_back(MatchingState::kNotMatched); /*acquire=*/0); // now release it.
// matcherState.push_back(MatchingState::kMatched); matcherState.clear();
// conditionCache[0] = ConditionState::kNotEvaluated; matcherState.push_back(MatchingState::kNotMatched);
// changedCache[0] = false; matcherState.push_back(MatchingState::kMatched);
// conditionTracker.evaluateCondition(event4, matcherState, allPredicates, conditionCache, conditionCache[0] = ConditionState::kNotEvaluated;
// changedCache); changedCache[0] = false;
// EXPECT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); conditionTracker.evaluateCondition(event4, matcherState, allPredicates, conditionCache,
// EXPECT_TRUE(changedCache[0]); changedCache);
// EXPECT_EQ(0UL, conditionTracker.mSlicedConditionState.size());
// // query again EXPECT_TRUE(changedCache[0]);
// conditionCache[0] = ConditionState::kNotEvaluated;
// conditionTracker.isConditionMet(queryKey, allPredicates, // query again
// true, conditionCache[0] = ConditionState::kNotEvaluated;
// conditionCache); conditionTracker.isConditionMet(queryKey, allPredicates, true, conditionCache);
// EXPECT_EQ(ConditionState::kFalse, conditionCache[0]); EXPECT_EQ(ConditionState::kFalse, conditionCache[0]);
//} }
//
//TEST(SimpleConditionTrackerTest, TestStopAll) { TEST(SimpleConditionTrackerTest, TestStopAll) {
// std::vector<sp<ConditionTracker>> allConditions; std::vector<sp<ConditionTracker>> allConditions;
// for (Position position : for (Position position : {Position::FIRST, Position::LAST}) {
// { Position::FIRST, Position::LAST }) { SimplePredicate simplePredicate =
// SimplePredicate simplePredicate = getWakeLockHeldCondition( getWakeLockHeldCondition(true /*nesting*/, true /*default to false*/,
// true /*nesting*/, true /*default to false*/, true /*output slice by uid*/, true /*output slice by uid*/, position);
// position); string conditionName = "WL_HELD_BY_UID3";
// string conditionName = "WL_HELD_BY_UID3";
// unordered_map<int64_t, int> trackerNameIndexMap;
// unordered_map<int64_t, int> trackerNameIndexMap; trackerNameIndexMap[StringToId("WAKE_LOCK_ACQUIRE")] = 0;
// trackerNameIndexMap[StringToId("WAKE_LOCK_ACQUIRE")] = 0; trackerNameIndexMap[StringToId("WAKE_LOCK_RELEASE")] = 1;
// trackerNameIndexMap[StringToId("WAKE_LOCK_RELEASE")] = 1; trackerNameIndexMap[StringToId("RELEASE_ALL")] = 2;
// trackerNameIndexMap[StringToId("RELEASE_ALL")] = 2;
// SimpleConditionTracker conditionTracker(kConfigKey, StringToId(conditionName),
// SimpleConditionTracker conditionTracker(kConfigKey, StringToId(conditionName), 0 /*condition tracker index*/, simplePredicate,
// 0 /*condition tracker index*/, simplePredicate, trackerNameIndexMap);
// trackerNameIndexMap);
// std::vector<int> uids1 = {111, 1111, 11111};
// std::vector<int> uid_list1 = {111, 1111, 11111}; std::vector<int> uids2 = {222, 2222, 22222};
// std::vector<int> uid_list2 = {222, 2222, 22222};
// LogEvent event1(/*uid=*/0, /*pid=*/0);
// LogEvent event(1 /*tagId*/, 0 /*timestamp*/); makeWakeLockEvent(&event1, /*atomId=*/1, /*timestamp=*/0, uids1, "wl1", /*acquire=*/1);
// makeWakeLockEvent(&event, uid_list1, "wl1", 1);
// // one matched start
// // one matched start vector<MatchingState> matcherState;
// vector<MatchingState> matcherState; matcherState.push_back(MatchingState::kMatched);
// matcherState.push_back(MatchingState::kMatched); matcherState.push_back(MatchingState::kNotMatched);
// matcherState.push_back(MatchingState::kNotMatched); matcherState.push_back(MatchingState::kNotMatched);
// matcherState.push_back(MatchingState::kNotMatched); vector<sp<ConditionTracker>> allPredicates;
// vector<sp<ConditionTracker>> allPredicates; vector<ConditionState> conditionCache(1, ConditionState::kNotEvaluated);
// vector<ConditionState> conditionCache(1, ConditionState::kNotEvaluated); vector<bool> changedCache(1, false);
// vector<bool> changedCache(1, false);
// conditionTracker.evaluateCondition(event1, matcherState, allPredicates, conditionCache,
// conditionTracker.evaluateCondition(event, matcherState, allPredicates, conditionCache, changedCache);
// changedCache); if (position == Position::FIRST || position == Position::LAST) {
// if (position == Position::FIRST || EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size());
// position == Position::LAST) { } else {
// EXPECT_EQ(1UL, conditionTracker.mSlicedConditionState.size()); EXPECT_EQ(uids1.size(), conditionTracker.mSlicedConditionState.size());
// } else { }
// EXPECT_EQ(uid_list1.size(), conditionTracker.mSlicedConditionState.size()); EXPECT_TRUE(changedCache[0]);
// } {
// EXPECT_TRUE(changedCache[0]); if (position == Position::FIRST || position == Position::LAST) {
// { EXPECT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size());
// if (position == Position::FIRST || EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty());
// position == Position::LAST) { } else {
// EXPECT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size()); EXPECT_EQ(uids1.size(),
// EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); conditionTracker.getChangedToTrueDimensions(allConditions)->size());
// } else { EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty());
// EXPECT_EQ(uid_list1.size(), conditionTracker.getChangedToTrueDimensions(allConditions)->size()); }
// EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); }
// }
// } // Now test query
// const auto queryKey = getWakeLockQueryKey(position, uids1, conditionName);
// // Now test query conditionCache[0] = ConditionState::kNotEvaluated;
// const auto queryKey = getWakeLockQueryKey(position, uid_list1, conditionName);
// conditionCache[0] = ConditionState::kNotEvaluated; conditionTracker.isConditionMet(queryKey, allPredicates, false, conditionCache);
// EXPECT_EQ(ConditionState::kTrue, conditionCache[0]);
// conditionTracker.isConditionMet(queryKey, allPredicates,
// false, // another wake lock acquired by uid2
// conditionCache); LogEvent event2(/*uid=*/0, /*pid=*/0);
// EXPECT_EQ(ConditionState::kTrue, conditionCache[0]); makeWakeLockEvent(&event2, /*atomId=*/1, /*timestamp=*/0, uids2, "wl2", /*acquire=*/1);
//
// // another wake lock acquired by uid2 matcherState.clear();
// LogEvent event2(1 /*tagId*/, 0 /*timestamp*/); matcherState.push_back(MatchingState::kMatched);
// makeWakeLockEvent(&event2, uid_list2, "wl2", 1); matcherState.push_back(MatchingState::kNotMatched);
// matcherState.clear(); matcherState.push_back(MatchingState::kNotMatched);
// matcherState.push_back(MatchingState::kMatched); conditionCache[0] = ConditionState::kNotEvaluated;
// matcherState.push_back(MatchingState::kNotMatched); changedCache[0] = false;
// matcherState.push_back(MatchingState::kNotMatched); conditionTracker.evaluateCondition(event2, matcherState, allPredicates, conditionCache,
// conditionCache[0] = ConditionState::kNotEvaluated; changedCache);
// changedCache[0] = false; if (position == Position::FIRST || position == Position::LAST) {
// conditionTracker.evaluateCondition(event2, matcherState, allPredicates, conditionCache, EXPECT_EQ(2UL, conditionTracker.mSlicedConditionState.size());
// changedCache); } else {
// if (position == Position::FIRST || EXPECT_EQ(uids1.size() + uids2.size(), conditionTracker.mSlicedConditionState.size());
// position == Position::LAST) { }
// EXPECT_EQ(2UL, conditionTracker.mSlicedConditionState.size()); EXPECT_TRUE(changedCache[0]);
// } else { {
// EXPECT_EQ(uid_list1.size() + uid_list2.size(), if (position == Position::FIRST || position == Position::LAST) {
// conditionTracker.mSlicedConditionState.size()); EXPECT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size());
// } EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty());
// EXPECT_TRUE(changedCache[0]); } else {
// { EXPECT_EQ(uids2.size(),
// if (position == Position::FIRST || conditionTracker.getChangedToTrueDimensions(allConditions)->size());
// position == Position::LAST) { EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty());
// EXPECT_EQ(1UL, conditionTracker.getChangedToTrueDimensions(allConditions)->size()); }
// EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); }
// } else {
// EXPECT_EQ(uid_list2.size(), conditionTracker.getChangedToTrueDimensions(allConditions)->size()); // TEST QUERY
// EXPECT_TRUE(conditionTracker.getChangedToFalseDimensions(allConditions)->empty()); const auto queryKey2 = getWakeLockQueryKey(position, uids2, conditionName);
// } conditionCache[0] = ConditionState::kNotEvaluated;
// } conditionTracker.isConditionMet(queryKey, allPredicates, false, conditionCache);
//
// EXPECT_EQ(ConditionState::kTrue, conditionCache[0]);
// // TEST QUERY
// const auto queryKey2 = getWakeLockQueryKey(position, uid_list2, conditionName); // stop all event
// conditionCache[0] = ConditionState::kNotEvaluated; LogEvent event3(/*uid=*/0, /*pid=*/0);
// conditionTracker.isConditionMet(queryKey, allPredicates, makeWakeLockEvent(&event3, /*atomId=*/1, /*timestamp=*/0, uids2, "wl2", /*acquire=*/1);
// false,
// conditionCache); matcherState.clear();
// matcherState.push_back(MatchingState::kNotMatched);
// EXPECT_EQ(ConditionState::kTrue, conditionCache[0]); matcherState.push_back(MatchingState::kNotMatched);
// matcherState.push_back(MatchingState::kMatched);
//
// // stop all event conditionCache[0] = ConditionState::kNotEvaluated;
// LogEvent event3(2 /*tagId*/, 0 /*timestamp*/); changedCache[0] = false;
// matcherState.clear(); conditionTracker.evaluateCondition(event3, matcherState, allPredicates, conditionCache,
// matcherState.push_back(MatchingState::kNotMatched); changedCache);
// matcherState.push_back(MatchingState::kNotMatched); EXPECT_TRUE(changedCache[0]);
// matcherState.push_back(MatchingState::kMatched); EXPECT_EQ(0UL, conditionTracker.mSlicedConditionState.size());
// {
// conditionCache[0] = ConditionState::kNotEvaluated; if (position == Position::FIRST || position == Position::LAST) {
// changedCache[0] = false; EXPECT_EQ(2UL, conditionTracker.getChangedToFalseDimensions(allConditions)->size());
// conditionTracker.evaluateCondition(event3, matcherState, allPredicates, conditionCache, EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty());
// changedCache); } else {
// EXPECT_TRUE(changedCache[0]); EXPECT_EQ(uids1.size() + uids2.size(),
// EXPECT_EQ(0UL, conditionTracker.mSlicedConditionState.size()); conditionTracker.getChangedToFalseDimensions(allConditions)->size());
// { EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty());
// if (position == Position::FIRST || position == Position::LAST) { }
// EXPECT_EQ(2UL, conditionTracker.getChangedToFalseDimensions(allConditions)->size()); }
// EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty());
// } else { // TEST QUERY
// EXPECT_EQ(uid_list1.size() + uid_list2.size(), const auto queryKey3 = getWakeLockQueryKey(position, uids1, conditionName);
// conditionTracker.getChangedToFalseDimensions(allConditions)->size()); conditionCache[0] = ConditionState::kNotEvaluated;
// EXPECT_TRUE(conditionTracker.getChangedToTrueDimensions(allConditions)->empty()); conditionTracker.isConditionMet(queryKey, allPredicates, false, conditionCache);
// } EXPECT_EQ(ConditionState::kFalse, conditionCache[0]);
// }
// // TEST QUERY
// // TEST QUERY const auto queryKey4 = getWakeLockQueryKey(position, uids2, conditionName);
// const auto queryKey3 = getWakeLockQueryKey(position, uid_list1, conditionName); conditionCache[0] = ConditionState::kNotEvaluated;
// conditionCache[0] = ConditionState::kNotEvaluated; conditionTracker.isConditionMet(queryKey, allPredicates, false, conditionCache);
// conditionTracker.isConditionMet(queryKey, allPredicates, EXPECT_EQ(ConditionState::kFalse, conditionCache[0]);
// false, }
// conditionCache); }
// EXPECT_EQ(ConditionState::kFalse, conditionCache[0]);
//
// // TEST QUERY
// const auto queryKey4 = getWakeLockQueryKey(position, uid_list2, conditionName);
// conditionCache[0] = ConditionState::kNotEvaluated;
// conditionTracker.isConditionMet(queryKey, allPredicates,
// false,
// conditionCache);
// EXPECT_EQ(ConditionState::kFalse, conditionCache[0]);
// }
//}
} // namespace statsd } // namespace statsd
} // namespace os } // namespace os

365
cmds/statsd/tests/e2e/Anomaly_count_e2e_test.cpp
View File

@@ -53,185 +53,192 @@ StatsdConfig CreateStatsdConfig(int num_buckets, int threshold) {
} // namespace } // namespace
// TODO(b/149590301): Update these tests to use new socket schema. TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_single_bucket) {
//TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_single_bucket) { const int num_buckets = 1;
// const int num_buckets = 1; const int threshold = 3;
// const int threshold = 3; auto config = CreateStatsdConfig(num_buckets, threshold);
// auto config = CreateStatsdConfig(num_buckets, threshold); const uint64_t alert_id = config.alert(0).id();
// const uint64_t alert_id = config.alert(0).id(); const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
// const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
// int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketStartTimeNs = 10000000000; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;
// int64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000; ConfigKey cfgKey;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// ConfigKey cfgKey; EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size());
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); sp<AnomalyTracker> anomalyTracker =
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0];
// sp<AnomalyTracker> anomalyTracker =
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; std::vector<int> attributionUids1 = {111};
// std::vector<string> attributionTags1 = {"App1"};
// std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; std::vector<int> attributionUids2 = {111, 222};
// std::vector<AttributionNodeInternal> attributions2 = { std::vector<string> attributionTags2 = {"App1", "GMSCoreModule1"};
// CreateAttribution(111, "App1"), CreateAttribution(222, "GMSCoreModule1")}; std::vector<int> attributionUids3 = {111, 333};
// std::vector<AttributionNodeInternal> attributions3 = { std::vector<string> attributionTags3 = {"App1", "App3"};
// CreateAttribution(111, "App1"), CreateAttribution(333, "App3")}; std::vector<int> attributionUids4 = {222, 333};
// std::vector<AttributionNodeInternal> attributions4 = { std::vector<string> attributionTags4 = {"GMSCoreModule1", "App3"};
// CreateAttribution(222, "GMSCoreModule1"), CreateAttribution(333, "App3")}; std::vector<int> attributionUids5 = {222};
// std::vector<AttributionNodeInternal> attributions5 = { std::vector<string> attributionTags5 = {"GMSCoreModule1"};
// CreateAttribution(222, "GMSCoreModule1") };
// FieldValue fieldValue1(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101),
// FieldValue fieldValue1(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101), Value((int32_t)111));
// Value((int32_t)111)); HashableDimensionKey whatKey1({fieldValue1});
// HashableDimensionKey whatKey1({fieldValue1}); MetricDimensionKey dimensionKey1(whatKey1, DEFAULT_DIMENSION_KEY);
// MetricDimensionKey dimensionKey1(whatKey1, DEFAULT_DIMENSION_KEY);
// FieldValue fieldValue2(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101),
// FieldValue fieldValue2(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101), Value((int32_t)222));
// Value((int32_t)222)); HashableDimensionKey whatKey2({fieldValue2});
// HashableDimensionKey whatKey2({fieldValue2}); MetricDimensionKey dimensionKey2(whatKey2, DEFAULT_DIMENSION_KEY);
// MetricDimensionKey dimensionKey2(whatKey2, DEFAULT_DIMENSION_KEY);
// auto event = CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
// auto event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 2); attributionTags1, "wl1");
// processor->OnLogEvent(event.get()); processor->OnLogEvent(event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
//
// event = CreateAcquireWakelockEvent(attributions4, "wl2", bucketStartTimeNs + 2); event = CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids4, attributionTags4,
// processor->OnLogEvent(event.get()); "wl2");
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); processor->OnLogEvent(event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// event = CreateAcquireWakelockEvent(attributions2, "wl1", bucketStartTimeNs + 3);
// processor->OnLogEvent(event.get()); event = CreateAcquireWakelockEvent(bucketStartTimeNs + 3, attributionUids2, attributionTags2,
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); "wl1");
// processor->OnLogEvent(event.get());
// event = CreateAcquireWakelockEvent(attributions5, "wl2", bucketStartTimeNs + 3); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// processor->OnLogEvent(event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); event = CreateAcquireWakelockEvent(bucketStartTimeNs + 3, attributionUids5, attributionTags5,
// "wl2");
// event = CreateAcquireWakelockEvent(attributions3, "wl1", bucketStartTimeNs + 4); processor->OnLogEvent(event.get());
// processor->OnLogEvent(event.get()); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// event = CreateAcquireWakelockEvent(bucketStartTimeNs + 4, attributionUids3, attributionTags3,
// event = CreateAcquireWakelockEvent(attributions5, "wl2", bucketStartTimeNs + 4); "wl1");
// processor->OnLogEvent(event.get()); processor->OnLogEvent(event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
//
// // Fired alarm and refractory period end timestamp updated. event = CreateAcquireWakelockEvent(bucketStartTimeNs + 4, attributionUids5, attributionTags5,
// event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 5); "wl2");
// processor->OnLogEvent(event.get()); processor->OnLogEvent(event.get());
// EXPECT_EQ(refractory_period_sec + bucketStartTimeNs / NS_PER_SEC + 1, EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// // Fired alarm and refractory period end timestamp updated.
// event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 100); event = CreateAcquireWakelockEvent(bucketStartTimeNs + 5, attributionUids1, attributionTags1,
// processor->OnLogEvent(event.get()); "wl1");
// EXPECT_EQ(refractory_period_sec + bucketStartTimeNs / NS_PER_SEC + 1, processor->OnLogEvent(event.get());
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); EXPECT_EQ(refractory_period_sec + bucketStartTimeNs / NS_PER_SEC + 1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + bucketSizeNs - 1);
// processor->OnLogEvent(event.get()); event = CreateAcquireWakelockEvent(bucketStartTimeNs + 100, attributionUids1, attributionTags1,
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs - 1) / NS_PER_SEC + 1, "wl1");
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); processor->OnLogEvent(event.get());
// EXPECT_EQ(refractory_period_sec + bucketStartTimeNs / NS_PER_SEC + 1,
// event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + bucketSizeNs + 1); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// processor->OnLogEvent(event.get());
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs - 1) / NS_PER_SEC + 1, event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 1, attributionUids1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); attributionTags1, "wl1");
// processor->OnLogEvent(event.get());
// event = CreateAcquireWakelockEvent(attributions4, "wl2", bucketStartTimeNs + bucketSizeNs + 1); EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs - 1) / NS_PER_SEC + 1,
// processor->OnLogEvent(event.get()); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 1, attributionUids1,
// event = CreateAcquireWakelockEvent(attributions5, "wl2", bucketStartTimeNs + bucketSizeNs + 2); attributionTags1, "wl1");
// processor->OnLogEvent(event.get()); processor->OnLogEvent(event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs - 1) / NS_PER_SEC + 1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// event = CreateAcquireWakelockEvent(attributions5, "wl2", bucketStartTimeNs + bucketSizeNs + 3);
// processor->OnLogEvent(event.get()); event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 1, attributionUids4,
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); attributionTags4, "wl2");
// processor->OnLogEvent(event.get());
// event = CreateAcquireWakelockEvent(attributions5, "wl2", bucketStartTimeNs + bucketSizeNs + 4); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// processor->OnLogEvent(event.get());
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 4) / NS_PER_SEC + 1, event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 2, attributionUids5,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); attributionTags5, "wl2");
//} processor->OnLogEvent(event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
//TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_multiple_buckets) {
// const int num_buckets = 3; event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 3, attributionUids5,
// const int threshold = 3; attributionTags5, "wl2");
// auto config = CreateStatsdConfig(num_buckets, threshold); processor->OnLogEvent(event.get());
// const uint64_t alert_id = config.alert(0).id(); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
// event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 4, attributionUids5,
// int64_t bucketStartTimeNs = 10000000000; attributionTags5, "wl2");
// int64_t bucketSizeNs = processor->OnLogEvent(event.get());
// TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000; EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 4) / NS_PER_SEC + 1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// ConfigKey cfgKey; }
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); TEST(AnomalyDetectionE2eTest, TestSlicedCountMetric_multiple_buckets) {
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); const int num_buckets = 3;
// EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); const int threshold = 3;
// auto config = CreateStatsdConfig(num_buckets, threshold);
// sp<AnomalyTracker> anomalyTracker = const uint64_t alert_id = config.alert(0).id();
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
//
// std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")}; int64_t bucketStartTimeNs = 10000000000;
// std::vector<AttributionNodeInternal> attributions2 = { int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;
// CreateAttribution(111, "App1"), CreateAttribution(222, "GMSCoreModule1")};
// std::vector<AttributionNodeInternal> attributions3 = { ConfigKey cfgKey;
// CreateAttribution(111, "App1"), CreateAttribution(333, "App3")}; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// std::vector<AttributionNodeInternal> attributions4 = { EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// CreateAttribution(222, "GMSCoreModule1"), CreateAttribution(333, "App3")}; EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// std::vector<AttributionNodeInternal> attributions5 = { EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size());
// CreateAttribution(222, "GMSCoreModule1") };
// sp<AnomalyTracker> anomalyTracker =
// FieldValue fieldValue1(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101), processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0];
// Value((int32_t)111));
// HashableDimensionKey whatKey1({fieldValue1}); std::vector<int> attributionUids1 = {111};
// MetricDimensionKey dimensionKey1(whatKey1, DEFAULT_DIMENSION_KEY); std::vector<string> attributionTags1 = {"App1"};
// std::vector<int> attributionUids2 = {111, 222};
// FieldValue fieldValue2(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101), std::vector<string> attributionTags2 = {"App1", "GMSCoreModule1"};
// Value((int32_t)222));
// HashableDimensionKey whatKey2({fieldValue2}); FieldValue fieldValue1(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101),
// MetricDimensionKey dimensionKey2(whatKey2, DEFAULT_DIMENSION_KEY); Value((int32_t)111));
// HashableDimensionKey whatKey1({fieldValue1});
// auto event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 2); MetricDimensionKey dimensionKey1(whatKey1, DEFAULT_DIMENSION_KEY);
// processor->OnLogEvent(event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); auto event = CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
// attributionTags1, "wl1");
// event = CreateAcquireWakelockEvent(attributions2, "wl1", bucketStartTimeNs + 3); processor->OnLogEvent(event.get());
// processor->OnLogEvent(event.get()); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// event = CreateAcquireWakelockEvent(bucketStartTimeNs + 3, attributionUids2, attributionTags2,
// // Fired alarm and refractory period end timestamp updated. "wl1");
// event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 4); processor->OnLogEvent(event.get());
// processor->OnLogEvent(event.get()); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// // Fired alarm and refractory period end timestamp updated.
// event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + bucketSizeNs + 1); event = CreateAcquireWakelockEvent(bucketStartTimeNs + 4, attributionUids1, attributionTags1,
// processor->OnLogEvent(event.get()); "wl1");
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 1) / NS_PER_SEC + 1, processor->OnLogEvent(event.get());
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
//
// event = CreateAcquireWakelockEvent(attributions2, "wl1", bucketStartTimeNs + bucketSizeNs + 2); event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 1, attributionUids1,
// processor->OnLogEvent(event.get()); attributionTags1, "wl1");
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 1) / NS_PER_SEC + 1, processor->OnLogEvent(event.get());
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 1) / NS_PER_SEC + 1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// event = CreateAcquireWakelockEvent(
// attributions2, "wl1", bucketStartTimeNs + 3 * bucketSizeNs + 1); event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 2, attributionUids2,
// processor->OnLogEvent(event.get()); attributionTags2, "wl1");
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 1) / NS_PER_SEC + 1, processor->OnLogEvent(event.get());
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 1) / NS_PER_SEC + 1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// event = CreateAcquireWakelockEvent(
// attributions2, "wl1", bucketStartTimeNs + 3 * bucketSizeNs + 2); event = CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs + 1, attributionUids2,
// processor->OnLogEvent(event.get()); attributionTags2, "wl1");
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + 3 * bucketSizeNs + 2) / NS_PER_SEC + 1, processor->OnLogEvent(event.get());
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1)); EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + 1) / NS_PER_SEC + 1,
//} anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
event = CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs + 2, attributionUids2,
attributionTags2, "wl1");
processor->OnLogEvent(event.get());
EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + 3 * bucketSizeNs + 2) / NS_PER_SEC + 1,
anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
}
#else #else
GTEST_LOG_(INFO) << "This test does nothing.\n"; GTEST_LOG_(INFO) << "This test does nothing.\n";

816
cmds/statsd/tests/e2e/Anomaly_duration_sum_e2e_test.cpp
View File

@@ -69,414 +69,432 @@ StatsdConfig CreateStatsdConfig(int num_buckets,
return config; return config;
} }
} // namespace std::vector<int> attributionUids1 = {111, 222};
std::vector<string> attributionTags1 = {"App1", "GMSCoreModule1"};
std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1"), std::vector<int> attributionUids2 = {111, 222};
CreateAttribution(222, "GMSCoreModule1")}; std::vector<string> attributionTags2 = {"App2", "GMSCoreModule1"};
std::vector<AttributionNodeInternal> attributions2 = {CreateAttribution(111, "App2"), std::vector<int> attributionUids3 = {222};
CreateAttribution(222, "GMSCoreModule1")}; std::vector<string> attributionTags3 = {"GMSCoreModule1"};
std::vector<AttributionNodeInternal> attributions3 = {CreateAttribution(222, "GMSCoreModule1")}; MetricDimensionKey dimensionKey1(
HashableDimensionKey({FieldValue(Field(android::util::WAKELOCK_STATE_CHANGED,
MetricDimensionKey dimensionKey( (int32_t)0x02010101),
HashableDimensionKey({FieldValue(Field(android::util::WAKELOCK_STATE_CHANGED, Value((int32_t)111))}),
(int32_t)0x02010101), Value((int32_t)111))}), DEFAULT_DIMENSION_KEY);
DEFAULT_DIMENSION_KEY);
MetricDimensionKey dimensionKey2( MetricDimensionKey dimensionKey2(
HashableDimensionKey({FieldValue(Field(android::util::WAKELOCK_STATE_CHANGED, HashableDimensionKey({FieldValue(Field(android::util::WAKELOCK_STATE_CHANGED,
(int32_t)0x02010101), Value((int32_t)222))}), (int32_t)0x02010101), Value((int32_t)222))}),
DEFAULT_DIMENSION_KEY); DEFAULT_DIMENSION_KEY);
// TODO(b/149590301): Update these tests to use new socket schema. } // namespace
//TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_single_bucket) {
// const int num_buckets = 1; TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_single_bucket) {
// const uint64_t threshold_ns = NS_PER_SEC; const int num_buckets = 1;
// auto config = CreateStatsdConfig(num_buckets, threshold_ns, DurationMetric::SUM, true); const uint64_t threshold_ns = NS_PER_SEC;
// const uint64_t alert_id = config.alert(0).id(); auto config = CreateStatsdConfig(num_buckets, threshold_ns, DurationMetric::SUM, true);
// const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs(); const uint64_t alert_id = config.alert(0).id();
// const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
// int64_t bucketStartTimeNs = 10 * NS_PER_SEC;
// int64_t bucketSizeNs = int64_t bucketStartTimeNs = 10 * NS_PER_SEC;
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000; int64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000;
// ConfigKey cfgKey;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); ConfigKey cfgKey;
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size());
// sp<AnomalyTracker> anomalyTracker =
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; sp<AnomalyTracker> anomalyTracker =
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0];
// auto screen_on_event = CreateScreenStateChangedEvent(
// android::view::DisplayStateEnum::DISPLAY_STATE_ON, bucketStartTimeNs + 1); auto screen_on_event = CreateScreenStateChangedEvent(
// auto screen_off_event = CreateScreenStateChangedEvent( bucketStartTimeNs + 1, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF, bucketStartTimeNs + 10); auto screen_off_event = CreateScreenStateChangedEvent(
// processor->OnLogEvent(screen_on_event.get()); bucketStartTimeNs + 10, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// processor->OnLogEvent(screen_off_event.get()); processor->OnLogEvent(screen_on_event.get());
// processor->OnLogEvent(screen_off_event.get());
// // Acquire wakelock wl1.
// auto acquire_event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 11); // Acquire wakelock wl1.
// processor->OnLogEvent(acquire_event.get()); auto acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + 11, attributionUids1,
// EXPECT_EQ((bucketStartTimeNs + 11 + threshold_ns) / NS_PER_SEC + 1, attributionTags1, "wl1");
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); processor->OnLogEvent(acquire_event.get());
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); EXPECT_EQ((bucketStartTimeNs + 11 + threshold_ns) / NS_PER_SEC + 1,
// anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// // Release wakelock wl1. No anomaly detected. Alarm cancelled at the "release" event. EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// auto release_event = CreateReleaseWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 101);
// processor->OnLogEvent(release_event.get()); // Release wakelock wl1. No anomaly detected. Alarm cancelled at the "release" event.
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); auto release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + 101, attributionUids1,
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); attributionTags1, "wl1");
// processor->OnLogEvent(release_event.get());
// // Acquire wakelock wl1 within bucket #0. EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// acquire_event = CreateAcquireWakelockEvent(attributions2, "wl1", bucketStartTimeNs + 110); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// processor->OnLogEvent(acquire_event.get());
// EXPECT_EQ((bucketStartTimeNs + 110 + threshold_ns - 90) / NS_PER_SEC + 1, // Acquire wakelock wl1 within bucket #0.
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + 110, attributionUids2,
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); attributionTags2, "wl1");
// processor->OnLogEvent(acquire_event.get());
// // Release wakelock wl1. One anomaly detected. EXPECT_EQ((bucketStartTimeNs + 110 + threshold_ns - 90) / NS_PER_SEC + 1,
// release_event = CreateReleaseWakelockEvent( anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// attributions2, "wl1", bucketStartTimeNs + NS_PER_SEC + 109); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// processor->OnLogEvent(release_event.get());
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); // Release wakelock wl1. One anomaly detected.
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + NS_PER_SEC + 109) / NS_PER_SEC + 1, release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + NS_PER_SEC + 109,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); attributionUids2, attributionTags2, "wl1");
// processor->OnLogEvent(release_event.get());
// // Acquire wakelock wl1. EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// acquire_event = CreateAcquireWakelockEvent( EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + NS_PER_SEC + 109) / NS_PER_SEC + 1,
// attributions1, "wl1", bucketStartTimeNs + NS_PER_SEC + 112); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// processor->OnLogEvent(acquire_event.get());
// // Wakelock has been hold longer than the threshold in bucket #0. The alarm is set at the // Acquire wakelock wl1.
// // end of the refractory period. acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + NS_PER_SEC + 112,
// const int64_t alarmFiredTimestampSec0 = anomalyTracker->getAlarmTimestampSec(dimensionKey); attributionUids1, attributionTags1, "wl1");
// EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + NS_PER_SEC + 109) / NS_PER_SEC + 1, processor->OnLogEvent(acquire_event.get());
// (uint32_t)alarmFiredTimestampSec0); // Wakelock has been hold longer than the threshold in bucket #0. The alarm is set at the
// // end of the refractory period.
// // Anomaly alarm fired. const int64_t alarmFiredTimestampSec0 = anomalyTracker->getAlarmTimestampSec(dimensionKey1);
// auto alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan( EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + NS_PER_SEC + 109) / NS_PER_SEC + 1,
// static_cast<uint32_t>(alarmFiredTimestampSec0)); (uint32_t)alarmFiredTimestampSec0);
// EXPECT_EQ(1u, alarmSet.size());
// processor->onAnomalyAlarmFired(alarmFiredTimestampSec0 * NS_PER_SEC, alarmSet); // Anomaly alarm fired.
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); auto alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan(
// EXPECT_EQ(refractory_period_sec + alarmFiredTimestampSec0, static_cast<uint32_t>(alarmFiredTimestampSec0));
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); EXPECT_EQ(1u, alarmSet.size());
// processor->onAnomalyAlarmFired(alarmFiredTimestampSec0 * NS_PER_SEC, alarmSet);
// // Release wakelock wl1. EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// release_event = CreateReleaseWakelockEvent( EXPECT_EQ(refractory_period_sec + alarmFiredTimestampSec0,
// attributions1, "wl1", alarmFiredTimestampSec0 * NS_PER_SEC + NS_PER_SEC + 1); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// processor->OnLogEvent(release_event.get());
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); // Release wakelock wl1.
// // Within refractory period. No more anomaly detected. release_event =
// EXPECT_EQ(refractory_period_sec + alarmFiredTimestampSec0, CreateReleaseWakelockEvent(alarmFiredTimestampSec0 * NS_PER_SEC + NS_PER_SEC + 1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); attributionUids1, attributionTags1, "wl1");
// processor->OnLogEvent(release_event.get());
// // Acquire wakelock wl1. EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// acquire_event = CreateAcquireWakelockEvent( // Within refractory period. No more anomaly detected.
// attributions2, "wl1", bucketStartTimeNs + bucketSizeNs - 5 * NS_PER_SEC - 11); EXPECT_EQ(refractory_period_sec + alarmFiredTimestampSec0,
// processor->OnLogEvent(acquire_event.get()); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// const int64_t alarmFiredTimestampSec1 = anomalyTracker->getAlarmTimestampSec(dimensionKey);
// EXPECT_EQ((bucketStartTimeNs + bucketSizeNs - 5 * NS_PER_SEC) / NS_PER_SEC, // Acquire wakelock wl1.
// (uint64_t)alarmFiredTimestampSec1); acquire_event =
// CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 5 * NS_PER_SEC - 11,
// // Release wakelock wl1. attributionUids2, attributionTags2, "wl1");
// release_event = CreateReleaseWakelockEvent( processor->OnLogEvent(acquire_event.get());
// attributions2, "wl1", bucketStartTimeNs + bucketSizeNs - 4 * NS_PER_SEC - 10); const int64_t alarmFiredTimestampSec1 = anomalyTracker->getAlarmTimestampSec(dimensionKey1);
// processor->OnLogEvent(release_event.get()); EXPECT_EQ((bucketStartTimeNs + bucketSizeNs - 5 * NS_PER_SEC) / NS_PER_SEC,
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); (uint64_t)alarmFiredTimestampSec1);
// EXPECT_EQ(refractory_period_sec +
// (bucketStartTimeNs + bucketSizeNs - 4 * NS_PER_SEC - 10) / NS_PER_SEC + 1, // Release wakelock wl1.
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); release_event =
// CreateReleaseWakelockEvent(bucketStartTimeNs + bucketSizeNs - 4 * NS_PER_SEC - 10,
// alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan( attributionUids2, attributionTags2, "wl1");
// static_cast<uint32_t>(alarmFiredTimestampSec1)); processor->OnLogEvent(release_event.get());
// EXPECT_EQ(0u, alarmSet.size()); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ(refractory_period_sec +
// // Acquire wakelock wl1 near the end of bucket #0. (bucketStartTimeNs + bucketSizeNs - 4 * NS_PER_SEC - 10) / NS_PER_SEC + 1,
// acquire_event = CreateAcquireWakelockEvent( anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// attributions1, "wl1", bucketStartTimeNs + bucketSizeNs - 2);
// processor->OnLogEvent(acquire_event.get()); alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan(
// EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC, static_cast<uint32_t>(alarmFiredTimestampSec1));
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); EXPECT_EQ(0u, alarmSet.size());
//
// // Release the event at early bucket #1. // Acquire wakelock wl1 near the end of bucket #0.
// release_event = CreateReleaseWakelockEvent( acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 2,
// attributions1, "wl1", bucketStartTimeNs + bucketSizeNs + NS_PER_SEC - 1); attributionUids1, attributionTags1, "wl1");
// processor->OnLogEvent(release_event.get()); processor->OnLogEvent(acquire_event.get());
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC,
// // Anomaly detected when stopping the alarm. The refractory period does not change. anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ(refractory_period_sec +
// (bucketStartTimeNs + bucketSizeNs + NS_PER_SEC) / NS_PER_SEC, // Release the event at early bucket #1.
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + bucketSizeNs + NS_PER_SEC - 1,
// attributionUids1, attributionTags1, "wl1");
// // Condition changes to false. processor->OnLogEvent(release_event.get());
// screen_on_event = CreateScreenStateChangedEvent( EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// android::view::DisplayStateEnum::DISPLAY_STATE_ON, // Anomaly detected when stopping the alarm. The refractory period does not change.
// bucketStartTimeNs + 2 * bucketSizeNs + 20); EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + NS_PER_SEC) / NS_PER_SEC,
// processor->OnLogEvent(screen_on_event.get()); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// EXPECT_EQ(refractory_period_sec +
// (bucketStartTimeNs + bucketSizeNs + NS_PER_SEC) / NS_PER_SEC, // Condition changes to false.
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); screen_on_event =
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 20,
// android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// acquire_event = CreateAcquireWakelockEvent( processor->OnLogEvent(screen_on_event.get());
// attributions2, "wl1", bucketStartTimeNs + 2 * bucketSizeNs + 30); EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + NS_PER_SEC) / NS_PER_SEC,
// processor->OnLogEvent(acquire_event.get()); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// // The condition is false. Do not start the alarm. EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey));
// EXPECT_EQ(refractory_period_sec + acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 30,
// (bucketStartTimeNs + bucketSizeNs + NS_PER_SEC) / NS_PER_SEC, attributionUids2, attributionTags2, "wl1");
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); processor->OnLogEvent(acquire_event.get());
// // The condition is false. Do not start the alarm.
// // Condition turns true. EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// screen_off_event = CreateScreenStateChangedEvent( EXPECT_EQ(refractory_period_sec + (bucketStartTimeNs + bucketSizeNs + NS_PER_SEC) / NS_PER_SEC,
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// bucketStartTimeNs + 2 * bucketSizeNs + NS_PER_SEC);
// processor->OnLogEvent(screen_off_event.get()); // Condition turns true.
// EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs + NS_PER_SEC + threshold_ns) / NS_PER_SEC, screen_off_event =
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + NS_PER_SEC,
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// // Condition turns to false. processor->OnLogEvent(screen_off_event.get());
// screen_on_event = CreateScreenStateChangedEvent( EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs + NS_PER_SEC + threshold_ns) / NS_PER_SEC,
// android::view::DisplayStateEnum::DISPLAY_STATE_ON, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC + 1);
// processor->OnLogEvent(screen_on_event.get()); // Condition turns to false.
// // Condition turns to false. Cancelled the alarm. screen_on_event =
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC + 1,
// // Detected one anomaly. android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// EXPECT_EQ(refractory_period_sec + processor->OnLogEvent(screen_on_event.get());
// (bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC + 1) / NS_PER_SEC + 1, // Condition turns to false. Cancelled the alarm.
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// // Detected one anomaly.
// // Condition turns to true again. EXPECT_EQ(refractory_period_sec +
// screen_off_event = CreateScreenStateChangedEvent( (bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC + 1) / NS_PER_SEC + 1,
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC + 2);
// processor->OnLogEvent(screen_off_event.get()); // Condition turns to true again.
// EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs) / NS_PER_SEC + 2 + 2 + 1, screen_off_event =
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC + 2,
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// release_event = CreateReleaseWakelockEvent( processor->OnLogEvent(screen_off_event.get());
// attributions2, "wl1", bucketStartTimeNs + 2 * bucketSizeNs + 5 * NS_PER_SEC); EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs) / NS_PER_SEC + 2 + 2 + 1,
// processor->OnLogEvent(release_event.get()); anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ(refractory_period_sec +
// (bucketStartTimeNs + 2 * bucketSizeNs + 5 * NS_PER_SEC) / NS_PER_SEC, release_event =
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); CreateReleaseWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 5 * NS_PER_SEC,
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); attributionUids2, attributionTags2, "wl1");
//} processor->OnLogEvent(release_event.get());
// EXPECT_EQ(refractory_period_sec +
//TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_multiple_buckets) { (bucketStartTimeNs + 2 * bucketSizeNs + 5 * NS_PER_SEC) / NS_PER_SEC,
// const int num_buckets = 3; anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// const uint64_t threshold_ns = NS_PER_SEC; EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// auto config = CreateStatsdConfig(num_buckets, threshold_ns, DurationMetric::SUM, true); }
// const uint64_t alert_id = config.alert(0).id();
// const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs(); TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_multiple_buckets) {
// const int num_buckets = 3;
// int64_t bucketStartTimeNs = 10 * NS_PER_SEC; const uint64_t threshold_ns = NS_PER_SEC;
// int64_t bucketSizeNs = auto config = CreateStatsdConfig(num_buckets, threshold_ns, DurationMetric::SUM, true);
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000; const uint64_t alert_id = config.alert(0).id();
// const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
// ConfigKey cfgKey;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); int64_t bucketStartTimeNs = 10 * NS_PER_SEC;
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); int64_t bucketSizeNs =
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000;
// EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size());
// ConfigKey cfgKey;
// sp<AnomalyTracker> anomalyTracker = auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// auto screen_off_event = CreateScreenStateChangedEvent( EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size());
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF, bucketStartTimeNs + 1);
// processor->OnLogEvent(screen_off_event.get()); sp<AnomalyTracker> anomalyTracker =
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0];
// // Acquire wakelock "wc1" in bucket #0.
// auto acquire_event = CreateAcquireWakelockEvent( auto screen_off_event = CreateScreenStateChangedEvent(
// attributions1, "wl1", bucketStartTimeNs + bucketSizeNs - NS_PER_SEC / 2 - 1); bucketStartTimeNs + 1, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// processor->OnLogEvent(acquire_event.get()); processor->OnLogEvent(screen_off_event.get());
// EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 1,
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); // Acquire wakelock "wc1" in bucket #0.
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); auto acquire_event =
// CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - NS_PER_SEC / 2 - 1,
// // Release wakelock "wc1" in bucket #0. attributionUids1, attributionTags1, "wl1");
// auto release_event = CreateReleaseWakelockEvent( processor->OnLogEvent(acquire_event.get());
// attributions1, "wl1", bucketStartTimeNs + bucketSizeNs - 1); EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 1,
// processor->OnLogEvent(release_event.get()); anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey));
// // Release wakelock "wc1" in bucket #0.
// // Acquire wakelock "wc1" in bucket #1. auto release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + bucketSizeNs - 1,
// acquire_event = CreateAcquireWakelockEvent( attributionUids1, attributionTags1, "wl1");
// attributions2, "wl1", bucketStartTimeNs + bucketSizeNs + 1); processor->OnLogEvent(release_event.get());
// processor->OnLogEvent(acquire_event.get()); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 1, EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// anomalyTracker->getAlarmTimestampSec(dimensionKey));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); // Acquire wakelock "wc1" in bucket #1.
// acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 1,
// release_event = CreateReleaseWakelockEvent( attributionUids2, attributionTags2, "wl1");
// attributions2, "wl1", bucketStartTimeNs + bucketSizeNs + 100); processor->OnLogEvent(acquire_event.get());
// processor->OnLogEvent(release_event.get()); EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 1,
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
//
// // Acquire wakelock "wc2" in bucket #2. release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + bucketSizeNs + 100,
// acquire_event = CreateAcquireWakelockEvent( attributionUids2, attributionTags2, "wl1");
// attributions3, "wl2", bucketStartTimeNs + 2 * bucketSizeNs + 1); processor->OnLogEvent(release_event.get());
// processor->OnLogEvent(acquire_event.get()); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs) / NS_PER_SEC + 2, EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// anomalyTracker->getAlarmTimestampSec(dimensionKey2));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); // Acquire wakelock "wc2" in bucket #2.
// acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 1,
// // Release wakelock "wc2" in bucket #2. attributionUids3, attributionTags3, "wl2");
// release_event = CreateReleaseWakelockEvent( processor->OnLogEvent(acquire_event.get());
// attributions3, "wl2", bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC); EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs) / NS_PER_SEC + 2,
// processor->OnLogEvent(release_event.get()); anomalyTracker->getAlarmTimestampSec(dimensionKey2));
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey2)); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// EXPECT_EQ(refractory_period_sec +
// (bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC) / NS_PER_SEC, // Release wakelock "wc2" in bucket #2.
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2)); release_event =
// CreateReleaseWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC,
// // Acquire wakelock "wc1" in bucket #2. attributionUids3, attributionTags3, "wl2");
// acquire_event = CreateAcquireWakelockEvent( processor->OnLogEvent(release_event.get());
// attributions2, "wl1", bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey2));
// processor->OnLogEvent(acquire_event.get()); EXPECT_EQ(refractory_period_sec +
// EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs) / NS_PER_SEC + 2 + 1, (bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC) / NS_PER_SEC,
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey2));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey));
// // Acquire wakelock "wc1" in bucket #2.
// // Release wakelock "wc1" in bucket #2. acquire_event =
// release_event = CreateReleaseWakelockEvent( CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 2 * NS_PER_SEC,
// attributions2, "wl1", bucketStartTimeNs + 2 * bucketSizeNs + 2.5 * NS_PER_SEC); attributionUids2, attributionTags2, "wl1");
// processor->OnLogEvent(release_event.get()); processor->OnLogEvent(acquire_event.get());
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); EXPECT_EQ((bucketStartTimeNs + 2 * bucketSizeNs) / NS_PER_SEC + 2 + 1,
// EXPECT_EQ(refractory_period_sec + anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// (int64_t)(bucketStartTimeNs + 2 * bucketSizeNs + 2.5 * NS_PER_SEC) / NS_PER_SEC + 1, EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey));
// // Release wakelock "wc1" in bucket #2.
// acquire_event = CreateAcquireWakelockEvent( release_event =
// attributions3, "wl2", bucketStartTimeNs + 6 * bucketSizeNs - NS_PER_SEC + 4); CreateReleaseWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 2.5 * NS_PER_SEC,
// processor->OnLogEvent(acquire_event.get()); attributionUids2, attributionTags2, "wl1");
// acquire_event = CreateAcquireWakelockEvent( processor->OnLogEvent(release_event.get());
// attributions1, "wl1", bucketStartTimeNs + 6 * bucketSizeNs - NS_PER_SEC + 5); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// processor->OnLogEvent(acquire_event.get()); EXPECT_EQ(refractory_period_sec +
// EXPECT_EQ((bucketStartTimeNs + 6 * bucketSizeNs) / NS_PER_SEC + 1, (int64_t)(bucketStartTimeNs + 2 * bucketSizeNs + 2.5 * NS_PER_SEC) /
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); NS_PER_SEC +
// EXPECT_EQ((bucketStartTimeNs + 6 * bucketSizeNs) / NS_PER_SEC + 1, 1,
// anomalyTracker->getAlarmTimestampSec(dimensionKey2)); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
//
// release_event = CreateReleaseWakelockEvent( acquire_event =
// attributions3, "wl2", bucketStartTimeNs + 6 * bucketSizeNs + 2); CreateAcquireWakelockEvent(bucketStartTimeNs + 6 * bucketSizeNs - NS_PER_SEC + 4,
// processor->OnLogEvent(release_event.get()); attributionUids3, attributionTags3, "wl2");
// release_event = CreateReleaseWakelockEvent( processor->OnLogEvent(acquire_event.get());
// attributions1, "wl1", bucketStartTimeNs + 6 * bucketSizeNs + 6); acquire_event =
// processor->OnLogEvent(release_event.get()); CreateAcquireWakelockEvent(bucketStartTimeNs + 6 * bucketSizeNs - NS_PER_SEC + 5,
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); attributionUids1, attributionTags1, "wl1");
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey2)); processor->OnLogEvent(acquire_event.get());
// // The buckets are not messed up across dimensions. Only one dimension has anomaly triggered. EXPECT_EQ((bucketStartTimeNs + 6 * bucketSizeNs) / NS_PER_SEC + 1,
// EXPECT_EQ(refractory_period_sec + anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// (int64_t)(bucketStartTimeNs + 6 * bucketSizeNs) / NS_PER_SEC + 1, EXPECT_EQ((bucketStartTimeNs + 6 * bucketSizeNs) / NS_PER_SEC + 1,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); anomalyTracker->getAlarmTimestampSec(dimensionKey2));
//}
// release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + 6 * bucketSizeNs + 2,
//TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_long_refractory_period) { attributionUids3, attributionTags3, "wl2");
// const int num_buckets = 2; processor->OnLogEvent(release_event.get());
// const uint64_t threshold_ns = 3 * NS_PER_SEC; release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + 6 * bucketSizeNs + 6,
// auto config = CreateStatsdConfig(num_buckets, threshold_ns, DurationMetric::SUM, false); attributionUids1, attributionTags1, "wl1");
// int64_t bucketStartTimeNs = 10 * NS_PER_SEC; processor->OnLogEvent(release_event.get());
// int64_t bucketSizeNs = EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000; EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey2));
// // The buckets are not messed up across dimensions. Only one dimension has anomaly triggered.
// const uint64_t alert_id = config.alert(0).id(); EXPECT_EQ(refractory_period_sec + (int64_t)(bucketStartTimeNs + 6 * bucketSizeNs) / NS_PER_SEC +
// const uint32_t refractory_period_sec = 3 * bucketSizeNs / NS_PER_SEC; 1,
// config.mutable_alert(0)->set_refractory_period_secs(refractory_period_sec); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// }
// ConfigKey cfgKey;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); TEST(AnomalyDetectionE2eTest, TestDurationMetric_SUM_long_refractory_period) {
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); const int num_buckets = 2;
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); const uint64_t threshold_ns = 3 * NS_PER_SEC;
// EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size()); auto config = CreateStatsdConfig(num_buckets, threshold_ns, DurationMetric::SUM, false);
// int64_t bucketStartTimeNs = 10 * NS_PER_SEC;
// sp<AnomalyTracker> anomalyTracker = int64_t bucketSizeNs =
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0]; TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000;
//
// auto screen_off_event = CreateScreenStateChangedEvent( const uint64_t alert_id = config.alert(0).id();
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF, bucketStartTimeNs + 1); const uint32_t refractory_period_sec = 3 * bucketSizeNs / NS_PER_SEC;
// processor->OnLogEvent(screen_off_event.get()); config.mutable_alert(0)->set_refractory_period_secs(refractory_period_sec);
//
// // Acquire wakelock "wc1" in bucket #0. ConfigKey cfgKey;
// auto acquire_event = CreateAcquireWakelockEvent( auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// attributions1, "wl1", bucketStartTimeNs + bucketSizeNs - 100); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// processor->OnLogEvent(acquire_event.get()); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 3, EXPECT_EQ(1u, processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers.size());
// anomalyTracker->getAlarmTimestampSec(dimensionKey));
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); sp<AnomalyTracker> anomalyTracker =
// processor->mMetricsManagers.begin()->second->mAllAnomalyTrackers[0];
// // Acquire the wakelock "wc1" again.
// acquire_event = CreateAcquireWakelockEvent( auto screen_off_event = CreateScreenStateChangedEvent(
// attributions1, "wl1", bucketStartTimeNs + bucketSizeNs + 2 * NS_PER_SEC + 1); bucketStartTimeNs + 1, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// processor->OnLogEvent(acquire_event.get()); processor->OnLogEvent(screen_off_event.get());
// // The alarm does not change.
// EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 3, // Acquire wakelock "wc1" in bucket #0.
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); auto acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 100,
// EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); attributionUids1, attributionTags1, "wl1");
// processor->OnLogEvent(acquire_event.get());
// // Anomaly alarm fired late. EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 3,
// const int64_t firedAlarmTimestampNs = bucketStartTimeNs + 2 * bucketSizeNs - NS_PER_SEC; anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// auto alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan( EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// static_cast<uint32_t>(firedAlarmTimestampNs / NS_PER_SEC));
// EXPECT_EQ(1u, alarmSet.size()); // Acquire the wakelock "wc1" again.
// processor->onAnomalyAlarmFired(firedAlarmTimestampNs, alarmSet); acquire_event =
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 2 * NS_PER_SEC + 1,
// EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC, attributionUids1, attributionTags1, "wl1");
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); processor->OnLogEvent(acquire_event.get());
// // The alarm does not change.
// acquire_event = CreateAcquireWakelockEvent( EXPECT_EQ((bucketStartTimeNs + bucketSizeNs) / NS_PER_SEC + 3,
// attributions1, "wl1", bucketStartTimeNs + 2 * bucketSizeNs - 100); anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// processor->OnLogEvent(acquire_event.get()); EXPECT_EQ(0u, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey));
// EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC, // Anomaly alarm fired late.
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); const int64_t firedAlarmTimestampNs = bucketStartTimeNs + 2 * bucketSizeNs - NS_PER_SEC;
// auto alarmSet = processor->getAnomalyAlarmMonitor()->popSoonerThan(
// auto release_event = CreateReleaseWakelockEvent( static_cast<uint32_t>(firedAlarmTimestampNs / NS_PER_SEC));
// attributions1, "wl1", bucketStartTimeNs + 2 * bucketSizeNs + 1); EXPECT_EQ(1u, alarmSet.size());
// processor->OnLogEvent(release_event.get()); processor->onAnomalyAlarmFired(firedAlarmTimestampNs, alarmSet);
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// // Within the refractory period. No anomaly. EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC,
// EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey));
// acquire_event = CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs - 100,
// // A new wakelock, but still within refractory period. attributionUids1, attributionTags1, "wl1");
// acquire_event = CreateAcquireWakelockEvent( processor->OnLogEvent(acquire_event.get());
// attributions1, "wl1", bucketStartTimeNs + 2 * bucketSizeNs + 10 * NS_PER_SEC); EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// processor->OnLogEvent(acquire_event.get()); EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC,
// EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC, anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// anomalyTracker->getAlarmTimestampSec(dimensionKey));
// auto release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 1,
// release_event = CreateReleaseWakelockEvent( attributionUids1, attributionTags1, "wl1");
// attributions1, "wl1", bucketStartTimeNs + 3 * bucketSizeNs - NS_PER_SEC); processor->OnLogEvent(release_event.get());
// // Still in the refractory period. No anomaly. EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// processor->OnLogEvent(release_event.get()); // Within the refractory period. No anomaly.
// EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC, EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC,
// anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey)); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
//
// acquire_event = CreateAcquireWakelockEvent( // A new wakelock, but still within refractory period.
// attributions1, "wl1", bucketStartTimeNs + 5 * bucketSizeNs - 3 * NS_PER_SEC - 5); acquire_event =
// processor->OnLogEvent(acquire_event.get()); CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 10 * NS_PER_SEC,
// EXPECT_EQ((bucketStartTimeNs + 5 * bucketSizeNs) / NS_PER_SEC, attributionUids1, attributionTags1, "wl1");
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); processor->OnLogEvent(acquire_event.get());
// EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC,
// release_event = CreateReleaseWakelockEvent( anomalyTracker->getAlarmTimestampSec(dimensionKey1));
// attributions1, "wl1", bucketStartTimeNs + 5 * bucketSizeNs - 3 * NS_PER_SEC - 4);
// processor->OnLogEvent(release_event.get()); release_event = CreateReleaseWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs - NS_PER_SEC,
// EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey)); attributionUids1, attributionTags1, "wl1");
// // Still in the refractory period. No anomaly.
// acquire_event = CreateAcquireWakelockEvent( processor->OnLogEvent(release_event.get());
// attributions1, "wl1", bucketStartTimeNs + 5 * bucketSizeNs - 3 * NS_PER_SEC - 3); EXPECT_EQ(refractory_period_sec + firedAlarmTimestampNs / NS_PER_SEC,
// processor->OnLogEvent(acquire_event.get()); anomalyTracker->getRefractoryPeriodEndsSec(dimensionKey1));
// EXPECT_EQ((bucketStartTimeNs + 5 * bucketSizeNs) / NS_PER_SEC,
// anomalyTracker->getAlarmTimestampSec(dimensionKey)); acquire_event =
//} CreateAcquireWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs - 3 * NS_PER_SEC - 5,
attributionUids1, attributionTags1, "wl1");
processor->OnLogEvent(acquire_event.get());
EXPECT_EQ((bucketStartTimeNs + 5 * bucketSizeNs) / NS_PER_SEC,
anomalyTracker->getAlarmTimestampSec(dimensionKey1));
release_event =
CreateReleaseWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs - 3 * NS_PER_SEC - 4,
attributionUids1, attributionTags1, "wl1");
processor->OnLogEvent(release_event.get());
EXPECT_EQ(0u, anomalyTracker->getAlarmTimestampSec(dimensionKey1));
acquire_event =
CreateAcquireWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs - 3 * NS_PER_SEC - 3,
attributionUids1, attributionTags1, "wl1");
processor->OnLogEvent(acquire_event.get());
EXPECT_EQ((bucketStartTimeNs + 5 * bucketSizeNs) / NS_PER_SEC,
anomalyTracker->getAlarmTimestampSec(dimensionKey1));
}
#else #else
GTEST_LOG_(INFO) << "This test does nothing.\n"; GTEST_LOG_(INFO) << "This test does nothing.\n";

669
cmds/statsd/tests/e2e/Attribution_e2e_test.cpp
View File

@@ -53,367 +53,318 @@ StatsdConfig CreateStatsdConfig(const Position position) {
return config; return config;
} }
// GMS core node is in the middle.
std::vector<int> attributionUids1 = {111, 222, 333};
std::vector<string> attributionTags1 = {"App1", "GMSCoreModule1", "App3"};
// GMS core node is the last one.
std::vector<int> attributionUids2 = {111, 333, 222};
std::vector<string> attributionTags2 = {"App1", "App3", "GMSCoreModule1"};
// GMS core node is the first one.
std::vector<int> attributionUids3 = {222, 333};
std::vector<string> attributionTags3 = {"GMSCoreModule1", "App3"};
// Single GMS core node.
std::vector<int> attributionUids4 = {222};
std::vector<string> attributionTags4 = {"GMSCoreModule1"};
// GMS core has another uid.
std::vector<int> attributionUids5 = {111, 444, 333};
std::vector<string> attributionTags5 = {"App1", "GMSCoreModule2", "App3"};
// Multiple GMS core nodes.
std::vector<int> attributionUids6 = {444, 222};
std::vector<string> attributionTags6 = {"GMSCoreModule2", "GMSCoreModule1"};
// No GMS core nodes
std::vector<int> attributionUids7 = {111, 333};
std::vector<string> attributionTags7 = {"App1", "App3"};
std::vector<int> attributionUids8 = {111};
std::vector<string> attributionTags8 = {"App1"};
// GMS core node with isolated uid.
const int isolatedUid = 666;
std::vector<int> attributionUids9 = {isolatedUid};
std::vector<string> attributionTags9 = {"GMSCoreModule3"};
std::vector<int> attributionUids10 = {isolatedUid};
std::vector<string> attributionTags10 = {"GMSCoreModule1"};
} // namespace } // namespace
// TODO(b/149590301): Update these tests to use new socket schema. TEST(AttributionE2eTest, TestAttributionMatchAndSliceByFirstUid) {
//TEST(AttributionE2eTest, TestAttributionMatchAndSliceByFirstUid) { auto config = CreateStatsdConfig(Position::FIRST);
// auto config = CreateStatsdConfig(Position::FIRST); int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketStartTimeNs = 10000000000; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;
// int64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000; ConfigKey cfgKey;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// ConfigKey cfgKey; EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); // Here it assumes that GMS core has two uids.
// processor->getUidMap()->updateMap(
// // Here it assumes that GMS core has two uids. 1, {222, 444, 111, 333}, {1, 1, 2, 2},
// processor->getUidMap()->updateMap( {String16("v1"), String16("v1"), String16("v2"), String16("v2")},
// 1, {222, 444, 111, 333}, {1, 1, 2, 2}, {String16("com.android.gmscore"), String16("com.android.gmscore"), String16("app1"),
// {String16("v1"), String16("v1"), String16("v2"), String16("v2")}, String16("APP3")},
// {String16("com.android.gmscore"), String16("com.android.gmscore"), String16("app1"), {String16(""), String16(""), String16(""), String16("")});
// String16("APP3")},
// {String16(""), String16(""), String16(""), String16("")}); std::vector<std::unique_ptr<LogEvent>> events;
// // Events 1~4 are in the 1st bucket.
// // GMS core node is in the middle. events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
// std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1"), attributionTags1, "wl1"));
// CreateAttribution(222, "GMSCoreModule1"), events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 200, attributionUids2,
// CreateAttribution(333, "App3")}; attributionTags2, "wl1"));
// events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 1,
// // GMS core node is the last one. attributionUids3, attributionTags3, "wl1"));
// std::vector<AttributionNodeInternal> attributions2 = {CreateAttribution(111, "App1"), events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs, attributionUids4,
// CreateAttribution(333, "App3"), attributionTags4, "wl1"));
// CreateAttribution(222, "GMSCoreModule1")};
// // Events 5~8 are in the 3rd bucket.
// // GMS core node is the first one. events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 1,
// std::vector<AttributionNodeInternal> attributions3 = {CreateAttribution(222, "GMSCoreModule1"), attributionUids5, attributionTags5, "wl2"));
// CreateAttribution(333, "App3")}; events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
// attributionUids6, attributionTags6, "wl2"));
// // Single GMS core node. events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs - 2,
// std::vector<AttributionNodeInternal> attributions4 = {CreateAttribution(222, "GMSCoreModule1")}; attributionUids7, attributionTags7, "wl2"));
// events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs,
// // GMS core has another uid. attributionUids8, attributionTags8, "wl2"));
// std::vector<AttributionNodeInternal> attributions5 = {CreateAttribution(111, "App1"), events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs + 1,
// CreateAttribution(444, "GMSCoreModule2"), attributionUids9, attributionTags9, "wl2"));
// CreateAttribution(333, "App3")}; events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs + 100,
// attributionUids9, attributionTags9, "wl2"));
// // Multiple GMS core nodes. events.push_back(CreateIsolatedUidChangedEvent(bucketStartTimeNs + 3 * bucketSizeNs - 1, 222,
// std::vector<AttributionNodeInternal> attributions6 = {CreateAttribution(444, "GMSCoreModule2"), isolatedUid, true /*is_create*/));
// CreateAttribution(222, "GMSCoreModule1")}; events.push_back(CreateIsolatedUidChangedEvent(bucketStartTimeNs + 3 * bucketSizeNs + 10, 222,
// isolatedUid, false /*is_create*/));
// // No GMS core nodes.
// std::vector<AttributionNodeInternal> attributions7 = {CreateAttribution(111, "App1"), sortLogEventsByTimestamp(&events);
// CreateAttribution(333, "App3")};
// std::vector<AttributionNodeInternal> attributions8 = {CreateAttribution(111, "App1")}; for (const auto& event : events) {
// processor->OnLogEvent(event.get());
// // GMS core node with isolated uid. }
// const int isolatedUid = 666; ConfigMetricsReportList reports;
// std::vector<AttributionNodeInternal> attributions9 = { vector<uint8_t> buffer;
// CreateAttribution(isolatedUid, "GMSCoreModule3")}; processor->onDumpReport(cfgKey, bucketStartTimeNs + 4 * bucketSizeNs + 1, false, true, ADB_DUMP,
// FAST, &buffer);
// std::vector<std::unique_ptr<LogEvent>> events; EXPECT_TRUE(buffer.size() > 0);
// // Events 1~4 are in the 1st bucket. EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// events.push_back(CreateAcquireWakelockEvent( backfillDimensionPath(&reports);
// attributions1, "wl1", bucketStartTimeNs + 2)); backfillStringInReport(&reports);
// events.push_back(CreateAcquireWakelockEvent( backfillStartEndTimestamp(&reports);
// attributions2, "wl1", bucketStartTimeNs + 200)); EXPECT_EQ(reports.reports_size(), 1);
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// attributions3, "wl1", bucketStartTimeNs + bucketSizeNs - 1));
// events.push_back(CreateAcquireWakelockEvent( StatsLogReport::CountMetricDataWrapper countMetrics;
// attributions4, "wl1", bucketStartTimeNs + bucketSizeNs)); sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics);
// EXPECT_EQ(countMetrics.data_size(), 4);
// // Events 5~8 are in the 3rd bucket.
// events.push_back(CreateAcquireWakelockEvent( auto data = countMetrics.data(0);
// attributions5, "wl2", bucketStartTimeNs + 2 * bucketSizeNs + 1)); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(),
// events.push_back(CreateAcquireWakelockEvent( android::util::WAKELOCK_STATE_CHANGED, 111, "App1");
// attributions6, "wl2", bucketStartTimeNs + 2 * bucketSizeNs + 100)); EXPECT_EQ(data.bucket_info_size(), 2);
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(data.bucket_info(0).count(), 2);
// attributions7, "wl2", bucketStartTimeNs + 3 * bucketSizeNs - 2)); EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs);
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs);
// attributions8, "wl2", bucketStartTimeNs + 3 * bucketSizeNs)); EXPECT_EQ(data.bucket_info(1).count(), 1);
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(data.bucket_info(1).start_bucket_elapsed_nanos(),
// attributions9, "wl2", bucketStartTimeNs + 3 * bucketSizeNs + 1)); bucketStartTimeNs + 2 * bucketSizeNs);
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(data.bucket_info(1).end_bucket_elapsed_nanos(), bucketStartTimeNs + 3 * bucketSizeNs);
// attributions9, "wl2", bucketStartTimeNs + 3 * bucketSizeNs + 100));
// events.push_back(CreateIsolatedUidChangedEvent( data = countMetrics.data(1);
// isolatedUid, 222, true/* is_create*/, bucketStartTimeNs + 3 * bucketSizeNs - 1)); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(),
// events.push_back(CreateIsolatedUidChangedEvent( android::util::WAKELOCK_STATE_CHANGED, 222,
// isolatedUid, 222, false/* is_create*/, bucketStartTimeNs + 3 * bucketSizeNs + 10)); "GMSCoreModule1");
// EXPECT_EQ(data.bucket_info_size(), 2);
// sortLogEventsByTimestamp(&events); EXPECT_EQ(data.bucket_info(0).count(), 1);
// EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs);
// for (const auto& event : events) { EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs);
// processor->OnLogEvent(event.get()); EXPECT_EQ(data.bucket_info(1).count(), 1);
// } EXPECT_EQ(data.bucket_info(1).start_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs);
// ConfigMetricsReportList reports; EXPECT_EQ(data.bucket_info(1).end_bucket_elapsed_nanos(), bucketStartTimeNs + 2 * bucketSizeNs);
// vector<uint8_t> buffer;
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 4 * bucketSizeNs + 1, false, true, data = countMetrics.data(2);
// ADB_DUMP, FAST, &buffer); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(),
// EXPECT_TRUE(buffer.size() > 0); android::util::WAKELOCK_STATE_CHANGED, 222,
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); "GMSCoreModule3");
// backfillDimensionPath(&reports); EXPECT_EQ(data.bucket_info_size(), 1);
// backfillStringInReport(&reports); EXPECT_EQ(data.bucket_info(0).count(), 1);
// backfillStartEndTimestamp(&reports); EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(),
// EXPECT_EQ(reports.reports_size(), 1); bucketStartTimeNs + 3 * bucketSizeNs);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + 4 * bucketSizeNs);
//
// StatsLogReport::CountMetricDataWrapper countMetrics; data = countMetrics.data(3);
// sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(),
// EXPECT_EQ(countMetrics.data_size(), 4); android::util::WAKELOCK_STATE_CHANGED, 444,
// "GMSCoreModule2");
// auto data = countMetrics.data(0); EXPECT_EQ(data.bucket_info_size(), 1);
// ValidateAttributionUidAndTagDimension( EXPECT_EQ(data.bucket_info(0).count(), 1);
// data.dimensions_in_what(), android::util::WAKELOCK_STATE_CHANGED, 111, EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(),
// "App1"); bucketStartTimeNs + 2 * bucketSizeNs);
// EXPECT_EQ(data.bucket_info_size(), 2); EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + 3 * bucketSizeNs);
// EXPECT_EQ(data.bucket_info(0).count(), 2); }
// EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs);
// EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs); TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) {
// EXPECT_EQ(data.bucket_info(1).count(), 1); auto config = CreateStatsdConfig(Position::ALL);
// EXPECT_EQ(data.bucket_info(1).start_bucket_elapsed_nanos(), bucketStartTimeNs + 2 * bucketSizeNs); int64_t bucketStartTimeNs = 10000000000;
// EXPECT_EQ(data.bucket_info(1).end_bucket_elapsed_nanos(), bucketStartTimeNs + 3 * bucketSizeNs); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;
//
// data = countMetrics.data(1); ConfigKey cfgKey;
// ValidateAttributionUidAndTagDimension( auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// data.dimensions_in_what(), android::util::WAKELOCK_STATE_CHANGED, 222, EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// "GMSCoreModule1"); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ(data.bucket_info_size(), 2);
// EXPECT_EQ(data.bucket_info(0).count(), 1); // Here it assumes that GMS core has two uids.
// EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs); processor->getUidMap()->updateMap(
// EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs); 1, {222, 444, 111, 333}, {1, 1, 2, 2},
// EXPECT_EQ(data.bucket_info(1).count(), 1); {String16("v1"), String16("v1"), String16("v2"), String16("v2")},
// EXPECT_EQ(data.bucket_info(1).start_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs); {String16("com.android.gmscore"), String16("com.android.gmscore"), String16("app1"),
// EXPECT_EQ(data.bucket_info(1).end_bucket_elapsed_nanos(), bucketStartTimeNs + 2 * bucketSizeNs); String16("APP3")},
// {String16(""), String16(""), String16(""), String16("")});
// data = countMetrics.data(2);
// ValidateAttributionUidAndTagDimension( std::vector<std::unique_ptr<LogEvent>> events;
// data.dimensions_in_what(), android::util::WAKELOCK_STATE_CHANGED, 222, // Events 1~4 are in the 1st bucket.
// "GMSCoreModule3"); events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
// EXPECT_EQ(data.bucket_info_size(), 1); attributionTags1, "wl1"));
// EXPECT_EQ(data.bucket_info(0).count(), 1); events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 200, attributionUids2,
// EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs + 3 * bucketSizeNs); attributionTags2, "wl1"));
// EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + 4 * bucketSizeNs); events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 1,
// attributionUids3, attributionTags3, "wl1"));
// data = countMetrics.data(3); events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs, attributionUids4,
// ValidateAttributionUidAndTagDimension( attributionTags4, "wl1"));
// data.dimensions_in_what(), android::util::WAKELOCK_STATE_CHANGED, 444,
// "GMSCoreModule2"); // Events 5~8 are in the 3rd bucket.
// EXPECT_EQ(data.bucket_info_size(), 1); events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 1,
// EXPECT_EQ(data.bucket_info(0).count(), 1); attributionUids5, attributionTags5, "wl2"));
// EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs + 2 * bucketSizeNs); events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
// EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + 3 * bucketSizeNs); attributionUids6, attributionTags6, "wl2"));
//} events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs - 2,
// attributionUids7, attributionTags7, "wl2"));
//TEST(AttributionE2eTest, TestAttributionMatchAndSliceByChain) { events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs,
// auto config = CreateStatsdConfig(Position::ALL); attributionUids8, attributionTags8, "wl2"));
// int64_t bucketStartTimeNs = 10000000000; events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs + 1,
// int64_t bucketSizeNs = attributionUids10, attributionTags10, "wl2"));
// TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000; events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 3 * bucketSizeNs + 100,
// attributionUids10, attributionTags10, "wl2"));
// ConfigKey cfgKey; events.push_back(CreateIsolatedUidChangedEvent(bucketStartTimeNs + 3 * bucketSizeNs - 1, 222,
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); isolatedUid, true /*is_create*/));
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); events.push_back(CreateIsolatedUidChangedEvent(bucketStartTimeNs + 3 * bucketSizeNs + 10, 222,
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); isolatedUid, false /*is_create*/));
//
// // Here it assumes that GMS core has two uids. sortLogEventsByTimestamp(&events);
// processor->getUidMap()->updateMap(
// 1, {222, 444, 111, 333}, {1, 1, 2, 2}, for (const auto& event : events) {
// {String16("v1"), String16("v1"), String16("v2"), String16("v2")}, processor->OnLogEvent(event.get());
// {String16("com.android.gmscore"), String16("com.android.gmscore"), String16("app1"), }
// String16("APP3")}, ConfigMetricsReportList reports;
// {String16(""), String16(""), String16(""), String16("")}); vector<uint8_t> buffer;
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 4 * bucketSizeNs + 1, false, true, ADB_DUMP,
// // GMS core node is in the middle. FAST, &buffer);
// std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1"), EXPECT_TRUE(buffer.size() > 0);
// CreateAttribution(222, "GMSCoreModule1"), EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// CreateAttribution(333, "App3")}; backfillDimensionPath(&reports);
// backfillStringInReport(&reports);
// // GMS core node is the last one. backfillStartEndTimestamp(&reports);
// std::vector<AttributionNodeInternal> attributions2 = {CreateAttribution(111, "App1"), EXPECT_EQ(reports.reports_size(), 1);
// CreateAttribution(333, "App3"), EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// CreateAttribution(222, "GMSCoreModule1")};
// StatsLogReport::CountMetricDataWrapper countMetrics;
// // GMS core node is the first one. sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics);
// std::vector<AttributionNodeInternal> attributions3 = {CreateAttribution(222, "GMSCoreModule1"), EXPECT_EQ(countMetrics.data_size(), 6);
// CreateAttribution(333, "App3")};
// auto data = countMetrics.data(0);
// // Single GMS core node. ValidateAttributionUidAndTagDimension(data.dimensions_in_what(),
// std::vector<AttributionNodeInternal> attributions4 = {CreateAttribution(222, "GMSCoreModule1")}; android::util::WAKELOCK_STATE_CHANGED, 222,
// "GMSCoreModule1");
// // GMS core has another uid. EXPECT_EQ(2, data.bucket_info_size());
// std::vector<AttributionNodeInternal> attributions5 = {CreateAttribution(111, "App1"), EXPECT_EQ(1, data.bucket_info(0).count());
// CreateAttribution(444, "GMSCoreModule2"), EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// CreateAttribution(333, "App3")}; EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(1).count());
// // Multiple GMS core nodes. EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs,
// std::vector<AttributionNodeInternal> attributions6 = {CreateAttribution(444, "GMSCoreModule2"), data.bucket_info(1).start_bucket_elapsed_nanos());
// CreateAttribution(222, "GMSCoreModule1")}; EXPECT_EQ(bucketStartTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
//
// // No GMS core nodes. data = countMetrics.data(1);
// std::vector<AttributionNodeInternal> attributions7 = {CreateAttribution(111, "App1"), ValidateUidDimension(data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 222);
// CreateAttribution(333, "App3")}; ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 0,
// std::vector<AttributionNodeInternal> attributions8 = {CreateAttribution(111, "App1")}; android::util::WAKELOCK_STATE_CHANGED, 222,
// "GMSCoreModule1");
// // GMS core node with isolated uid. ValidateUidDimension(data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 333);
// const int isolatedUid = 666; ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 1,
// std::vector<AttributionNodeInternal> attributions9 = { android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// CreateAttribution(isolatedUid, "GMSCoreModule1")}; EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(data.bucket_info(0).count(), 1);
// std::vector<std::unique_ptr<LogEvent>> events; EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs);
// // Events 1~4 are in the 1st bucket. EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs);
// events.push_back(CreateAcquireWakelockEvent(
// attributions1, "wl1", bucketStartTimeNs + 2)); data = countMetrics.data(2);
// events.push_back(CreateAcquireWakelockEvent( ValidateUidDimension(data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 444);
// attributions2, "wl1", bucketStartTimeNs + 200)); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 0,
// events.push_back(CreateAcquireWakelockEvent( android::util::WAKELOCK_STATE_CHANGED, 444,
// attributions3, "wl1", bucketStartTimeNs + bucketSizeNs - 1)); "GMSCoreModule2");
// events.push_back(CreateAcquireWakelockEvent( ValidateUidDimension(data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 222);
// attributions4, "wl1", bucketStartTimeNs + bucketSizeNs)); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 1,
// android::util::WAKELOCK_STATE_CHANGED, 222,
// // Events 5~8 are in the 3rd bucket. "GMSCoreModule1");
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(data.bucket_info_size(), 1);
// attributions5, "wl2", bucketStartTimeNs + 2 * bucketSizeNs + 1)); EXPECT_EQ(data.bucket_info(0).count(), 1);
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// attributions6, "wl2", bucketStartTimeNs + 2 * bucketSizeNs + 100)); data.bucket_info(0).start_bucket_elapsed_nanos());
// events.push_back(CreateAcquireWakelockEvent( EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// attributions7, "wl2", bucketStartTimeNs + 3 * bucketSizeNs - 2));
// events.push_back(CreateAcquireWakelockEvent( data = countMetrics.data(3);
// attributions8, "wl2", bucketStartTimeNs + 3 * bucketSizeNs)); ValidateUidDimension(data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111);
// events.push_back(CreateAcquireWakelockEvent( ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 0,
// attributions9, "wl2", bucketStartTimeNs + 3 * bucketSizeNs + 1)); android::util::WAKELOCK_STATE_CHANGED, 111, "App1");
// events.push_back(CreateAcquireWakelockEvent( ValidateUidDimension(data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 222);
// attributions9, "wl2", bucketStartTimeNs + 3 * bucketSizeNs + 100)); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 1,
// events.push_back(CreateIsolatedUidChangedEvent( android::util::WAKELOCK_STATE_CHANGED, 222,
// isolatedUid, 222, true/* is_create*/, bucketStartTimeNs + 3 * bucketSizeNs - 1)); "GMSCoreModule1");
// events.push_back(CreateIsolatedUidChangedEvent( ValidateUidDimension(data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 333);
// isolatedUid, 222, false/* is_create*/, bucketStartTimeNs + 3 * bucketSizeNs + 10)); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 2,
// android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// sortLogEventsByTimestamp(&events); EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(data.bucket_info(0).count(), 1);
// for (const auto& event : events) { EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// processor->OnLogEvent(event.get()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// }
// ConfigMetricsReportList reports; data = countMetrics.data(4);
// vector<uint8_t> buffer; ValidateUidDimension(data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111);
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 4 * bucketSizeNs + 1, false, true, ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 0,
// ADB_DUMP, FAST, &buffer); android::util::WAKELOCK_STATE_CHANGED, 111, "App1");
// EXPECT_TRUE(buffer.size() > 0); ValidateUidDimension(data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 333);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 1,
// backfillDimensionPath(&reports); android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// backfillStringInReport(&reports); ValidateUidDimension(data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 222);
// backfillStartEndTimestamp(&reports); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 2,
// EXPECT_EQ(reports.reports_size(), 1); android::util::WAKELOCK_STATE_CHANGED, 222,
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); "GMSCoreModule1");
// EXPECT_EQ(data.bucket_info_size(), 1);
// StatsLogReport::CountMetricDataWrapper countMetrics; EXPECT_EQ(data.bucket_info(0).count(), 1);
// sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).count_metrics(), &countMetrics); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(countMetrics.data_size(), 6); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
//
// auto data = countMetrics.data(0); data = countMetrics.data(5);
// ValidateAttributionUidAndTagDimension( ValidateUidDimension(data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111);
// data.dimensions_in_what(), android::util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1"); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 0,
// EXPECT_EQ(2, data.bucket_info_size()); android::util::WAKELOCK_STATE_CHANGED, 111, "App1");
// EXPECT_EQ(1, data.bucket_info(0).count()); ValidateUidDimension(data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 444);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 1,
// data.bucket_info(0).start_bucket_elapsed_nanos()); android::util::WAKELOCK_STATE_CHANGED, 444,
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, "GMSCoreModule2");
// data.bucket_info(0).end_bucket_elapsed_nanos()); ValidateUidDimension(data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 333);
// EXPECT_EQ(1, data.bucket_info(1).count()); ValidateAttributionUidAndTagDimension(data.dimensions_in_what(), 2,
// EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(bucketStartTimeNs + 4 * bucketSizeNs, EXPECT_EQ(data.bucket_info(0).count(), 1);
// data.bucket_info(1).end_bucket_elapsed_nanos()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// data.bucket_info(0).start_bucket_elapsed_nanos());
// data = countMetrics.data(1); EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// ValidateUidDimension( }
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 222);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1");
// ValidateUidDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 333);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(data.bucket_info(0).count(), 1);
// EXPECT_EQ(data.bucket_info(0).start_bucket_elapsed_nanos(), bucketStartTimeNs);
// EXPECT_EQ(data.bucket_info(0).end_bucket_elapsed_nanos(), bucketStartTimeNs + bucketSizeNs);
//
// data = countMetrics.data(2);
// ValidateUidDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 444);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 444, "GMSCoreModule2");
// ValidateUidDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 222);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1");
// EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(data.bucket_info(0).count(), 1);
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs,
// data.bucket_info(0).end_bucket_elapsed_nanos());
//
// data = countMetrics.data(3);
// ValidateUidDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111, "App1");
// ValidateUidDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 222);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1");
// ValidateUidDimension(
// data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 333);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(data.bucket_info(0).count(), 1);
// EXPECT_EQ(bucketStartTimeNs,
// data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs,
// data.bucket_info(0).end_bucket_elapsed_nanos());
//
// data = countMetrics.data(4);
// ValidateUidDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111, "App1");
// ValidateUidDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 333);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// ValidateUidDimension(
// data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 222);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 222, "GMSCoreModule1");
// EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(data.bucket_info(0).count(), 1);
// EXPECT_EQ(bucketStartTimeNs,
// data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs,
// data.bucket_info(0).end_bucket_elapsed_nanos());
//
// data = countMetrics.data(5);
// ValidateUidDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 0, android::util::WAKELOCK_STATE_CHANGED, 111, "App1");
// ValidateUidDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 444);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 1, android::util::WAKELOCK_STATE_CHANGED, 444, "GMSCoreModule2");
// ValidateUidDimension(
// data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 333);
// ValidateAttributionUidAndTagDimension(
// data.dimensions_in_what(), 2, android::util::WAKELOCK_STATE_CHANGED, 333, "App3");
// EXPECT_EQ(data.bucket_info_size(), 1);
// EXPECT_EQ(data.bucket_info(0).count(), 1);
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs,
// data.bucket_info(0).end_bucket_elapsed_nanos());
//}
#else #else
GTEST_LOG_(INFO) << "This test does nothing.\n"; GTEST_LOG_(INFO) << "This test does nothing.\n";

94
cmds/statsd/tests/e2e/ConfigTtl_e2e_test.cpp
View File

@@ -56,54 +56,54 @@ StatsdConfig CreateStatsdConfig(int num_buckets, int threshold) {
} // namespace } // namespace
// TODO(b/149590301): Update this test to use new socket schema. TEST(ConfigTtlE2eTest, TestCountMetric) {
//TEST(ConfigTtlE2eTest, TestCountMetric) { const int num_buckets = 1;
// const int num_buckets = 1; const int threshold = 3;
// const int threshold = 3; auto config = CreateStatsdConfig(num_buckets, threshold);
// auto config = CreateStatsdConfig(num_buckets, threshold); const uint64_t alert_id = config.alert(0).id();
// const uint64_t alert_id = config.alert(0).id(); const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
// const uint32_t refractory_period_sec = config.alert(0).refractory_period_secs();
//
// int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;
//
// ConfigKey cfgKey;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
//
// std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1")};
//
// FieldValue fieldValue1(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101),
// Value((int32_t)111));
// HashableDimensionKey whatKey1({fieldValue1});
// MetricDimensionKey dimensionKey1(whatKey1, DEFAULT_DIMENSION_KEY);
//
// FieldValue fieldValue2(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101),
// Value((int32_t)222));
// HashableDimensionKey whatKey2({fieldValue2});
// MetricDimensionKey dimensionKey2(whatKey2, DEFAULT_DIMENSION_KEY);
//
// auto event = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 2);
// processor->OnLogEvent(event.get());
//
// event = CreateAcquireWakelockEvent(attributions1, "wl2", bucketStartTimeNs + bucketSizeNs + 2);
// processor->OnLogEvent(event.get());
//
// event = CreateAcquireWakelockEvent(
// attributions1, "wl1", bucketStartTimeNs + 25 * bucketSizeNs + 2);
// processor->OnLogEvent(event.get());
//
// EXPECT_EQ((int64_t)(bucketStartTimeNs + 25 * bucketSizeNs + 2 + 2 * 3600 * NS_PER_SEC),
// processor->mMetricsManagers.begin()->second->getTtlEndNs());
//
// // Clear the data stored on disk as a result of the ttl.
// vector<uint8_t> buffer;
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 25 * bucketSizeNs + 3, false, true,
// ADB_DUMP, FAST, &buffer);
//}
int64_t bucketStartTimeNs = 10000000000;
int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000;
ConfigKey cfgKey;
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
std::vector<int> attributionUids1 = {111};
std::vector<string> attributionTags1 = {"App1"};
FieldValue fieldValue1(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101),
Value((int32_t)111));
HashableDimensionKey whatKey1({fieldValue1});
MetricDimensionKey dimensionKey1(whatKey1, DEFAULT_DIMENSION_KEY);
FieldValue fieldValue2(Field(android::util::WAKELOCK_STATE_CHANGED, (int32_t)0x02010101),
Value((int32_t)222));
HashableDimensionKey whatKey2({fieldValue2});
MetricDimensionKey dimensionKey2(whatKey2, DEFAULT_DIMENSION_KEY);
auto event = CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
attributionTags1, "wl1");
processor->OnLogEvent(event.get());
event = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs + 2, attributionUids1,
attributionTags1, "wl2");
processor->OnLogEvent(event.get());
event = CreateAcquireWakelockEvent(bucketStartTimeNs + 25 * bucketSizeNs + 2, attributionUids1,
attributionTags1, "wl1");
processor->OnLogEvent(event.get());
EXPECT_EQ((int64_t)(bucketStartTimeNs + 25 * bucketSizeNs + 2 + 2 * 3600 * NS_PER_SEC),
processor->mMetricsManagers.begin()->second->getTtlEndNs());
// Clear the data stored on disk as a result of the ttl.
vector<uint8_t> buffer;
processor->onDumpReport(cfgKey, bucketStartTimeNs + 25 * bucketSizeNs + 3, false, true,
ADB_DUMP, FAST, &buffer);
}
#else #else
GTEST_LOG_(INFO) << "This test does nothing.\n"; GTEST_LOG_(INFO) << "This test does nothing.\n";

1536
cmds/statsd/tests/e2e/CountMetric_e2e_test.cpp
View File

File diff suppressed because it is too large Load Diff

1364
cmds/statsd/tests/e2e/DurationMetric_e2e_test.cpp
View File

File diff suppressed because it is too large Load Diff

935
cmds/statsd/tests/e2e/GaugeMetric_e2e_pull_test.cpp
View File

@@ -65,482 +65,465 @@ StatsdConfig CreateStatsdConfig(const GaugeMetric::SamplingType sampling_type,
} // namespaces } // namespaces
// TODO(b/149590301): Update this test to use new socket schema. TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents) {
//TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents) { auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE);
// auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE); int64_t baseTimeNs = getElapsedRealtimeNs();
// int64_t baseTimeNs = getElapsedRealtimeNs(); int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// int64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000; ConfigKey cfgKey;
// auto processor =
// ConfigKey cfgKey; CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
// SharedRefBase::make<FakeSubsystemSleepCallback>(), EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// ATOM_TAG); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); processor->mPullerManager->ForceClearPullerCache();
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// processor->mPullerManager->ForceClearPullerCache(); int startBucketNum = processor->mMetricsManagers.begin()
// ->second->mAllMetricProducers[0]
// int startBucketNum = processor->mMetricsManagers.begin()->second-> ->getCurrentBucketNum();
// mAllMetricProducers[0]->getCurrentBucketNum(); EXPECT_GT(startBucketNum, (int64_t)0);
// EXPECT_GT(startBucketNum, (int64_t)0);
// // When creating the config, the gauge metric producer should register the alarm at the
// // When creating the config, the gauge metric producer should register the alarm at the // end of the current bucket.
// // end of the current bucket. EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
// EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs,
// EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
// processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& nextPullTimeNs =
// int64_t& nextPullTimeNs = processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
// processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs; EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
// auto screenOffEvent =
// auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
// configAddedTimeNs + 55); processor->OnLogEvent(screenOffEvent.get());
// processor->OnLogEvent(screenOffEvent.get());
// // Pulling alarm arrives on time and reset the sequential pulling alarm.
// // Pulling alarm arrives on time and reset the sequential pulling alarm. processor->informPullAlarmFired(nextPullTimeNs + 1);
// processor->informPullAlarmFired(nextPullTimeNs + 1); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
// auto screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
// auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, android::view::DISPLAY_STATE_ON);
// configAddedTimeNs + bucketSizeNs + 10); processor->OnLogEvent(screenOnEvent.get());
// processor->OnLogEvent(screenOnEvent.get());
// screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 100,
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, android::view::DISPLAY_STATE_OFF);
// configAddedTimeNs + bucketSizeNs + 100); processor->OnLogEvent(screenOffEvent.get());
// processor->OnLogEvent(screenOffEvent.get());
// processor->informPullAlarmFired(nextPullTimeNs + 1);
// processor->informPullAlarmFired(nextPullTimeNs + 1); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs,
// nextPullTimeNs); processor->informPullAlarmFired(nextPullTimeNs + 1);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs);
// processor->informPullAlarmFired(nextPullTimeNs + 1);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs); screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 2,
// android::view::DISPLAY_STATE_ON);
// screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, processor->OnLogEvent(screenOnEvent.get());
// configAddedTimeNs + 3 * bucketSizeNs + 2);
// processor->OnLogEvent(screenOnEvent.get()); processor->informPullAlarmFired(nextPullTimeNs + 3);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
// processor->informPullAlarmFired(nextPullTimeNs + 3);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs); screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 1,
// android::view::DISPLAY_STATE_OFF);
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, processor->OnLogEvent(screenOffEvent.get());
// configAddedTimeNs + 5 * bucketSizeNs + 1);
// processor->OnLogEvent(screenOffEvent.get()); processor->informPullAlarmFired(nextPullTimeNs + 2);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, nextPullTimeNs);
// processor->informPullAlarmFired(nextPullTimeNs + 2);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, nextPullTimeNs); processor->informPullAlarmFired(nextPullTimeNs + 2);
//
// processor->informPullAlarmFired(nextPullTimeNs + 2); ConfigMetricsReportList reports;
// vector<uint8_t> buffer;
// ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
// vector<uint8_t> buffer; ADB_DUMP, FAST, &buffer);
// processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true, EXPECT_TRUE(buffer.size() > 0);
// ADB_DUMP, FAST, &buffer); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// EXPECT_TRUE(buffer.size() > 0); backfillDimensionPath(&reports);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillStringInReport(&reports);
// backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports);
// backfillStringInReport(&reports); EXPECT_EQ(1, reports.reports_size());
// backfillStartEndTimestamp(&reports); EXPECT_EQ(1, reports.reports(0).metrics_size());
// EXPECT_EQ(1, reports.reports_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
// EXPECT_EQ(1, reports.reports(0).metrics_size()); sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
// StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; EXPECT_GT((int)gaugeMetrics.data_size(), 1);
// sortMetricDataByDimensionsValue(
// reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); auto data = gaugeMetrics.data(0);
// EXPECT_GT((int)gaugeMetrics.data_size(), 1); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// auto data = gaugeMetrics.data(0); EXPECT_EQ(1 /* subsystem name field */,
// EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
// EXPECT_EQ(1 /* subsystem name field */, EXPECT_EQ(6, data.bucket_info_size());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); EXPECT_EQ(1, data.bucket_info(0).atom_size());
// EXPECT_EQ(6, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
// EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
// EXPECT_EQ(1, data.bucket_info(0).atom_size()); EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
// EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_EQ(1, data.bucket_info(1).atom_size());
// EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0));
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0));
// EXPECT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
// data.bucket_info(1).elapsed_timestamp_nanos(0)); EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0)); EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(2).atom_size());
// EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
// EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, data.bucket_info(2).elapsed_timestamp_nanos(0));
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(2).atom_size()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
// data.bucket_info(2).elapsed_timestamp_nanos(0));
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(3).atom_size());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(3).elapsed_timestamp_nanos_size());
// EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 1, data.bucket_info(3).elapsed_timestamp_nanos(0));
// EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(3).atom_size()); EXPECT_TRUE(data.bucket_info(3).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(1, data.bucket_info(3).elapsed_timestamp_nanos_size()); EXPECT_GT(data.bucket_info(3).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 1,
// data.bucket_info(3).elapsed_timestamp_nanos(0)); EXPECT_EQ(1, data.bucket_info(4).atom_size());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(4).elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, data.bucket_info(4).elapsed_timestamp_nanos(0));
// EXPECT_TRUE(data.bucket_info(3).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(4).start_bucket_elapsed_nanos());
// EXPECT_GT(data.bucket_info(3).atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(4).end_bucket_elapsed_nanos());
// EXPECT_TRUE(data.bucket_info(4).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(1, data.bucket_info(4).atom_size()); EXPECT_GT(data.bucket_info(4).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(1, data.bucket_info(4).elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, EXPECT_EQ(1, data.bucket_info(5).atom_size());
// data.bucket_info(4).elapsed_timestamp_nanos(0)); EXPECT_EQ(1, data.bucket_info(5).elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(4).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs + 2, data.bucket_info(5).elapsed_timestamp_nanos(0));
// EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(4).end_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(5).start_bucket_elapsed_nanos());
// EXPECT_TRUE(data.bucket_info(4).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(5).end_bucket_elapsed_nanos());
// EXPECT_GT(data.bucket_info(4).atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_TRUE(data.bucket_info(5).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_GT(data.bucket_info(5).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(1, data.bucket_info(5).atom_size()); }
// EXPECT_EQ(1, data.bucket_info(5).elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs + 2, TEST(GaugeMetricE2eTest, TestConditionChangeToTrueSamplePulledEvents) {
// data.bucket_info(5).elapsed_timestamp_nanos(0)); auto config = CreateStatsdConfig(GaugeMetric::CONDITION_CHANGE_TO_TRUE);
// EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(5).start_bucket_elapsed_nanos()); int64_t baseTimeNs = getElapsedRealtimeNs();
// EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(5).end_bucket_elapsed_nanos()); int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// EXPECT_TRUE(data.bucket_info(5).atom(0).subsystem_sleep_state().subsystem_name().empty()); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// EXPECT_GT(data.bucket_info(5).atom(0).subsystem_sleep_state().time_millis(), 0);
//} ConfigKey cfgKey;
// auto processor =
//TEST(GaugeMetricE2eTest, TestConditionChangeToTrueSamplePulledEvents) { CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
// auto config = CreateStatsdConfig(GaugeMetric::CONDITION_CHANGE_TO_TRUE); SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
// int64_t baseTimeNs = getElapsedRealtimeNs(); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs; EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// int64_t bucketSizeNs = processor->mPullerManager->ForceClearPullerCache();
// TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// int startBucketNum = processor->mMetricsManagers.begin()
// ConfigKey cfgKey; ->second->mAllMetricProducers[0]
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, ->getCurrentBucketNum();
// SharedRefBase::make<FakeSubsystemSleepCallback>(), EXPECT_GT(startBucketNum, (int64_t)0);
// ATOM_TAG);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); auto screenOffEvent =
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
// processor->mPullerManager->ForceClearPullerCache(); processor->OnLogEvent(screenOffEvent.get());
//
// int startBucketNum = processor->mMetricsManagers.begin()->second-> auto screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
// mAllMetricProducers[0]->getCurrentBucketNum(); android::view::DISPLAY_STATE_ON);
// EXPECT_GT(startBucketNum, (int64_t)0); processor->OnLogEvent(screenOnEvent.get());
//
// auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 100,
// configAddedTimeNs + 55); android::view::DISPLAY_STATE_OFF);
// processor->OnLogEvent(screenOffEvent.get()); processor->OnLogEvent(screenOffEvent.get());
//
// auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 2,
// configAddedTimeNs + bucketSizeNs + 10); android::view::DISPLAY_STATE_ON);
// processor->OnLogEvent(screenOnEvent.get()); processor->OnLogEvent(screenOnEvent.get());
//
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 1,
// configAddedTimeNs + bucketSizeNs + 100); android::view::DISPLAY_STATE_OFF);
// processor->OnLogEvent(screenOffEvent.get()); processor->OnLogEvent(screenOffEvent.get());
// screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 3,
// screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, android::view::DISPLAY_STATE_ON);
// configAddedTimeNs + 3 * bucketSizeNs + 2); processor->OnLogEvent(screenOnEvent.get());
// processor->OnLogEvent(screenOnEvent.get()); screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 10,
// android::view::DISPLAY_STATE_OFF);
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, processor->OnLogEvent(screenOffEvent.get());
// configAddedTimeNs + 5 * bucketSizeNs + 1);
// processor->OnLogEvent(screenOffEvent.get()); ConfigMetricsReportList reports;
// screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, vector<uint8_t> buffer;
// configAddedTimeNs + 5 * bucketSizeNs + 3); processor->onDumpReport(cfgKey, configAddedTimeNs + 8 * bucketSizeNs + 10, false, true,
// processor->OnLogEvent(screenOnEvent.get()); ADB_DUMP, FAST, &buffer);
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, EXPECT_TRUE(buffer.size() > 0);
// configAddedTimeNs + 5 * bucketSizeNs + 10); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// processor->OnLogEvent(screenOffEvent.get()); backfillDimensionPath(&reports);
// backfillStringInReport(&reports);
// ConfigMetricsReportList reports; backfillStartEndTimestamp(&reports);
// vector<uint8_t> buffer; EXPECT_EQ(1, reports.reports_size());
// processor->onDumpReport(cfgKey, configAddedTimeNs + 8 * bucketSizeNs + 10, false, true, EXPECT_EQ(1, reports.reports(0).metrics_size());
// ADB_DUMP, FAST, &buffer); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
// EXPECT_TRUE(buffer.size() > 0); sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); EXPECT_GT((int)gaugeMetrics.data_size(), 1);
// backfillDimensionPath(&reports);
// backfillStringInReport(&reports); auto data = gaugeMetrics.data(0);
// backfillStartEndTimestamp(&reports); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
// EXPECT_EQ(1, reports.reports_size()); EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// EXPECT_EQ(1, reports.reports(0).metrics_size()); EXPECT_EQ(1 /* subsystem name field */,
// StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// sortMetricDataByDimensionsValue( EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
// reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); EXPECT_EQ(3, data.bucket_info_size());
// EXPECT_GT((int)gaugeMetrics.data_size(), 1);
// EXPECT_EQ(1, data.bucket_info(0).atom_size());
// auto data = gaugeMetrics.data(0); EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
// EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
// EXPECT_EQ(1 /* subsystem name field */, EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(3, data.bucket_info_size()); EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
//
// EXPECT_EQ(1, data.bucket_info(0).atom_size()); EXPECT_EQ(1, data.bucket_info(1).atom_size());
// EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 100, data.bucket_info(1).elapsed_timestamp_nanos(0));
// EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
// EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(2, data.bucket_info(2).atom_size());
// EXPECT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 100, EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, data.bucket_info(2).elapsed_timestamp_nanos(0));
// data.bucket_info(1).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 10, data.bucket_info(2).elapsed_timestamp_nanos(1));
// EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0)); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos()); EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_TRUE(data.bucket_info(2).atom(1).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_GT(data.bucket_info(2).atom(1).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(2, data.bucket_info(2).atom_size()); }
// EXPECT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm) {
// data.bucket_info(2).elapsed_timestamp_nanos(0)); auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE);
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 10, int64_t baseTimeNs = getElapsedRealtimeNs();
// data.bucket_info(2).elapsed_timestamp_nanos(1)); int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty()); ConfigKey cfgKey;
// EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0); auto processor =
// EXPECT_TRUE(data.bucket_info(2).atom(1).subsystem_sleep_state().subsystem_name().empty()); CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
// EXPECT_GT(data.bucket_info(2).atom(1).subsystem_sleep_state().time_millis(), 0); SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
//} EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// processor->mPullerManager->ForceClearPullerCache();
//TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm) {
// auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE); int startBucketNum = processor->mMetricsManagers.begin()
// int64_t baseTimeNs = getElapsedRealtimeNs(); ->second->mAllMetricProducers[0]
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs; ->getCurrentBucketNum();
// int64_t bucketSizeNs = EXPECT_GT(startBucketNum, (int64_t)0);
// TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// // When creating the config, the gauge metric producer should register the alarm at the
// ConfigKey cfgKey; // end of the current bucket.
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
// SharedRefBase::make<FakeSubsystemSleepCallback>(), EXPECT_EQ(bucketSizeNs,
// ATOM_TAG); processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); int64_t& nextPullTimeNs =
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
// processor->mPullerManager->ForceClearPullerCache(); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
//
// int startBucketNum = processor->mMetricsManagers.begin()->second-> auto screenOffEvent =
// mAllMetricProducers[0]->getCurrentBucketNum(); CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
// EXPECT_GT(startBucketNum, (int64_t)0); processor->OnLogEvent(screenOffEvent.get());
//
// // When creating the config, the gauge metric producer should register the alarm at the auto screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
// // end of the current bucket. android::view::DISPLAY_STATE_ON);
// EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); processor->OnLogEvent(screenOnEvent.get());
// EXPECT_EQ(bucketSizeNs,
// processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); // Pulling alarm arrives one bucket size late.
// int64_t& nextPullTimeNs = processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs);
// processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs; EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
// screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 11,
// auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, android::view::DISPLAY_STATE_OFF);
// configAddedTimeNs + 55); processor->OnLogEvent(screenOffEvent.get());
// processor->OnLogEvent(screenOffEvent.get());
// // Pulling alarm arrives more than one bucket size late.
// auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs + 12);
// configAddedTimeNs + bucketSizeNs + 10); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
// processor->OnLogEvent(screenOnEvent.get());
// ConfigMetricsReportList reports;
// // Pulling alarm arrives one bucket size late. vector<uint8_t> buffer;
// processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs); processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs); ADB_DUMP, FAST, &buffer);
// EXPECT_TRUE(buffer.size() > 0);
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// configAddedTimeNs + 3 * bucketSizeNs + 11); backfillDimensionPath(&reports);
// processor->OnLogEvent(screenOffEvent.get()); backfillStringInReport(&reports);
// backfillStartEndTimestamp(&reports);
// // Pulling alarm arrives more than one bucket size late. EXPECT_EQ(1, reports.reports_size());
// processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs + 12); EXPECT_EQ(1, reports.reports(0).metrics_size());
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
// sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
// ConfigMetricsReportList reports; EXPECT_GT((int)gaugeMetrics.data_size(), 1);
// vector<uint8_t> buffer;
// processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true, auto data = gaugeMetrics.data(0);
// ADB_DUMP, FAST, &buffer); EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
// EXPECT_TRUE(buffer.size() > 0); EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); EXPECT_EQ(1 /* subsystem name field */,
// backfillDimensionPath(&reports); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// backfillStringInReport(&reports); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
// backfillStartEndTimestamp(&reports); EXPECT_EQ(3, data.bucket_info_size());
// EXPECT_EQ(1, reports.reports_size());
// EXPECT_EQ(1, reports.reports(0).metrics_size()); EXPECT_EQ(1, data.bucket_info(0).atom_size());
// StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
// sortMetricDataByDimensionsValue( EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
// reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_GT((int)gaugeMetrics.data_size(), 1); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
// auto data = gaugeMetrics.data(0); EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1, data.bucket_info(1).atom_size());
// EXPECT_EQ(1 /* subsystem name field */, EXPECT_EQ(configAddedTimeNs + 3 * bucketSizeNs + 11,
// data.dimensions_in_what().value_tuple().dimensions_value(0).field()); data.bucket_info(1).elapsed_timestamp_nanos(0));
// EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
// EXPECT_EQ(3, data.bucket_info_size()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(0).atom_size()); EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
// EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(2).atom_size());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
// EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs + 12, data.bucket_info(2).elapsed_timestamp_nanos(0));
// EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(configAddedTimeNs + 3 * bucketSizeNs + 11, EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
// data.bucket_info(1).elapsed_timestamp_nanos(0)); }
// EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsWithActivation) {
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos()); auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);
// EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0); int64_t baseTimeNs = getElapsedRealtimeNs();
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// EXPECT_EQ(1, data.bucket_info(2).atom_size()); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs + 12, auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher();
// data.bucket_info(2).elapsed_timestamp_nanos(0)); *config.add_atom_matcher() = batterySaverStartMatcher;
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets.
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos()); auto metric_activation = config.add_metric_activation();
// EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty()); metric_activation->set_metric_id(metricId);
// EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0); metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY);
//} auto event_activation = metric_activation->add_event_activation();
// event_activation->set_atom_matcher_id(batterySaverStartMatcher.id());
//TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsWithActivation) { event_activation->set_ttl_seconds(ttlNs / 1000000000);
// auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);
// ConfigKey cfgKey;
// int64_t baseTimeNs = getElapsedRealtimeNs(); auto processor =
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs; CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
// int64_t bucketSizeNs = SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
// TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000; EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher(); processor->mPullerManager->ForceClearPullerCache();
// *config.add_atom_matcher() = batterySaverStartMatcher;
// const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets. int startBucketNum = processor->mMetricsManagers.begin()
// auto metric_activation = config.add_metric_activation(); ->second->mAllMetricProducers[0]
// metric_activation->set_metric_id(metricId); ->getCurrentBucketNum();
// metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY); EXPECT_GT(startBucketNum, (int64_t)0);
// auto event_activation = metric_activation->add_event_activation(); EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// event_activation->set_atom_matcher_id(batterySaverStartMatcher.id());
// event_activation->set_ttl_seconds(ttlNs / 1000000000); // When creating the config, the gauge metric producer should register the alarm at the
// // end of the current bucket.
// ConfigKey cfgKey; EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, EXPECT_EQ(bucketSizeNs,
// SharedRefBase::make<FakeSubsystemSleepCallback>(), processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
// ATOM_TAG); int64_t& nextPullTimeNs =
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
// processor->mPullerManager->ForceClearPullerCache();
// // Pulling alarm arrives on time and reset the sequential pulling alarm.
// int startBucketNum = processor->mMetricsManagers.begin()->second-> // Event should not be kept.
// mAllMetricProducers[0]->getCurrentBucketNum(); processor->informPullAlarmFired(nextPullTimeNs + 1); // 15 mins + 1 ns.
// EXPECT_GT(startBucketNum, (int64_t)0); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
// EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive()); EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
//
// // When creating the config, the gauge metric producer should register the alarm at the // Activate the metric. A pull occurs upon activation.
// // end of the current bucket. const int64_t activationNs = configAddedTimeNs + bucketSizeNs + (2 * 1000 * 1000); // 2 millis.
// EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs);
// EXPECT_EQ(bucketSizeNs, processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 2 ms.
// processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// int64_t& nextPullTimeNs =
// processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs; // This event should be kept. 2 total.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs); processor->informPullAlarmFired(nextPullTimeNs + 1); // 20 mins + 1 ns.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs);
// // Pulling alarm arrives on time and reset the sequential pulling alarm.
// // Event should not be kept. // This event should be kept. 3 total.
// processor->informPullAlarmFired(nextPullTimeNs + 1); // 15 mins + 1 ns. processor->informPullAlarmFired(nextPullTimeNs + 2); // 25 mins + 2 ns.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs);
// EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// // Create random event to deactivate metric.
// // Activate the metric. A pull occurs upon activation. auto deactivationEvent = CreateScreenBrightnessChangedEvent(activationNs + ttlNs + 1, 50);
// const int64_t activationNs = configAddedTimeNs + bucketSizeNs + (2 * 1000 * 1000); // 2 millis. processor->OnLogEvent(deactivationEvent.get());
// auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs); EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 2 ms.
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive()); // Event should not be kept. 3 total.
// processor->informPullAlarmFired(nextPullTimeNs + 3);
// // This event should be kept. 2 total. EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
// processor->informPullAlarmFired(nextPullTimeNs + 1); // 20 mins + 1 ns.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, processor->informPullAlarmFired(nextPullTimeNs + 2);
// nextPullTimeNs);
// ConfigMetricsReportList reports;
// // This event should be kept. 3 total. vector<uint8_t> buffer;
// processor->informPullAlarmFired(nextPullTimeNs + 2); // 25 mins + 2 ns. processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs); ADB_DUMP, FAST, &buffer);
// EXPECT_TRUE(buffer.size() > 0);
// // Create random event to deactivate metric. EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// auto deactivationEvent = CreateScreenBrightnessChangedEvent(50, activationNs + ttlNs + 1); backfillDimensionPath(&reports);
// processor->OnLogEvent(deactivationEvent.get()); backfillStringInReport(&reports);
// EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive()); backfillStartEndTimestamp(&reports);
// EXPECT_EQ(1, reports.reports_size());
// // Event should not be kept. 3 total. EXPECT_EQ(1, reports.reports(0).metrics_size());
// processor->informPullAlarmFired(nextPullTimeNs + 3); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs); sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
// EXPECT_GT((int)gaugeMetrics.data_size(), 0);
// processor->informPullAlarmFired(nextPullTimeNs + 2);
// auto data = gaugeMetrics.data(0);
// ConfigMetricsReportList reports; EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
// vector<uint8_t> buffer; EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true, EXPECT_EQ(1 /* subsystem name field */,
// ADB_DUMP, FAST, &buffer); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_TRUE(buffer.size() > 0); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); EXPECT_EQ(3, data.bucket_info_size());
// backfillDimensionPath(&reports);
// backfillStringInReport(&reports); auto bucketInfo = data.bucket_info(0);
// backfillStartEndTimestamp(&reports); EXPECT_EQ(1, bucketInfo.atom_size());
// EXPECT_EQ(1, reports.reports_size()); EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
// EXPECT_EQ(1, reports.reports(0).metrics_size()); EXPECT_EQ(activationNs, bucketInfo.elapsed_timestamp_nanos(0));
// StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
// sortMetricDataByDimensionsValue( EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
// reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
// EXPECT_GT((int)gaugeMetrics.data_size(), 0); EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
// auto data = gaugeMetrics.data(0);
// EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field()); bucketInfo = data.bucket_info(1);
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_EQ(1, bucketInfo.atom_size());
// EXPECT_EQ(1 /* subsystem name field */, EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, bucketInfo.elapsed_timestamp_nanos(0));
// EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
// EXPECT_EQ(3, data.bucket_info_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
// auto bucketInfo = data.bucket_info(0); EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(1, bucketInfo.atom_size()); EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
// EXPECT_EQ(activationNs, bucketInfo.elapsed_timestamp_nanos(0)); bucketInfo = data.bucket_info(2);
// EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); EXPECT_EQ(1, bucketInfo.atom_size());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos()); EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 2, bucketInfo.elapsed_timestamp_nanos(0));
// EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty()); EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
// EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0); EXPECT_EQ(MillisToNano(NanoToMillis(baseTimeNs + 5 * bucketSizeNs)),
// bucketInfo.start_bucket_elapsed_nanos());
// bucketInfo = data.bucket_info(1); EXPECT_EQ(MillisToNano(NanoToMillis(activationNs + ttlNs + 1)),
// EXPECT_EQ(1, bucketInfo.atom_size()); bucketInfo.end_bucket_elapsed_nanos());
// EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size()); EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, bucketInfo.elapsed_timestamp_nanos(0)); EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
// EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size()); }
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
// EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
//
// bucketInfo = data.bucket_info(2);
// EXPECT_EQ(1, bucketInfo.atom_size());
// EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 2, bucketInfo.elapsed_timestamp_nanos(0));
// EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
// EXPECT_EQ(MillisToNano(NanoToMillis(baseTimeNs + 5 * bucketSizeNs)),
// bucketInfo.start_bucket_elapsed_nanos());
// EXPECT_EQ(MillisToNano(NanoToMillis(activationNs + ttlNs + 1)),
// bucketInfo.end_bucket_elapsed_nanos());
// EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
// EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
//}
TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsNoCondition) { TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsNoCondition) {
auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false); auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);

435
cmds/statsd/tests/e2e/GaugeMetric_e2e_push_test.cpp
View File

@@ -14,12 +14,13 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <vector>
#include "src/StatsLogProcessor.h" #include "src/StatsLogProcessor.h"
#include "src/stats_log_util.h" #include "src/stats_log_util.h"
#include "stats_event.h"
#include "tests/statsd_test_util.h" #include "tests/statsd_test_util.h"
#include <vector>
namespace android { namespace android {
namespace os { namespace os {
namespace statsd { namespace statsd {
@@ -68,221 +69,227 @@ StatsdConfig CreateStatsdConfigForPushedEvent(const GaugeMetric::SamplingType sa
return config; return config;
} }
// TODO(b/149590301): Update this helper to use new socket schema. std::unique_ptr<LogEvent> CreateAppStartOccurredEvent(
//std::unique_ptr<LogEvent> CreateAppStartOccurredEvent( uint64_t timestampNs, const int uid, const string& pkg_name,
// const int uid, const string& pkg_name, AppStartOccurred::TransitionType type, AppStartOccurred::TransitionType type, const string& activity_name,
// const string& activity_name, const string& calling_pkg_name, const bool is_instant_app, const string& calling_pkg_name, const bool is_instant_app, int64_t activity_start_msec) {
// int64_t activity_start_msec, uint64_t timestampNs) { AStatsEvent* statsEvent = AStatsEvent_obtain();
// auto logEvent = std::make_unique<LogEvent>( AStatsEvent_setAtomId(statsEvent, android::util::APP_START_OCCURRED);
// android::util::APP_START_OCCURRED, timestampNs); AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// logEvent->write(uid);
// logEvent->write(pkg_name); AStatsEvent_writeInt32(statsEvent, uid);
// logEvent->write(type); AStatsEvent_writeString(statsEvent, pkg_name.c_str());
// logEvent->write(activity_name); AStatsEvent_writeInt32(statsEvent, type);
// logEvent->write(calling_pkg_name); AStatsEvent_writeString(statsEvent, activity_name.c_str());
// logEvent->write(is_instant_app); AStatsEvent_writeString(statsEvent, calling_pkg_name.c_str());
// logEvent->write(activity_start_msec); AStatsEvent_writeInt32(statsEvent, is_instant_app);
// logEvent->init(); AStatsEvent_writeInt32(statsEvent, activity_start_msec);
// return logEvent; AStatsEvent_build(statsEvent);
//}
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
} // namespace } // namespace
// TODO(b/149590301): Update this test to use new socket schema. TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) {
//TEST(GaugeMetricE2eTest, TestMultipleFieldsForPushedEvent) { for (const auto& sampling_type :
// for (const auto& sampling_type : {GaugeMetric::FIRST_N_SAMPLES, GaugeMetric::RANDOM_ONE_SAMPLE}) {
// { GaugeMetric::FIRST_N_SAMPLES, GaugeMetric:: RANDOM_ONE_SAMPLE }) { auto config = CreateStatsdConfigForPushedEvent(sampling_type);
// auto config = CreateStatsdConfigForPushedEvent(sampling_type); int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketStartTimeNs = 10000000000; int64_t bucketSizeNs =
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
// ConfigKey cfgKey;
// ConfigKey cfgKey; auto processor =
// auto processor = CreateStatsLogProcessor( CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// int appUid1 = 123;
// int appUid1 = 123; int appUid2 = 456;
// int appUid2 = 456; std::vector<std::unique_ptr<LogEvent>> events;
// std::vector<std::unique_ptr<LogEvent>> events; events.push_back(CreateMoveToBackgroundEvent(bucketStartTimeNs + 15, appUid1));
// events.push_back(CreateMoveToBackgroundEvent(appUid1, bucketStartTimeNs + 15)); events.push_back(
// events.push_back(CreateMoveToForegroundEvent( CreateMoveToForegroundEvent(bucketStartTimeNs + bucketSizeNs + 250, appUid1));
// appUid1, bucketStartTimeNs + bucketSizeNs + 250)); events.push_back(
// events.push_back(CreateMoveToBackgroundEvent( CreateMoveToBackgroundEvent(bucketStartTimeNs + bucketSizeNs + 350, appUid1));
// appUid1, bucketStartTimeNs + bucketSizeNs + 350)); events.push_back(
// events.push_back(CreateMoveToForegroundEvent( CreateMoveToForegroundEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100, appUid1));
// appUid1, bucketStartTimeNs + 2 * bucketSizeNs + 100));
// events.push_back(CreateAppStartOccurredEvent(
// bucketStartTimeNs + 10, appUid1, "app1", AppStartOccurred::WARM, "activity_name1",
// events.push_back(CreateAppStartOccurredEvent( "calling_pkg_name1", true /*is_instant_app*/, 101 /*activity_start_msec*/));
// appUid1, "app1", AppStartOccurred::WARM, "activity_name1", "calling_pkg_name1", events.push_back(CreateAppStartOccurredEvent(
// true /*is_instant_app*/, 101 /*activity_start_msec*/, bucketStartTimeNs + 10)); bucketStartTimeNs + 20, appUid1, "app1", AppStartOccurred::HOT, "activity_name2",
// events.push_back(CreateAppStartOccurredEvent( "calling_pkg_name2", true /*is_instant_app*/, 102 /*activity_start_msec*/));
// appUid1, "app1", AppStartOccurred::HOT, "activity_name2", "calling_pkg_name2", events.push_back(CreateAppStartOccurredEvent(
// true /*is_instant_app*/, 102 /*activity_start_msec*/, bucketStartTimeNs + 20)); bucketStartTimeNs + 30, appUid1, "app1", AppStartOccurred::COLD, "activity_name3",
// events.push_back(CreateAppStartOccurredEvent( "calling_pkg_name3", true /*is_instant_app*/, 103 /*activity_start_msec*/));
// appUid1, "app1", AppStartOccurred::COLD, "activity_name3", "calling_pkg_name3", events.push_back(CreateAppStartOccurredEvent(
// true /*is_instant_app*/, 103 /*activity_start_msec*/, bucketStartTimeNs + 30)); bucketStartTimeNs + bucketSizeNs + 30, appUid1, "app1", AppStartOccurred::WARM,
// events.push_back(CreateAppStartOccurredEvent( "activity_name4", "calling_pkg_name4", true /*is_instant_app*/,
// appUid1, "app1", AppStartOccurred::WARM, "activity_name4", "calling_pkg_name4", 104 /*activity_start_msec*/));
// true /*is_instant_app*/, 104 /*activity_start_msec*/, events.push_back(CreateAppStartOccurredEvent(
// bucketStartTimeNs + bucketSizeNs + 30)); bucketStartTimeNs + 2 * bucketSizeNs, appUid1, "app1", AppStartOccurred::COLD,
// events.push_back(CreateAppStartOccurredEvent( "activity_name5", "calling_pkg_name5", true /*is_instant_app*/,
// appUid1, "app1", AppStartOccurred::COLD, "activity_name5", "calling_pkg_name5", 105 /*activity_start_msec*/));
// true /*is_instant_app*/, 105 /*activity_start_msec*/, events.push_back(CreateAppStartOccurredEvent(
// bucketStartTimeNs + 2 * bucketSizeNs)); bucketStartTimeNs + 2 * bucketSizeNs + 10, appUid1, "app1", AppStartOccurred::HOT,
// events.push_back(CreateAppStartOccurredEvent( "activity_name6", "calling_pkg_name6", false /*is_instant_app*/,
// appUid1, "app1", AppStartOccurred::HOT, "activity_name6", "calling_pkg_name6", 106 /*activity_start_msec*/));
// false /*is_instant_app*/, 106 /*activity_start_msec*/,
// bucketStartTimeNs + 2 * bucketSizeNs + 10)); events.push_back(
// CreateMoveToBackgroundEvent(bucketStartTimeNs + bucketSizeNs + 10, appUid2));
// events.push_back(CreateMoveToBackgroundEvent( events.push_back(CreateAppStartOccurredEvent(
// appUid2, bucketStartTimeNs + bucketSizeNs + 10)); bucketStartTimeNs + 2 * bucketSizeNs + 10, appUid2, "app2", AppStartOccurred::COLD,
// events.push_back(CreateAppStartOccurredEvent( "activity_name7", "calling_pkg_name7", true /*is_instant_app*/,
// appUid2, "app2", AppStartOccurred::COLD, "activity_name7", "calling_pkg_name7", 201 /*activity_start_msec*/));
// true /*is_instant_app*/, 201 /*activity_start_msec*/,
// bucketStartTimeNs + 2 * bucketSizeNs + 10)); sortLogEventsByTimestamp(&events);
//
// sortLogEventsByTimestamp(&events); for (const auto& event : events) {
// processor->OnLogEvent(event.get());
// for (const auto& event : events) { }
// processor->OnLogEvent(event.get()); ConfigMetricsReportList reports;
// } vector<uint8_t> buffer;
// ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + 3 * bucketSizeNs, false, true, ADB_DUMP,
// vector<uint8_t> buffer; FAST, &buffer);
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 3 * bucketSizeNs, false, true, EXPECT_TRUE(buffer.size() > 0);
// ADB_DUMP, FAST, &buffer); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// EXPECT_TRUE(buffer.size() > 0); backfillDimensionPath(&reports);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillStringInReport(&reports);
// backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports);
// backfillStringInReport(&reports); EXPECT_EQ(1, reports.reports_size());
// backfillStartEndTimestamp(&reports); EXPECT_EQ(1, reports.reports(0).metrics_size());
// EXPECT_EQ(1, reports.reports_size()); StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
// EXPECT_EQ(1, reports.reports(0).metrics_size()); sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(),
// StatsLogReport::GaugeMetricDataWrapper gaugeMetrics; &gaugeMetrics);
// sortMetricDataByDimensionsValue( EXPECT_EQ(2, gaugeMetrics.data_size());
// reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
// EXPECT_EQ(2, gaugeMetrics.data_size()); auto data = gaugeMetrics.data(0);
// EXPECT_EQ(android::util::APP_START_OCCURRED, data.dimensions_in_what().field());
// auto data = gaugeMetrics.data(0); EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// EXPECT_EQ(android::util::APP_START_OCCURRED, data.dimensions_in_what().field()); EXPECT_EQ(1 /* uid field */,
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_EQ(1 /* uid field */, EXPECT_EQ(appUid1, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(3, data.bucket_info_size());
// EXPECT_EQ(appUid1, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); if (sampling_type == GaugeMetric::FIRST_N_SAMPLES) {
// EXPECT_EQ(3, data.bucket_info_size()); EXPECT_EQ(2, data.bucket_info(0).atom_size());
// if (sampling_type == GaugeMetric::FIRST_N_SAMPLES) { EXPECT_EQ(2, data.bucket_info(0).elapsed_timestamp_nanos_size());
// EXPECT_EQ(2, data.bucket_info(0).atom_size()); EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
// EXPECT_EQ(2, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs,
// EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, EXPECT_EQ(AppStartOccurred::HOT,
// data.bucket_info(0).end_bucket_elapsed_nanos()); data.bucket_info(0).atom(0).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::HOT, EXPECT_EQ("activity_name2",
// data.bucket_info(0).atom(0).app_start_occurred().type()); data.bucket_info(0).atom(0).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name2", EXPECT_EQ(102L,
// data.bucket_info(0).atom(0).app_start_occurred().activity_name()); data.bucket_info(0).atom(0).app_start_occurred().activity_start_millis());
// EXPECT_EQ(102L, EXPECT_EQ(AppStartOccurred::COLD,
// data.bucket_info(0).atom(0).app_start_occurred().activity_start_millis()); data.bucket_info(0).atom(1).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::COLD, EXPECT_EQ("activity_name3",
// data.bucket_info(0).atom(1).app_start_occurred().type()); data.bucket_info(0).atom(1).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name3", EXPECT_EQ(103L,
// data.bucket_info(0).atom(1).app_start_occurred().activity_name()); data.bucket_info(0).atom(1).app_start_occurred().activity_start_millis());
// EXPECT_EQ(103L,
// data.bucket_info(0).atom(1).app_start_occurred().activity_start_millis()); EXPECT_EQ(1, data.bucket_info(1).atom_size());
// EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size());
// EXPECT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs,
// EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// data.bucket_info(1).start_bucket_elapsed_nanos()); data.bucket_info(1).end_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, EXPECT_EQ(AppStartOccurred::WARM,
// data.bucket_info(1).end_bucket_elapsed_nanos()); data.bucket_info(1).atom(0).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::WARM, EXPECT_EQ("activity_name4",
// data.bucket_info(1).atom(0).app_start_occurred().type()); data.bucket_info(1).atom(0).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name4", EXPECT_EQ(104L,
// data.bucket_info(1).atom(0).app_start_occurred().activity_name()); data.bucket_info(1).atom(0).app_start_occurred().activity_start_millis());
// EXPECT_EQ(104L,
// data.bucket_info(1).atom(0).app_start_occurred().activity_start_millis()); EXPECT_EQ(2, data.bucket_info(2).atom_size());
// EXPECT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size());
// EXPECT_EQ(2, data.bucket_info(2).atom_size()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// EXPECT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size()); data.bucket_info(2).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs,
// data.bucket_info(2).start_bucket_elapsed_nanos()); data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, EXPECT_EQ(AppStartOccurred::COLD,
// data.bucket_info(2).end_bucket_elapsed_nanos()); data.bucket_info(2).atom(0).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::COLD, EXPECT_EQ("activity_name5",
// data.bucket_info(2).atom(0).app_start_occurred().type()); data.bucket_info(2).atom(0).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name5", EXPECT_EQ(105L,
// data.bucket_info(2).atom(0).app_start_occurred().activity_name()); data.bucket_info(2).atom(0).app_start_occurred().activity_start_millis());
// EXPECT_EQ(105L, EXPECT_EQ(AppStartOccurred::HOT,
// data.bucket_info(2).atom(0).app_start_occurred().activity_start_millis()); data.bucket_info(2).atom(1).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::HOT, EXPECT_EQ("activity_name6",
// data.bucket_info(2).atom(1).app_start_occurred().type()); data.bucket_info(2).atom(1).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name6", EXPECT_EQ(106L,
// data.bucket_info(2).atom(1).app_start_occurred().activity_name()); data.bucket_info(2).atom(1).app_start_occurred().activity_start_millis());
// EXPECT_EQ(106L, } else {
// data.bucket_info(2).atom(1).app_start_occurred().activity_start_millis()); EXPECT_EQ(1, data.bucket_info(0).atom_size());
// } else { EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
// EXPECT_EQ(1, data.bucket_info(0).atom_size()); EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs,
// EXPECT_EQ(bucketStartTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, EXPECT_EQ(AppStartOccurred::HOT,
// data.bucket_info(0).end_bucket_elapsed_nanos()); data.bucket_info(0).atom(0).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::HOT, EXPECT_EQ("activity_name2",
// data.bucket_info(0).atom(0).app_start_occurred().type()); data.bucket_info(0).atom(0).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name2", EXPECT_EQ(102L,
// data.bucket_info(0).atom(0).app_start_occurred().activity_name()); data.bucket_info(0).atom(0).app_start_occurred().activity_start_millis());
// EXPECT_EQ(102L,
// data.bucket_info(0).atom(0).app_start_occurred().activity_start_millis()); EXPECT_EQ(1, data.bucket_info(1).atom_size());
// EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size());
// EXPECT_EQ(1, data.bucket_info(1).atom_size()); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs,
// EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size()); data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// data.bucket_info(1).start_bucket_elapsed_nanos()); data.bucket_info(1).end_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, EXPECT_EQ(AppStartOccurred::WARM,
// data.bucket_info(1).end_bucket_elapsed_nanos()); data.bucket_info(1).atom(0).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::WARM, EXPECT_EQ("activity_name4",
// data.bucket_info(1).atom(0).app_start_occurred().type()); data.bucket_info(1).atom(0).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name4", EXPECT_EQ(104L,
// data.bucket_info(1).atom(0).app_start_occurred().activity_name()); data.bucket_info(1).atom(0).app_start_occurred().activity_start_millis());
// EXPECT_EQ(104L,
// data.bucket_info(1).atom(0).app_start_occurred().activity_start_millis()); EXPECT_EQ(1, data.bucket_info(2).atom_size());
// EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
// EXPECT_EQ(1, data.bucket_info(2).atom_size()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size()); data.bucket_info(2).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs,
// data.bucket_info(2).start_bucket_elapsed_nanos()); data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, EXPECT_EQ(AppStartOccurred::COLD,
// data.bucket_info(2).end_bucket_elapsed_nanos()); data.bucket_info(2).atom(0).app_start_occurred().type());
// EXPECT_EQ(AppStartOccurred::COLD, EXPECT_EQ("activity_name5",
// data.bucket_info(2).atom(0).app_start_occurred().type()); data.bucket_info(2).atom(0).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name5", EXPECT_EQ(105L,
// data.bucket_info(2).atom(0).app_start_occurred().activity_name()); data.bucket_info(2).atom(0).app_start_occurred().activity_start_millis());
// EXPECT_EQ(105L, }
// data.bucket_info(2).atom(0).app_start_occurred().activity_start_millis());
// } data = gaugeMetrics.data(1);
//
// data = gaugeMetrics.data(1); EXPECT_EQ(data.dimensions_in_what().field(), android::util::APP_START_OCCURRED);
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1);
// EXPECT_EQ(data.dimensions_in_what().field(), android::util::APP_START_OCCURRED); EXPECT_EQ(1 /* uid field */,
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_EQ(1 /* uid field */, EXPECT_EQ(appUid2, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field()); EXPECT_EQ(1, data.bucket_info_size());
// EXPECT_EQ(appUid2, data.dimensions_in_what().value_tuple().dimensions_value(0).value_int()); EXPECT_EQ(1, data.bucket_info(0).atom_size());
// EXPECT_EQ(1, data.bucket_info_size()); EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
// EXPECT_EQ(1, data.bucket_info(0).atom_size()); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size()); data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs,
// data.bucket_info(0).start_bucket_elapsed_nanos()); data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, EXPECT_EQ(AppStartOccurred::COLD, data.bucket_info(0).atom(0).app_start_occurred().type());
// data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_EQ("activity_name7",
// EXPECT_EQ(AppStartOccurred::COLD, data.bucket_info(0).atom(0).app_start_occurred().type()); data.bucket_info(0).atom(0).app_start_occurred().activity_name());
// EXPECT_EQ("activity_name7", EXPECT_EQ(201L, data.bucket_info(0).atom(0).app_start_occurred().activity_start_millis());
// data.bucket_info(0).atom(0).app_start_occurred().activity_name()); }
// EXPECT_EQ(201L, data.bucket_info(0).atom(0).app_start_occurred().activity_start_millis()); }
// }
//}
#else #else
GTEST_LOG_(INFO) << "This test does nothing.\n"; GTEST_LOG_(INFO) << "This test does nothing.\n";

3199
cmds/statsd/tests/e2e/MetricActivation_e2e_test.cpp
View File

File diff suppressed because it is too large Load Diff

485
cmds/statsd/tests/e2e/MetricConditionLink_e2e_test.cpp
View File

@@ -97,250 +97,247 @@ StatsdConfig CreateStatsdConfig() {
} }
} // namespace } // namespace
// TODO(b/149590301): Update these tests to use new socket schema. // If we want to test multiple dump data, we must do it in separate tests, because in the e2e tests,
//// If we want to test multiple dump data, we must do it in separate tests, because in the e2e tests, // we should use the real API which will clear the data after dump data is called.
//// we should use the real API which will clear the data after dump data is called. TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks1) {
//TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks1) { auto config = CreateStatsdConfig();
// auto config = CreateStatsdConfig(); uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketSizeNs =
// uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000LL;
// TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000LL;
// ConfigKey cfgKey;
// ConfigKey cfgKey; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// int appUid = 123;
// int appUid = 123; auto crashEvent1 = CreateAppCrashEvent(bucketStartTimeNs + 1, appUid);
// auto crashEvent1 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 1); auto crashEvent2 = CreateAppCrashEvent(bucketStartTimeNs + 201, appUid);
// auto crashEvent2 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 201); auto crashEvent3 = CreateAppCrashEvent(bucketStartTimeNs + 2 * bucketSizeNs - 101, appUid);
// auto crashEvent3= CreateAppCrashEvent(appUid, bucketStartTimeNs + 2 * bucketSizeNs - 101);
// auto crashEvent4 = CreateAppCrashEvent(bucketStartTimeNs + 51, appUid);
// auto crashEvent4 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 51); auto crashEvent5 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 299, appUid);
// auto crashEvent5 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 299); auto crashEvent6 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 2001, appUid);
// auto crashEvent6 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 2001);
// auto crashEvent7 = CreateAppCrashEvent(bucketStartTimeNs + 16, appUid);
// auto crashEvent7 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 16); auto crashEvent8 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 249, appUid);
// auto crashEvent8 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 249);
// auto crashEvent9 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 351, appUid);
// auto crashEvent9 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 351); auto crashEvent10 = CreateAppCrashEvent(bucketStartTimeNs + 2 * bucketSizeNs - 2, appUid);
// auto crashEvent10 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 2 * bucketSizeNs - 2);
// auto screenTurnedOnEvent = CreateScreenStateChangedEvent(
// auto screenTurnedOnEvent = bucketStartTimeNs + 2, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// CreateScreenStateChangedEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON, auto screenTurnedOffEvent = CreateScreenStateChangedEvent(
// bucketStartTimeNs + 2); bucketStartTimeNs + 200, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// auto screenTurnedOffEvent = auto screenTurnedOnEvent2 =
// CreateScreenStateChangedEvent(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs - 100,
// bucketStartTimeNs + 200); android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// auto screenTurnedOnEvent2 =
// CreateScreenStateChangedEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON, std::vector<int> attributionUids = {appUid, appUid + 1};
// bucketStartTimeNs + 2 * bucketSizeNs - 100); std::vector<string> attributionTags = {"App1", "GMSCoreModule1"};
//
// std::vector<AttributionNodeInternal> attributions = { auto syncOnEvent1 = CreateSyncStartEvent(bucketStartTimeNs + 50, attributionUids,
// CreateAttribution(appUid, "App1"), CreateAttribution(appUid + 1, "GMSCoreModule1")}; attributionTags, "ReadEmail");
// auto syncOnEvent1 = auto syncOffEvent1 = CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs + 300, attributionUids,
// CreateSyncStartEvent(attributions, "ReadEmail", bucketStartTimeNs + 50); attributionTags, "ReadEmail");
// auto syncOffEvent1 = auto syncOnEvent2 = CreateSyncStartEvent(bucketStartTimeNs + bucketSizeNs + 2000,
// CreateSyncEndEvent(attributions, "ReadEmail", bucketStartTimeNs + bucketSizeNs + 300); attributionUids, attributionTags, "ReadDoc");
// auto syncOnEvent2 =
// CreateSyncStartEvent(attributions, "ReadDoc", bucketStartTimeNs + bucketSizeNs + 2000); auto moveToBackgroundEvent1 = CreateMoveToBackgroundEvent(bucketStartTimeNs + 15, appUid);
// auto moveToForegroundEvent1 =
// auto moveToBackgroundEvent1 = CreateMoveToForegroundEvent(bucketStartTimeNs + bucketSizeNs + 250, appUid);
// CreateMoveToBackgroundEvent(appUid, bucketStartTimeNs + 15);
// auto moveToForegroundEvent1 = auto moveToBackgroundEvent2 =
// CreateMoveToForegroundEvent(appUid, bucketStartTimeNs + bucketSizeNs + 250); CreateMoveToBackgroundEvent(bucketStartTimeNs + bucketSizeNs + 350, appUid);
// auto moveToForegroundEvent2 =
// auto moveToBackgroundEvent2 = CreateMoveToForegroundEvent(bucketStartTimeNs + 2 * bucketSizeNs - 1, appUid);
// CreateMoveToBackgroundEvent(appUid, bucketStartTimeNs + bucketSizeNs + 350);
// auto moveToForegroundEvent2 = /*
// CreateMoveToForegroundEvent(appUid, bucketStartTimeNs + 2 * bucketSizeNs - 1); bucket #1 bucket #2
//
// /*
// bucket #1 bucket #2 | | | | | | | | | | (crashEvents)
// |-------------------------------------|-----------------------------------|---------
//
// | | | | | | | | | | (crashEvents) | | (MoveToBkground)
// |-------------------------------------|-----------------------------------|---------
// | | (MoveToForeground)
// | | (MoveToBkground)
// | | (SyncIsOn)
// | | (MoveToForeground) | (SyncIsOff)
// | | (ScreenIsOn)
// | | (SyncIsOn) | (ScreenIsOff)
// | (SyncIsOff) */
// | | (ScreenIsOn) std::vector<std::unique_ptr<LogEvent>> events;
// | (ScreenIsOff) events.push_back(std::move(crashEvent1));
// */ events.push_back(std::move(crashEvent2));
// std::vector<std::unique_ptr<LogEvent>> events; events.push_back(std::move(crashEvent3));
// events.push_back(std::move(crashEvent1)); events.push_back(std::move(crashEvent4));
// events.push_back(std::move(crashEvent2)); events.push_back(std::move(crashEvent5));
// events.push_back(std::move(crashEvent3)); events.push_back(std::move(crashEvent6));
// events.push_back(std::move(crashEvent4)); events.push_back(std::move(crashEvent7));
// events.push_back(std::move(crashEvent5)); events.push_back(std::move(crashEvent8));
// events.push_back(std::move(crashEvent6)); events.push_back(std::move(crashEvent9));
// events.push_back(std::move(crashEvent7)); events.push_back(std::move(crashEvent10));
// events.push_back(std::move(crashEvent8)); events.push_back(std::move(screenTurnedOnEvent));
// events.push_back(std::move(crashEvent9)); events.push_back(std::move(screenTurnedOffEvent));
// events.push_back(std::move(crashEvent10)); events.push_back(std::move(screenTurnedOnEvent2));
// events.push_back(std::move(screenTurnedOnEvent)); events.push_back(std::move(syncOnEvent1));
// events.push_back(std::move(screenTurnedOffEvent)); events.push_back(std::move(syncOffEvent1));
// events.push_back(std::move(screenTurnedOnEvent2)); events.push_back(std::move(syncOnEvent2));
// events.push_back(std::move(syncOnEvent1)); events.push_back(std::move(moveToBackgroundEvent1));
// events.push_back(std::move(syncOffEvent1)); events.push_back(std::move(moveToForegroundEvent1));
// events.push_back(std::move(syncOnEvent2)); events.push_back(std::move(moveToBackgroundEvent2));
// events.push_back(std::move(moveToBackgroundEvent1)); events.push_back(std::move(moveToForegroundEvent2));
// events.push_back(std::move(moveToForegroundEvent1));
// events.push_back(std::move(moveToBackgroundEvent2)); sortLogEventsByTimestamp(&events);
// events.push_back(std::move(moveToForegroundEvent2));
// for (const auto& event : events) {
// sortLogEventsByTimestamp(&events); processor->OnLogEvent(event.get());
// }
// for (const auto& event : events) { ConfigMetricsReportList reports;
// processor->OnLogEvent(event.get()); vector<uint8_t> buffer;
// } processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, ADB_DUMP,
// ConfigMetricsReportList reports; FAST, &buffer);
// vector<uint8_t> buffer; EXPECT_TRUE(buffer.size() > 0);
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// ADB_DUMP, FAST, &buffer); backfillDimensionPath(&reports);
// EXPECT_TRUE(buffer.size() > 0); backfillStringInReport(&reports);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillStartEndTimestamp(&reports);
// backfillDimensionPath(&reports); EXPECT_EQ(reports.reports_size(), 1);
// backfillStringInReport(&reports); EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// backfillStartEndTimestamp(&reports); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1);
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(0).count(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1); auto data = reports.reports(0).metrics(0).count_metrics().data(0);
// EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 1); // Validate dimension value.
// EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(0).count(), 1); EXPECT_EQ(data.dimensions_in_what().field(), android::util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
// auto data = reports.reports(0).metrics(0).count_metrics().data(0); EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1);
// // Validate dimension value. // Uid field.
// EXPECT_EQ(data.dimensions_in_what().field(), android::util::PROCESS_LIFE_CYCLE_STATE_CHANGED); EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(), 1);
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(), appUid);
// // Uid field. }
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(), 1);
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(), appUid); TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks2) {
//} auto config = CreateStatsdConfig();
// uint64_t bucketStartTimeNs = 10000000000;
//TEST(MetricConditionLinkE2eTest, TestMultiplePredicatesAndLinks2) { uint64_t bucketSizeNs =
// auto config = CreateStatsdConfig(); TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000LL;
// uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketSizeNs = ConfigKey cfgKey;
// TimeUnitToBucketSizeInMillis(config.count_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// ConfigKey cfgKey; EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// auto processor = CreateStatsLogProcessor(
// bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); int appUid = 123;
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); auto crashEvent1 = CreateAppCrashEvent(bucketStartTimeNs + 1, appUid);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); auto crashEvent2 = CreateAppCrashEvent(bucketStartTimeNs + 201, appUid);
// auto crashEvent3 = CreateAppCrashEvent(bucketStartTimeNs + 2 * bucketSizeNs - 101, appUid);
// int appUid = 123;
// auto crashEvent1 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 1); auto crashEvent4 = CreateAppCrashEvent(bucketStartTimeNs + 51, appUid);
// auto crashEvent2 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 201); auto crashEvent5 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 299, appUid);
// auto crashEvent3 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 2 * bucketSizeNs - 101); auto crashEvent6 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 2001, appUid);
//
// auto crashEvent4 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 51); auto crashEvent7 = CreateAppCrashEvent(bucketStartTimeNs + 16, appUid);
// auto crashEvent5 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 299); auto crashEvent8 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 249, appUid);
// auto crashEvent6 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 2001);
// auto crashEvent9 = CreateAppCrashEvent(bucketStartTimeNs + bucketSizeNs + 351, appUid);
// auto crashEvent7 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 16); auto crashEvent10 = CreateAppCrashEvent(bucketStartTimeNs + 2 * bucketSizeNs - 2, appUid);
// auto crashEvent8 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 249);
// auto screenTurnedOnEvent = CreateScreenStateChangedEvent(
// auto crashEvent9 = CreateAppCrashEvent(appUid, bucketStartTimeNs + bucketSizeNs + 351); bucketStartTimeNs + 2, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// auto crashEvent10 = CreateAppCrashEvent(appUid, bucketStartTimeNs + 2 * bucketSizeNs - 2); auto screenTurnedOffEvent = CreateScreenStateChangedEvent(
// bucketStartTimeNs + 200, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// auto screenTurnedOnEvent = CreateScreenStateChangedEvent( auto screenTurnedOnEvent2 =
// android::view::DisplayStateEnum::DISPLAY_STATE_ON, bucketStartTimeNs + 2); CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs - 100,
// auto screenTurnedOffEvent = CreateScreenStateChangedEvent( android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF, bucketStartTimeNs + 200);
// auto screenTurnedOnEvent2 = std::vector<int> attributionUids = {appUid, appUid + 1};
// CreateScreenStateChangedEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON, std::vector<string> attributionTags = {"App1", "GMSCoreModule1"};
// bucketStartTimeNs + 2 * bucketSizeNs - 100);
// auto syncOnEvent1 = CreateSyncStartEvent(bucketStartTimeNs + 50, attributionUids,
// std::vector<AttributionNodeInternal> attributions = { attributionTags, "ReadEmail");
// CreateAttribution(appUid, "App1"), CreateAttribution(appUid + 1, "GMSCoreModule1")}; auto syncOffEvent1 = CreateSyncEndEvent(bucketStartTimeNs + bucketSizeNs + 300, attributionUids,
// auto syncOnEvent1 = CreateSyncStartEvent(attributions, "ReadEmail", bucketStartTimeNs + 50); attributionTags, "ReadEmail");
// auto syncOffEvent1 = auto syncOnEvent2 = CreateSyncStartEvent(bucketStartTimeNs + bucketSizeNs + 2000,
// CreateSyncEndEvent(attributions, "ReadEmail", bucketStartTimeNs + bucketSizeNs + 300); attributionUids, attributionTags, "ReadDoc");
// auto syncOnEvent2 =
// CreateSyncStartEvent(attributions, "ReadDoc", bucketStartTimeNs + bucketSizeNs + 2000); auto moveToBackgroundEvent1 = CreateMoveToBackgroundEvent(bucketStartTimeNs + 15, appUid);
// auto moveToForegroundEvent1 =
// auto moveToBackgroundEvent1 = CreateMoveToBackgroundEvent(appUid, bucketStartTimeNs + 15); CreateMoveToForegroundEvent(bucketStartTimeNs + bucketSizeNs + 250, appUid);
// auto moveToForegroundEvent1 =
// CreateMoveToForegroundEvent(appUid, bucketStartTimeNs + bucketSizeNs + 250); auto moveToBackgroundEvent2 =
// CreateMoveToBackgroundEvent(bucketStartTimeNs + bucketSizeNs + 350, appUid);
// auto moveToBackgroundEvent2 = auto moveToForegroundEvent2 =
// CreateMoveToBackgroundEvent(appUid, bucketStartTimeNs + bucketSizeNs + 350); CreateMoveToForegroundEvent(bucketStartTimeNs + 2 * bucketSizeNs - 1, appUid);
// auto moveToForegroundEvent2 =
// CreateMoveToForegroundEvent(appUid, bucketStartTimeNs + 2 * bucketSizeNs - 1); /*
// bucket #1 bucket #2
// /*
// bucket #1 bucket #2
// | | | | | | | | | | (crashEvents)
// |-------------------------------------|-----------------------------------|---------
// | | | | | | | | | | (crashEvents)
// |-------------------------------------|-----------------------------------|--------- | | (MoveToBkground)
//
// | | (MoveToBkground) | | (MoveToForeground)
//
// | | (MoveToForeground) | | (SyncIsOn)
// | (SyncIsOff)
// | | (SyncIsOn) | | (ScreenIsOn)
// | (SyncIsOff) | (ScreenIsOff)
// | | (ScreenIsOn) */
// | (ScreenIsOff) std::vector<std::unique_ptr<LogEvent>> events;
// */ events.push_back(std::move(crashEvent1));
// std::vector<std::unique_ptr<LogEvent>> events; events.push_back(std::move(crashEvent2));
// events.push_back(std::move(crashEvent1)); events.push_back(std::move(crashEvent3));
// events.push_back(std::move(crashEvent2)); events.push_back(std::move(crashEvent4));
// events.push_back(std::move(crashEvent3)); events.push_back(std::move(crashEvent5));
// events.push_back(std::move(crashEvent4)); events.push_back(std::move(crashEvent6));
// events.push_back(std::move(crashEvent5)); events.push_back(std::move(crashEvent7));
// events.push_back(std::move(crashEvent6)); events.push_back(std::move(crashEvent8));
// events.push_back(std::move(crashEvent7)); events.push_back(std::move(crashEvent9));
// events.push_back(std::move(crashEvent8)); events.push_back(std::move(crashEvent10));
// events.push_back(std::move(crashEvent9)); events.push_back(std::move(screenTurnedOnEvent));
// events.push_back(std::move(crashEvent10)); events.push_back(std::move(screenTurnedOffEvent));
// events.push_back(std::move(screenTurnedOnEvent)); events.push_back(std::move(screenTurnedOnEvent2));
// events.push_back(std::move(screenTurnedOffEvent)); events.push_back(std::move(syncOnEvent1));
// events.push_back(std::move(screenTurnedOnEvent2)); events.push_back(std::move(syncOffEvent1));
// events.push_back(std::move(syncOnEvent1)); events.push_back(std::move(syncOnEvent2));
// events.push_back(std::move(syncOffEvent1)); events.push_back(std::move(moveToBackgroundEvent1));
// events.push_back(std::move(syncOnEvent2)); events.push_back(std::move(moveToForegroundEvent1));
// events.push_back(std::move(moveToBackgroundEvent1)); events.push_back(std::move(moveToBackgroundEvent2));
// events.push_back(std::move(moveToForegroundEvent1)); events.push_back(std::move(moveToForegroundEvent2));
// events.push_back(std::move(moveToBackgroundEvent2));
// events.push_back(std::move(moveToForegroundEvent2)); sortLogEventsByTimestamp(&events);
//
// sortLogEventsByTimestamp(&events); for (const auto& event : events) {
// processor->OnLogEvent(event.get());
// for (const auto& event : events) { }
// processor->OnLogEvent(event.get()); ConfigMetricsReportList reports;
// } vector<uint8_t> buffer;
// ConfigMetricsReportList reports;
// vector<uint8_t> buffer; processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, ADB_DUMP,
// FAST, &buffer);
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, EXPECT_TRUE(buffer.size() > 0);
// ADB_DUMP, FAST, &buffer); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// EXPECT_TRUE(buffer.size() > 0); backfillDimensionPath(&reports);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillStringInReport(&reports);
// backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports);
// backfillStringInReport(&reports); EXPECT_EQ(reports.reports_size(), 1);
// backfillStartEndTimestamp(&reports); EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 2);
// EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(0).count(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info_size(), 2); EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(1).count(), 3);
// EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(0).count(), 1); auto data = reports.reports(0).metrics(0).count_metrics().data(0);
// EXPECT_EQ(reports.reports(0).metrics(0).count_metrics().data(0).bucket_info(1).count(), 3); // Validate dimension value.
// auto data = reports.reports(0).metrics(0).count_metrics().data(0); EXPECT_EQ(data.dimensions_in_what().field(), android::util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
// // Validate dimension value. EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1);
// EXPECT_EQ(data.dimensions_in_what().field(), // Uid field.
// android::util::PROCESS_LIFE_CYCLE_STATE_CHANGED); EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(), 1);
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1); EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(), appUid);
// // Uid field. }
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(), 1);
// EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(), appUid);
//}
#else #else
GTEST_LOG_(INFO) << "This test does nothing.\n"; GTEST_LOG_(INFO) << "This test does nothing.\n";

191
cmds/statsd/tests/e2e/PartialBucket_e2e_test.cpp
View File

@@ -113,96 +113,107 @@ StatsdConfig MakeGaugeMetricConfig(int64_t minTime) {
} }
} // anonymous namespace } // anonymous namespace
// TODO(b/149590301): Update this test to use new socket schema. TEST(PartialBucketE2eTest, TestCountMetricWithoutSplit) {
//TEST(PartialBucketE2eTest, TestCountMetricWithoutSplit) { shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr);
// shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr); SendConfig(service, MakeConfig());
// SendConfig(service, MakeConfig()); int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are
// int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are // initialized with.
// // initialized with.
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 1, 100).get());
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 1).get()); service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 2, 100).get());
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 2).get());
// ConfigMetricsReport report = GetReports(service->mProcessor, start + 3);
// ConfigMetricsReport report = GetReports(service->mProcessor, start + 3); // Expect no metrics since the bucket has not finished yet.
// // Expect no metrics since the bucket has not finished yet. EXPECT_EQ(1, report.metrics_size());
// EXPECT_EQ(1, report.metrics_size()); EXPECT_EQ(0, report.metrics(0).count_metrics().data_size());
// EXPECT_EQ(0, report.metrics(0).count_metrics().data_size()); }
//}
// TEST(PartialBucketE2eTest, TestCountMetricNoSplitOnNewApp) {
//TEST(PartialBucketE2eTest, TestCountMetricNoSplitOnNewApp) { shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr);
// shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr); SendConfig(service, MakeConfig());
// SendConfig(service, MakeConfig()); int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are
// int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are // initialized with.
// // initialized with.
// // Force the uidmap to update at timestamp 2.
// // Force the uidmap to update at timestamp 2. service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 1, 100).get());
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 1).get()); // This is a new installation, so there shouldn't be a split (should be same as the without
// // This is a new installation, so there shouldn't be a split (should be same as the without // split case).
// // split case). service->mUidMap->updateApp(start + 2, String16(kApp1.c_str()), 1, 2, String16("v2"),
// service->mUidMap->updateApp(start + 2, String16(kApp1.c_str()), 1, 2, String16("v2"), String16(""));
// String16("")); // Goes into the second bucket.
// // Goes into the second bucket. service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 3, 100).get());
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 3).get());
// ConfigMetricsReport report = GetReports(service->mProcessor, start + 4);
// ConfigMetricsReport report = GetReports(service->mProcessor, start + 4); EXPECT_EQ(1, report.metrics_size());
// EXPECT_EQ(1, report.metrics_size()); EXPECT_EQ(0, report.metrics(0).count_metrics().data_size());
// EXPECT_EQ(0, report.metrics(0).count_metrics().data_size()); }
//}
// TEST(PartialBucketE2eTest, TestCountMetricSplitOnUpgrade) {
//TEST(PartialBucketE2eTest, TestCountMetricSplitOnUpgrade) { shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr);
// shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr); SendConfig(service, MakeConfig());
// SendConfig(service, MakeConfig()); int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are
// int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are // initialized with.
// // initialized with. service->mUidMap->updateMap(start, {1}, {1}, {String16("v1")}, {String16(kApp1.c_str())},
// service->mUidMap->updateMap(start, {1}, {1}, {String16("v1")}, {String16(kApp1.c_str())}, {String16("")});
// {String16("")});
// // Force the uidmap to update at timestamp 2.
// // Force the uidmap to update at timestamp 2. service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 1, 100).get());
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 1).get()); service->mUidMap->updateApp(start + 2, String16(kApp1.c_str()), 1, 2, String16("v2"),
// service->mUidMap->updateApp(start + 2, String16(kApp1.c_str()), 1, 2, String16("v2"), String16(""));
// String16("")); // Goes into the second bucket.
// // Goes into the second bucket. service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 3, 100).get());
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 3).get());
// ConfigMetricsReport report = GetReports(service->mProcessor, start + 4);
// ConfigMetricsReport report = GetReports(service->mProcessor, start + 4); backfillStartEndTimestamp(&report);
// backfillStartEndTimestamp(&report);
// ASSERT_EQ(1, report.metrics_size());
// ASSERT_EQ(1, report.metrics_size()); ASSERT_EQ(1, report.metrics(0).count_metrics().data_size());
// ASSERT_EQ(1, report.metrics(0).count_metrics().data_size()); ASSERT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info_size());
// ASSERT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info_size()); EXPECT_TRUE(report.metrics(0)
// EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). .count_metrics()
// has_start_bucket_elapsed_nanos()); .data(0)
// EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). .bucket_info(0)
// has_end_bucket_elapsed_nanos()); .has_start_bucket_elapsed_nanos());
// EXPECT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info(0).count()); EXPECT_TRUE(report.metrics(0)
//} .count_metrics()
// .data(0)
//TEST(PartialBucketE2eTest, TestCountMetricSplitOnRemoval) { .bucket_info(0)
// shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr); .has_end_bucket_elapsed_nanos());
// SendConfig(service, MakeConfig()); EXPECT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info(0).count());
// int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are }
// // initialized with.
// service->mUidMap->updateMap(start, {1}, {1}, {String16("v1")}, {String16(kApp1.c_str())}, TEST(PartialBucketE2eTest, TestCountMetricSplitOnRemoval) {
// {String16("")}); shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr);
// SendConfig(service, MakeConfig());
// // Force the uidmap to update at timestamp 2. int64_t start = getElapsedRealtimeNs(); // This is the start-time the metrics producers are
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 1).get()); // initialized with.
// service->mUidMap->removeApp(start + 2, String16(kApp1.c_str()), 1); service->mUidMap->updateMap(start, {1}, {1}, {String16("v1")}, {String16(kApp1.c_str())},
// // Goes into the second bucket. {String16("")});
// service->mProcessor->OnLogEvent(CreateAppCrashEvent(100, start + 3).get());
// // Force the uidmap to update at timestamp 2.
// ConfigMetricsReport report = GetReports(service->mProcessor, start + 4); service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 1, 100).get());
// backfillStartEndTimestamp(&report); service->mUidMap->removeApp(start + 2, String16(kApp1.c_str()), 1);
// // Goes into the second bucket.
// ASSERT_EQ(1, report.metrics_size()); service->mProcessor->OnLogEvent(CreateAppCrashEvent(start + 3, 100).get());
// ASSERT_EQ(1, report.metrics(0).count_metrics().data_size());
// ASSERT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info_size()); ConfigMetricsReport report = GetReports(service->mProcessor, start + 4);
// EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). backfillStartEndTimestamp(&report);
// has_start_bucket_elapsed_nanos());
// EXPECT_TRUE(report.metrics(0).count_metrics().data(0).bucket_info(0). ASSERT_EQ(1, report.metrics_size());
// has_end_bucket_elapsed_nanos()); ASSERT_EQ(1, report.metrics(0).count_metrics().data_size());
// EXPECT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info(0).count()); ASSERT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info_size());
//} EXPECT_TRUE(report.metrics(0)
.count_metrics()
.data(0)
.bucket_info(0)
.has_start_bucket_elapsed_nanos());
EXPECT_TRUE(report.metrics(0)
.count_metrics()
.data(0)
.bucket_info(0)
.has_end_bucket_elapsed_nanos());
EXPECT_EQ(1, report.metrics(0).count_metrics().data(0).bucket_info(0).count());
}
TEST(PartialBucketE2eTest, TestValueMetricWithoutMinPartialBucket) { TEST(PartialBucketE2eTest, TestValueMetricWithoutMinPartialBucket) {
shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr); shared_ptr<StatsService> service = SharedRefBase::make<StatsService>(nullptr, nullptr);

618
cmds/statsd/tests/e2e/ValueMetric_pull_e2e_test.cpp
View File

@@ -64,317 +64,313 @@ StatsdConfig CreateStatsdConfig(bool useCondition = true) {
} // namespace } // namespace
// TODO(b/149590301): Update this test to use new socket schema. TEST(ValueMetricE2eTest, TestPulledEvents) {
//TEST(ValueMetricE2eTest, TestPulledEvents) { auto config = CreateStatsdConfig();
// auto config = CreateStatsdConfig(); int64_t baseTimeNs = getElapsedRealtimeNs();
// int64_t baseTimeNs = getElapsedRealtimeNs(); int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000;
// int64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000; ConfigKey cfgKey;
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
// ConfigKey cfgKey; SharedRefBase::make<FakeSubsystemSleepCallback>(),
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, android::util::SUBSYSTEM_SLEEP_STATE);
// SharedRefBase::make<FakeSubsystemSleepCallback>(), EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// android::util::SUBSYSTEM_SLEEP_STATE); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); processor->mPullerManager->ForceClearPullerCache();
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// processor->mPullerManager->ForceClearPullerCache(); int startBucketNum = processor->mMetricsManagers.begin()
// ->second->mAllMetricProducers[0]
// int startBucketNum = processor->mMetricsManagers.begin()->second-> ->getCurrentBucketNum();
// mAllMetricProducers[0]->getCurrentBucketNum(); EXPECT_GT(startBucketNum, (int64_t)0);
// EXPECT_GT(startBucketNum, (int64_t)0);
// // When creating the config, the value metric producer should register the alarm at the
// // When creating the config, the value metric producer should register the alarm at the // end of the current bucket.
// // end of the current bucket. EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
// EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); EXPECT_EQ(bucketSizeNs,
// EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
// processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); int64_t& expectedPullTimeNs =
// int64_t& expectedPullTimeNs = processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
// processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs; EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs);
// auto screenOffEvent =
// auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
// configAddedTimeNs + 55); processor->OnLogEvent(screenOffEvent.get());
// processor->OnLogEvent(screenOffEvent.get());
// auto screenOnEvent =
// auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, CreateScreenStateChangedEvent(configAddedTimeNs + 65, android::view::DISPLAY_STATE_ON);
// configAddedTimeNs + 65); processor->OnLogEvent(screenOnEvent.get());
// processor->OnLogEvent(screenOnEvent.get());
// screenOffEvent =
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, CreateScreenStateChangedEvent(configAddedTimeNs + 75, android::view::DISPLAY_STATE_OFF);
// configAddedTimeNs + 75); processor->OnLogEvent(screenOffEvent.get());
// processor->OnLogEvent(screenOffEvent.get());
// // Pulling alarm arrives on time and reset the sequential pulling alarm.
// // Pulling alarm arrives on time and reset the sequential pulling alarm. processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, expectedPullTimeNs);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, expectedPullTimeNs);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 2 * bucketSizeNs + 15,
// screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, android::view::DISPLAY_STATE_ON);
// configAddedTimeNs + 2 * bucketSizeNs + 15); processor->OnLogEvent(screenOnEvent.get());
// processor->OnLogEvent(screenOnEvent.get());
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 4 * bucketSizeNs + 11,
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, android::view::DISPLAY_STATE_OFF);
// configAddedTimeNs + 4 * bucketSizeNs + 11); processor->OnLogEvent(screenOffEvent.get());
// processor->OnLogEvent(screenOffEvent.get());
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// ConfigMetricsReportList reports;
// ConfigMetricsReportList reports; vector<uint8_t> buffer;
// vector<uint8_t> buffer; processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
// processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true, ADB_DUMP, FAST, &buffer);
// ADB_DUMP, FAST, &buffer); EXPECT_TRUE(buffer.size() > 0);
// EXPECT_TRUE(buffer.size() > 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports);
// backfillDimensionPath(&reports); backfillStringInReport(&reports);
// backfillStringInReport(&reports); backfillStartEndTimestamp(&reports);
// backfillStartEndTimestamp(&reports); EXPECT_EQ(1, reports.reports_size());
// EXPECT_EQ(1, reports.reports_size()); EXPECT_EQ(1, reports.reports(0).metrics_size());
// EXPECT_EQ(1, reports.reports(0).metrics_size()); StatsLogReport::ValueMetricDataWrapper valueMetrics;
// StatsLogReport::ValueMetricDataWrapper valueMetrics; sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).value_metrics(), &valueMetrics);
// sortMetricDataByDimensionsValue( EXPECT_GT((int)valueMetrics.data_size(), 1);
// reports.reports(0).metrics(0).value_metrics(), &valueMetrics);
// EXPECT_GT((int)valueMetrics.data_size(), 1); auto data = valueMetrics.data(0);
// EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
// auto data = valueMetrics.data(0); EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field()); EXPECT_EQ(1 /* subsystem name field */,
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_EQ(1 /* subsystem name field */, EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field()); // We have 4 buckets, the first one was incomplete since the condition was unknown.
// EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); EXPECT_EQ(4, data.bucket_info_size());
// // We have 4 buckets, the first one was incomplete since the condition was unknown.
// EXPECT_EQ(4, data.bucket_info_size()); EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(0).values_size());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(0).values_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(1).values_size());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(1).values_size()); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(2).values_size());
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(2).values_size()); EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos()); EXPECT_EQ(1, data.bucket_info(3).values_size());
// EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos()); }
// EXPECT_EQ(1, data.bucket_info(3).values_size());
//} TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm) {
// auto config = CreateStatsdConfig();
//TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm) { int64_t baseTimeNs = getElapsedRealtimeNs();
// auto config = CreateStatsdConfig(); // 10 mins == 2 bucket durations.
// int64_t baseTimeNs = getElapsedRealtimeNs(); int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// // 10 mins == 2 bucket durations. int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000;
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// int64_t bucketSizeNs = ConfigKey cfgKey;
// TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000; auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
// SharedRefBase::make<FakeSubsystemSleepCallback>(),
// ConfigKey cfgKey; android::util::SUBSYSTEM_SLEEP_STATE);
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// SharedRefBase::make<FakeSubsystemSleepCallback>(), EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// android::util::SUBSYSTEM_SLEEP_STATE); processor->mPullerManager->ForceClearPullerCache();
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); int startBucketNum = processor->mMetricsManagers.begin()
// processor->mPullerManager->ForceClearPullerCache(); ->second->mAllMetricProducers[0]
// ->getCurrentBucketNum();
// int startBucketNum = processor->mMetricsManagers.begin()->second-> EXPECT_GT(startBucketNum, (int64_t)0);
// mAllMetricProducers[0]->getCurrentBucketNum();
// EXPECT_GT(startBucketNum, (int64_t)0); // When creating the config, the value metric producer should register the alarm at the
// // end of the current bucket.
// // When creating the config, the value metric producer should register the alarm at the EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
// // end of the current bucket. EXPECT_EQ(bucketSizeNs,
// EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
// EXPECT_EQ(bucketSizeNs, int64_t& expectedPullTimeNs =
// processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
// int64_t& expectedPullTimeNs = EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs);
// processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs); // Screen off/on/off events.
// auto screenOffEvent =
// // Screen off/on/off events. CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
// auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, processor->OnLogEvent(screenOffEvent.get());
// configAddedTimeNs + 55);
// processor->OnLogEvent(screenOffEvent.get()); auto screenOnEvent =
// CreateScreenStateChangedEvent(configAddedTimeNs + 65, android::view::DISPLAY_STATE_ON);
// auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, processor->OnLogEvent(screenOnEvent.get());
// configAddedTimeNs + 65);
// processor->OnLogEvent(screenOnEvent.get()); screenOffEvent =
// CreateScreenStateChangedEvent(configAddedTimeNs + 75, android::view::DISPLAY_STATE_OFF);
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, processor->OnLogEvent(screenOffEvent.get());
// configAddedTimeNs + 75);
// processor->OnLogEvent(screenOffEvent.get()); // Pulling alarm arrives late by 2 buckets and 1 ns. 2 buckets late is too far away in the
// // future, data will be skipped.
// // Pulling alarm arrives late by 2 buckets and 1 ns. 2 buckets late is too far away in the processor->informPullAlarmFired(expectedPullTimeNs + 2 * bucketSizeNs + 1);
// // future, data will be skipped. EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, expectedPullTimeNs);
// processor->informPullAlarmFired(expectedPullTimeNs + 2 * bucketSizeNs + 1);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, expectedPullTimeNs); // This screen state change will start a new bucket.
// screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 4 * bucketSizeNs + 65,
// // This screen state change will start a new bucket. android::view::DISPLAY_STATE_ON);
// screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON, processor->OnLogEvent(screenOnEvent.get());
// configAddedTimeNs + 4 * bucketSizeNs + 65);
// processor->OnLogEvent(screenOnEvent.get()); // The alarm is delayed but we already created a bucket thanks to the screen state condition.
// // This bucket does not have to be skipped since the alarm arrives in time for the next bucket.
// // The alarm is delayed but we already created a bucket thanks to the screen state condition. processor->informPullAlarmFired(expectedPullTimeNs + bucketSizeNs + 21);
// // This bucket does not have to be skipped since the alarm arrives in time for the next bucket. EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, expectedPullTimeNs);
// processor->informPullAlarmFired(expectedPullTimeNs + bucketSizeNs + 21);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, expectedPullTimeNs); screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 6 * bucketSizeNs + 31,
// android::view::DISPLAY_STATE_OFF);
// screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF, processor->OnLogEvent(screenOffEvent.get());
// configAddedTimeNs + 6 * bucketSizeNs + 31);
// processor->OnLogEvent(screenOffEvent.get()); processor->informPullAlarmFired(expectedPullTimeNs + bucketSizeNs + 21);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 8 * bucketSizeNs, expectedPullTimeNs);
// processor->informPullAlarmFired(expectedPullTimeNs + bucketSizeNs + 21);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 8 * bucketSizeNs, expectedPullTimeNs); processor->informPullAlarmFired(expectedPullTimeNs + 1);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 9 * bucketSizeNs, expectedPullTimeNs);
// processor->informPullAlarmFired(expectedPullTimeNs + 1);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 9 * bucketSizeNs, expectedPullTimeNs); ConfigMetricsReportList reports;
// vector<uint8_t> buffer;
// ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, configAddedTimeNs + 9 * bucketSizeNs + 10, false, true,
// vector<uint8_t> buffer; ADB_DUMP, FAST, &buffer);
// processor->onDumpReport(cfgKey, configAddedTimeNs + 9 * bucketSizeNs + 10, false, true, EXPECT_TRUE(buffer.size() > 0);
// ADB_DUMP, FAST, &buffer); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// EXPECT_TRUE(buffer.size() > 0); backfillDimensionPath(&reports);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillStringInReport(&reports);
// backfillDimensionPath(&reports); backfillStartEndTimestamp(&reports);
// backfillStringInReport(&reports); EXPECT_EQ(1, reports.reports_size());
// backfillStartEndTimestamp(&reports); EXPECT_EQ(1, reports.reports(0).metrics_size());
// EXPECT_EQ(1, reports.reports_size()); StatsLogReport::ValueMetricDataWrapper valueMetrics;
// EXPECT_EQ(1, reports.reports(0).metrics_size()); sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).value_metrics(), &valueMetrics);
// StatsLogReport::ValueMetricDataWrapper valueMetrics; EXPECT_GT((int)valueMetrics.data_size(), 1);
// sortMetricDataByDimensionsValue(
// reports.reports(0).metrics(0).value_metrics(), &valueMetrics); auto data = valueMetrics.data(0);
// EXPECT_GT((int)valueMetrics.data_size(), 1); EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// auto data = valueMetrics.data(0); EXPECT_EQ(1 /* subsystem name field */,
// EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field()); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
// EXPECT_EQ(1 /* subsystem name field */, EXPECT_EQ(3, data.bucket_info_size());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(3, data.bucket_info_size()); EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(0).values_size());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(0).values_size()); EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(1).values_size());
// EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(1).values_size()); EXPECT_EQ(baseTimeNs + 10 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(2).values_size());
// EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos()); }
// EXPECT_EQ(baseTimeNs + 10 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
// EXPECT_EQ(1, data.bucket_info(2).values_size()); TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation) {
//} auto config = CreateStatsdConfig(false);
// int64_t baseTimeNs = getElapsedRealtimeNs();
//TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation) { int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
// auto config = CreateStatsdConfig(false); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000;
// int64_t baseTimeNs = getElapsedRealtimeNs();
// int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs; auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher();
// int64_t bucketSizeNs = *config.add_atom_matcher() = batterySaverStartMatcher;
// TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000; const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets.
// auto metric_activation = config.add_metric_activation();
// auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher(); metric_activation->set_metric_id(metricId);
// *config.add_atom_matcher() = batterySaverStartMatcher; metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY);
// const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets. auto event_activation = metric_activation->add_event_activation();
// auto metric_activation = config.add_metric_activation(); event_activation->set_atom_matcher_id(batterySaverStartMatcher.id());
// metric_activation->set_metric_id(metricId); event_activation->set_ttl_seconds(ttlNs / 1000000000);
// metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY);
// auto event_activation = metric_activation->add_event_activation(); ConfigKey cfgKey;
// event_activation->set_atom_matcher_id(batterySaverStartMatcher.id()); auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
// event_activation->set_ttl_seconds(ttlNs / 1000000000); SharedRefBase::make<FakeSubsystemSleepCallback>(),
// android::util::SUBSYSTEM_SLEEP_STATE);
// ConfigKey cfgKey; EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey, EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// SharedRefBase::make<FakeSubsystemSleepCallback>(), processor->mPullerManager->ForceClearPullerCache();
// android::util::SUBSYSTEM_SLEEP_STATE);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); int startBucketNum = processor->mMetricsManagers.begin()
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); ->second->mAllMetricProducers[0]
// processor->mPullerManager->ForceClearPullerCache(); ->getCurrentBucketNum();
// EXPECT_GT(startBucketNum, (int64_t)0);
// int startBucketNum = processor->mMetricsManagers.begin()->second-> EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// mAllMetricProducers[0]->getCurrentBucketNum();
// EXPECT_GT(startBucketNum, (int64_t)0); // When creating the config, the value metric producer should register the alarm at the
// EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive()); // end of the current bucket.
// EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
// // When creating the config, the value metric producer should register the alarm at the EXPECT_EQ(bucketSizeNs,
// // end of the current bucket. processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
// EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size()); int64_t& expectedPullTimeNs =
// EXPECT_EQ(bucketSizeNs, processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
// processor->mPullerManager->mReceivers.begin()->second.front().intervalNs); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs);
// int64_t& expectedPullTimeNs =
// processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs; // Pulling alarm arrives on time and reset the sequential pulling alarm.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs); processor->informPullAlarmFired(expectedPullTimeNs + 1); // 15 mins + 1 ns.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, expectedPullTimeNs);
// // Pulling alarm arrives on time and reset the sequential pulling alarm. EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// processor->informPullAlarmFired(expectedPullTimeNs + 1); // 15 mins + 1 ns.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, expectedPullTimeNs); // Activate the metric. A pull occurs here
// EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive()); const int64_t activationNs = configAddedTimeNs + bucketSizeNs + (2 * 1000 * 1000); // 2 millis.
// auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs);
// // Activate the metric. A pull occurs here processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 2 ms.
// const int64_t activationNs = configAddedTimeNs + bucketSizeNs + (2 * 1000 * 1000); // 2 millis. EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs);
// processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 2 ms. processor->informPullAlarmFired(expectedPullTimeNs + 1); // 20 mins + 1 ns.
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive()); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, expectedPullTimeNs);
//
// processor->informPullAlarmFired(expectedPullTimeNs + 1); // 20 mins + 1 ns. processor->informPullAlarmFired(expectedPullTimeNs + 2); // 25 mins + 2 ns.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, expectedPullTimeNs); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, expectedPullTimeNs);
//
// processor->informPullAlarmFired(expectedPullTimeNs + 2); // 25 mins + 2 ns. // Create random event to deactivate metric.
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, expectedPullTimeNs); auto deactivationEvent = CreateScreenBrightnessChangedEvent(activationNs + ttlNs + 1, 50);
// processor->OnLogEvent(deactivationEvent.get());
// // Create random event to deactivate metric. EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
// auto deactivationEvent = CreateScreenBrightnessChangedEvent(50, activationNs + ttlNs + 1);
// processor->OnLogEvent(deactivationEvent.get()); processor->informPullAlarmFired(expectedPullTimeNs + 3);
// EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive()); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, expectedPullTimeNs);
//
// processor->informPullAlarmFired(expectedPullTimeNs + 3); processor->informPullAlarmFired(expectedPullTimeNs + 4);
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, expectedPullTimeNs); EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, expectedPullTimeNs);
//
// processor->informPullAlarmFired(expectedPullTimeNs + 4); ConfigMetricsReportList reports;
// EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, expectedPullTimeNs); vector<uint8_t> buffer;
// processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
// ConfigMetricsReportList reports; ADB_DUMP, FAST, &buffer);
// vector<uint8_t> buffer; EXPECT_TRUE(buffer.size() > 0);
// processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true, EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// ADB_DUMP, FAST, &buffer); backfillDimensionPath(&reports);
// EXPECT_TRUE(buffer.size() > 0); backfillStringInReport(&reports);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillStartEndTimestamp(&reports);
// backfillDimensionPath(&reports); EXPECT_EQ(1, reports.reports_size());
// backfillStringInReport(&reports); EXPECT_EQ(1, reports.reports(0).metrics_size());
// backfillStartEndTimestamp(&reports); StatsLogReport::ValueMetricDataWrapper valueMetrics;
// EXPECT_EQ(1, reports.reports_size()); sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).value_metrics(), &valueMetrics);
// EXPECT_EQ(1, reports.reports(0).metrics_size()); EXPECT_GT((int)valueMetrics.data_size(), 0);
// StatsLogReport::ValueMetricDataWrapper valueMetrics;
// sortMetricDataByDimensionsValue( auto data = valueMetrics.data(0);
// reports.reports(0).metrics(0).value_metrics(), &valueMetrics); EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
// EXPECT_GT((int)valueMetrics.data_size(), 0); EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
// EXPECT_EQ(1 /* subsystem name field */,
// auto data = valueMetrics.data(0); data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field()); EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
// EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size()); // We have 2 full buckets, the two surrounding the activation are dropped.
// EXPECT_EQ(1 /* subsystem name field */, EXPECT_EQ(2, data.bucket_info_size());
// data.dimensions_in_what().value_tuple().dimensions_value(0).field());
// EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty()); auto bucketInfo = data.bucket_info(0);
// // We have 2 full buckets, the two surrounding the activation are dropped. EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
// EXPECT_EQ(2, data.bucket_info_size()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
// EXPECT_EQ(1, bucketInfo.values_size());
// auto bucketInfo = data.bucket_info(0);
// EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos()); bucketInfo = data.bucket_info(1);
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos()); EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
// EXPECT_EQ(1, bucketInfo.values_size()); EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
// EXPECT_EQ(1, bucketInfo.values_size());
// bucketInfo = data.bucket_info(1); }
// EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
// EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
// EXPECT_EQ(1, bucketInfo.values_size());
//}
/** /**
* Test initialization of a simple value metric that is sliced by a state. * Test initialization of a simple value metric that is sliced by a state.

560
cmds/statsd/tests/e2e/WakelockDuration_e2e_test.cpp
View File

@@ -61,292 +61,290 @@ StatsdConfig CreateStatsdConfig(DurationMetric::AggregationType aggregationType)
return config; return config;
} }
std::vector<AttributionNodeInternal> attributions1 = {CreateAttribution(111, "App1"), std::vector<int> attributionUids1 = {111, 222, 222};
CreateAttribution(222, "GMSCoreModule1"), std::vector<string> attributionTags1 = {"App1", "GMSCoreModule1", "GMSCoreModule2"};
CreateAttribution(222, "GMSCoreModule2")};
std::vector<AttributionNodeInternal> attributions2 = {CreateAttribution(111, "App2"), std::vector<int> attributionUids2 = {111, 222, 222};
CreateAttribution(222, "GMSCoreModule1"), std::vector<string> attributionTags2 = {"App2", "GMSCoreModule1", "GMSCoreModule2"};
CreateAttribution(222, "GMSCoreModule2")};
// TODO(b/149590301): Update this helper to use new socket schema. /*
///* Events:
//Events: Screen off is met from (200ns,1 min+500ns].
//Screen off is met from (200ns,1 min+500ns]. Acquire event for wl1 from 2ns to 1min+2ns
//Acquire event for wl1 from 2ns to 1min+2ns Acquire event for wl2 from 1min-10ns to 2min-15ns
//Acquire event for wl2 from 1min-10ns to 2min-15ns */
//*/ void FeedEvents(StatsdConfig config, sp<StatsLogProcessor> processor) {
//void FeedEvents(StatsdConfig config, sp<StatsLogProcessor> processor) { uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketSizeNs =
// uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// auto screenTurnedOnEvent = CreateScreenStateChangedEvent(
// auto screenTurnedOnEvent = CreateScreenStateChangedEvent( bucketStartTimeNs + 1, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// android::view::DisplayStateEnum::DISPLAY_STATE_ON, bucketStartTimeNs + 1); auto screenTurnedOffEvent = CreateScreenStateChangedEvent(
// auto screenTurnedOffEvent = CreateScreenStateChangedEvent( bucketStartTimeNs + 200, android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
// android::view::DisplayStateEnum::DISPLAY_STATE_OFF, bucketStartTimeNs + 200); auto screenTurnedOnEvent2 =
// auto screenTurnedOnEvent2 = CreateScreenStateChangedEvent(bucketStartTimeNs + bucketSizeNs + 500,
// CreateScreenStateChangedEvent(android::view::DisplayStateEnum::DISPLAY_STATE_ON, android::view::DisplayStateEnum::DISPLAY_STATE_ON);
// bucketStartTimeNs + bucketSizeNs + 500);
// auto acquireEvent1 = CreateAcquireWakelockEvent(bucketStartTimeNs + 2, attributionUids1,
// auto acquireEvent1 = CreateAcquireWakelockEvent(attributions1, "wl1", bucketStartTimeNs + 2); attributionTags1, "wl1");
// auto releaseEvent1 = auto releaseEvent1 = CreateReleaseWakelockEvent(bucketStartTimeNs + bucketSizeNs + 2,
// CreateReleaseWakelockEvent(attributions1, "wl1", bucketStartTimeNs + bucketSizeNs + 2); attributionUids1, attributionTags1, "wl1");
// auto acquireEvent2 = auto acquireEvent2 = CreateAcquireWakelockEvent(bucketStartTimeNs + bucketSizeNs - 10,
// CreateAcquireWakelockEvent(attributions2, "wl2", bucketStartTimeNs + bucketSizeNs - 10); attributionUids2, attributionTags2, "wl2");
// auto releaseEvent2 = CreateReleaseWakelockEvent(attributions2, "wl2", auto releaseEvent2 = CreateReleaseWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs - 15,
// bucketStartTimeNs + 2 * bucketSizeNs - 15); attributionUids2, attributionTags2, "wl2");
//
// std::vector<std::unique_ptr<LogEvent>> events; std::vector<std::unique_ptr<LogEvent>> events;
//
// events.push_back(std::move(screenTurnedOnEvent)); events.push_back(std::move(screenTurnedOnEvent));
// events.push_back(std::move(screenTurnedOffEvent)); events.push_back(std::move(screenTurnedOffEvent));
// events.push_back(std::move(screenTurnedOnEvent2)); events.push_back(std::move(screenTurnedOnEvent2));
// events.push_back(std::move(acquireEvent1)); events.push_back(std::move(acquireEvent1));
// events.push_back(std::move(acquireEvent2)); events.push_back(std::move(acquireEvent2));
// events.push_back(std::move(releaseEvent1)); events.push_back(std::move(releaseEvent1));
// events.push_back(std::move(releaseEvent2)); events.push_back(std::move(releaseEvent2));
//
// sortLogEventsByTimestamp(&events); sortLogEventsByTimestamp(&events);
//
// for (const auto& event : events) { for (const auto& event : events) {
// processor->OnLogEvent(event.get()); processor->OnLogEvent(event.get());
// } }
//} }
} // namespace } // namespace
// TODO(b/149590301): Update these tests to use new socket schema. TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration1) {
//TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration1) { ConfigKey cfgKey;
// ConfigKey cfgKey; auto config = CreateStatsdConfig(DurationMetric::SUM);
// auto config = CreateStatsdConfig(DurationMetric::SUM); uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketSizeNs =
// uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor);
// FeedEvents(config, processor); vector<uint8_t> buffer;
// vector<uint8_t> buffer; ConfigMetricsReportList reports;
// ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, ADB_DUMP,
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, FAST, &buffer);
// ADB_DUMP, FAST, &buffer); EXPECT_TRUE(buffer.size() > 0);
// EXPECT_TRUE(buffer.size() > 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports);
// backfillDimensionPath(&reports); backfillStringInReport(&reports);
// backfillStringInReport(&reports); backfillStartEndTimestamp(&reports);
// backfillStartEndTimestamp(&reports);
// EXPECT_EQ(reports.reports_size(), 1);
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); // Only 1 dimension output. The tag dimension in the predicate has been aggregated.
// // Only 1 dimension output. The tag dimension in the predicate has been aggregated. EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
// auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
// auto data = reports.reports(0).metrics(0).duration_metrics().data(0); // Validate dimension value.
// // Validate dimension value. ValidateAttributionUidDimension(data.dimensions_in_what(),
// ValidateAttributionUidDimension(data.dimensions_in_what(), android::util::WAKELOCK_STATE_CHANGED, 111);
// android::util::WAKELOCK_STATE_CHANGED, 111); // Validate bucket info.
// // Validate bucket info. EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1); data = reports.reports(0).metrics(0).duration_metrics().data(0);
// data = reports.reports(0).metrics(0).duration_metrics().data(0); // The wakelock holding interval starts from the screen off event and to the end of the 1st
// // The wakelock holding interval starts from the screen off event and to the end of the 1st // bucket.
// // bucket. EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs - 200);
// EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs - 200); }
//}
// TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration2) {
//TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration2) { ConfigKey cfgKey;
// ConfigKey cfgKey; auto config = CreateStatsdConfig(DurationMetric::SUM);
// auto config = CreateStatsdConfig(DurationMetric::SUM); uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketSizeNs =
// uint64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); FeedEvents(config, processor);
// FeedEvents(config, processor); vector<uint8_t> buffer;
// vector<uint8_t> buffer; ConfigMetricsReportList reports;
// ConfigMetricsReportList reports; processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, ADB_DUMP,
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, FAST, &buffer);
// ADB_DUMP, FAST, &buffer); EXPECT_TRUE(buffer.size() > 0);
// EXPECT_TRUE(buffer.size() > 0); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); backfillDimensionPath(&reports);
// backfillDimensionPath(&reports); backfillStringInReport(&reports);
// backfillStringInReport(&reports); backfillStartEndTimestamp(&reports);
// backfillStartEndTimestamp(&reports); EXPECT_EQ(reports.reports_size(), 1);
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); // Dump the report after the end of 2nd bucket.
// // Dump the report after the end of 2nd bucket. EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2); auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
// auto data = reports.reports(0).metrics(0).duration_metrics().data(0); // Validate dimension value.
// // Validate dimension value. ValidateAttributionUidDimension(data.dimensions_in_what(),
// ValidateAttributionUidDimension(data.dimensions_in_what(), android::util::WAKELOCK_STATE_CHANGED, 111);
// android::util::WAKELOCK_STATE_CHANGED, 111); // Two output buckets.
// // Two output buckets. // The wakelock holding interval in the 1st bucket starts from the screen off event and to
// // The wakelock holding interval in the 1st bucket starts from the screen off event and to // the end of the 1st bucket.
// // the end of the 1st bucket. EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(),
// EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketStartTimeNs + bucketSizeNs - (bucketStartTimeNs + 200));
// bucketStartTimeNs + bucketSizeNs - (bucketStartTimeNs + 200)); // The wakelock holding interval in the 2nd bucket starts at the beginning of the bucket and
// // The wakelock holding interval in the 2nd bucket starts at the beginning of the bucket and // ends at the second screen on event.
// // ends at the second screen on event. EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 500UL);
// EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 500UL); }
//}
//TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration3) { TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForSumDuration3) {
// ConfigKey cfgKey; ConfigKey cfgKey;
// auto config = CreateStatsdConfig(DurationMetric::SUM); auto config = CreateStatsdConfig(DurationMetric::SUM);
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketSizeNs = uint64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// FeedEvents(config, processor); FeedEvents(config, processor);
// vector<uint8_t> buffer; vector<uint8_t> buffer;
// ConfigMetricsReportList reports; ConfigMetricsReportList reports;
//
// std::vector<std::unique_ptr<LogEvent>> events; std::vector<std::unique_ptr<LogEvent>> events;
// events.push_back( events.push_back(
// CreateScreenStateChangedEvent(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 90,
// bucketStartTimeNs + 2 * bucketSizeNs + 90)); android::view::DisplayStateEnum::DISPLAY_STATE_OFF));
// events.push_back(CreateAcquireWakelockEvent(attributions1, "wl3", events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
// bucketStartTimeNs + 2 * bucketSizeNs + 100)); attributionUids1, attributionTags1, "wl3"));
// events.push_back(CreateReleaseWakelockEvent(attributions1, "wl3", events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs + 100,
// bucketStartTimeNs + 5 * bucketSizeNs + 100)); attributionUids1, attributionTags1, "wl3"));
// sortLogEventsByTimestamp(&events); sortLogEventsByTimestamp(&events);
// for (const auto& event : events) { for (const auto& event : events) {
// processor->OnLogEvent(event.get()); processor->OnLogEvent(event.get());
// } }
//
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, ADB_DUMP,
// ADB_DUMP, FAST, &buffer); FAST, &buffer);
// EXPECT_TRUE(buffer.size() > 0); EXPECT_TRUE(buffer.size() > 0);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// backfillDimensionPath(&reports); backfillDimensionPath(&reports);
// backfillStringInReport(&reports); backfillStringInReport(&reports);
// backfillStartEndTimestamp(&reports); backfillStartEndTimestamp(&reports);
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 6); EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 6);
// auto data = reports.reports(0).metrics(0).duration_metrics().data(0); auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
// ValidateAttributionUidDimension(data.dimensions_in_what(), ValidateAttributionUidDimension(data.dimensions_in_what(),
// android::util::WAKELOCK_STATE_CHANGED, 111); android::util::WAKELOCK_STATE_CHANGED, 111);
// // The last wakelock holding spans 4 buckets. // The last wakelock holding spans 4 buckets.
// EXPECT_EQ((unsigned long long)data.bucket_info(2).duration_nanos(), bucketSizeNs - 100); EXPECT_EQ((unsigned long long)data.bucket_info(2).duration_nanos(), bucketSizeNs - 100);
// EXPECT_EQ((unsigned long long)data.bucket_info(3).duration_nanos(), bucketSizeNs); EXPECT_EQ((unsigned long long)data.bucket_info(3).duration_nanos(), bucketSizeNs);
// EXPECT_EQ((unsigned long long)data.bucket_info(4).duration_nanos(), bucketSizeNs); EXPECT_EQ((unsigned long long)data.bucket_info(4).duration_nanos(), bucketSizeNs);
// EXPECT_EQ((unsigned long long)data.bucket_info(5).duration_nanos(), 100UL); EXPECT_EQ((unsigned long long)data.bucket_info(5).duration_nanos(), 100UL);
//} }
//
//TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration1) { TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration1) {
// ConfigKey cfgKey; ConfigKey cfgKey;
// auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE); auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketSizeNs = uint64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// FeedEvents(config, processor); FeedEvents(config, processor);
// ConfigMetricsReportList reports; ConfigMetricsReportList reports;
// vector<uint8_t> buffer; vector<uint8_t> buffer;
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs - 1, false, true, ADB_DUMP,
// ADB_DUMP, FAST, &buffer); FAST, &buffer);
// EXPECT_TRUE(buffer.size() > 0); EXPECT_TRUE(buffer.size() > 0);
//
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// backfillDimensionPath(&reports); backfillDimensionPath(&reports);
// backfillStringInReport(&reports); backfillStringInReport(&reports);
// backfillStartEndTimestamp(&reports); backfillStartEndTimestamp(&reports);
//
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports_size(), 1);
//
// // When using ProtoOutputStream, if nothing written to a sub msg, it won't be treated as // When using ProtoOutputStream, if nothing written to a sub msg, it won't be treated as
// // one. It was previsouly 1 because we had a fake onDumpReport which calls add_metric() by // one. It was previsouly 1 because we had a fake onDumpReport which calls add_metric() by
// // itself. // itself.
// EXPECT_EQ(1, reports.reports(0).metrics_size()); EXPECT_EQ(1, reports.reports(0).metrics_size());
// EXPECT_EQ(0, reports.reports(0).metrics(0).duration_metrics().data_size()); EXPECT_EQ(0, reports.reports(0).metrics(0).duration_metrics().data_size());
//} }
//
//TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration2) { TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration2) {
// ConfigKey cfgKey; ConfigKey cfgKey;
// auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE); auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketSizeNs = uint64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// FeedEvents(config, processor); FeedEvents(config, processor);
// ConfigMetricsReportList reports; ConfigMetricsReportList reports;
// vector<uint8_t> buffer; vector<uint8_t> buffer;
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, processor->onDumpReport(cfgKey, bucketStartTimeNs + 2 * bucketSizeNs + 1, false, true, ADB_DUMP,
// ADB_DUMP, FAST, &buffer); FAST, &buffer);
// EXPECT_TRUE(buffer.size() > 0); EXPECT_TRUE(buffer.size() > 0);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// backfillDimensionPath(&reports); backfillDimensionPath(&reports);
// backfillStringInReport(&reports); backfillStringInReport(&reports);
// backfillStartEndTimestamp(&reports); backfillStartEndTimestamp(&reports);
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
// // Dump the report after the end of 2nd bucket. One dimension with one bucket. // Dump the report after the end of 2nd bucket. One dimension with one bucket.
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 1);
// auto data = reports.reports(0).metrics(0).duration_metrics().data(0); auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
// // Validate dimension value. // Validate dimension value.
// ValidateAttributionUidDimension(data.dimensions_in_what(), ValidateAttributionUidDimension(data.dimensions_in_what(),
// android::util::WAKELOCK_STATE_CHANGED, 111); android::util::WAKELOCK_STATE_CHANGED, 111);
// // The max is acquire event for wl1 to screen off start. // The max is acquire event for wl1 to screen off start.
// EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs + 2 - 200); EXPECT_EQ((unsigned long long)data.bucket_info(0).duration_nanos(), bucketSizeNs + 2 - 200);
//} }
//
//TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration3) { TEST(WakelockDurationE2eTest, TestAggregatedPredicateDimensionsForMaxDuration3) {
// ConfigKey cfgKey; ConfigKey cfgKey;
// auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE); auto config = CreateStatsdConfig(DurationMetric::MAX_SPARSE);
// uint64_t bucketStartTimeNs = 10000000000; uint64_t bucketStartTimeNs = 10000000000;
// uint64_t bucketSizeNs = uint64_t bucketSizeNs =
// TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL; TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
// auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey); auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
// EXPECT_EQ(processor->mMetricsManagers.size(), 1u); EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
// EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid()); EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
// FeedEvents(config, processor); FeedEvents(config, processor);
// ConfigMetricsReportList reports; ConfigMetricsReportList reports;
// vector<uint8_t> buffer; vector<uint8_t> buffer;
//
// std::vector<std::unique_ptr<LogEvent>> events; std::vector<std::unique_ptr<LogEvent>> events;
// events.push_back( events.push_back(
// CreateScreenStateChangedEvent(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * bucketSizeNs + 90,
// bucketStartTimeNs + 2 * bucketSizeNs + 90)); android::view::DisplayStateEnum::DISPLAY_STATE_OFF));
// events.push_back(CreateAcquireWakelockEvent(attributions1, "wl3", events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 2 * bucketSizeNs + 100,
// bucketStartTimeNs + 2 * bucketSizeNs + 100)); attributionUids1, attributionTags1, "wl3"));
// events.push_back(CreateReleaseWakelockEvent(attributions1, "wl3", events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 5 * bucketSizeNs + 100,
// bucketStartTimeNs + 5 * bucketSizeNs + 100)); attributionUids1, attributionTags1, "wl3"));
// sortLogEventsByTimestamp(&events); sortLogEventsByTimestamp(&events);
// for (const auto& event : events) { for (const auto& event : events) {
// processor->OnLogEvent(event.get()); processor->OnLogEvent(event.get());
// } }
//
// processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, processor->onDumpReport(cfgKey, bucketStartTimeNs + 6 * bucketSizeNs + 1, false, true, ADB_DUMP,
// ADB_DUMP, FAST, &buffer); FAST, &buffer);
// EXPECT_TRUE(buffer.size() > 0); EXPECT_TRUE(buffer.size() > 0);
// EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size())); EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
// backfillDimensionPath(&reports); backfillDimensionPath(&reports);
// backfillStringInReport(&reports); backfillStringInReport(&reports);
// backfillStartEndTimestamp(&reports); backfillStartEndTimestamp(&reports);
// EXPECT_EQ(reports.reports_size(), 1); EXPECT_EQ(reports.reports_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics_size(), 1); EXPECT_EQ(reports.reports(0).metrics_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1); EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data_size(), 1);
// EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2); EXPECT_EQ(reports.reports(0).metrics(0).duration_metrics().data(0).bucket_info_size(), 2);
// auto data = reports.reports(0).metrics(0).duration_metrics().data(0); auto data = reports.reports(0).metrics(0).duration_metrics().data(0);
// ValidateAttributionUidDimension(data.dimensions_in_what(), ValidateAttributionUidDimension(data.dimensions_in_what(),
// android::util::WAKELOCK_STATE_CHANGED, 111); android::util::WAKELOCK_STATE_CHANGED, 111);
// // The last wakelock holding spans 4 buckets. // The last wakelock holding spans 4 buckets.
// EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 3 * bucketSizeNs); EXPECT_EQ((unsigned long long)data.bucket_info(1).duration_nanos(), 3 * bucketSizeNs);
// EXPECT_EQ((unsigned long long)data.bucket_info(1).start_bucket_elapsed_nanos(), EXPECT_EQ((unsigned long long)data.bucket_info(1).start_bucket_elapsed_nanos(),
// bucketStartTimeNs + 5 * bucketSizeNs); bucketStartTimeNs + 5 * bucketSizeNs);
// EXPECT_EQ((unsigned long long)data.bucket_info(1).end_bucket_elapsed_nanos(), EXPECT_EQ((unsigned long long)data.bucket_info(1).end_bucket_elapsed_nanos(),
// bucketStartTimeNs + 6 * bucketSizeNs); bucketStartTimeNs + 6 * bucketSizeNs);
//} }
#else #else
GTEST_LOG_(INFO) << "This test does nothing.\n"; GTEST_LOG_(INFO) << "This test does nothing.\n";

311
cmds/statsd/tests/external/StatsPuller_test.cpp vendored
View File

@@ -15,11 +15,14 @@
#include <gmock/gmock.h> #include <gmock/gmock.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <stdio.h> #include <stdio.h>
#include <chrono> #include <chrono>
#include <thread> #include <thread>
#include <vector> #include <vector>
#include "../metrics/metrics_test_helper.h" #include "../metrics/metrics_test_helper.h"
#include "src/stats_log_util.h" #include "src/stats_log_util.h"
#include "stats_event.h"
#include "tests/statsd_test_util.h" #include "tests/statsd_test_util.h"
#ifdef __ANDROID__ #ifdef __ANDROID__
@@ -57,13 +60,22 @@ private:
FakePuller puller; FakePuller puller;
// TODO(b/149590301): Update this helper to use new socket schema. std::unique_ptr<LogEvent> createSimpleEvent(int64_t eventTimeNs, int64_t value) {
//shared_ptr<LogEvent> createSimpleEvent(int64_t eventTimeNs, int64_t value) { AStatsEvent* statsEvent = AStatsEvent_obtain();
// shared_ptr<LogEvent> event = make_shared<LogEvent>(pullTagId, eventTimeNs); AStatsEvent_setAtomId(statsEvent, pullTagId);
// event->write(value); AStatsEvent_overwriteTimestamp(statsEvent, eventTimeNs);
// event->init();
// return event; AStatsEvent_writeInt64(statsEvent, value);
//} AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
class StatsPullerTest : public ::testing::Test { class StatsPullerTest : public ::testing::Test {
public: public:
@@ -80,149 +92,148 @@ public:
} // Anonymous namespace. } // Anonymous namespace.
// TODO(b/149590301): Update these tests to use new socket schema. TEST_F(StatsPullerTest, PullSuccess) {
//TEST_F(StatsPullerTest, PullSuccess) { pullData.push_back(createSimpleEvent(1111L, 33));
// pullData.push_back(createSimpleEvent(1111L, 33));
// pullSuccess = true;
// pullSuccess = true;
// vector<std::shared_ptr<LogEvent>> dataHolder;
// vector<std::shared_ptr<LogEvent>> dataHolder; EXPECT_TRUE(puller.Pull(&dataHolder));
// EXPECT_TRUE(puller.Pull(&dataHolder)); EXPECT_EQ(1, dataHolder.size());
// EXPECT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId());
// EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs());
// EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); EXPECT_EQ(1, dataHolder[0]->size());
// EXPECT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value);
// EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value);
// sleep_for(std::chrono::seconds(1));
// sleep_for(std::chrono::seconds(1));
// pullData.clear();
// pullData.clear(); pullData.push_back(createSimpleEvent(2222L, 44));
// pullData.push_back(createSimpleEvent(2222L, 44));
// pullSuccess = true;
// pullSuccess = true;
// EXPECT_TRUE(puller.Pull(&dataHolder));
// EXPECT_TRUE(puller.Pull(&dataHolder)); EXPECT_EQ(1, dataHolder.size());
// EXPECT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId());
// EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(2222L, dataHolder[0]->GetElapsedTimestampNs());
// EXPECT_EQ(2222L, dataHolder[0]->GetElapsedTimestampNs()); EXPECT_EQ(1, dataHolder[0]->size());
// EXPECT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(44, dataHolder[0]->getValues()[0].mValue.int_value);
// EXPECT_EQ(44, dataHolder[0]->getValues()[0].mValue.int_value); }
//}
// TEST_F(StatsPullerTest, PullFailAfterSuccess) {
//TEST_F(StatsPullerTest, PullFailAfterSuccess) { pullData.push_back(createSimpleEvent(1111L, 33));
// pullData.push_back(createSimpleEvent(1111L, 33));
// pullSuccess = true;
// pullSuccess = true;
// vector<std::shared_ptr<LogEvent>> dataHolder;
// vector<std::shared_ptr<LogEvent>> dataHolder; EXPECT_TRUE(puller.Pull(&dataHolder));
// EXPECT_TRUE(puller.Pull(&dataHolder)); EXPECT_EQ(1, dataHolder.size());
// EXPECT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId());
// EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs());
// EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); EXPECT_EQ(1, dataHolder[0]->size());
// EXPECT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value);
// EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value);
// sleep_for(std::chrono::seconds(1));
// sleep_for(std::chrono::seconds(1));
// pullData.clear();
// pullData.clear(); pullData.push_back(createSimpleEvent(2222L, 44));
// pullData.push_back(createSimpleEvent(2222L, 44));
// pullSuccess = false;
// pullSuccess = false; dataHolder.clear();
// dataHolder.clear(); EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size());
// pullSuccess = true;
// pullSuccess = true; dataHolder.clear();
// dataHolder.clear(); EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size()); }
//}
// // Test pull takes longer than timeout, 2nd pull happens shorter than cooldown
//// Test pull takes longer than timeout, 2nd pull happens shorter than cooldown TEST_F(StatsPullerTest, PullTakeTooLongAndPullFast) {
//TEST_F(StatsPullerTest, PullTakeTooLongAndPullFast) { pullData.push_back(createSimpleEvent(1111L, 33));
// pullData.push_back(createSimpleEvent(1111L, 33)); pullSuccess = true;
// pullSuccess = true; // timeout is 0.5
// // timeout is 0.5 pullDelayNs = (long)(0.8 * NS_PER_SEC);
// pullDelayNs = (long)(0.8 * NS_PER_SEC);
// vector<std::shared_ptr<LogEvent>> dataHolder;
// vector<std::shared_ptr<LogEvent>> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size());
// pullData.clear();
// pullData.clear(); pullData.push_back(createSimpleEvent(2222L, 44));
// pullData.push_back(createSimpleEvent(2222L, 44));
// pullSuccess = true;
// pullSuccess = true; dataHolder.clear();
// dataHolder.clear(); EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size()); }
//}
// TEST_F(StatsPullerTest, PullFail) {
//TEST_F(StatsPullerTest, PullFail) { pullData.push_back(createSimpleEvent(1111L, 33));
// pullData.push_back(createSimpleEvent(1111L, 33));
// pullSuccess = false;
// pullSuccess = false;
// vector<std::shared_ptr<LogEvent>> dataHolder;
// vector<std::shared_ptr<LogEvent>> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size()); }
//}
// TEST_F(StatsPullerTest, PullTakeTooLong) {
//TEST_F(StatsPullerTest, PullTakeTooLong) { pullData.push_back(createSimpleEvent(1111L, 33));
// pullData.push_back(createSimpleEvent(1111L, 33));
// pullSuccess = true;
// pullSuccess = true; pullDelayNs = NS_PER_SEC;
// pullDelayNs = NS_PER_SEC;
// vector<std::shared_ptr<LogEvent>> dataHolder;
// vector<std::shared_ptr<LogEvent>> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size()); }
//}
// TEST_F(StatsPullerTest, PullTooFast) {
//TEST_F(StatsPullerTest, PullTooFast) { pullData.push_back(createSimpleEvent(1111L, 33));
// pullData.push_back(createSimpleEvent(1111L, 33));
// pullSuccess = true;
// pullSuccess = true;
// vector<std::shared_ptr<LogEvent>> dataHolder;
// vector<std::shared_ptr<LogEvent>> dataHolder; EXPECT_TRUE(puller.Pull(&dataHolder));
// EXPECT_TRUE(puller.Pull(&dataHolder)); EXPECT_EQ(1, dataHolder.size());
// EXPECT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId());
// EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs());
// EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); EXPECT_EQ(1, dataHolder[0]->size());
// EXPECT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value);
// EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value);
// pullData.clear();
// pullData.clear(); pullData.push_back(createSimpleEvent(2222L, 44));
// pullData.push_back(createSimpleEvent(2222L, 44));
// pullSuccess = true;
// pullSuccess = true;
// dataHolder.clear();
// dataHolder.clear(); EXPECT_TRUE(puller.Pull(&dataHolder));
// EXPECT_TRUE(puller.Pull(&dataHolder)); EXPECT_EQ(1, dataHolder.size());
// EXPECT_EQ(1, dataHolder.size()); EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId());
// EXPECT_EQ(pullTagId, dataHolder[0]->GetTagId()); EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs());
// EXPECT_EQ(1111L, dataHolder[0]->GetElapsedTimestampNs()); EXPECT_EQ(1, dataHolder[0]->size());
// EXPECT_EQ(1, dataHolder[0]->size()); EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value);
// EXPECT_EQ(33, dataHolder[0]->getValues()[0].mValue.int_value); }
//}
// TEST_F(StatsPullerTest, PullFailsAndTooFast) {
//TEST_F(StatsPullerTest, PullFailsAndTooFast) { pullData.push_back(createSimpleEvent(1111L, 33));
// pullData.push_back(createSimpleEvent(1111L, 33));
// pullSuccess = false;
// pullSuccess = false;
// vector<std::shared_ptr<LogEvent>> dataHolder;
// vector<std::shared_ptr<LogEvent>> dataHolder; EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size());
// pullData.clear();
// pullData.clear(); pullData.push_back(createSimpleEvent(2222L, 44));
// pullData.push_back(createSimpleEvent(2222L, 44));
// pullSuccess = true;
// pullSuccess = true;
// EXPECT_FALSE(puller.Pull(&dataHolder));
// EXPECT_FALSE(puller.Pull(&dataHolder)); EXPECT_EQ(0, dataHolder.size());
// EXPECT_EQ(0, dataHolder.size()); }
//}
} // namespace statsd } // namespace statsd
} // namespace os } // namespace os

389
cmds/statsd/tests/external/puller_util_test.cpp vendored
View File

@@ -13,12 +13,16 @@
// limitations under the License. // limitations under the License.
#include "external/puller_util.h" #include "external/puller_util.h"
#include <gmock/gmock.h> #include <gmock/gmock.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <stdio.h> #include <stdio.h>
#include <vector> #include <vector>
#include "statslog.h"
#include "../metrics/metrics_test_helper.h" #include "../metrics/metrics_test_helper.h"
#include "stats_event.h"
#include "statslog.h"
#ifdef __ANDROID__ #ifdef __ANDROID__
@@ -58,212 +62,187 @@ void extractIntoVector(vector<shared_ptr<LogEvent>> events,
ret.push_back(vec); ret.push_back(vec);
} }
} }
std::shared_ptr<LogEvent> makeUidLogEvent(uint64_t timestampNs, int uid, int data1, int data2) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, uidAtomTagId);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, uid);
AStatsEvent_writeInt32(statsEvent, data1);
AStatsEvent_writeInt32(statsEvent, data2);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::shared_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::shared_ptr<LogEvent> makeNonUidAtomLogEvent(uint64_t timestampNs, int data1) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, nonUidAtomTagId);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, data1);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::shared_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
} // anonymous namespace } // anonymous namespace
// TODO(b/149590301): Update these tests to use new socket schema. TEST(puller_util, MergeNoDimension) {
//TEST(puller_util, MergeNoDimension) { vector<shared_ptr<LogEvent>> inputData;
// vector<shared_ptr<LogEvent>> inputData;
// shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp); // 30->22->31
// // 30->22->31 inputData.push_back(
// event->write(isolatedUid); makeUidLogEvent(timestamp, isolatedUid, hostNonAdditiveData, isolatedAdditiveData));
// event->write(hostNonAdditiveData);
// event->write(isolatedAdditiveData); // 20->22->21
// event->init(); inputData.push_back(makeUidLogEvent(timestamp, hostUid, hostNonAdditiveData, hostAdditiveData));
// inputData.push_back(event);
// sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// // 20->22->21 EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid)).WillRepeatedly(Return(hostUid));
// event = make_shared<LogEvent>(uidAtomTagId, timestamp); EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))).WillRepeatedly(ReturnArg<0>());
// event->write(hostUid); mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
// event->write(hostNonAdditiveData);
// event->write(hostAdditiveData); vector<vector<int>> actual;
// event->init(); extractIntoVector(inputData, actual);
// inputData.push_back(event); vector<int> expectedV1 = {20, 22, 52};
// EXPECT_EQ(1, (int)actual.size());
// sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>(); EXPECT_THAT(actual, Contains(expectedV1));
// EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid)) }
// .WillRepeatedly(Return(hostUid));
// EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))) TEST(puller_util, MergeWithDimension) {
// .WillRepeatedly(ReturnArg<0>()); vector<shared_ptr<LogEvent>> inputData;
// mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
// // 30->32->31
// vector<vector<int>> actual; inputData.push_back(
// extractIntoVector(inputData, actual); makeUidLogEvent(timestamp, isolatedUid, isolatedNonAdditiveData, isolatedAdditiveData));
// vector<int> expectedV1 = {20, 22, 52};
// EXPECT_EQ(1, (int)actual.size()); // 20->32->21
// EXPECT_THAT(actual, Contains(expectedV1)); inputData.push_back(
//} makeUidLogEvent(timestamp, hostUid, isolatedNonAdditiveData, hostAdditiveData));
//
//TEST(puller_util, MergeWithDimension) { // 20->22->21
// vector<shared_ptr<LogEvent>> inputData; inputData.push_back(makeUidLogEvent(timestamp, hostUid, hostNonAdditiveData, hostAdditiveData));
// shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp);
// // 30->32->31 sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// event->write(isolatedUid); EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid)).WillRepeatedly(Return(hostUid));
// event->write(isolatedNonAdditiveData); EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))).WillRepeatedly(ReturnArg<0>());
// event->write(isolatedAdditiveData); mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
// event->init();
// inputData.push_back(event); vector<vector<int>> actual;
// extractIntoVector(inputData, actual);
// // 20->32->21 vector<int> expectedV1 = {20, 22, 21};
// event = make_shared<LogEvent>(uidAtomTagId, timestamp); vector<int> expectedV2 = {20, 32, 52};
// event->write(hostUid); EXPECT_EQ(2, (int)actual.size());
// event->write(isolatedNonAdditiveData); EXPECT_THAT(actual, Contains(expectedV1));
// event->write(hostAdditiveData); EXPECT_THAT(actual, Contains(expectedV2));
// event->init(); }
// inputData.push_back(event);
// TEST(puller_util, NoMergeHostUidOnly) {
// // 20->22->21 vector<shared_ptr<LogEvent>> inputData;
// event = make_shared<LogEvent>(uidAtomTagId, timestamp);
// event->write(hostUid); // 20->32->31
// event->write(hostNonAdditiveData); inputData.push_back(
// event->write(hostAdditiveData); makeUidLogEvent(timestamp, hostUid, isolatedNonAdditiveData, isolatedAdditiveData));
// event->init();
// inputData.push_back(event); // 20->22->21
// inputData.push_back(makeUidLogEvent(timestamp, hostUid, hostNonAdditiveData, hostAdditiveData));
// sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid)) sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// .WillRepeatedly(Return(hostUid)); EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid)).WillRepeatedly(Return(hostUid));
// EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))) EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))).WillRepeatedly(ReturnArg<0>());
// .WillRepeatedly(ReturnArg<0>()); mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
// mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
// // 20->32->31
// vector<vector<int>> actual; // 20->22->21
// extractIntoVector(inputData, actual); vector<vector<int>> actual;
// vector<int> expectedV1 = {20, 22, 21}; extractIntoVector(inputData, actual);
// vector<int> expectedV2 = {20, 32, 52}; vector<int> expectedV1 = {20, 32, 31};
// EXPECT_EQ(2, (int)actual.size()); vector<int> expectedV2 = {20, 22, 21};
// EXPECT_THAT(actual, Contains(expectedV1)); EXPECT_EQ(2, (int)actual.size());
// EXPECT_THAT(actual, Contains(expectedV2)); EXPECT_THAT(actual, Contains(expectedV1));
//} EXPECT_THAT(actual, Contains(expectedV2));
// }
//TEST(puller_util, NoMergeHostUidOnly) {
// vector<shared_ptr<LogEvent>> inputData; TEST(puller_util, IsolatedUidOnly) {
// shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp); vector<shared_ptr<LogEvent>> inputData;
// // 20->32->31
// event->write(hostUid); // 30->32->31
// event->write(isolatedNonAdditiveData); inputData.push_back(
// event->write(isolatedAdditiveData); makeUidLogEvent(timestamp, hostUid, isolatedNonAdditiveData, isolatedAdditiveData));
// event->init();
// inputData.push_back(event); // 30->22->21
// inputData.push_back(makeUidLogEvent(timestamp, hostUid, hostNonAdditiveData, hostAdditiveData));
// // 20->22->21
// event = make_shared<LogEvent>(uidAtomTagId, timestamp); sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// event->write(hostUid); EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid)).WillRepeatedly(Return(hostUid));
// event->write(hostNonAdditiveData); EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))).WillRepeatedly(ReturnArg<0>());
// event->write(hostAdditiveData); mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
// event->init();
// inputData.push_back(event); // 20->32->31
// // 20->22->21
// sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>(); vector<vector<int>> actual;
// EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid)) extractIntoVector(inputData, actual);
// .WillRepeatedly(Return(hostUid)); vector<int> expectedV1 = {20, 32, 31};
// EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))) vector<int> expectedV2 = {20, 22, 21};
// .WillRepeatedly(ReturnArg<0>()); EXPECT_EQ(2, (int)actual.size());
// mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields); EXPECT_THAT(actual, Contains(expectedV1));
// EXPECT_THAT(actual, Contains(expectedV2));
// // 20->32->31 }
// // 20->22->21
// vector<vector<int>> actual; TEST(puller_util, MultipleIsolatedUidToOneHostUid) {
// extractIntoVector(inputData, actual); vector<shared_ptr<LogEvent>> inputData;
// vector<int> expectedV1 = {20, 32, 31};
// vector<int> expectedV2 = {20, 22, 21}; // 30->32->31
// EXPECT_EQ(2, (int)actual.size()); inputData.push_back(
// EXPECT_THAT(actual, Contains(expectedV1)); makeUidLogEvent(timestamp, isolatedUid, isolatedNonAdditiveData, isolatedAdditiveData));
// EXPECT_THAT(actual, Contains(expectedV2));
//} // 31->32->21
// inputData.push_back(
//TEST(puller_util, IsolatedUidOnly) { makeUidLogEvent(timestamp, isolatedUid + 1, isolatedNonAdditiveData, hostAdditiveData));
// vector<shared_ptr<LogEvent>> inputData;
// shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp); // 20->32->21
// // 30->32->31 inputData.push_back(
// event->write(hostUid); makeUidLogEvent(timestamp, hostUid, isolatedNonAdditiveData, hostAdditiveData));
// event->write(isolatedNonAdditiveData);
// event->write(isolatedAdditiveData); sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// event->init(); EXPECT_CALL(*uidMap, getHostUidOrSelf(_)).WillRepeatedly(Return(hostUid));
// inputData.push_back(event); mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
//
// // 30->22->21 vector<vector<int>> actual;
// event = make_shared<LogEvent>(uidAtomTagId, timestamp); extractIntoVector(inputData, actual);
// event->write(hostUid); vector<int> expectedV1 = {20, 32, 73};
// event->write(hostNonAdditiveData); EXPECT_EQ(1, (int)actual.size());
// event->write(hostAdditiveData); EXPECT_THAT(actual, Contains(expectedV1));
// event->init(); }
// inputData.push_back(event);
// TEST(puller_util, NoNeedToMerge) {
// sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>(); vector<shared_ptr<LogEvent>> inputData;
// EXPECT_CALL(*uidMap, getHostUidOrSelf(isolatedUid))
// .WillRepeatedly(Return(hostUid)); // 32
// EXPECT_CALL(*uidMap, getHostUidOrSelf(Ne(isolatedUid))) inputData.push_back(makeNonUidAtomLogEvent(timestamp, isolatedNonAdditiveData));
// .WillRepeatedly(ReturnArg<0>());
// mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields); // 22
// inputData.push_back(makeNonUidAtomLogEvent(timestamp, hostNonAdditiveData));
// // 20->32->31
// // 20->22->21 sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// vector<vector<int>> actual; mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, nonUidAtomTagId, {} /*no additive fields*/);
// extractIntoVector(inputData, actual);
// vector<int> expectedV1 = {20, 32, 31}; EXPECT_EQ(2, (int)inputData.size());
// vector<int> expectedV2 = {20, 22, 21}; }
// EXPECT_EQ(2, (int)actual.size());
// EXPECT_THAT(actual, Contains(expectedV1));
// EXPECT_THAT(actual, Contains(expectedV2));
//}
//
//TEST(puller_util, MultipleIsolatedUidToOneHostUid) {
// vector<shared_ptr<LogEvent>> inputData;
// shared_ptr<LogEvent> event = make_shared<LogEvent>(uidAtomTagId, timestamp);
// // 30->32->31
// event->write(isolatedUid);
// event->write(isolatedNonAdditiveData);
// event->write(isolatedAdditiveData);
// event->init();
// inputData.push_back(event);
//
// // 31->32->21
// event = make_shared<LogEvent>(uidAtomTagId, timestamp);
// event->write(isolatedUid + 1);
// event->write(isolatedNonAdditiveData);
// event->write(hostAdditiveData);
// event->init();
// inputData.push_back(event);
//
// // 20->32->21
// event = make_shared<LogEvent>(uidAtomTagId, timestamp);
// event->write(hostUid);
// event->write(isolatedNonAdditiveData);
// event->write(hostAdditiveData);
// event->init();
// inputData.push_back(event);
//
// sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// EXPECT_CALL(*uidMap, getHostUidOrSelf(_)).WillRepeatedly(Return(hostUid));
// mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, uidAtomTagId, uidAdditiveFields);
//
// vector<vector<int>> actual;
// extractIntoVector(inputData, actual);
// vector<int> expectedV1 = {20, 32, 73};
// EXPECT_EQ(1, (int)actual.size());
// EXPECT_THAT(actual, Contains(expectedV1));
//}
//
//TEST(puller_util, NoNeedToMerge) {
// vector<shared_ptr<LogEvent>> inputData;
// shared_ptr<LogEvent> event =
// make_shared<LogEvent>(nonUidAtomTagId, timestamp);
// // 32
// event->write(isolatedNonAdditiveData);
// event->init();
// inputData.push_back(event);
//
// event = make_shared<LogEvent>(nonUidAtomTagId, timestamp);
// // 22
// event->write(hostNonAdditiveData);
// event->init();
// inputData.push_back(event);
//
// sp<MockUidMap> uidMap = new NaggyMock<MockUidMap>();
// mapAndMergeIsolatedUidsToHostUid(inputData, uidMap, nonUidAtomTagId, {} /*no additive fields*/);
//
// EXPECT_EQ(2, (int)inputData.size());
//}
} // namespace statsd } // namespace statsd
} // namespace os } // namespace os

2
cmds/statsd/tests/log_event/LogEventQueue_test.cpp
View File

@@ -42,7 +42,7 @@ std::unique_ptr<LogEvent> makeLogEvent(uint64_t timestampNs) {
size_t size; size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size); uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/-1, /*pid=*/-1); std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size); logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent); AStatsEvent_release(statsEvent);
return logEvent; return logEvent;

755
cmds/statsd/tests/metrics/CountMetricProducer_test.cpp
View File

@@ -13,16 +13,19 @@
// limitations under the License. // limitations under the License.
#include "src/metrics/CountMetricProducer.h" #include "src/metrics/CountMetricProducer.h"
#include "src/stats_log_util.h"
#include "metrics_test_helper.h"
#include "tests/statsd_test_util.h"
#include <gmock/gmock.h> #include <gmock/gmock.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <math.h> #include <math.h>
#include <stdio.h> #include <stdio.h>
#include <vector> #include <vector>
#include "metrics_test_helper.h"
#include "src/stats_log_util.h"
#include "stats_event.h"
#include "tests/statsd_test_util.h"
using namespace testing; using namespace testing;
using android::sp; using android::sp;
using std::set; using std::set;
@@ -37,366 +40,392 @@ namespace statsd {
const ConfigKey kConfigKey(0, 12345); const ConfigKey kConfigKey(0, 12345);
// TODO(b/149590301): Update these tests to use new socket schema. namespace {
//TEST(CountMetricProducerTest, TestFirstBucket) {
// CountMetric metric; void makeLogEvent(LogEvent* logEvent, int64_t timestampNs, int atomId) {
// metric.set_id(1); AStatsEvent* statsEvent = AStatsEvent_obtain();
// metric.set_bucket(ONE_MINUTE); AStatsEvent_setAtomId(statsEvent, atomId);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// AStatsEvent_build(statsEvent);
// CountMetricProducer countProducer(kConfigKey, metric, -1 /*-1 meaning no condition*/, wizard, 5,
// 600 * NS_PER_SEC + NS_PER_SEC / 2); size_t size;
// EXPECT_EQ(600500000000, countProducer.mCurrentBucketStartTimeNs); uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// EXPECT_EQ(10, countProducer.mCurrentBucketNum); logEvent->parseBuffer(buf, size);
// EXPECT_EQ(660000000005, countProducer.getCurrentBucketEndTimeNs()); AStatsEvent_release(statsEvent);
//} }
//
//TEST(CountMetricProducerTest, TestNonDimensionalEvents) { void makeLogEvent(LogEvent* logEvent, int64_t timestampNs, int atomId, string uid) {
// int64_t bucketStartTimeNs = 10000000000; AStatsEvent* statsEvent = AStatsEvent_obtain();
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; AStatsEvent_setAtomId(statsEvent, atomId);
// int64_t bucket2StartTimeNs = bucketStartTimeNs + bucketSizeNs; AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// int64_t bucket3StartTimeNs = bucketStartTimeNs + 2 * bucketSizeNs;
// int tagId = 1; AStatsEvent_writeString(statsEvent, uid.c_str());
// AStatsEvent_build(statsEvent);
// CountMetric metric;
// metric.set_id(1); size_t size;
// metric.set_bucket(ONE_MINUTE); uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// logEvent->parseBuffer(buf, size);
// LogEvent event1(tagId, bucketStartTimeNs + 1); AStatsEvent_release(statsEvent);
// event1.init(); }
// LogEvent event2(tagId, bucketStartTimeNs + 2);
// event2.init(); } // namespace
//
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); TEST(CountMetricProducerTest, TestFirstBucket) {
// CountMetric metric;
// CountMetricProducer countProducer(kConfigKey, metric, -1 /*-1 meaning no condition*/, wizard, metric.set_id(1);
// bucketStartTimeNs, bucketStartTimeNs); metric.set_bucket(ONE_MINUTE);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// // 2 events in bucket 1.
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); CountMetricProducer countProducer(kConfigKey, metric, -1 /*-1 meaning no condition*/, wizard, 5,
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); 600 * NS_PER_SEC + NS_PER_SEC / 2);
// EXPECT_EQ(600500000000, countProducer.mCurrentBucketStartTimeNs);
// // Flushes at event #2. EXPECT_EQ(10, countProducer.mCurrentBucketNum);
// countProducer.flushIfNeededLocked(bucketStartTimeNs + 2); EXPECT_EQ(660000000005, countProducer.getCurrentBucketEndTimeNs());
// EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); }
//
// // Flushes. TEST(CountMetricProducerTest, TestNonDimensionalEvents) {
// countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); int64_t bucketStartTimeNs = 10000000000;
// EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != int64_t bucket2StartTimeNs = bucketStartTimeNs + bucketSizeNs;
// countProducer.mPastBuckets.end()); int64_t bucket3StartTimeNs = bucketStartTimeNs + 2 * bucketSizeNs;
// const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; int tagId = 1;
// EXPECT_EQ(1UL, buckets.size());
// EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs); CountMetric metric;
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs); metric.set_id(1);
// EXPECT_EQ(2LL, buckets[0].mCount); metric.set_bucket(ONE_MINUTE);
//
// // 1 matched event happens in bucket 2. sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// LogEvent event3(tagId, bucketStartTimeNs + bucketSizeNs + 2);
// event3.init(); CountMetricProducer countProducer(kConfigKey, metric, -1 /*-1 meaning no condition*/, wizard,
// bucketStartTimeNs, bucketStartTimeNs);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3);
// countProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); // 2 events in bucket 1.
// EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); LogEvent event1(/*uid=*/0, /*pid=*/0);
// EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
// countProducer.mPastBuckets.end()); LogEvent event2(/*uid=*/0, /*pid=*/0);
// EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); makeLogEvent(&event2, bucketStartTimeNs + 2, tagId);
// const auto& bucketInfo2 = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1];
// EXPECT_EQ(bucket2StartTimeNs, bucketInfo2.mBucketStartNs); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1);
// EXPECT_EQ(bucket2StartTimeNs + bucketSizeNs, bucketInfo2.mBucketEndNs); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2);
// EXPECT_EQ(1LL, bucketInfo2.mCount);
// // Flushes at event #2.
// // nothing happens in bucket 3. we should not record anything for bucket 3. countProducer.flushIfNeededLocked(bucketStartTimeNs + 2);
// countProducer.flushIfNeededLocked(bucketStartTimeNs + 3 * bucketSizeNs + 1); EXPECT_EQ(0UL, countProducer.mPastBuckets.size());
// EXPECT_EQ(1UL, countProducer.mPastBuckets.size());
// EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != // Flushes.
// countProducer.mPastBuckets.end()); countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
// const auto& buckets3 = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; EXPECT_EQ(1UL, countProducer.mPastBuckets.size());
// EXPECT_EQ(2UL, buckets3.size()); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
//} countProducer.mPastBuckets.end());
// const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
//TEST(CountMetricProducerTest, TestEventsWithNonSlicedCondition) { EXPECT_EQ(1UL, buckets.size());
// int64_t bucketStartTimeNs = 10000000000; EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs);
// EXPECT_EQ(2LL, buckets[0].mCount);
// CountMetric metric;
// metric.set_id(1); // 1 matched event happens in bucket 2.
// metric.set_bucket(ONE_MINUTE); LogEvent event3(/*uid=*/0, /*pid=*/0);
// metric.set_condition(StringToId("SCREEN_ON")); makeLogEvent(&event3, bucketStartTimeNs + bucketSizeNs + 2, tagId);
//
// LogEvent event1(1, bucketStartTimeNs + 1); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3);
// event1.init();
// countProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
// LogEvent event2(1, bucketStartTimeNs + 10); EXPECT_EQ(1UL, countProducer.mPastBuckets.size());
// event2.init(); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
// countProducer.mPastBuckets.end());
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// const auto& bucketInfo2 = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1];
// CountMetricProducer countProducer(kConfigKey, metric, 1, wizard, bucketStartTimeNs, EXPECT_EQ(bucket2StartTimeNs, bucketInfo2.mBucketStartNs);
// bucketStartTimeNs); EXPECT_EQ(bucket2StartTimeNs + bucketSizeNs, bucketInfo2.mBucketEndNs);
// EXPECT_EQ(1LL, bucketInfo2.mCount);
// countProducer.onConditionChanged(true, bucketStartTimeNs);
// countProducer.onMatchedLogEvent(1 /*matcher index*/, event1); // nothing happens in bucket 3. we should not record anything for bucket 3.
// EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); countProducer.flushIfNeededLocked(bucketStartTimeNs + 3 * bucketSizeNs + 1);
// EXPECT_EQ(1UL, countProducer.mPastBuckets.size());
// countProducer.onConditionChanged(false /*new condition*/, bucketStartTimeNs + 2); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
// // Upon this match event, the matched event1 is flushed. countProducer.mPastBuckets.end());
// countProducer.onMatchedLogEvent(1 /*matcher index*/, event2); const auto& buckets3 = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); EXPECT_EQ(2UL, buckets3.size());
// }
// countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
// EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); TEST(CountMetricProducerTest, TestEventsWithNonSlicedCondition) {
// EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != int64_t bucketStartTimeNs = 10000000000;
// countProducer.mPastBuckets.end()); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// {
// const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; CountMetric metric;
// EXPECT_EQ(1UL, buckets.size()); metric.set_id(1);
// const auto& bucketInfo = buckets[0]; metric.set_bucket(ONE_MINUTE);
// EXPECT_EQ(bucketStartTimeNs, bucketInfo.mBucketStartNs); metric.set_condition(StringToId("SCREEN_ON"));
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.mBucketEndNs);
// EXPECT_EQ(1LL, bucketInfo.mCount); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// }
//} CountMetricProducer countProducer(kConfigKey, metric, 1, wizard, bucketStartTimeNs,
// bucketStartTimeNs);
//TEST(CountMetricProducerTest, TestEventsWithSlicedCondition) {
// int64_t bucketStartTimeNs = 10000000000; countProducer.onConditionChanged(true, bucketStartTimeNs);
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// LogEvent event1(/*uid=*/0, /*pid=*/0);
// int tagId = 1; makeLogEvent(&event1, bucketStartTimeNs + 1, /*atomId=*/1);
// int conditionTagId = 2; countProducer.onMatchedLogEvent(1 /*matcher index*/, event1);
//
// CountMetric metric; EXPECT_EQ(0UL, countProducer.mPastBuckets.size());
// metric.set_id(1);
// metric.set_bucket(ONE_MINUTE); countProducer.onConditionChanged(false /*new condition*/, bucketStartTimeNs + 2);
// metric.set_condition(StringToId("APP_IN_BACKGROUND_PER_UID_AND_SCREEN_ON"));
// MetricConditionLink* link = metric.add_links(); // Upon this match event, the matched event1 is flushed.
// link->set_condition(StringToId("APP_IN_BACKGROUND_PER_UID")); LogEvent event2(/*uid=*/0, /*pid=*/0);
// buildSimpleAtomFieldMatcher(tagId, 1, link->mutable_fields_in_what()); makeLogEvent(&event2, bucketStartTimeNs + 10, /*atomId=*/1);
// buildSimpleAtomFieldMatcher(conditionTagId, 2, link->mutable_fields_in_condition()); countProducer.onMatchedLogEvent(1 /*matcher index*/, event2);
// EXPECT_EQ(0UL, countProducer.mPastBuckets.size());
// LogEvent event1(tagId, bucketStartTimeNs + 1);
// event1.write("111"); // uid countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
// event1.init(); EXPECT_EQ(1UL, countProducer.mPastBuckets.size());
// ConditionKey key1; EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
// key1[StringToId("APP_IN_BACKGROUND_PER_UID")] = countProducer.mPastBuckets.end());
// {getMockedDimensionKey(conditionTagId, 2, "111")};
// const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// LogEvent event2(tagId, bucketStartTimeNs + 10); EXPECT_EQ(1UL, buckets.size());
// event2.write("222"); // uid const auto& bucketInfo = buckets[0];
// event2.init(); EXPECT_EQ(bucketStartTimeNs, bucketInfo.mBucketStartNs);
// ConditionKey key2; EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.mBucketEndNs);
// key2[StringToId("APP_IN_BACKGROUND_PER_UID")] = EXPECT_EQ(1LL, bucketInfo.mCount);
// {getMockedDimensionKey(conditionTagId, 2, "222")}; }
//
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); TEST(CountMetricProducerTest, TestEventsWithSlicedCondition) {
// EXPECT_CALL(*wizard, query(_, key1, _)).WillOnce(Return(ConditionState::kFalse)); int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// EXPECT_CALL(*wizard, query(_, key2, _)).WillOnce(Return(ConditionState::kTrue));
// int tagId = 1;
// CountMetricProducer countProducer(kConfigKey, metric, 1 /*condition tracker index*/, wizard, int conditionTagId = 2;
// bucketStartTimeNs, bucketStartTimeNs);
// CountMetric metric;
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); metric.set_id(1);
// countProducer.flushIfNeededLocked(bucketStartTimeNs + 1); metric.set_bucket(ONE_MINUTE);
// EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); metric.set_condition(StringToId("APP_IN_BACKGROUND_PER_UID_AND_SCREEN_ON"));
// MetricConditionLink* link = metric.add_links();
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); link->set_condition(StringToId("APP_IN_BACKGROUND_PER_UID"));
// countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); buildSimpleAtomFieldMatcher(tagId, 1, link->mutable_fields_in_what());
// EXPECT_EQ(1UL, countProducer.mPastBuckets.size()); buildSimpleAtomFieldMatcher(conditionTagId, 2, link->mutable_fields_in_condition());
// EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
// countProducer.mPastBuckets.end()); LogEvent event1(/*uid=*/0, /*pid=*/0);
// const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; makeLogEvent(&event1, bucketStartTimeNs + 1, tagId, /*uid=*/"111");
// EXPECT_EQ(1UL, buckets.size());
// const auto& bucketInfo = buckets[0]; LogEvent event2(/*uid=*/0, /*pid=*/0);
// EXPECT_EQ(bucketStartTimeNs, bucketInfo.mBucketStartNs); makeLogEvent(&event2, bucketStartTimeNs + 10, tagId, /*uid=*/"222");
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.mBucketEndNs);
// EXPECT_EQ(1LL, bucketInfo.mCount); ConditionKey key1;
//} key1[StringToId("APP_IN_BACKGROUND_PER_UID")] = {
// getMockedDimensionKey(conditionTagId, 2, "111")};
//TEST(CountMetricProducerTest, TestEventWithAppUpgrade) {
// sp<AlarmMonitor> alarmMonitor; ConditionKey key2;
// int64_t bucketStartTimeNs = 10000000000; key2[StringToId("APP_IN_BACKGROUND_PER_UID")] = {
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; getMockedDimensionKey(conditionTagId, 2, "222")};
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// int tagId = 1; EXPECT_CALL(*wizard, query(_, key1, _)).WillOnce(Return(ConditionState::kFalse));
// int conditionTagId = 2;
// EXPECT_CALL(*wizard, query(_, key2, _)).WillOnce(Return(ConditionState::kTrue));
// CountMetric metric;
// metric.set_id(1); CountMetricProducer countProducer(kConfigKey, metric, 1 /*condition tracker index*/, wizard,
// metric.set_bucket(ONE_MINUTE); bucketStartTimeNs, bucketStartTimeNs);
// Alert alert;
// alert.set_num_buckets(3); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1);
// alert.set_trigger_if_sum_gt(2); countProducer.flushIfNeededLocked(bucketStartTimeNs + 1);
// LogEvent event1(tagId, bucketStartTimeNs + 1); EXPECT_EQ(0UL, countProducer.mPastBuckets.size());
// event1.write("111"); // uid
// event1.init(); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); countProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
// CountMetricProducer countProducer(kConfigKey, metric, -1 /* no condition */, wizard, EXPECT_EQ(1UL, countProducer.mPastBuckets.size());
// bucketStartTimeNs, bucketStartTimeNs); EXPECT_TRUE(countProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
// countProducer.mPastBuckets.end());
// sp<AnomalyTracker> anomalyTracker = countProducer.addAnomalyTracker(alert, alarmMonitor); const auto& buckets = countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_TRUE(anomalyTracker != nullptr); EXPECT_EQ(1UL, buckets.size());
// const auto& bucketInfo = buckets[0];
// // Bucket is flushed yet. EXPECT_EQ(bucketStartTimeNs, bucketInfo.mBucketStartNs);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.mBucketEndNs);
// EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); EXPECT_EQ(1LL, bucketInfo.mCount);
// EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); }
//
// // App upgrade forces bucket flush. TEST(CountMetricProducerTest, TestEventWithAppUpgrade) {
// // Check that there's a past bucket and the bucket end is not adjusted. sp<AlarmMonitor> alarmMonitor;
// countProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1); int64_t bucketStartTimeNs = 10000000000;
// EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// EXPECT_EQ((long long)bucketStartTimeNs, int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
// countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs);
// EXPECT_EQ((long long)eventUpgradeTimeNs, int tagId = 1;
// countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketEndNs); int conditionTagId = 2;
// EXPECT_EQ(eventUpgradeTimeNs, countProducer.mCurrentBucketStartTimeNs);
// // Anomaly tracker only contains full buckets. CountMetric metric;
// EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); metric.set_id(1);
// metric.set_bucket(ONE_MINUTE);
// int64_t lastEndTimeNs = countProducer.getCurrentBucketEndTimeNs(); Alert alert;
// // Next event occurs in same bucket as partial bucket created. alert.set_num_buckets(3);
// LogEvent event2(tagId, bucketStartTimeNs + 59 * NS_PER_SEC + 10); alert.set_trigger_if_sum_gt(2);
// event2.write("222"); // uid
// event2.init(); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); CountMetricProducer countProducer(kConfigKey, metric, -1 /* no condition */, wizard,
// EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); bucketStartTimeNs, bucketStartTimeNs);
// EXPECT_EQ(eventUpgradeTimeNs, countProducer.mCurrentBucketStartTimeNs);
// EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); sp<AnomalyTracker> anomalyTracker = countProducer.addAnomalyTracker(alert, alarmMonitor);
// EXPECT_TRUE(anomalyTracker != nullptr);
// // Third event in following bucket.
// LogEvent event3(tagId, bucketStartTimeNs + 62 * NS_PER_SEC + 10); // Bucket is flushed yet.
// event3.write("333"); // uid LogEvent event1(/*uid=*/0, /*pid=*/0);
// event3.init(); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId, /*uid=*/"111");
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1);
// EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(0UL, countProducer.mPastBuckets.size());
// EXPECT_EQ(lastEndTimeNs, countProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY));
// EXPECT_EQ(2, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY));
//} // App upgrade forces bucket flush.
// // Check that there's a past bucket and the bucket end is not adjusted.
//TEST(CountMetricProducerTest, TestEventWithAppUpgradeInNextBucket) { countProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// int64_t bucketStartTimeNs = 10000000000; EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; EXPECT_EQ((long long)bucketStartTimeNs,
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC; countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs);
// EXPECT_EQ((long long)eventUpgradeTimeNs,
// int tagId = 1; countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketEndNs);
// int conditionTagId = 2; EXPECT_EQ(eventUpgradeTimeNs, countProducer.mCurrentBucketStartTimeNs);
// // Anomaly tracker only contains full buckets.
// CountMetric metric; EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY));
// metric.set_id(1);
// metric.set_bucket(ONE_MINUTE); int64_t lastEndTimeNs = countProducer.getCurrentBucketEndTimeNs();
// LogEvent event1(tagId, bucketStartTimeNs + 1); // Next event occurs in same bucket as partial bucket created.
// event1.write("111"); // uid LogEvent event2(/*uid=*/0, /*pid=*/0);
// event1.init(); makeLogEvent(&event2, bucketStartTimeNs + 59 * NS_PER_SEC + 10, tagId, /*uid=*/"222");
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2);
// CountMetricProducer countProducer(kConfigKey, metric, -1 /* no condition */, wizard, EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// bucketStartTimeNs, bucketStartTimeNs); EXPECT_EQ(eventUpgradeTimeNs, countProducer.mCurrentBucketStartTimeNs);
// EXPECT_EQ(0, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY));
// // Bucket is flushed yet.
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); // Third event in following bucket.
// EXPECT_EQ(0UL, countProducer.mPastBuckets.size()); LogEvent event3(/*uid=*/0, /*pid=*/0);
// makeLogEvent(&event3, bucketStartTimeNs + 62 * NS_PER_SEC + 10, tagId, /*uid=*/"333");
// // App upgrade forces bucket flush. countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3);
// // Check that there's a past bucket and the bucket end is not adjusted. EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// countProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1); EXPECT_EQ(lastEndTimeNs, countProducer.mCurrentBucketStartTimeNs);
// EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(2, anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY));
// EXPECT_EQ((int64_t)bucketStartTimeNs, }
// countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, TEST(CountMetricProducerTest, TestEventWithAppUpgradeInNextBucket) {
// countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketEndNs); int64_t bucketStartTimeNs = 10000000000;
// EXPECT_EQ(eventUpgradeTimeNs, countProducer.mCurrentBucketStartTimeNs); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC;
// // Next event occurs in same bucket as partial bucket created.
// LogEvent event2(tagId, bucketStartTimeNs + 70 * NS_PER_SEC + 10); int tagId = 1;
// event2.write("222"); // uid int conditionTagId = 2;
// event2.init();
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); CountMetric metric;
// EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); metric.set_id(1);
// metric.set_bucket(ONE_MINUTE);
// // Third event in following bucket.
// LogEvent event3(tagId, bucketStartTimeNs + 121 * NS_PER_SEC + 10); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// event3.write("333"); // uid CountMetricProducer countProducer(kConfigKey, metric, -1 /* no condition */, wizard,
// event3.init(); bucketStartTimeNs, bucketStartTimeNs);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3);
// EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); // Bucket is flushed yet.
// EXPECT_EQ((int64_t)eventUpgradeTimeNs, LogEvent event1(/*uid=*/0, /*pid=*/0);
// countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1].mBucketStartNs); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId, /*uid=*/"111");
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1);
// countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1].mBucketEndNs); EXPECT_EQ(0UL, countProducer.mPastBuckets.size());
//}
// // App upgrade forces bucket flush.
//TEST(CountMetricProducerTest, TestAnomalyDetectionUnSliced) { // Check that there's a past bucket and the bucket end is not adjusted.
// sp<AlarmMonitor> alarmMonitor; countProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// Alert alert; EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// alert.set_id(11); EXPECT_EQ((int64_t)bucketStartTimeNs,
// alert.set_metric_id(1); countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketStartNs);
// alert.set_trigger_if_sum_gt(2); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs,
// alert.set_num_buckets(2); countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][0].mBucketEndNs);
// const int32_t refPeriodSec = 1; EXPECT_EQ(eventUpgradeTimeNs, countProducer.mCurrentBucketStartTimeNs);
// alert.set_refractory_period_secs(refPeriodSec);
// // Next event occurs in same bucket as partial bucket created.
// int64_t bucketStartTimeNs = 10000000000; LogEvent event2(/*uid=*/0, /*pid=*/0);
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; makeLogEvent(&event2, bucketStartTimeNs + 70 * NS_PER_SEC + 10, tagId, /*uid=*/"222");
// int64_t bucket2StartTimeNs = bucketStartTimeNs + bucketSizeNs; countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2);
// int64_t bucket3StartTimeNs = bucketStartTimeNs + 2 * bucketSizeNs; EXPECT_EQ(1UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
//
// CountMetric metric; // Third event in following bucket.
// metric.set_id(1); LogEvent event3(/*uid=*/0, /*pid=*/0);
// metric.set_bucket(ONE_MINUTE); makeLogEvent(&event3, bucketStartTimeNs + 121 * NS_PER_SEC + 10, tagId, /*uid=*/"333");
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); EXPECT_EQ(2UL, countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// CountMetricProducer countProducer(kConfigKey, metric, -1 /*-1 meaning no condition*/, wizard, EXPECT_EQ((int64_t)eventUpgradeTimeNs,
// bucketStartTimeNs, bucketStartTimeNs); countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1].mBucketStartNs);
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs,
// sp<AnomalyTracker> anomalyTracker = countProducer.addAnomalyTracker(alert, alarmMonitor); countProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY][1].mBucketEndNs);
// }
// int tagId = 1;
// LogEvent event1(tagId, bucketStartTimeNs + 1); TEST(CountMetricProducerTest, TestAnomalyDetectionUnSliced) {
// event1.init(); sp<AlarmMonitor> alarmMonitor;
// LogEvent event2(tagId, bucketStartTimeNs + 2); Alert alert;
// event2.init(); alert.set_id(11);
// LogEvent event3(tagId, bucketStartTimeNs + 2 * bucketSizeNs + 1); alert.set_metric_id(1);
// event3.init(); alert.set_trigger_if_sum_gt(2);
// LogEvent event4(tagId, bucketStartTimeNs + 3 * bucketSizeNs + 1); alert.set_num_buckets(2);
// event4.init(); const int32_t refPeriodSec = 1;
// LogEvent event5(tagId, bucketStartTimeNs + 3 * bucketSizeNs + 2); alert.set_refractory_period_secs(refPeriodSec);
// event5.init();
// LogEvent event6(tagId, bucketStartTimeNs + 3 * bucketSizeNs + 3); int64_t bucketStartTimeNs = 10000000000;
// event6.init(); int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// LogEvent event7(tagId, bucketStartTimeNs + 3 * bucketSizeNs + 2 * NS_PER_SEC); int64_t bucket2StartTimeNs = bucketStartTimeNs + bucketSizeNs;
// event7.init(); int64_t bucket3StartTimeNs = bucketStartTimeNs + 2 * bucketSizeNs;
//
// // Two events in bucket #0. CountMetric metric;
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1); metric.set_id(1);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2); metric.set_bucket(ONE_MINUTE);
//
// EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// EXPECT_EQ(2L, countProducer.mCurrentSlicedCounter->begin()->second); CountMetricProducer countProducer(kConfigKey, metric, -1 /*-1 meaning no condition*/, wizard,
// EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), 0U); bucketStartTimeNs, bucketStartTimeNs);
//
// // One event in bucket #2. No alarm as bucket #0 is trashed out. sp<AnomalyTracker> anomalyTracker = countProducer.addAnomalyTracker(alert, alarmMonitor);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3);
// EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); int tagId = 1;
// EXPECT_EQ(1L, countProducer.mCurrentSlicedCounter->begin()->second); LogEvent event1(/*uid=*/0, /*pid=*/0);
// EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), 0U); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
// LogEvent event2(/*uid=*/0, /*pid=*/0);
// // Two events in bucket #3. makeLogEvent(&event2, bucketStartTimeNs + 2, tagId);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event4); LogEvent event3(/*uid=*/0, /*pid=*/0);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event5); makeLogEvent(&event3, bucketStartTimeNs + 2 * bucketSizeNs + 1, tagId);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event6); LogEvent event4(/*uid=*/0, /*pid=*/0);
// EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size()); makeLogEvent(&event4, bucketStartTimeNs + 3 * bucketSizeNs + 1, tagId);
// EXPECT_EQ(3L, countProducer.mCurrentSlicedCounter->begin()->second); LogEvent event5(/*uid=*/0, /*pid=*/0);
// // Anomaly at event 6 is within refractory period. The alarm is at event 5 timestamp not event 6 makeLogEvent(&event5, bucketStartTimeNs + 3 * bucketSizeNs + 2, tagId);
// EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), LogEvent event6(/*uid=*/0, /*pid=*/0);
// std::ceil(1.0 * event5.GetElapsedTimestampNs() / NS_PER_SEC + refPeriodSec)); makeLogEvent(&event6, bucketStartTimeNs + 3 * bucketSizeNs + 3, tagId);
// LogEvent event7(/*uid=*/0, /*pid=*/0);
// countProducer.onMatchedLogEvent(1 /*log matcher index*/, event7); makeLogEvent(&event7, bucketStartTimeNs + 3 * bucketSizeNs + 2 * NS_PER_SEC, tagId);
// EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size());
// EXPECT_EQ(4L, countProducer.mCurrentSlicedCounter->begin()->second); // Two events in bucket #0.
// EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), countProducer.onMatchedLogEvent(1 /*log matcher index*/, event1);
// std::ceil(1.0 * event7.GetElapsedTimestampNs() / NS_PER_SEC + refPeriodSec)); countProducer.onMatchedLogEvent(1 /*log matcher index*/, event2);
//}
EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size());
EXPECT_EQ(2L, countProducer.mCurrentSlicedCounter->begin()->second);
EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), 0U);
// One event in bucket #2. No alarm as bucket #0 is trashed out.
countProducer.onMatchedLogEvent(1 /*log matcher index*/, event3);
EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size());
EXPECT_EQ(1L, countProducer.mCurrentSlicedCounter->begin()->second);
EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY), 0U);
// Two events in bucket #3.
countProducer.onMatchedLogEvent(1 /*log matcher index*/, event4);
countProducer.onMatchedLogEvent(1 /*log matcher index*/, event5);
countProducer.onMatchedLogEvent(1 /*log matcher index*/, event6);
EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size());
EXPECT_EQ(3L, countProducer.mCurrentSlicedCounter->begin()->second);
// Anomaly at event 6 is within refractory period. The alarm is at event 5 timestamp not event 6
EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY),
std::ceil(1.0 * event5.GetElapsedTimestampNs() / NS_PER_SEC + refPeriodSec));
countProducer.onMatchedLogEvent(1 /*log matcher index*/, event7);
EXPECT_EQ(1UL, countProducer.mCurrentSlicedCounter->size());
EXPECT_EQ(4L, countProducer.mCurrentSlicedCounter->begin()->second);
EXPECT_EQ(anomalyTracker->getRefractoryPeriodEndsSec(DEFAULT_METRIC_DIMENSION_KEY),
std::ceil(1.0 * event7.GetElapsedTimestampNs() / NS_PER_SEC + refPeriodSec));
}
TEST(CountMetricProducerTest, TestOneWeekTimeUnit) { TEST(CountMetricProducerTest, TestOneWeekTimeUnit) {
CountMetric metric; CountMetric metric;

782
cmds/statsd/tests/metrics/DurationMetricProducer_test.cpp
View File

@@ -13,17 +13,20 @@
// limitations under the License. // limitations under the License.
#include "src/metrics/DurationMetricProducer.h" #include "src/metrics/DurationMetricProducer.h"
#include "src/stats_log_util.h"
#include "metrics_test_helper.h"
#include "src/condition/ConditionWizard.h"
#include <gmock/gmock.h> #include <gmock/gmock.h>
#include <gtest/gtest.h> #include <gtest/gtest.h>
#include <stdio.h> #include <stdio.h>
#include <set> #include <set>
#include <unordered_map> #include <unordered_map>
#include <vector> #include <vector>
#include "metrics_test_helper.h"
#include "src/condition/ConditionWizard.h"
#include "src/stats_log_util.h"
#include "stats_event.h"
using namespace android::os::statsd; using namespace android::os::statsd;
using namespace testing; using namespace testing;
using android::sp; using android::sp;
@@ -39,6 +42,22 @@ namespace statsd {
const ConfigKey kConfigKey(0, 12345); const ConfigKey kConfigKey(0, 12345);
namespace {
void makeLogEvent(LogEvent* logEvent, int64_t timestampNs, int atomId) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, atomId);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
}
} // namespace
TEST(DurationMetricTrackerTest, TestFirstBucket) { TEST(DurationMetricTrackerTest, TestFirstBucket) {
sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
DurationMetric metric; DurationMetric metric;
@@ -56,383 +75,386 @@ TEST(DurationMetricTrackerTest, TestFirstBucket) {
EXPECT_EQ(660000000005, durationProducer.getCurrentBucketEndTimeNs()); EXPECT_EQ(660000000005, durationProducer.getCurrentBucketEndTimeNs());
} }
// TODO(b/149590301): Update these to use new socket schema. TEST(DurationMetricTrackerTest, TestNoCondition) {
//TEST(DurationMetricTrackerTest, TestNoCondition) { sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketStartTimeNs = 10000000000; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// DurationMetric metric;
// DurationMetric metric; metric.set_id(1);
// metric.set_id(1); metric.set_bucket(ONE_MINUTE);
// metric.set_bucket(ONE_MINUTE); metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
// int tagId = 1;
// int tagId = 1; LogEvent event1(/*uid=*/0, /*pid=*/0);
// LogEvent event1(tagId, bucketStartTimeNs + 1); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
// event1.init(); LogEvent event2(/*uid=*/0, /*pid=*/0);
// LogEvent event2(tagId, bucketStartTimeNs + bucketSizeNs + 2); makeLogEvent(&event2, bucketStartTimeNs + bucketSizeNs + 2, tagId);
// event2.init();
// FieldMatcher dimensions;
// FieldMatcher dimensions; DurationMetricProducer durationProducer(kConfigKey, metric, -1 /*no condition*/,
// DurationMetricProducer durationProducer( 1 /* start index */, 2 /* stop index */,
// kConfigKey, metric, -1 /*no condition*/, 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/, wizard,
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); dimensions, bucketStartTimeNs, bucketStartTimeNs);
//
// durationProducer.onMatchedLogEvent(1 /* start index*/, event1); durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
// EXPECT_EQ(1UL, durationProducer.mPastBuckets.size()); EXPECT_EQ(1UL, durationProducer.mPastBuckets.size());
// EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
// durationProducer.mPastBuckets.end()); durationProducer.mPastBuckets.end());
// const auto& buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; const auto& buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(2UL, buckets.size()); EXPECT_EQ(2UL, buckets.size());
// EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs);
// EXPECT_EQ(bucketSizeNs - 1LL, buckets[0].mDuration); EXPECT_EQ(bucketSizeNs - 1LL, buckets[0].mDuration);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketStartNs);
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[1].mBucketEndNs); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[1].mBucketEndNs);
// EXPECT_EQ(2LL, buckets[1].mDuration); EXPECT_EQ(2LL, buckets[1].mDuration);
//} }
//
//TEST(DurationMetricTrackerTest, TestNonSlicedCondition) { TEST(DurationMetricTrackerTest, TestNonSlicedCondition) {
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// int64_t bucketStartTimeNs = 10000000000; int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
//
// DurationMetric metric; DurationMetric metric;
// metric.set_id(1); metric.set_id(1);
// metric.set_bucket(ONE_MINUTE); metric.set_bucket(ONE_MINUTE);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM); metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
//
// int tagId = 1; int tagId = 1;
// LogEvent event1(tagId, bucketStartTimeNs + 1); LogEvent event1(/*uid=*/0, /*pid=*/0);
// event1.init(); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
// LogEvent event2(tagId, bucketStartTimeNs + 2); LogEvent event2(/*uid=*/0, /*pid=*/0);
// event2.init(); makeLogEvent(&event2, bucketStartTimeNs + 2, tagId);
// LogEvent event3(tagId, bucketStartTimeNs + bucketSizeNs + 1); LogEvent event3(/*uid=*/0, /*pid=*/0);
// event3.init(); makeLogEvent(&event3, bucketStartTimeNs + bucketSizeNs + 1, tagId);
// LogEvent event4(tagId, bucketStartTimeNs + bucketSizeNs + 3); LogEvent event4(/*uid=*/0, /*pid=*/0);
// event4.init(); makeLogEvent(&event4, bucketStartTimeNs + bucketSizeNs + 3, tagId);
//
// FieldMatcher dimensions; FieldMatcher dimensions;
// DurationMetricProducer durationProducer( DurationMetricProducer durationProducer(kConfigKey, metric, 0 /* condition index */,
// kConfigKey, metric, 0 /* condition index */, 1 /* start index */, 2 /* stop index */, 1 /* start index */, 2 /* stop index */,
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); 3 /* stop_all index */, false /*nesting*/, wizard,
// durationProducer.mCondition = ConditionState::kFalse; dimensions, bucketStartTimeNs, bucketStartTimeNs);
// durationProducer.mCondition = ConditionState::kFalse;
// EXPECT_FALSE(durationProducer.mCondition);
// EXPECT_FALSE(durationProducer.isConditionSliced()); EXPECT_FALSE(durationProducer.mCondition);
// EXPECT_FALSE(durationProducer.isConditionSliced());
// durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, event2); durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size());
// durationProducer.onMatchedLogEvent(1 /* start index*/, event3);
// durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2); durationProducer.onMatchedLogEvent(1 /* start index*/, event3);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, event4); durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2);
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); durationProducer.onMatchedLogEvent(2 /* stop index*/, event4);
// EXPECT_EQ(1UL, durationProducer.mPastBuckets.size()); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
// EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) != EXPECT_EQ(1UL, durationProducer.mPastBuckets.size());
// durationProducer.mPastBuckets.end()); EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
// const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; durationProducer.mPastBuckets.end());
// EXPECT_EQ(1UL, buckets2.size()); const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs); EXPECT_EQ(1UL, buckets2.size());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs);
// EXPECT_EQ(1LL, buckets2[0].mDuration); EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs);
//} EXPECT_EQ(1LL, buckets2[0].mDuration);
// }
//TEST(DurationMetricTrackerTest, TestNonSlicedConditionUnknownState) {
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); TEST(DurationMetricTrackerTest, TestNonSlicedConditionUnknownState) {
// int64_t bucketStartTimeNs = 10000000000; sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// DurationMetric metric;
// metric.set_id(1); DurationMetric metric;
// metric.set_bucket(ONE_MINUTE); metric.set_id(1);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM); metric.set_bucket(ONE_MINUTE);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
// int tagId = 1;
// LogEvent event1(tagId, bucketStartTimeNs + 1); int tagId = 1;
// event1.init(); LogEvent event1(/*uid=*/0, /*pid=*/0);
// LogEvent event2(tagId, bucketStartTimeNs + 2); makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
// event2.init(); LogEvent event2(/*uid=*/0, /*pid=*/0);
// LogEvent event3(tagId, bucketStartTimeNs + bucketSizeNs + 1); makeLogEvent(&event2, bucketStartTimeNs + 2, tagId);
// event3.init(); LogEvent event3(/*uid=*/0, /*pid=*/0);
// LogEvent event4(tagId, bucketStartTimeNs + bucketSizeNs + 3); makeLogEvent(&event3, bucketStartTimeNs + bucketSizeNs + 1, tagId);
// event4.init(); LogEvent event4(/*uid=*/0, /*pid=*/0);
// makeLogEvent(&event4, bucketStartTimeNs + bucketSizeNs + 3, tagId);
// FieldMatcher dimensions;
// DurationMetricProducer durationProducer( FieldMatcher dimensions;
// kConfigKey, metric, 0 /* condition index */, 1 /* start index */, 2 /* stop index */, DurationMetricProducer durationProducer(kConfigKey, metric, 0 /* condition index */,
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); 1 /* start index */, 2 /* stop index */,
// 3 /* stop_all index */, false /*nesting*/, wizard,
// EXPECT_EQ(ConditionState::kUnknown, durationProducer.mCondition); dimensions, bucketStartTimeNs, bucketStartTimeNs);
// EXPECT_FALSE(durationProducer.isConditionSliced());
// EXPECT_EQ(ConditionState::kUnknown, durationProducer.mCondition);
// durationProducer.onMatchedLogEvent(1 /* start index*/, event1); EXPECT_FALSE(durationProducer.isConditionSliced());
// durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1); durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
// durationProducer.onMatchedLogEvent(1 /* start index*/, event3); EXPECT_EQ(0UL, durationProducer.mPastBuckets.size());
// durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, event4); durationProducer.onMatchedLogEvent(1 /* start index*/, event3);
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2);
// EXPECT_EQ(1UL, durationProducer.mPastBuckets.size()); durationProducer.onMatchedLogEvent(2 /* stop index*/, event4);
// const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
// EXPECT_EQ(1UL, buckets2.size()); EXPECT_EQ(1UL, durationProducer.mPastBuckets.size());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs); const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs); EXPECT_EQ(1UL, buckets2.size());
// EXPECT_EQ(1LL, buckets2[0].mDuration); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs);
//} EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs);
// EXPECT_EQ(1LL, buckets2[0].mDuration);
//TEST(DurationMetricTrackerTest, TestSumDurationWithUpgrade) { }
// /**
// * The duration starts from the first bucket, through the two partial buckets (10-70sec), TEST(DurationMetricTrackerTest, TestSumDurationWithUpgrade) {
// * another bucket, and ends at the beginning of the next full bucket. /**
// * Expected buckets: * The duration starts from the first bucket, through the two partial buckets (10-70sec),
// * - [10,25]: 14 secs * another bucket, and ends at the beginning of the next full bucket.
// * - [25,70]: All 45 secs * Expected buckets:
// * - [70,130]: All 60 secs * - [10,25]: 14 secs
// * - [130, 210]: Only 5 secs (event ended at 135sec) * - [25,70]: All 45 secs
// */ * - [70,130]: All 60 secs
// int64_t bucketStartTimeNs = 10000000000; * - [130, 210]: Only 5 secs (event ended at 135sec)
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; */
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC; int64_t bucketStartTimeNs = 10000000000;
// int64_t startTimeNs = bucketStartTimeNs + 1 * NS_PER_SEC; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC; int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
// int64_t startTimeNs = bucketStartTimeNs + 1 * NS_PER_SEC;
// int tagId = 1; int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC;
//
// DurationMetric metric; int tagId = 1;
// metric.set_id(1); LogEvent event1(/*uid=*/0, /*pid=*/0);
// metric.set_bucket(ONE_MINUTE); makeLogEvent(&event1, startTimeNs, tagId);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM); LogEvent event2(/*uid=*/0, /*pid=*/0);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); makeLogEvent(&event2, endTimeNs, tagId);
// FieldMatcher dimensions;
// DurationMetricProducer durationProducer( DurationMetric metric;
// kConfigKey, metric, -1 /* no condition */, 1 /* start index */, 2 /* stop index */, metric.set_id(1);
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); metric.set_bucket(ONE_MINUTE);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
// LogEvent start_event(tagId, startTimeNs); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// start_event.init(); FieldMatcher dimensions;
// durationProducer.onMatchedLogEvent(1 /* start index*/, start_event); DurationMetricProducer durationProducer(kConfigKey, metric, -1 /* no condition */,
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); 1 /* start index */, 2 /* stop index */,
// EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); 3 /* stop_all index */, false /*nesting*/, wizard,
// dimensions, bucketStartTimeNs, bucketStartTimeNs);
// durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// EXPECT_EQ(1UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// std::vector<DurationBucket> buckets = EXPECT_EQ(0UL, durationProducer.mPastBuckets.size());
// durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
// EXPECT_EQ(eventUpgradeTimeNs, buckets[0].mBucketEndNs); durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// EXPECT_EQ(eventUpgradeTimeNs - startTimeNs, buckets[0].mDuration); EXPECT_EQ(1UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs); std::vector<DurationBucket> buckets =
// durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket. EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
// LogEvent end_event(tagId, endTimeNs); EXPECT_EQ(eventUpgradeTimeNs, buckets[0].mBucketEndNs);
// end_event.init(); EXPECT_EQ(eventUpgradeTimeNs - startTimeNs, buckets[0].mDuration);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, end_event); EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(3UL, buckets.size()); // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
// EXPECT_EQ(eventUpgradeTimeNs, buckets[1].mBucketStartNs); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketEndNs); buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - eventUpgradeTimeNs, buckets[1].mDuration); EXPECT_EQ(3UL, buckets.size());
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[2].mBucketStartNs); EXPECT_EQ(eventUpgradeTimeNs, buckets[1].mBucketStartNs);
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[2].mBucketEndNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketEndNs);
// EXPECT_EQ(bucketSizeNs, buckets[2].mDuration); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - eventUpgradeTimeNs, buckets[1].mDuration);
//} EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[2].mBucketStartNs);
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[2].mBucketEndNs);
//TEST(DurationMetricTrackerTest, TestSumDurationWithUpgradeInFollowingBucket) { EXPECT_EQ(bucketSizeNs, buckets[2].mDuration);
// /** }
// * Expected buckets (start at 11s, upgrade at 75s, end at 135s):
// * - [10,70]: 59 secs TEST(DurationMetricTrackerTest, TestSumDurationWithUpgradeInFollowingBucket) {
// * - [70,75]: 5 sec /**
// * - [75,130]: 55 secs * Expected buckets (start at 11s, upgrade at 75s, end at 135s):
// */ * - [10,70]: 59 secs
// int64_t bucketStartTimeNs = 10000000000; * - [70,75]: 5 sec
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; * - [75,130]: 55 secs
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC; */
// int64_t startTimeNs = bucketStartTimeNs + 1 * NS_PER_SEC; int64_t bucketStartTimeNs = 10000000000;
// int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC;
// int tagId = 1; int64_t startTimeNs = bucketStartTimeNs + 1 * NS_PER_SEC;
// int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC;
// DurationMetric metric;
// metric.set_id(1); int tagId = 1;
// metric.set_bucket(ONE_MINUTE); LogEvent event1(/*uid=*/0, /*pid=*/0);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM); makeLogEvent(&event1, startTimeNs, tagId);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); LogEvent event2(/*uid=*/0, /*pid=*/0);
// FieldMatcher dimensions; makeLogEvent(&event2, endTimeNs, tagId);
// DurationMetricProducer durationProducer(
// kConfigKey, metric, -1 /* no condition */, 1 /* start index */, 2 /* stop index */, DurationMetric metric;
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); metric.set_id(1);
// metric.set_bucket(ONE_MINUTE);
// LogEvent start_event(tagId, startTimeNs); metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
// start_event.init(); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// durationProducer.onMatchedLogEvent(1 /* start index*/, start_event); FieldMatcher dimensions;
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); DurationMetricProducer durationProducer(kConfigKey, metric, -1 /* no condition */,
// EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); 1 /* start index */, 2 /* stop index */,
// 3 /* stop_all index */, false /*nesting*/, wizard,
// durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1); dimensions, bucketStartTimeNs, bucketStartTimeNs);
// EXPECT_EQ(2UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// std::vector<DurationBucket> buckets = durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; EXPECT_EQ(0UL, durationProducer.mPastBuckets.size());
// EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs); EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - startTimeNs, buckets[0].mDuration); durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketStartNs); EXPECT_EQ(2UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// EXPECT_EQ(eventUpgradeTimeNs, buckets[1].mBucketEndNs); std::vector<DurationBucket> buckets =
// EXPECT_EQ(eventUpgradeTimeNs - (bucketStartTimeNs + bucketSizeNs), buckets[1].mDuration); durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs);
// // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket. EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - startTimeNs, buckets[0].mDuration);
// LogEvent end_event(tagId, endTimeNs); EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketStartNs);
// end_event.init(); EXPECT_EQ(eventUpgradeTimeNs, buckets[1].mBucketEndNs);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, end_event); EXPECT_EQ(eventUpgradeTimeNs - (bucketStartTimeNs + bucketSizeNs), buckets[1].mDuration);
// buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// EXPECT_EQ(3UL, buckets.size());
// EXPECT_EQ(eventUpgradeTimeNs, buckets[2].mBucketStartNs); // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[2].mBucketEndNs); durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs - eventUpgradeTimeNs, buckets[2].mDuration); buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
//} EXPECT_EQ(3UL, buckets.size());
// EXPECT_EQ(eventUpgradeTimeNs, buckets[2].mBucketStartNs);
//TEST(DurationMetricTrackerTest, TestSumDurationAnomalyWithUpgrade) { EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[2].mBucketEndNs);
// sp<AlarmMonitor> alarmMonitor; EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs - eventUpgradeTimeNs, buckets[2].mDuration);
// int64_t bucketStartTimeNs = 10000000000; }
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC; TEST(DurationMetricTrackerTest, TestSumDurationAnomalyWithUpgrade) {
// int64_t startTimeNs = bucketStartTimeNs + 1; sp<AlarmMonitor> alarmMonitor;
// int64_t endTimeNs = startTimeNs + 65 * NS_PER_SEC; int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int tagId = 1; int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
// int64_t startTimeNs = bucketStartTimeNs + 1;
// // Setup metric with alert. int64_t endTimeNs = startTimeNs + 65 * NS_PER_SEC;
// DurationMetric metric;
// metric.set_id(1); int tagId = 1;
// metric.set_bucket(ONE_MINUTE); LogEvent event1(/*uid=*/0, /*pid=*/0);
// metric.set_aggregation_type(DurationMetric_AggregationType_SUM); makeLogEvent(&event1, startTimeNs, tagId);
// Alert alert; LogEvent event2(/*uid=*/0, /*pid=*/0);
// alert.set_num_buckets(3); makeLogEvent(&event2, endTimeNs, tagId);
// alert.set_trigger_if_sum_gt(2);
// // Setup metric with alert.
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); DurationMetric metric;
// FieldMatcher dimensions; metric.set_id(1);
// DurationMetricProducer durationProducer( metric.set_bucket(ONE_MINUTE);
// kConfigKey, metric, -1 /* no condition */, 1 /* start index */, 2 /* stop index */, metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); Alert alert;
// alert.set_num_buckets(3);
// sp<AnomalyTracker> anomalyTracker = durationProducer.addAnomalyTracker(alert, alarmMonitor); alert.set_trigger_if_sum_gt(2);
// EXPECT_TRUE(anomalyTracker != nullptr);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// LogEvent start_event(tagId, startTimeNs); FieldMatcher dimensions;
// start_event.init(); DurationMetricProducer durationProducer(kConfigKey, metric, -1 /* no condition */,
// durationProducer.onMatchedLogEvent(1 /* start index*/, start_event); 1 /* start index */, 2 /* stop index */,
// durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1); 3 /* stop_all index */, false /*nesting*/, wizard,
// // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket. dimensions, bucketStartTimeNs, bucketStartTimeNs);
// LogEvent end_event(tagId, endTimeNs);
// end_event.init(); sp<AnomalyTracker> anomalyTracker = durationProducer.addAnomalyTracker(alert, alarmMonitor);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, end_event); EXPECT_TRUE(anomalyTracker != nullptr);
//
// EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - startTimeNs, durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY)); durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
//}
// // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
//TEST(DurationMetricTrackerTest, TestMaxDurationWithUpgrade) { durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// int64_t bucketStartTimeNs = 10000000000; EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - startTimeNs,
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY));
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC; }
// int64_t startTimeNs = bucketStartTimeNs + 1;
// int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC; TEST(DurationMetricTrackerTest, TestMaxDurationWithUpgrade) {
// int64_t bucketStartTimeNs = 10000000000;
// int tagId = 1; int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
// DurationMetric metric; int64_t startTimeNs = bucketStartTimeNs + 1;
// metric.set_id(1); int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC;
// metric.set_bucket(ONE_MINUTE);
// metric.set_aggregation_type(DurationMetric_AggregationType_MAX_SPARSE); int tagId = 1;
// LogEvent event1(tagId, startTimeNs); LogEvent event1(/*uid=*/0, /*pid=*/0);
// event1.write("111"); // uid makeLogEvent(&event1, startTimeNs, tagId);
// event1.init(); LogEvent event2(/*uid=*/0, /*pid=*/0);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>(); makeLogEvent(&event2, endTimeNs, tagId);
// FieldMatcher dimensions;
// DurationMetricProducer durationProducer( DurationMetric metric;
// kConfigKey, metric, -1 /* no condition */, 1 /* start index */, 2 /* stop index */, metric.set_id(1);
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); metric.set_bucket(ONE_MINUTE);
// metric.set_aggregation_type(DurationMetric_AggregationType_MAX_SPARSE);
// LogEvent start_event(tagId, startTimeNs);
// start_event.init(); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// durationProducer.onMatchedLogEvent(1 /* start index*/, start_event); FieldMatcher dimensions;
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); DurationMetricProducer durationProducer(kConfigKey, metric, -1 /* no condition */,
// EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); 1 /* start index */, 2 /* stop index */,
// 3 /* stop_all index */, false /*nesting*/, wizard,
// durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1); dimensions, bucketStartTimeNs, bucketStartTimeNs);
// EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs); durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size());
// // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket. EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// LogEvent end_event(tagId, endTimeNs);
// end_event.init(); durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// durationProducer.onMatchedLogEvent(2 /* stop index*/, end_event); EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs);
//
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + 3 * bucketSizeNs + 1); // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
// std::vector<DurationBucket> buckets = durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY]; EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// EXPECT_EQ(1UL, buckets.size());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketStartNs); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 3 * bucketSizeNs + 1);
// EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, buckets[0].mBucketEndNs); std::vector<DurationBucket> buckets =
// EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration); durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
//} EXPECT_EQ(1UL, buckets.size());
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketStartNs);
//TEST(DurationMetricTrackerTest, TestMaxDurationWithUpgradeInNextBucket) { EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, buckets[0].mBucketEndNs);
// int64_t bucketStartTimeNs = 10000000000; EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration);
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL; }
// int64_t eventUpgradeTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC;
// int64_t startTimeNs = bucketStartTimeNs + 1; TEST(DurationMetricTrackerTest, TestMaxDurationWithUpgradeInNextBucket) {
// int64_t endTimeNs = startTimeNs + 115 * NS_PER_SEC; int64_t bucketStartTimeNs = 10000000000;
// int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
// int tagId = 1; int64_t eventUpgradeTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC;
// int64_t startTimeNs = bucketStartTimeNs + 1;
// DurationMetric metric; int64_t endTimeNs = startTimeNs + 115 * NS_PER_SEC;
// metric.set_id(1);
// metric.set_bucket(ONE_MINUTE); int tagId = 1;
// metric.set_aggregation_type(DurationMetric_AggregationType_MAX_SPARSE); LogEvent event1(/*uid=*/0, /*pid=*/0);
// LogEvent event1(tagId, startTimeNs); makeLogEvent(&event1, startTimeNs, tagId);
// event1.write("111"); // uid LogEvent event2(/*uid=*/0, /*pid=*/0);
// event1.init(); makeLogEvent(&event2, endTimeNs, tagId);
// sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// FieldMatcher dimensions; DurationMetric metric;
// DurationMetricProducer durationProducer( metric.set_id(1);
// kConfigKey, metric, -1 /* no condition */, 1 /* start index */, 2 /* stop index */, metric.set_bucket(ONE_MINUTE);
// 3 /* stop_all index */, false /*nesting*/, wizard, dimensions, bucketStartTimeNs, bucketStartTimeNs); metric.set_aggregation_type(DurationMetric_AggregationType_MAX_SPARSE);
//
// LogEvent start_event(tagId, startTimeNs); sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
// start_event.init(); FieldMatcher dimensions;
// durationProducer.onMatchedLogEvent(1 /* start index*/, start_event); DurationMetricProducer durationProducer(kConfigKey, metric, -1 /* no condition */,
// EXPECT_EQ(0UL, durationProducer.mPastBuckets.size()); 1 /* start index */, 2 /* stop index */,
// EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs); 3 /* stop_all index */, false /*nesting*/, wizard,
// dimensions, bucketStartTimeNs, bucketStartTimeNs);
// durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size()); durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
// EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs); EXPECT_EQ(0UL, durationProducer.mPastBuckets.size());
// EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// // Stop occurs in the same partial bucket as created for the app upgrade.
// LogEvent end_event(tagId, endTimeNs); durationProducer.notifyAppUpgrade(eventUpgradeTimeNs, "ANY.APP", 1, 1);
// end_event.init(); EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// durationProducer.onMatchedLogEvent(2 /* stop index*/, end_event); EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs); // Stop occurs in the same partial bucket as created for the app upgrade.
// durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
// durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1); EXPECT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
// std::vector<DurationBucket> buckets = EXPECT_EQ(eventUpgradeTimeNs, durationProducer.mCurrentBucketStartTimeNs);
// durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(1UL, buckets.size()); durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
// EXPECT_EQ(eventUpgradeTimeNs, buckets[0].mBucketStartNs); std::vector<DurationBucket> buckets =
// EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketEndNs); durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
// EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration); EXPECT_EQ(1UL, buckets.size());
//} EXPECT_EQ(eventUpgradeTimeNs, buckets[0].mBucketStartNs);
EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketEndNs);
EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration);
}
} // namespace statsd } // namespace statsd
} // namespace os } // namespace os

424
cmds/statsd/tests/statsd_test_util.cpp
View File

@@ -410,40 +410,75 @@ FieldMatcher CreateDimensions(const int atomId, const std::vector<int>& fields)
return dimensions; return dimensions;
} }
// TODO(b/149590301): Update these helpers to use new socket schema. std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(
//std::unique_ptr<LogEvent> CreateScreenStateChangedEvent( uint64_t timestampNs, const android::view::DisplayStateEnum state) {
// const android::view::DisplayStateEnum state, uint64_t timestampNs) { AStatsEvent* statsEvent = AStatsEvent_obtain();
// auto event = std::make_unique<LogEvent>(android::util::SCREEN_STATE_CHANGED, timestampNs); AStatsEvent_setAtomId(statsEvent, android::util::SCREEN_STATE_CHANGED);
// EXPECT_TRUE(event->write(state)); AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// event->init();
// return event; AStatsEvent_writeInt32(statsEvent, state);
//} AStatsEvent_build(statsEvent);
//
//std::unique_ptr<LogEvent> CreateBatterySaverOnEvent(uint64_t timestampNs) { size_t size;
// auto event = std::make_unique<LogEvent>( uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// android::util::BATTERY_SAVER_MODE_STATE_CHANGED, timestampNs);
// EXPECT_TRUE(event->write(BatterySaverModeStateChanged::ON)); std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
// event->init(); logEvent->parseBuffer(buf, size);
// return event; AStatsEvent_release(statsEvent);
//} return logEvent;
// }
//std::unique_ptr<LogEvent> CreateBatterySaverOffEvent(uint64_t timestampNs) {
// auto event = std::make_unique<LogEvent>( std::unique_ptr<LogEvent> CreateBatterySaverOnEvent(uint64_t timestampNs) {
// android::util::BATTERY_SAVER_MODE_STATE_CHANGED, timestampNs); AStatsEvent* statsEvent = AStatsEvent_obtain();
// EXPECT_TRUE(event->write(BatterySaverModeStateChanged::OFF)); AStatsEvent_setAtomId(statsEvent, android::util::BATTERY_SAVER_MODE_STATE_CHANGED);
// event->init(); AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// return event;
//} AStatsEvent_writeInt32(statsEvent, BatterySaverModeStateChanged::ON);
// AStatsEvent_build(statsEvent);
//std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(
// int level, uint64_t timestampNs) { size_t size;
// auto event = std::make_unique<LogEvent>(android::util::SCREEN_BRIGHTNESS_CHANGED, timestampNs); uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// EXPECT_TRUE(event->write(level));
// event->init(); std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
// return event; logEvent->parseBuffer(buf, size);
// AStatsEvent_release(statsEvent);
//} return logEvent;
// }
std::unique_ptr<LogEvent> CreateBatterySaverOffEvent(uint64_t timestampNs) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, android::util::BATTERY_SAVER_MODE_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, BatterySaverModeStateChanged::OFF);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(uint64_t timestampNs, int level) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, android::util::SCREEN_BRIGHTNESS_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, level);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
//std::unique_ptr<LogEvent> CreateScheduledJobStateChangedEvent( //std::unique_ptr<LogEvent> CreateScheduledJobStateChangedEvent(
// const std::vector<AttributionNodeInternal>& attributions, const string& jobName, // const std::vector<AttributionNodeInternal>& attributions, const string& jobName,
// const ScheduledJobStateChanged::State state, uint64_t timestampNs) { // const ScheduledJobStateChanged::State state, uint64_t timestampNs) {
@@ -470,121 +505,212 @@ FieldMatcher CreateDimensions(const int atomId, const std::vector<int>& fields)
// attributions, name, ScheduledJobStateChanged::FINISHED, timestampNs); // attributions, name, ScheduledJobStateChanged::FINISHED, timestampNs);
//} //}
// //
//std::unique_ptr<LogEvent> CreateWakelockStateChangedEvent( std::unique_ptr<LogEvent> CreateWakelockStateChangedEvent(uint64_t timestampNs,
// const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName, const vector<int>& attributionUids,
// const WakelockStateChanged::State state, uint64_t timestampNs) { const vector<string>& attributionTags,
// auto event = std::make_unique<LogEvent>(android::util::WAKELOCK_STATE_CHANGED, timestampNs); const string& wakelockName,
// event->write(attributions); const WakelockStateChanged::State state) {
// event->write(android::os::WakeLockLevelEnum::PARTIAL_WAKE_LOCK); AStatsEvent* statsEvent = AStatsEvent_obtain();
// event->write(wakelockName); AStatsEvent_setAtomId(statsEvent, android::util::WAKELOCK_STATE_CHANGED);
// event->write(state); AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// event->init();
// return event; vector<const char*> cTags(attributionTags.size());
//} for (int i = 0; i < cTags.size(); i++) {
// cTags[i] = attributionTags[i].c_str();
//std::unique_ptr<LogEvent> CreateAcquireWakelockEvent( }
// const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName,
// uint64_t timestampNs) { AStatsEvent_writeAttributionChain(statsEvent,
// return CreateWakelockStateChangedEvent( reinterpret_cast<const uint32_t*>(attributionUids.data()),
// attributions, wakelockName, WakelockStateChanged::ACQUIRE, timestampNs); cTags.data(), attributionUids.size());
//} AStatsEvent_writeInt32(statsEvent, android::os::WakeLockLevelEnum::PARTIAL_WAKE_LOCK);
// AStatsEvent_writeString(statsEvent, wakelockName.c_str());
//std::unique_ptr<LogEvent> CreateReleaseWakelockEvent( AStatsEvent_writeInt32(statsEvent, state);
// const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName, AStatsEvent_build(statsEvent);
// uint64_t timestampNs) {
// return CreateWakelockStateChangedEvent( size_t size;
// attributions, wakelockName, WakelockStateChanged::RELEASE, timestampNs); uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
//}
// std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
//std::unique_ptr<LogEvent> CreateActivityForegroundStateChangedEvent( logEvent->parseBuffer(buf, size);
// const int uid, const ActivityForegroundStateChanged::State state, uint64_t timestampNs) { AStatsEvent_release(statsEvent);
// auto event = std::make_unique<LogEvent>( return logEvent;
// android::util::ACTIVITY_FOREGROUND_STATE_CHANGED, timestampNs); }
// event->write(uid);
// event->write("pkg_name"); std::unique_ptr<LogEvent> CreateAcquireWakelockEvent(uint64_t timestampNs,
// event->write("class_name"); const vector<int>& attributionUids,
// event->write(state); const vector<string>& attributionTags,
// event->init(); const string& wakelockName) {
// return event; return CreateWakelockStateChangedEvent(timestampNs, attributionUids, attributionTags,
//} wakelockName, WakelockStateChanged::ACQUIRE);
// }
//std::unique_ptr<LogEvent> CreateMoveToBackgroundEvent(const int uid, uint64_t timestampNs) {
// return CreateActivityForegroundStateChangedEvent( std::unique_ptr<LogEvent> CreateReleaseWakelockEvent(uint64_t timestampNs,
// uid, ActivityForegroundStateChanged::BACKGROUND, timestampNs); const vector<int>& attributionUids,
//} const vector<string>& attributionTags,
// const string& wakelockName) {
//std::unique_ptr<LogEvent> CreateMoveToForegroundEvent(const int uid, uint64_t timestampNs) { return CreateWakelockStateChangedEvent(timestampNs, attributionUids, attributionTags,
// return CreateActivityForegroundStateChangedEvent( wakelockName, WakelockStateChanged::RELEASE);
// uid, ActivityForegroundStateChanged::FOREGROUND, timestampNs); }
//}
// std::unique_ptr<LogEvent> CreateActivityForegroundStateChangedEvent(
//std::unique_ptr<LogEvent> CreateSyncStateChangedEvent( uint64_t timestampNs, const int uid, const ActivityForegroundStateChanged::State state) {
// const std::vector<AttributionNodeInternal>& attributions, const string& name, AStatsEvent* statsEvent = AStatsEvent_obtain();
// const SyncStateChanged::State state, uint64_t timestampNs) { AStatsEvent_setAtomId(statsEvent, android::util::ACTIVITY_FOREGROUND_STATE_CHANGED);
// auto event = std::make_unique<LogEvent>(android::util::SYNC_STATE_CHANGED, timestampNs); AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
// event->write(attributions);
// event->write(name); AStatsEvent_writeInt32(statsEvent, uid);
// event->write(state); AStatsEvent_writeString(statsEvent, "pkg_name");
// event->init(); AStatsEvent_writeString(statsEvent, "class_name");
// return event; AStatsEvent_writeInt32(statsEvent, state);
//} AStatsEvent_build(statsEvent);
//
//std::unique_ptr<LogEvent> CreateSyncStartEvent( size_t size;
// const std::vector<AttributionNodeInternal>& attributions, const string& name, uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// uint64_t timestampNs) {
// return CreateSyncStateChangedEvent(attributions, name, SyncStateChanged::ON, timestampNs); std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
//} logEvent->parseBuffer(buf, size);
// AStatsEvent_release(statsEvent);
//std::unique_ptr<LogEvent> CreateSyncEndEvent( return logEvent;
// const std::vector<AttributionNodeInternal>& attributions, const string& name, }
// uint64_t timestampNs) {
// return CreateSyncStateChangedEvent(attributions, name, SyncStateChanged::OFF, timestampNs); std::unique_ptr<LogEvent> CreateMoveToBackgroundEvent(uint64_t timestampNs, const int uid) {
//} return CreateActivityForegroundStateChangedEvent(timestampNs, uid,
// ActivityForegroundStateChanged::BACKGROUND);
//std::unique_ptr<LogEvent> CreateProcessLifeCycleStateChangedEvent( }
// const int uid, const ProcessLifeCycleStateChanged::State state, uint64_t timestampNs) {
// auto logEvent = std::make_unique<LogEvent>( std::unique_ptr<LogEvent> CreateMoveToForegroundEvent(uint64_t timestampNs, const int uid) {
// android::util::PROCESS_LIFE_CYCLE_STATE_CHANGED, timestampNs); return CreateActivityForegroundStateChangedEvent(timestampNs, uid,
// logEvent->write(uid); ActivityForegroundStateChanged::FOREGROUND);
// logEvent->write(""); }
// logEvent->write(state);
// logEvent->init(); std::unique_ptr<LogEvent> CreateSyncStateChangedEvent(uint64_t timestampNs,
// return logEvent; const vector<int>& attributionUids,
//} const vector<string>& attributionTags,
// const string& name,
//std::unique_ptr<LogEvent> CreateAppCrashEvent(const int uid, uint64_t timestampNs) { const SyncStateChanged::State state) {
// return CreateProcessLifeCycleStateChangedEvent( AStatsEvent* statsEvent = AStatsEvent_obtain();
// uid, ProcessLifeCycleStateChanged::CRASHED, timestampNs); AStatsEvent_setAtomId(statsEvent, android::util::SYNC_STATE_CHANGED);
//} AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
//
//std::unique_ptr<LogEvent> CreateAppCrashOccurredEvent(const int uid, uint64_t timestampNs) { vector<const char*> cTags(attributionTags.size());
// auto event = std::make_unique<LogEvent>(android::util::APP_CRASH_OCCURRED, timestampNs); for (int i = 0; i < cTags.size(); i++) {
// event->write(uid); cTags[i] = attributionTags[i].c_str();
// event->write("eventType"); }
// event->write("processName");
// event->init(); AStatsEvent_writeAttributionChain(statsEvent,
// return event; reinterpret_cast<const uint32_t*>(attributionUids.data()),
//} cTags.data(), attributionUids.size());
// AStatsEvent_writeString(statsEvent, name.c_str());
//std::unique_ptr<LogEvent> CreateIsolatedUidChangedEvent( AStatsEvent_writeInt32(statsEvent, state);
// int isolatedUid, int hostUid, bool is_create, uint64_t timestampNs) { AStatsEvent_build(statsEvent);
// auto logEvent = std::make_unique<LogEvent>(
// android::util::ISOLATED_UID_CHANGED, timestampNs); size_t size;
// logEvent->write(hostUid); uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
// logEvent->write(isolatedUid);
// logEvent->write(is_create); std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
// logEvent->init(); logEvent->parseBuffer(buf, size);
// return logEvent; AStatsEvent_release(statsEvent);
//} return logEvent;
// }
//std::unique_ptr<LogEvent> CreateUidProcessStateChangedEvent(
// int uid, const android::app::ProcessStateEnum state, uint64_t timestampNs) { std::unique_ptr<LogEvent> CreateSyncStartEvent(uint64_t timestampNs,
// auto event = std::make_unique<LogEvent>(android::util::UID_PROCESS_STATE_CHANGED, timestampNs); const vector<int>& attributionUids,
// event->write(uid); const vector<string>& attributionTags,
// event->write(state); const string& name) {
// event->init(); return CreateSyncStateChangedEvent(timestampNs, attributionUids, attributionTags, name,
// return event; SyncStateChanged::ON);
//} }
std::unique_ptr<LogEvent> CreateSyncEndEvent(uint64_t timestampNs,
const vector<int>& attributionUids,
const vector<string>& attributionTags,
const string& name) {
return CreateSyncStateChangedEvent(timestampNs, attributionUids, attributionTags, name,
SyncStateChanged::OFF);
}
std::unique_ptr<LogEvent> CreateProcessLifeCycleStateChangedEvent(
uint64_t timestampNs, const int uid, const ProcessLifeCycleStateChanged::State state) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, android::util::PROCESS_LIFE_CYCLE_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, uid);
AStatsEvent_writeString(statsEvent, "");
AStatsEvent_writeInt32(statsEvent, state);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateAppCrashEvent(uint64_t timestampNs, const int uid) {
return CreateProcessLifeCycleStateChangedEvent(timestampNs, uid,
ProcessLifeCycleStateChanged::CRASHED);
}
std::unique_ptr<LogEvent> CreateAppCrashOccurredEvent(uint64_t timestampNs, const int uid) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, android::util::APP_CRASH_OCCURRED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, uid);
AStatsEvent_writeString(statsEvent, "eventType");
AStatsEvent_writeString(statsEvent, "processName");
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateIsolatedUidChangedEvent(uint64_t timestampNs, int hostUid,
int isolatedUid, bool is_create) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, android::util::ISOLATED_UID_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, hostUid);
AStatsEvent_writeInt32(statsEvent, isolatedUid);
AStatsEvent_writeInt32(statsEvent, is_create);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
std::unique_ptr<LogEvent> CreateUidProcessStateChangedEvent(
uint64_t timestampNs, int uid, const android::app::ProcessStateEnum state) {
AStatsEvent* statsEvent = AStatsEvent_obtain();
AStatsEvent_setAtomId(statsEvent, android::util::UID_PROCESS_STATE_CHANGED);
AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
AStatsEvent_writeInt32(statsEvent, uid);
AStatsEvent_writeInt32(statsEvent, state);
AStatsEvent_build(statsEvent);
size_t size;
uint8_t* buf = AStatsEvent_getBuffer(statsEvent, &size);
std::unique_ptr<LogEvent> logEvent = std::make_unique<LogEvent>(/*uid=*/0, /*pid=*/0);
logEvent->parseBuffer(buf, size);
AStatsEvent_release(statsEvent);
return logEvent;
}
sp<StatsLogProcessor> CreateStatsLogProcessor(const int64_t timeBaseNs, const int64_t currentTimeNs, sp<StatsLogProcessor> CreateStatsLogProcessor(const int64_t timeBaseNs, const int64_t currentTimeNs,
const StatsdConfig& config, const ConfigKey& key, const StatsdConfig& config, const ConfigKey& key,

42
cmds/statsd/tests/statsd_test_util.h
View File

@@ -166,11 +166,10 @@ FieldMatcher CreateAttributionUidDimensions(const int atomId,
// Create log event for screen state changed. // Create log event for screen state changed.
std::unique_ptr<LogEvent> CreateScreenStateChangedEvent( std::unique_ptr<LogEvent> CreateScreenStateChangedEvent(
const android::view::DisplayStateEnum state, uint64_t timestampNs); uint64_t timestampNs, const android::view::DisplayStateEnum state);
// Create log event for screen brightness state changed. // Create log event for screen brightness state changed.
std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent( std::unique_ptr<LogEvent> CreateScreenBrightnessChangedEvent(uint64_t timestampNs, int level);
int level, uint64_t timestampNs);
// Create log event when scheduled job starts. // Create log event when scheduled job starts.
std::unique_ptr<LogEvent> CreateStartScheduledJobEvent( std::unique_ptr<LogEvent> CreateStartScheduledJobEvent(
@@ -188,45 +187,42 @@ std::unique_ptr<LogEvent> CreateBatterySaverOnEvent(uint64_t timestampNs);
std::unique_ptr<LogEvent> CreateBatterySaverOffEvent(uint64_t timestampNs); std::unique_ptr<LogEvent> CreateBatterySaverOffEvent(uint64_t timestampNs);
// Create log event for app moving to background. // Create log event for app moving to background.
std::unique_ptr<LogEvent> CreateMoveToBackgroundEvent(const int uid, uint64_t timestampNs); std::unique_ptr<LogEvent> CreateMoveToBackgroundEvent(uint64_t timestampNs, const int uid);
// Create log event for app moving to foreground. // Create log event for app moving to foreground.
std::unique_ptr<LogEvent> CreateMoveToForegroundEvent(const int uid, uint64_t timestampNs); std::unique_ptr<LogEvent> CreateMoveToForegroundEvent(uint64_t timestampNs, const int uid);
// Create log event when the app sync starts. // Create log event when the app sync starts.
std::unique_ptr<LogEvent> CreateSyncStartEvent( std::unique_ptr<LogEvent> CreateSyncStartEvent(uint64_t timestampNs, const vector<int>& uids,
const std::vector<AttributionNodeInternal>& attributions, const string& name, const vector<string>& tags, const string& name);
uint64_t timestampNs);
// Create log event when the app sync ends. // Create log event when the app sync ends.
std::unique_ptr<LogEvent> CreateSyncEndEvent( std::unique_ptr<LogEvent> CreateSyncEndEvent(uint64_t timestampNs, const vector<int>& uids,
const std::vector<AttributionNodeInternal>& attributions, const string& name, const vector<string>& tags, const string& name);
uint64_t timestampNs);
// Create log event when the app sync ends. // Create log event when the app sync ends.
std::unique_ptr<LogEvent> CreateAppCrashEvent( std::unique_ptr<LogEvent> CreateAppCrashEvent(uint64_t timestampNs, const int uid);
const int uid, uint64_t timestampNs);
// Create log event for an app crash. // Create log event for an app crash.
std::unique_ptr<LogEvent> CreateAppCrashOccurredEvent(const int uid, uint64_t timestampNs); std::unique_ptr<LogEvent> CreateAppCrashOccurredEvent(uint64_t timestampNs, const int uid);
// Create log event for acquiring wakelock. // Create log event for acquiring wakelock.
std::unique_ptr<LogEvent> CreateAcquireWakelockEvent( std::unique_ptr<LogEvent> CreateAcquireWakelockEvent(uint64_t timestampNs, const vector<int>& uids,
const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName, const vector<string>& tags,
uint64_t timestampNs); const string& wakelockName);
// Create log event for releasing wakelock. // Create log event for releasing wakelock.
std::unique_ptr<LogEvent> CreateReleaseWakelockEvent( std::unique_ptr<LogEvent> CreateReleaseWakelockEvent(uint64_t timestampNs, const vector<int>& uids,
const std::vector<AttributionNodeInternal>& attributions, const string& wakelockName, const vector<string>& tags,
uint64_t timestampNs); const string& wakelockName);
// Create log event for releasing wakelock. // Create log event for releasing wakelock.
std::unique_ptr<LogEvent> CreateIsolatedUidChangedEvent( std::unique_ptr<LogEvent> CreateIsolatedUidChangedEvent(uint64_t timestampNs, int isolatedUid,
int isolatedUid, int hostUid, bool is_create, uint64_t timestampNs); int hostUid, bool is_create);
// Create log event for uid process state change. // Create log event for uid process state change.
std::unique_ptr<LogEvent> CreateUidProcessStateChangedEvent( std::unique_ptr<LogEvent> CreateUidProcessStateChangedEvent(
int uid, const android::app::ProcessStateEnum state, uint64_t timestampNs); uint64_t timestampNs, int uid, const android::app::ProcessStateEnum state);
// Helper function to create an AttributionNodeInternal proto. // Helper function to create an AttributionNodeInternal proto.
AttributionNodeInternal CreateAttribution(const int& uid, const string& tag); AttributionNodeInternal CreateAttribution(const int& uid, const string& tag);