| // Copyright (C) 2017 The Android Open Source Project |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "src/guardrail/StatsdStats.h" |
| |
| #include <gtest/gtest.h> |
| |
| #include <vector> |
| |
| #include "gtest_matchers.h" |
| #include "src/metrics/parsing_utils/metrics_manager_util.h" |
| #include "src/shell/ShellSubscriber.h" |
| #include "src/stats_log.pb.h" |
| #include "statslog_statsdtest.h" |
| #include "tests/statsd_test_util.h" |
| |
| #ifdef __ANDROID__ |
| |
| namespace std { |
| void PrintTo(const tuple<int, size_t>& atomIdDimensionLimitTuple, ostream* os) { |
| *os << get<0>(atomIdDimensionLimitTuple) << "_" << get<1>(atomIdDimensionLimitTuple); |
| } |
| } // namespace std |
| |
| namespace android { |
| namespace os { |
| namespace statsd { |
| namespace { |
| |
| using namespace testing; |
| using PerSubscriptionStats = StatsdStatsReport_SubscriptionStats_PerSubscriptionStats; |
| using std::tuple; |
| using std::unordered_map; |
| using std::vector; |
| |
| class StatsdStatsTest_GetAtomDimensionKeySizeLimit_InMap |
| : public TestWithParam<tuple<int, size_t>> {}; |
| INSTANTIATE_TEST_SUITE_P(StatsdStatsTest_GetAtomDimensionKeySizeLimit_InMap, |
| StatsdStatsTest_GetAtomDimensionKeySizeLimit_InMap, |
| Combine(Values(10022 /* BINDER_CALLS */, 10024 /* LOOPER_STATS */, |
| 10010 /* CPU_TIME_PER_UID_FREQ */), |
| Values(-1, 0, 500, 800, 1000, 3000, 3300)), |
| PrintToStringParamName()); |
| |
| class StatsdStatsTest_GetAtomDimensionKeySizeLimit_NotInMap |
| : public StatsdStatsTest_GetAtomDimensionKeySizeLimit_InMap {}; |
| |
| INSTANTIATE_TEST_SUITE_P(StatsdStatsTest_GetAtomDimensionKeySizeLimit_NotInMap, |
| StatsdStatsTest_GetAtomDimensionKeySizeLimit_NotInMap, |
| Combine(Values(util::TEST_ATOM_REPORTED, util::SCREEN_STATE_CHANGED, |
| util::SUBSYSTEM_SLEEP_STATE), |
| Values(-1, 0, 500, 800, 1000, 3000, 3300)), |
| PrintToStringParamName()); |
| |
| } // anonymous namespace |
| |
| TEST(StatsdStatsTest, TestValidConfigAdd) { |
| StatsdStats stats; |
| ConfigKey key(0, 12345); |
| const int metricsCount = 10; |
| const int conditionsCount = 20; |
| const int matchersCount = 30; |
| const int alertsCount = 10; |
| stats.noteConfigReceived(key, metricsCount, conditionsCount, matchersCount, alertsCount, {}, |
| nullopt /*valid config*/); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport = report.config_stats(0); |
| EXPECT_EQ(0, configReport.uid()); |
| EXPECT_EQ(12345, configReport.id()); |
| EXPECT_EQ(metricsCount, configReport.metric_count()); |
| EXPECT_EQ(conditionsCount, configReport.condition_count()); |
| EXPECT_EQ(matchersCount, configReport.matcher_count()); |
| EXPECT_EQ(alertsCount, configReport.alert_count()); |
| EXPECT_EQ(true, configReport.is_valid()); |
| EXPECT_FALSE(configReport.has_invalid_config_reason()); |
| EXPECT_FALSE(configReport.has_deletion_time_sec()); |
| } |
| |
| TEST(StatsdStatsTest, TestConfigMetadataProviderPromotionFailed) { |
| StatsdStats stats; |
| ConfigKey key(0, 12345); |
| stats.noteConfigReceived(key, /*metricsCount=*/0, /*conditionsCount=*/0, /*matchersCount=*/0, |
| /*alertCount=*/0, /*annotations=*/{}, nullopt /*valid config*/); |
| |
| stats.noteConfigMetadataProviderPromotionFailed(key); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport = report.config_stats(0); |
| EXPECT_EQ(1, configReport.config_metadata_provider_promotion_failed()); |
| } |
| |
| TEST(StatsdStatsTest, TestInvalidConfigAdd) { |
| StatsdStats stats; |
| ConfigKey key(0, 12345); |
| const int metricsCount = 10; |
| const int conditionsCount = 20; |
| const int matchersCount = 30; |
| const int alertsCount = 10; |
| optional<InvalidConfigReason> invalidConfigReason = |
| InvalidConfigReason(INVALID_CONFIG_REASON_UNKNOWN, 1); |
| invalidConfigReason->stateId = 2; |
| invalidConfigReason->alertId = 3; |
| invalidConfigReason->alarmId = 4; |
| invalidConfigReason->subscriptionId = 5; |
| invalidConfigReason->matcherIds.push_back(6); |
| invalidConfigReason->matcherIds.push_back(7); |
| invalidConfigReason->conditionIds.push_back(8); |
| invalidConfigReason->conditionIds.push_back(9); |
| invalidConfigReason->conditionIds.push_back(10); |
| stats.noteConfigReceived(key, metricsCount, conditionsCount, matchersCount, alertsCount, {}, |
| invalidConfigReason /*bad config*/); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport = report.config_stats(0); |
| // The invalid config should be put into icebox with a deletion time. |
| EXPECT_TRUE(configReport.has_deletion_time_sec()); |
| EXPECT_TRUE(configReport.has_invalid_config_reason()); |
| EXPECT_EQ(configReport.invalid_config_reason().reason(), INVALID_CONFIG_REASON_UNKNOWN); |
| EXPECT_EQ(configReport.invalid_config_reason().metric_id(), 1); |
| EXPECT_EQ(configReport.invalid_config_reason().state_id(), 2); |
| EXPECT_EQ(configReport.invalid_config_reason().alert_id(), 3); |
| EXPECT_EQ(configReport.invalid_config_reason().alarm_id(), 4); |
| EXPECT_EQ(configReport.invalid_config_reason().subscription_id(), 5); |
| EXPECT_EQ(configReport.invalid_config_reason().matcher_id_size(), 2); |
| EXPECT_EQ(configReport.invalid_config_reason().matcher_id(0), 6); |
| EXPECT_EQ(configReport.invalid_config_reason().matcher_id(1), 7); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id_size(), 3); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id(0), 8); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id(1), 9); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id(2), 10); |
| } |
| |
| TEST(StatsdStatsTest, TestInvalidConfigMissingMetricId) { |
| StatsdStats stats; |
| ConfigKey key(0, 12345); |
| const int metricsCount = 10; |
| const int conditionsCount = 20; |
| const int matchersCount = 30; |
| const int alertsCount = 10; |
| optional<InvalidConfigReason> invalidConfigReason = |
| InvalidConfigReason(INVALID_CONFIG_REASON_SUBSCRIPTION_SUBSCRIBER_INFO_MISSING); |
| invalidConfigReason->stateId = 1; |
| invalidConfigReason->alertId = 2; |
| invalidConfigReason->alarmId = 3; |
| invalidConfigReason->subscriptionId = 4; |
| invalidConfigReason->matcherIds.push_back(5); |
| invalidConfigReason->conditionIds.push_back(6); |
| invalidConfigReason->conditionIds.push_back(7); |
| stats.noteConfigReceived(key, metricsCount, conditionsCount, matchersCount, alertsCount, {}, |
| invalidConfigReason /*bad config*/); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport = report.config_stats(0); |
| // The invalid config should be put into icebox with a deletion time. |
| EXPECT_TRUE(configReport.has_deletion_time_sec()); |
| EXPECT_TRUE(configReport.has_invalid_config_reason()); |
| EXPECT_EQ(configReport.invalid_config_reason().reason(), |
| INVALID_CONFIG_REASON_SUBSCRIPTION_SUBSCRIBER_INFO_MISSING); |
| EXPECT_FALSE(configReport.invalid_config_reason().has_metric_id()); |
| EXPECT_EQ(configReport.invalid_config_reason().state_id(), 1); |
| EXPECT_EQ(configReport.invalid_config_reason().alert_id(), 2); |
| EXPECT_EQ(configReport.invalid_config_reason().alarm_id(), 3); |
| EXPECT_EQ(configReport.invalid_config_reason().subscription_id(), 4); |
| EXPECT_EQ(configReport.invalid_config_reason().matcher_id_size(), 1); |
| EXPECT_EQ(configReport.invalid_config_reason().matcher_id(0), 5); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id_size(), 2); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id(0), 6); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id(1), 7); |
| } |
| |
| TEST(StatsdStatsTest, TestInvalidConfigOnlyMetricId) { |
| StatsdStats stats; |
| ConfigKey key(0, 12345); |
| const int metricsCount = 10; |
| const int conditionsCount = 20; |
| const int matchersCount = 30; |
| const int alertsCount = 10; |
| optional<InvalidConfigReason> invalidConfigReason = |
| InvalidConfigReason(INVALID_CONFIG_REASON_METRIC_NOT_IN_PREV_CONFIG, 1); |
| stats.noteConfigReceived(key, metricsCount, conditionsCount, matchersCount, alertsCount, {}, |
| invalidConfigReason /*bad config*/); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport = report.config_stats(0); |
| // The invalid config should be put into icebox with a deletion time. |
| EXPECT_TRUE(configReport.has_deletion_time_sec()); |
| EXPECT_TRUE(configReport.has_invalid_config_reason()); |
| EXPECT_EQ(configReport.invalid_config_reason().reason(), |
| INVALID_CONFIG_REASON_METRIC_NOT_IN_PREV_CONFIG); |
| EXPECT_EQ(configReport.invalid_config_reason().metric_id(), 1); |
| EXPECT_FALSE(configReport.invalid_config_reason().has_state_id()); |
| EXPECT_FALSE(configReport.invalid_config_reason().has_alert_id()); |
| EXPECT_FALSE(configReport.invalid_config_reason().has_alarm_id()); |
| EXPECT_FALSE(configReport.invalid_config_reason().has_subscription_id()); |
| EXPECT_EQ(configReport.invalid_config_reason().matcher_id_size(), 0); |
| EXPECT_EQ(configReport.invalid_config_reason().condition_id_size(), 0); |
| } |
| |
| TEST(StatsdStatsTest, TestConfigRemove) { |
| StatsdStats stats; |
| ConfigKey key(0, 12345); |
| const int metricsCount = 10; |
| const int conditionsCount = 20; |
| const int matchersCount = 30; |
| const int alertsCount = 10; |
| stats.noteConfigReceived(key, metricsCount, conditionsCount, matchersCount, alertsCount, {}, |
| nullopt); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport = report.config_stats(0); |
| EXPECT_FALSE(configReport.has_deletion_time_sec()); |
| |
| stats.noteConfigRemoved(key); |
| |
| report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport2 = report.config_stats(0); |
| EXPECT_TRUE(configReport2.has_deletion_time_sec()); |
| } |
| |
| TEST(StatsdStatsTest, TestSubStats) { |
| StatsdStats stats; |
| ConfigKey key(0, 12345); |
| stats.noteConfigReceived(key, 2, 3, 4, 5, {std::make_pair(123, 456)}, nullopt); |
| |
| stats.noteMatcherMatched(key, StringToId("matcher1")); |
| stats.noteMatcherMatched(key, StringToId("matcher1")); |
| stats.noteMatcherMatched(key, StringToId("matcher2")); |
| |
| stats.noteConditionDimensionSize(key, StringToId("condition1"), 250); |
| stats.noteConditionDimensionSize(key, StringToId("condition1"), 240); |
| |
| stats.noteMetricDimensionSize(key, StringToId("metric1"), 201); |
| stats.noteMetricDimensionSize(key, StringToId("metric1"), 202); |
| |
| stats.noteAnomalyDeclared(key, StringToId("alert1")); |
| stats.noteAnomalyDeclared(key, StringToId("alert1")); |
| stats.noteAnomalyDeclared(key, StringToId("alert2")); |
| |
| // broadcast-> 2 |
| stats.noteBroadcastSent(key); |
| stats.noteBroadcastSent(key); |
| |
| // data drop -> 1 |
| stats.noteDataDropped(key, 123); |
| |
| // dump report -> 3 |
| stats.noteMetricsReportSent(key, 0, 1); |
| stats.noteMetricsReportSent(key, 0, 2); |
| stats.noteMetricsReportSent(key, 0, 3); |
| |
| // activation_time_sec -> 2 |
| stats.noteActiveStatusChanged(key, true); |
| stats.noteActiveStatusChanged(key, true); |
| |
| // deactivation_time_sec -> 1 |
| stats.noteActiveStatusChanged(key, false); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ true); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport = report.config_stats(0); |
| ASSERT_EQ(2, configReport.broadcast_sent_time_sec_size()); |
| ASSERT_EQ(1, configReport.data_drop_time_sec_size()); |
| ASSERT_EQ(1, configReport.data_drop_bytes_size()); |
| EXPECT_EQ(123, configReport.data_drop_bytes(0)); |
| ASSERT_EQ(3, configReport.dump_report_time_sec_size()); |
| ASSERT_EQ(3, configReport.dump_report_data_size_size()); |
| ASSERT_EQ(3, configReport.dump_report_number_size()); |
| EXPECT_EQ(1, configReport.dump_report_number(0)); |
| EXPECT_EQ(2, configReport.dump_report_number(1)); |
| EXPECT_EQ(3, configReport.dump_report_number(2)); |
| ASSERT_EQ(2, configReport.activation_time_sec_size()); |
| ASSERT_EQ(1, configReport.deactivation_time_sec_size()); |
| ASSERT_EQ(1, configReport.annotation_size()); |
| EXPECT_EQ(123, configReport.annotation(0).field_int64()); |
| EXPECT_EQ(456, configReport.annotation(0).field_int32()); |
| |
| ASSERT_EQ(2, configReport.matcher_stats_size()); |
| // matcher1 is the first in the list |
| if (configReport.matcher_stats(0).id() == StringToId("matcher1")) { |
| EXPECT_EQ(2, configReport.matcher_stats(0).matched_times()); |
| EXPECT_EQ(1, configReport.matcher_stats(1).matched_times()); |
| EXPECT_EQ(StringToId("matcher2"), configReport.matcher_stats(1).id()); |
| } else { |
| // matcher1 is the second in the list. |
| EXPECT_EQ(1, configReport.matcher_stats(0).matched_times()); |
| EXPECT_EQ(StringToId("matcher2"), configReport.matcher_stats(0).id()); |
| |
| EXPECT_EQ(2, configReport.matcher_stats(1).matched_times()); |
| EXPECT_EQ(StringToId("matcher1"), configReport.matcher_stats(1).id()); |
| } |
| |
| ASSERT_EQ(2, configReport.alert_stats_size()); |
| bool alert1first = configReport.alert_stats(0).id() == StringToId("alert1"); |
| EXPECT_EQ(StringToId("alert1"), configReport.alert_stats(alert1first ? 0 : 1).id()); |
| EXPECT_EQ(2, configReport.alert_stats(alert1first ? 0 : 1).alerted_times()); |
| EXPECT_EQ(StringToId("alert2"), configReport.alert_stats(alert1first ? 1 : 0).id()); |
| EXPECT_EQ(1, configReport.alert_stats(alert1first ? 1 : 0).alerted_times()); |
| |
| ASSERT_EQ(1, configReport.condition_stats_size()); |
| EXPECT_EQ(StringToId("condition1"), configReport.condition_stats(0).id()); |
| EXPECT_EQ(250, configReport.condition_stats(0).max_tuple_counts()); |
| |
| ASSERT_EQ(1, configReport.metric_stats_size()); |
| EXPECT_EQ(StringToId("metric1"), configReport.metric_stats(0).id()); |
| EXPECT_EQ(202, configReport.metric_stats(0).max_tuple_counts()); |
| |
| // after resetting the stats, some new events come |
| stats.noteMatcherMatched(key, StringToId("matcher99")); |
| stats.noteConditionDimensionSize(key, StringToId("condition99"), 300); |
| stats.noteMetricDimensionSize(key, StringToId("metric99tion99"), 270); |
| stats.noteAnomalyDeclared(key, StringToId("alert99")); |
| |
| // now the config stats should only contain the stats about the new event. |
| report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.config_stats_size()); |
| const auto& configReport2 = report.config_stats(0); |
| ASSERT_EQ(1, configReport2.matcher_stats_size()); |
| EXPECT_EQ(StringToId("matcher99"), configReport2.matcher_stats(0).id()); |
| EXPECT_EQ(1, configReport2.matcher_stats(0).matched_times()); |
| |
| ASSERT_EQ(1, configReport2.condition_stats_size()); |
| EXPECT_EQ(StringToId("condition99"), configReport2.condition_stats(0).id()); |
| EXPECT_EQ(300, configReport2.condition_stats(0).max_tuple_counts()); |
| |
| ASSERT_EQ(1, configReport2.metric_stats_size()); |
| EXPECT_EQ(StringToId("metric99tion99"), configReport2.metric_stats(0).id()); |
| EXPECT_EQ(270, configReport2.metric_stats(0).max_tuple_counts()); |
| |
| ASSERT_EQ(1, configReport2.alert_stats_size()); |
| EXPECT_EQ(StringToId("alert99"), configReport2.alert_stats(0).id()); |
| EXPECT_EQ(1, configReport2.alert_stats(0).alerted_times()); |
| } |
| |
| TEST(StatsdStatsTest, TestAtomLog) { |
| StatsdStats stats; |
| time_t now = time(nullptr); |
| // old event, we get it from the stats buffer. should be ignored. |
| stats.noteAtomLogged(util::SENSOR_STATE_CHANGED, 1000, false); |
| |
| stats.noteAtomLogged(util::SENSOR_STATE_CHANGED, now + 1, false); |
| stats.noteAtomLogged(util::SENSOR_STATE_CHANGED, now + 2, false); |
| stats.noteAtomLogged(util::APP_CRASH_OCCURRED, now + 3, false); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(2, report.atom_stats_size()); |
| bool sensorAtomGood = false; |
| bool dropboxAtomGood = false; |
| |
| for (const auto& atomStats : report.atom_stats()) { |
| if (atomStats.tag() == util::SENSOR_STATE_CHANGED && atomStats.count() == 3) { |
| sensorAtomGood = true; |
| } |
| if (atomStats.tag() == util::APP_CRASH_OCCURRED && atomStats.count() == 1) { |
| dropboxAtomGood = true; |
| } |
| EXPECT_FALSE(atomStats.has_dropped_count()); |
| EXPECT_FALSE(atomStats.has_skip_count()); |
| } |
| |
| EXPECT_TRUE(dropboxAtomGood); |
| EXPECT_TRUE(sensorAtomGood); |
| } |
| |
| TEST(StatsdStatsTest, TestNonPlatformAtomLog) { |
| StatsdStats stats; |
| time_t now = time(nullptr); |
| int newAtom1 = StatsdStats::kMaxPushedAtomId + 1; |
| int newAtom2 = StatsdStats::kMaxPushedAtomId + 2; |
| |
| stats.noteAtomLogged(newAtom1, now + 1, false); |
| stats.noteAtomLogged(newAtom1, now + 2, false); |
| stats.noteAtomLogged(newAtom2, now + 3, false); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(2, report.atom_stats_size()); |
| bool newAtom1Good = false; |
| bool newAtom2Good = false; |
| |
| for (const auto& atomStats : report.atom_stats()) { |
| if (atomStats.tag() == newAtom1 && atomStats.count() == 2) { |
| newAtom1Good = true; |
| } |
| if (atomStats.tag() == newAtom2 && atomStats.count() == 1) { |
| newAtom2Good = true; |
| } |
| EXPECT_FALSE(atomStats.has_dropped_count()); |
| EXPECT_FALSE(atomStats.has_skip_count()); |
| } |
| |
| EXPECT_TRUE(newAtom1Good); |
| EXPECT_TRUE(newAtom2Good); |
| } |
| |
| TEST(StatsdStatsTest, TestPullAtomStats) { |
| StatsdStats stats; |
| |
| stats.updateMinPullIntervalSec(util::DISK_SPACE, 3333L); |
| stats.updateMinPullIntervalSec(util::DISK_SPACE, 2222L); |
| stats.updateMinPullIntervalSec(util::DISK_SPACE, 4444L); |
| |
| stats.notePull(util::DISK_SPACE); |
| stats.notePullTime(util::DISK_SPACE, 1111L); |
| stats.notePullDelay(util::DISK_SPACE, 1111L); |
| stats.notePull(util::DISK_SPACE); |
| stats.notePullTime(util::DISK_SPACE, 3333L); |
| stats.notePullDelay(util::DISK_SPACE, 3335L); |
| stats.notePull(util::DISK_SPACE); |
| stats.notePullFromCache(util::DISK_SPACE); |
| stats.notePullerCallbackRegistrationChanged(util::DISK_SPACE, true); |
| stats.notePullerCallbackRegistrationChanged(util::DISK_SPACE, false); |
| stats.notePullerCallbackRegistrationChanged(util::DISK_SPACE, true); |
| stats.notePullBinderCallFailed(util::DISK_SPACE); |
| stats.notePullUidProviderNotFound(util::DISK_SPACE); |
| stats.notePullerNotFound(util::DISK_SPACE); |
| stats.notePullerNotFound(util::DISK_SPACE); |
| stats.notePullTimeout(util::DISK_SPACE, 3000L, 6000L); |
| stats.notePullTimeout(util::DISK_SPACE, 4000L, 7000L); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(1, report.pulled_atom_stats_size()); |
| |
| EXPECT_EQ(util::DISK_SPACE, report.pulled_atom_stats(0).atom_id()); |
| EXPECT_EQ(3, report.pulled_atom_stats(0).total_pull()); |
| EXPECT_EQ(1, report.pulled_atom_stats(0).total_pull_from_cache()); |
| EXPECT_EQ(2222L, report.pulled_atom_stats(0).min_pull_interval_sec()); |
| EXPECT_EQ(2222L, report.pulled_atom_stats(0).average_pull_time_nanos()); |
| EXPECT_EQ(3333L, report.pulled_atom_stats(0).max_pull_time_nanos()); |
| EXPECT_EQ(2223L, report.pulled_atom_stats(0).average_pull_delay_nanos()); |
| EXPECT_EQ(3335L, report.pulled_atom_stats(0).max_pull_delay_nanos()); |
| EXPECT_EQ(2L, report.pulled_atom_stats(0).registered_count()); |
| EXPECT_EQ(1L, report.pulled_atom_stats(0).unregistered_count()); |
| EXPECT_EQ(1L, report.pulled_atom_stats(0).binder_call_failed()); |
| EXPECT_EQ(1L, report.pulled_atom_stats(0).failed_uid_provider_not_found()); |
| EXPECT_EQ(2L, report.pulled_atom_stats(0).puller_not_found()); |
| ASSERT_EQ(2, report.pulled_atom_stats(0).pull_atom_metadata_size()); |
| EXPECT_EQ(3000L, report.pulled_atom_stats(0).pull_atom_metadata(0).pull_timeout_uptime_millis()); |
| EXPECT_EQ(4000L, report.pulled_atom_stats(0).pull_atom_metadata(1).pull_timeout_uptime_millis()); |
| EXPECT_EQ(6000L, report.pulled_atom_stats(0).pull_atom_metadata(0) |
| .pull_timeout_elapsed_millis()); |
| EXPECT_EQ(7000L, report.pulled_atom_stats(0).pull_atom_metadata(1) |
| .pull_timeout_elapsed_millis()); |
| } |
| |
| TEST(StatsdStatsTest, TestAtomMetricsStats) { |
| StatsdStats stats; |
| time_t now = time(nullptr); |
| // old event, we get it from the stats buffer. should be ignored. |
| stats.noteBucketDropped(10000000000LL); |
| |
| stats.noteBucketBoundaryDelayNs(10000000000LL, -1L); |
| stats.noteBucketBoundaryDelayNs(10000000000LL, -10L); |
| stats.noteBucketBoundaryDelayNs(10000000000LL, 2L); |
| |
| stats.noteBucketBoundaryDelayNs(10000000001LL, 1L); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(2, report.atom_metric_stats().size()); |
| |
| auto atomStats = report.atom_metric_stats(0); |
| EXPECT_EQ(10000000000LL, atomStats.metric_id()); |
| EXPECT_EQ(1L, atomStats.bucket_dropped()); |
| EXPECT_EQ(-10L, atomStats.min_bucket_boundary_delay_ns()); |
| EXPECT_EQ(2L, atomStats.max_bucket_boundary_delay_ns()); |
| |
| auto atomStats2 = report.atom_metric_stats(1); |
| EXPECT_EQ(10000000001LL, atomStats2.metric_id()); |
| EXPECT_EQ(0L, atomStats2.bucket_dropped()); |
| EXPECT_EQ(0L, atomStats2.min_bucket_boundary_delay_ns()); |
| EXPECT_EQ(1L, atomStats2.max_bucket_boundary_delay_ns()); |
| } |
| |
| TEST(StatsdStatsTest, TestRestrictedMetricsStats) { |
| StatsdStats stats; |
| const int64_t metricId = -1234556L; |
| ConfigKey key(0, 12345); |
| stats.noteConfigReceived(key, 2, 3, 4, 5, {}, nullopt); |
| stats.noteRestrictedMetricInsertError(key, metricId); |
| stats.noteRestrictedMetricTableCreationError(key, metricId); |
| stats.noteRestrictedMetricTableDeletionError(key, metricId); |
| stats.noteDeviceInfoTableCreationFailed(key); |
| stats.noteRestrictedMetricFlushLatency(key, metricId, 3000); |
| stats.noteRestrictedMetricFlushLatency(key, metricId, 3001); |
| stats.noteRestrictedMetricCategoryChanged(key, metricId); |
| stats.noteRestrictedConfigFlushLatency(key, 4000); |
| ConfigKey configKeyWithoutError(0, 666); |
| stats.noteConfigReceived(configKeyWithoutError, 2, 3, 4, 5, {}, nullopt); |
| stats.noteDbCorrupted(key); |
| stats.noteDbCorrupted(key); |
| stats.noteDbSizeExceeded(key); |
| stats.noteDbStatFailed(key); |
| stats.noteDbConfigInvalid(key); |
| stats.noteDbTooOld(key); |
| stats.noteDbDeletionConfigRemoved(key); |
| stats.noteDbDeletionConfigUpdated(key); |
| stats.noteRestrictedConfigDbSize(key, 999, 111); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(2, report.config_stats().size()); |
| ASSERT_EQ(0, report.config_stats(0).restricted_metric_stats().size()); |
| ASSERT_EQ(1, report.config_stats(1).restricted_metric_stats().size()); |
| EXPECT_EQ(1, report.config_stats(1).restricted_metric_stats(0).insert_error()); |
| EXPECT_EQ(1, report.config_stats(1).restricted_metric_stats(0).table_creation_error()); |
| EXPECT_EQ(1, report.config_stats(1).restricted_metric_stats(0).table_deletion_error()); |
| EXPECT_EQ(1, report.config_stats(1).restricted_metric_stats(0).category_changed_count()); |
| ASSERT_EQ(2, report.config_stats(1).restricted_metric_stats(0).flush_latency_ns().size()); |
| EXPECT_EQ(3000, report.config_stats(1).restricted_metric_stats(0).flush_latency_ns(0)); |
| EXPECT_EQ(3001, report.config_stats(1).restricted_metric_stats(0).flush_latency_ns(1)); |
| ASSERT_EQ(1, report.config_stats(1).restricted_db_size_time_sec().size()); |
| EXPECT_EQ(999, report.config_stats(1).restricted_db_size_time_sec(0)); |
| ASSERT_EQ(1, report.config_stats(1).restricted_db_size_bytes().size()); |
| EXPECT_EQ(111, report.config_stats(1).restricted_db_size_bytes(0)); |
| ASSERT_EQ(1, report.config_stats(1).restricted_flush_latency().size()); |
| EXPECT_EQ(4000, report.config_stats(1).restricted_flush_latency(0)); |
| EXPECT_TRUE(report.config_stats(1).device_info_table_creation_failed()); |
| EXPECT_EQ(metricId, report.config_stats(1).restricted_metric_stats(0).restricted_metric_id()); |
| EXPECT_EQ(2, report.config_stats(1).restricted_db_corrupted_count()); |
| EXPECT_EQ(1, report.config_stats(1).db_deletion_stat_failed()); |
| EXPECT_EQ(1, report.config_stats(1).db_deletion_size_exceeded_limit()); |
| EXPECT_EQ(1, report.config_stats(1).db_deletion_config_invalid()); |
| EXPECT_EQ(1, report.config_stats(1).db_deletion_too_old()); |
| EXPECT_EQ(1, report.config_stats(1).db_deletion_config_removed()); |
| EXPECT_EQ(1, report.config_stats(1).db_deletion_config_updated()); |
| } |
| |
| TEST(StatsdStatsTest, TestRestrictedMetricsQueryStats) { |
| StatsdStats stats; |
| const int32_t callingUid = 100; |
| ConfigKey configKey(0, 12345); |
| const string configPackage = "com.google.android.gm"; |
| int64_t beforeNoteMetricSucceed = getWallClockNs(); |
| stats.noteQueryRestrictedMetricSucceed(configKey.GetId(), configPackage, configKey.GetUid(), |
| callingUid, /*queryLatencyNs=*/5 * NS_PER_SEC); |
| int64_t afterNoteMetricSucceed = getWallClockNs(); |
| |
| const int64_t configIdWithError = 111; |
| stats.noteQueryRestrictedMetricFailed(configIdWithError, configPackage, std::nullopt, |
| callingUid, InvalidQueryReason(AMBIGUOUS_CONFIG_KEY)); |
| stats.noteQueryRestrictedMetricFailed(configIdWithError, configPackage, std::nullopt, |
| callingUid, InvalidQueryReason(AMBIGUOUS_CONFIG_KEY), |
| "error_message"); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(3, report.restricted_metric_query_stats().size()); |
| EXPECT_EQ(configKey.GetId(), report.restricted_metric_query_stats(0).config_id()); |
| EXPECT_EQ(configKey.GetUid(), report.restricted_metric_query_stats(0).config_uid()); |
| EXPECT_EQ(callingUid, report.restricted_metric_query_stats(0).calling_uid()); |
| EXPECT_EQ(configPackage, report.restricted_metric_query_stats(0).config_package()); |
| EXPECT_FALSE(report.restricted_metric_query_stats(0).has_query_error()); |
| EXPECT_LT(beforeNoteMetricSucceed, |
| report.restricted_metric_query_stats(0).query_wall_time_ns()); |
| EXPECT_GT(afterNoteMetricSucceed, report.restricted_metric_query_stats(0).query_wall_time_ns()); |
| EXPECT_EQ(5 * NS_PER_SEC, report.restricted_metric_query_stats(0).query_latency_ns()); |
| EXPECT_EQ(configIdWithError, report.restricted_metric_query_stats(1).config_id()); |
| EXPECT_EQ(AMBIGUOUS_CONFIG_KEY, report.restricted_metric_query_stats(1).invalid_query_reason()); |
| EXPECT_EQ(false, report.restricted_metric_query_stats(1).has_config_uid()); |
| EXPECT_FALSE(report.restricted_metric_query_stats(1).has_query_error()); |
| EXPECT_FALSE(report.restricted_metric_query_stats(1).has_query_latency_ns()); |
| EXPECT_EQ("error_message", report.restricted_metric_query_stats(2).query_error()); |
| EXPECT_FALSE(report.restricted_metric_query_stats(2).has_query_latency_ns()); |
| EXPECT_NE(report.restricted_metric_query_stats(1).query_wall_time_ns(), |
| report.restricted_metric_query_stats(0).query_wall_time_ns()); |
| } |
| |
| TEST(StatsdStatsTest, TestAnomalyMonitor) { |
| StatsdStats stats; |
| stats.noteRegisteredAnomalyAlarmChanged(); |
| stats.noteRegisteredAnomalyAlarmChanged(); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| EXPECT_EQ(2, report.anomaly_alarm_stats().alarms_registered()); |
| } |
| |
| TEST(StatsdStatsTest, TestTimestampThreshold) { |
| StatsdStats stats; |
| vector<int32_t> timestamps; |
| for (int i = 0; i < StatsdStats::kMaxTimestampCount; i++) { |
| timestamps.push_back(i); |
| } |
| ConfigKey key(0, 12345); |
| stats.noteConfigReceived(key, 2, 3, 4, 5, {}, nullopt); |
| |
| for (int i = 0; i < StatsdStats::kMaxTimestampCount; i++) { |
| stats.noteDataDropped(key, timestamps[i]); |
| stats.noteBroadcastSent(key, timestamps[i]); |
| stats.noteMetricsReportSent(key, 0, timestamps[i], i + 1); |
| stats.noteActiveStatusChanged(key, true, timestamps[i]); |
| stats.noteActiveStatusChanged(key, false, timestamps[i]); |
| } |
| |
| int32_t newTimestamp = 10000; |
| |
| // now it should trigger removing oldest timestamp |
| stats.noteDataDropped(key, 123, 10000); |
| stats.noteBroadcastSent(key, 10000); |
| stats.noteMetricsReportSent(key, 0, 10000, 21); |
| stats.noteActiveStatusChanged(key, true, 10000); |
| stats.noteActiveStatusChanged(key, false, 10000); |
| |
| EXPECT_TRUE(stats.mConfigStats.find(key) != stats.mConfigStats.end()); |
| const auto& configStats = stats.mConfigStats[key]; |
| |
| size_t maxCount = StatsdStats::kMaxTimestampCount; |
| ASSERT_EQ(maxCount, configStats->broadcast_sent_time_sec.size()); |
| ASSERT_EQ(maxCount, configStats->data_drop_time_sec.size()); |
| ASSERT_EQ(maxCount, configStats->dump_report_stats.size()); |
| ASSERT_EQ(maxCount, configStats->activation_time_sec.size()); |
| ASSERT_EQ(maxCount, configStats->deactivation_time_sec.size()); |
| |
| // the oldest timestamp is the second timestamp in history |
| EXPECT_EQ(1, configStats->broadcast_sent_time_sec.front()); |
| EXPECT_EQ(1, configStats->data_drop_bytes.front()); |
| EXPECT_EQ(1, configStats->dump_report_stats.front().mDumpReportTimeSec); |
| EXPECT_EQ(1, configStats->activation_time_sec.front()); |
| EXPECT_EQ(1, configStats->deactivation_time_sec.front()); |
| |
| // the last timestamp is the newest timestamp. |
| EXPECT_EQ(newTimestamp, configStats->broadcast_sent_time_sec.back()); |
| EXPECT_EQ(newTimestamp, configStats->data_drop_time_sec.back()); |
| EXPECT_EQ(123, configStats->data_drop_bytes.back()); |
| EXPECT_EQ(newTimestamp, configStats->dump_report_stats.back().mDumpReportTimeSec); |
| EXPECT_EQ(newTimestamp, configStats->activation_time_sec.back()); |
| EXPECT_EQ(newTimestamp, configStats->deactivation_time_sec.back()); |
| } |
| |
| TEST(StatsdStatsTest, TestSystemServerCrash) { |
| StatsdStats stats; |
| vector<int32_t> timestamps; |
| for (int i = 0; i < StatsdStats::kMaxSystemServerRestarts; i++) { |
| timestamps.push_back(i); |
| stats.noteSystemServerRestart(timestamps[i]); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| const int maxCount = StatsdStats::kMaxSystemServerRestarts; |
| ASSERT_EQ(maxCount, (int)report.system_restart_sec_size()); |
| |
| stats.noteSystemServerRestart(StatsdStats::kMaxSystemServerRestarts + 1); |
| |
| report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(maxCount, (int)report.system_restart_sec_size()); |
| EXPECT_EQ(StatsdStats::kMaxSystemServerRestarts + 1, report.system_restart_sec(maxCount - 1)); |
| } |
| |
| TEST(StatsdStatsTest, TestActivationBroadcastGuardrailHit) { |
| StatsdStats stats; |
| int uid1 = 1; |
| int uid2 = 2; |
| stats.noteActivationBroadcastGuardrailHit(uid1, 10); |
| stats.noteActivationBroadcastGuardrailHit(uid1, 20); |
| |
| // Test that we only keep 20 timestamps. |
| for (int i = 0; i < 100; i++) { |
| stats.noteActivationBroadcastGuardrailHit(uid2, i); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| ASSERT_EQ(2, report.activation_guardrail_stats_size()); |
| bool uid1Good = false; |
| bool uid2Good = false; |
| for (const auto& guardrailTimes : report.activation_guardrail_stats()) { |
| if (uid1 == guardrailTimes.uid()) { |
| uid1Good = true; |
| ASSERT_EQ(2, guardrailTimes.guardrail_met_sec_size()); |
| EXPECT_EQ(10, guardrailTimes.guardrail_met_sec(0)); |
| EXPECT_EQ(20, guardrailTimes.guardrail_met_sec(1)); |
| } else if (uid2 == guardrailTimes.uid()) { |
| int maxCount = StatsdStats::kMaxTimestampCount; |
| uid2Good = true; |
| ASSERT_EQ(maxCount, guardrailTimes.guardrail_met_sec_size()); |
| for (int i = 0; i < maxCount; i++) { |
| EXPECT_EQ(100 - maxCount + i, guardrailTimes.guardrail_met_sec(i)); |
| } |
| } else { |
| FAIL() << "Unexpected uid."; |
| } |
| } |
| EXPECT_TRUE(uid1Good); |
| EXPECT_TRUE(uid2Good); |
| } |
| |
| TEST(StatsdStatsTest, TestAtomErrorStats) { |
| StatsdStats stats; |
| |
| int pushAtomTag = 100; |
| int pullAtomTag = 1000; |
| int numErrors = 10; |
| |
| for (int i = 0; i < numErrors; i++) { |
| // We must call noteAtomLogged as well because only those pushed atoms |
| // that have been logged will have stats printed about them in the |
| // proto. |
| stats.noteAtomLogged(pushAtomTag, /*timeSec=*/0, false); |
| stats.noteAtomError(pushAtomTag, /*pull=*/false); |
| |
| stats.noteAtomError(pullAtomTag, /*pull=*/true); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| // Check error count = numErrors for push atom |
| ASSERT_EQ(1, report.atom_stats_size()); |
| const auto& pushedAtomStats = report.atom_stats(0); |
| EXPECT_EQ(pushAtomTag, pushedAtomStats.tag()); |
| EXPECT_EQ(numErrors, pushedAtomStats.error_count()); |
| EXPECT_FALSE(pushedAtomStats.has_dropped_count()); |
| EXPECT_FALSE(pushedAtomStats.has_skip_count()); |
| |
| // Check error count = numErrors for pull atom |
| ASSERT_EQ(1, report.pulled_atom_stats_size()); |
| const auto& pulledAtomStats = report.pulled_atom_stats(0); |
| EXPECT_EQ(pullAtomTag, pulledAtomStats.atom_id()); |
| EXPECT_EQ(numErrors, pulledAtomStats.atom_error_count()); |
| } |
| |
| TEST(StatsdStatsTest, TestAtomDroppedStats) { |
| StatsdStats stats; |
| |
| const int pushAtomTag = 100; |
| const int nonPlatformPushAtomTag = StatsdStats::kMaxPushedAtomId + 100; |
| |
| const int numDropped = 10; |
| for (int i = 0; i < numDropped; i++) { |
| stats.noteEventQueueOverflow(/*oldestEventTimestampNs*/ 0, pushAtomTag, false); |
| stats.noteEventQueueOverflow(/*oldestEventTimestampNs*/ 0, nonPlatformPushAtomTag, false); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ true); |
| |
| ASSERT_EQ(0, stats.mPushedAtomDropsStats.size()); |
| |
| // Check dropped_count = numDropped for push atoms |
| ASSERT_EQ(2, report.atom_stats_size()); |
| |
| const auto& pushedAtomStats = report.atom_stats(0); |
| EXPECT_EQ(pushAtomTag, pushedAtomStats.tag()); |
| EXPECT_EQ(numDropped, pushedAtomStats.count()); |
| EXPECT_EQ(numDropped, pushedAtomStats.dropped_count()); |
| EXPECT_FALSE(pushedAtomStats.has_error_count()); |
| EXPECT_FALSE(pushedAtomStats.has_skip_count()); |
| |
| const auto& nonPlatformPushedAtomStats = report.atom_stats(1); |
| EXPECT_EQ(nonPlatformPushAtomTag, nonPlatformPushedAtomStats.tag()); |
| EXPECT_EQ(numDropped, nonPlatformPushedAtomStats.count()); |
| EXPECT_EQ(numDropped, nonPlatformPushedAtomStats.dropped_count()); |
| EXPECT_FALSE(nonPlatformPushedAtomStats.has_error_count()); |
| EXPECT_FALSE(nonPlatformPushedAtomStats.has_skip_count()); |
| } |
| |
| TEST(StatsdStatsTest, TestQueueStats) { |
| StatsdStats stats; |
| |
| stats.noteEventQueueSize(100, 1000); |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ true); |
| |
| ASSERT_EQ(100, report.event_queue_stats().max_size_observed()); |
| ASSERT_EQ(1000, report.event_queue_stats().max_size_observed_elapsed_nanos()); |
| } |
| |
| TEST(StatsdStatsTest, TestAtomLoggedAndDroppedStats) { |
| StatsdStats stats; |
| |
| const int pushAtomTag = 100; |
| const int nonPlatformPushAtomTag = StatsdStats::kMaxPushedAtomId + 100; |
| |
| const int numLogged = 10; |
| for (int i = 0; i < numLogged; i++) { |
| stats.noteAtomLogged(pushAtomTag, /*timeSec*/ 0, false); |
| stats.noteAtomLogged(nonPlatformPushAtomTag, /*timeSec*/ 0, false); |
| } |
| |
| const int numDropped = 10; |
| for (int i = 0; i < numDropped; i++) { |
| stats.noteEventQueueOverflow(/*oldestEventTimestampNs*/ 0, pushAtomTag, false); |
| stats.noteEventQueueOverflow(/*oldestEventTimestampNs*/ 0, nonPlatformPushAtomTag, false); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| // Check dropped_count = numDropped for push atoms |
| ASSERT_EQ(2, report.atom_stats_size()); |
| |
| const auto& pushedAtomStats = report.atom_stats(0); |
| EXPECT_EQ(pushAtomTag, pushedAtomStats.tag()); |
| EXPECT_EQ(numLogged + numDropped, pushedAtomStats.count()); |
| EXPECT_EQ(numDropped, pushedAtomStats.dropped_count()); |
| EXPECT_FALSE(pushedAtomStats.has_error_count()); |
| EXPECT_FALSE(pushedAtomStats.has_skip_count()); |
| |
| const auto& nonPlatformPushedAtomStats = report.atom_stats(1); |
| EXPECT_EQ(nonPlatformPushAtomTag, nonPlatformPushedAtomStats.tag()); |
| EXPECT_EQ(numLogged + numDropped, nonPlatformPushedAtomStats.count()); |
| EXPECT_EQ(numDropped, nonPlatformPushedAtomStats.dropped_count()); |
| EXPECT_FALSE(nonPlatformPushedAtomStats.has_error_count()); |
| EXPECT_FALSE(nonPlatformPushedAtomStats.has_skip_count()); |
| } |
| |
| TEST(StatsdStatsTest, TestAtomSkippedStats) { |
| StatsdStats stats; |
| |
| const int pushAtomTag = 100; |
| const int nonPlatformPushAtomTag = StatsdStats::kMaxPushedAtomId + 100; |
| const int numSkipped = 10; |
| |
| for (int i = 0; i < numSkipped; i++) { |
| stats.noteAtomLogged(pushAtomTag, /*timeSec=*/0, /*isSkipped*/ true); |
| stats.noteAtomLogged(nonPlatformPushAtomTag, /*timeSec=*/0, /*isSkipped*/ true); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| // Check skip_count = numSkipped for push atoms |
| ASSERT_EQ(2, report.atom_stats_size()); |
| |
| const auto& pushedAtomStats = report.atom_stats(0); |
| EXPECT_EQ(pushAtomTag, pushedAtomStats.tag()); |
| EXPECT_EQ(numSkipped, pushedAtomStats.count()); |
| EXPECT_EQ(numSkipped, pushedAtomStats.skip_count()); |
| EXPECT_FALSE(pushedAtomStats.has_error_count()); |
| |
| const auto& nonPlatformPushedAtomStats = report.atom_stats(1); |
| EXPECT_EQ(nonPlatformPushAtomTag, nonPlatformPushedAtomStats.tag()); |
| EXPECT_EQ(numSkipped, nonPlatformPushedAtomStats.count()); |
| EXPECT_EQ(numSkipped, nonPlatformPushedAtomStats.skip_count()); |
| EXPECT_FALSE(nonPlatformPushedAtomStats.has_error_count()); |
| } |
| |
| TEST(StatsdStatsTest, TestAtomLoggedAndDroppedAndSkippedStats) { |
| StatsdStats stats; |
| |
| const int pushAtomTag = 100; |
| const int nonPlatformPushAtomTag = StatsdStats::kMaxPushedAtomId + 100; |
| |
| const int numLogged = 10; |
| for (int i = 0; i < numLogged; i++) { |
| stats.noteAtomLogged(pushAtomTag, /*timeSec*/ 0, false); |
| stats.noteAtomLogged(nonPlatformPushAtomTag, /*timeSec*/ 0, false); |
| } |
| |
| const int numDropped = 10; |
| for (int i = 0; i < numDropped; i++) { |
| stats.noteEventQueueOverflow(/*oldestEventTimestampNs*/ 0, pushAtomTag, true); |
| stats.noteEventQueueOverflow(/*oldestEventTimestampNs*/ 0, nonPlatformPushAtomTag, true); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| // Check dropped_count = numDropped for push atoms |
| ASSERT_EQ(2, report.atom_stats_size()); |
| |
| const auto& pushedAtomStats = report.atom_stats(0); |
| EXPECT_EQ(pushAtomTag, pushedAtomStats.tag()); |
| EXPECT_EQ(numLogged + numDropped, pushedAtomStats.count()); |
| EXPECT_EQ(numDropped, pushedAtomStats.dropped_count()); |
| EXPECT_EQ(numDropped, pushedAtomStats.skip_count()); |
| EXPECT_FALSE(pushedAtomStats.has_error_count()); |
| |
| const auto& nonPlatformPushedAtomStats = report.atom_stats(1); |
| EXPECT_EQ(nonPlatformPushAtomTag, nonPlatformPushedAtomStats.tag()); |
| EXPECT_EQ(numLogged + numDropped, nonPlatformPushedAtomStats.count()); |
| EXPECT_EQ(numDropped, nonPlatformPushedAtomStats.dropped_count()); |
| EXPECT_EQ(numDropped, nonPlatformPushedAtomStats.skip_count()); |
| EXPECT_FALSE(nonPlatformPushedAtomStats.has_error_count()); |
| } |
| |
| TEST(StatsdStatsTest, TestShardOffsetProvider) { |
| StatsdStats stats; |
| ShardOffsetProvider::getInstance().setShardOffset(15); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| EXPECT_EQ(report.shard_offset(), 15); |
| } |
| |
| TEST(StatsdStatsTest, TestHasHitDimensionGuardrail) { |
| StatsdStats stats; |
| int metricId1 = 1; |
| int metricId2 = 2; |
| int metricId3 = 3; |
| |
| stats.noteBucketCount(metricId2); |
| stats.noteHardDimensionLimitReached(metricId3); |
| |
| // No AtomMetricStats. |
| EXPECT_FALSE(stats.hasHitDimensionGuardrail(metricId1)); |
| |
| // Has AtomMetricStats but hasn't hit dimension guardrail. |
| EXPECT_FALSE(stats.hasHitDimensionGuardrail(metricId2)); |
| |
| // Has hit dimension guardrail. |
| EXPECT_TRUE(stats.hasHitDimensionGuardrail(metricId3)); |
| } |
| |
| TEST(StatsdStatsTest, TestSubscriptionStarted) { |
| StatsdStats stats; |
| |
| stats.noteSubscriptionStarted(/* id */ 1, /* pushedCount */ 3, /* pulledCount */ 1); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto subscriptionStats = report.subscription_stats(); |
| EXPECT_EQ(subscriptionStats.pull_thread_wakeup_count(), 0); |
| ASSERT_EQ(subscriptionStats.per_subscription_stats_size(), 1); |
| auto perSubscriptionStats = subscriptionStats.per_subscription_stats(0); |
| EXPECT_EQ(perSubscriptionStats.pushed_atom_count(), 3); |
| EXPECT_EQ(perSubscriptionStats.pulled_atom_count(), 1); |
| EXPECT_GT(perSubscriptionStats.start_time_sec(), 0); |
| EXPECT_FALSE(perSubscriptionStats.has_end_time_sec()); |
| EXPECT_EQ(perSubscriptionStats.flush_count(), 0); |
| } |
| |
| TEST(StatsdStatsTest, TestSubscriptionFlushed) { |
| StatsdStats stats; |
| |
| stats.noteSubscriptionStarted(/* id */ 1, /* pushedCount */ 3, /* pulledCount */ 1); |
| stats.noteSubscriptionFlushed(/* id */ 1); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto subscriptionStats = report.subscription_stats(); |
| ASSERT_EQ(subscriptionStats.per_subscription_stats_size(), 1); |
| auto perSubscriptionStats = subscriptionStats.per_subscription_stats(0); |
| EXPECT_EQ(perSubscriptionStats.flush_count(), 1); |
| } |
| |
| TEST(StatsdStatsTest, TestSubscriptionEnded) { |
| StatsdStats stats; |
| |
| stats.noteSubscriptionStarted(/* id */ 1, /* pushedCount */ 3, /* pulledCount */ 1); |
| stats.noteSubscriptionEnded(/* id */ 1); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto subscriptionStats = report.subscription_stats(); |
| ASSERT_EQ(subscriptionStats.per_subscription_stats_size(), 1); |
| EXPECT_GT(subscriptionStats.per_subscription_stats(0).end_time_sec(), 0); |
| } |
| |
| TEST(StatsdStatsTest, TestSubscriptionAtomPulled) { |
| StatsdStats stats; |
| |
| stats.noteSubscriptionAtomPulled(/* atomId */ 10'001); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| ASSERT_EQ(report.pulled_atom_stats_size(), 1); |
| auto pulledAtomStats = report.pulled_atom_stats(0); |
| EXPECT_EQ(pulledAtomStats.subscription_pull_count(), 1); |
| } |
| |
| TEST(StatsdStatsTest, TestSubscriptionPullThreadWakeup) { |
| StatsdStats stats; |
| |
| stats.noteSubscriptionPullThreadWakeup(); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto subscriptionStats = report.subscription_stats(); |
| EXPECT_EQ(subscriptionStats.pull_thread_wakeup_count(), 1); |
| } |
| |
| TEST(StatsdStatsTest, TestSubscriptionStartedMaxActiveSubscriptions) { |
| StatsdStats stats; |
| |
| const int maxSubs = ShellSubscriber::getMaxSubscriptions(); |
| |
| // Start more than max # of allowed subscriptions. |
| // maxSub + 1th subscriptions should not have been added. |
| for (int id = 1; id <= maxSubs + 1; id++) { |
| stats.noteSubscriptionStarted(id, /* pushedCount */ 3, /* pulledCount */ 1); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto subscriptionStats = report.subscription_stats(); |
| ASSERT_EQ(subscriptionStats.per_subscription_stats_size(), maxSubs); |
| EXPECT_THAT(subscriptionStats.per_subscription_stats(), |
| Not(Contains(Property(&PerSubscriptionStats::id, Eq(maxSubs + 1))))); |
| } |
| |
| TEST(StatsdStatsTest, TestSubscriptionStartedRemoveFinishedSubscription) { |
| StatsdStats stats; |
| |
| const int maxSubs = ShellSubscriber::getMaxSubscriptions(); |
| |
| // Start max # of allowed subscriptions |
| for (int id = 1; id <= maxSubs; id++) { |
| stats.noteSubscriptionStarted(id, /* pushedCount */ 3, /* pulledCount */ 1); |
| } |
| |
| // End subscription with id 5. |
| stats.noteSubscriptionEnded(/* id */ 5); |
| |
| // Add one more subscription after we've added max # of subscriptions. |
| // Subscription wth id 5 should be removed and the new subscription added here should be |
| // accepted. |
| stats.noteSubscriptionStarted(maxSubs + 1, /* pushedCount */ 3, /* pulledCount */ 1); |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto subscriptionStats = report.subscription_stats(); |
| ASSERT_EQ(subscriptionStats.per_subscription_stats_size(), maxSubs); |
| EXPECT_THAT(subscriptionStats.per_subscription_stats(), |
| Not(Contains(Property(&PerSubscriptionStats::id, Eq(5))))); |
| EXPECT_THAT(subscriptionStats.per_subscription_stats(), |
| Contains(Property(&PerSubscriptionStats::id, Eq(maxSubs + 1)))); |
| } |
| |
| TEST(StatsdStatsTest, TestEnforceDimensionKeySizeLimit) { |
| EXPECT_EQ(StatsdStats::clampDimensionKeySizeLimit(-1), |
| StatsdStats::kDimensionKeySizeHardLimitMin); |
| EXPECT_EQ(StatsdStats::clampDimensionKeySizeLimit(0), |
| StatsdStats::kDimensionKeySizeHardLimitMin); |
| EXPECT_EQ(StatsdStats::clampDimensionKeySizeLimit(500), |
| StatsdStats::kDimensionKeySizeHardLimitMin); |
| EXPECT_EQ(StatsdStats::clampDimensionKeySizeLimit(1000), 1000); |
| EXPECT_EQ(StatsdStats::clampDimensionKeySizeLimit(3500), |
| StatsdStats::kDimensionKeySizeHardLimitMax); |
| } |
| |
| TEST(StatsdStatsTest, TestSocketLossStats) { |
| StatsdStats stats; |
| |
| const int maxLossEvents = StatsdStats::kMaxSocketLossStatsSize; |
| |
| // Note maxLossEvents + 1 |
| for (int eventId = 0; eventId <= maxLossEvents; eventId++) { |
| SocketLossInfo info; |
| |
| info.uid = eventId; |
| info.firstLossTsNanos = 10 * eventId; |
| info.lastLossTsNanos = 10 * eventId + 1; |
| |
| info.atomIds.push_back(eventId * 10); |
| info.errors.push_back(eventId * 20); |
| info.counts.push_back(eventId * 30); |
| |
| stats.noteAtomSocketLoss(info); |
| } |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto socketLossStats = report.socket_loss_stats(); |
| ASSERT_EQ(socketLossStats.loss_stats_per_uid().size(), maxLossEvents); |
| |
| for (int i = 0; i < socketLossStats.loss_stats_per_uid().size(); i++) { |
| const auto& info = report.socket_loss_stats().loss_stats_per_uid(i); |
| |
| // due to the very first one with id 0 is popped out from the list ids (index) start from 1 |
| const int index = i + 1; |
| |
| ASSERT_EQ(info.uid(), index); |
| ASSERT_EQ(info.first_timestamp_nanos(), 10 * index); |
| ASSERT_EQ(info.last_timestamp_nanos(), 10 * index + 1); |
| |
| ASSERT_EQ(info.atom_id_loss_stats().size(), 1); |
| |
| ASSERT_EQ(info.atom_id_loss_stats(0).atom_id(), index * 10); |
| ASSERT_EQ(info.atom_id_loss_stats(0).error(), index * 20); |
| ASSERT_EQ(info.atom_id_loss_stats(0).count(), index * 30); |
| } |
| } |
| |
| TEST(StatsdStatsTest, TestSocketLossStatsOverflowCounter) { |
| StatsdStats stats; |
| |
| const int uidsCount = 5; |
| const int lossEventCount = 5; |
| |
| for (int uid = 0; uid < uidsCount; uid++) { |
| for (int eventId = 0; eventId < lossEventCount; eventId++) { |
| SocketLossInfo info; |
| |
| info.uid = uid; |
| info.firstLossTsNanos = 10 * eventId; |
| info.lastLossTsNanos = 10 * eventId + 1; |
| // the counter value will be accumulated |
| info.overflowCounter = 1; |
| |
| info.atomIds.push_back(eventId * 10); |
| info.errors.push_back(eventId * 20); |
| info.counts.push_back(eventId * 30); |
| |
| stats.noteAtomSocketLoss(info); |
| } |
| } |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| |
| auto socketLossStatsOverflowCounters = |
| report.socket_loss_stats().loss_stats_overflow_counters(); |
| ASSERT_EQ(socketLossStatsOverflowCounters.size(), uidsCount); |
| |
| for (int i = 0; i < socketLossStatsOverflowCounters.size(); i++) { |
| const auto& counters = report.socket_loss_stats().loss_stats_overflow_counters(i); |
| |
| ASSERT_EQ(counters.uid(), i); |
| ASSERT_EQ(counters.count(), lossEventCount); |
| } |
| } |
| |
| TEST(StatsdStatsTest, TestSocketBatchReadStats) { |
| unordered_map<int32_t, int32_t> empty; |
| unordered_map<int32_t, int32_t> m1199 = {{1, 1}, {2, 1190}, {3, 8}}; // only 2 should show up |
| unordered_map<int32_t, int32_t> m1200 = {{1, 1}, {2, 4}, {3, 8}}; // none should show up |
| unordered_map<int32_t, int32_t> m120000 = {{1, 1000}, {2, 2000}, {3, 800}}; // all show up |
| StatsdStats stats; |
| stats.noteBatchSocketRead(1, 0, 0, 0, 0, empty); // bin 1 |
| stats.noteBatchSocketRead(2, 0, 0, 0, 0, empty); // bin 2 |
| stats.noteBatchSocketRead(2, 0, 0, 0, 0, empty); // bin 2 |
| stats.noteBatchSocketRead(4, 0, 0, 0, 0, empty); // bin 4 |
| stats.noteBatchSocketRead(5, 0, 0, 0, 0, empty); // bin 5 |
| stats.noteBatchSocketRead(9, 0, 0, 0, 0, empty); // bin 5 |
| stats.noteBatchSocketRead(9, 0, 0, 0, 0, empty); // bin 5 |
| stats.noteBatchSocketRead(10, 0, 0, 0, 0, empty); // bin 6 |
| stats.noteBatchSocketRead(19, 0, 0, 0, 0, empty); // bin 6 |
| stats.noteBatchSocketRead(30, 0, 0, 0, 0, empty); // bin 8 |
| stats.noteBatchSocketRead(32, 0, 0, 0, 0, empty); // bin 8 |
| stats.noteBatchSocketRead(39, 0, 0, 0, 0, empty); // bin 8 |
| stats.noteBatchSocketRead(90, 0, 0, 0, 0, empty); // bin 14 |
| stats.noteBatchSocketRead(99, 0, 0, 0, 0, empty); // bin 14 |
| stats.noteBatchSocketRead(100, 0, 0, 0, 0, empty); // bin 15 |
| stats.noteBatchSocketRead(100, 0, 0, 0, 0, empty); // bin 15 |
| stats.noteBatchSocketRead(199, 0, 0, 0, 0, empty); // bin 15 |
| stats.noteBatchSocketRead(200, 0, 0, 0, 0, empty); // bin 16 |
| stats.noteBatchSocketRead(299, 0, 0, 0, 0, empty); // bin 16 |
| stats.noteBatchSocketRead(999, 0, 0, 0, 0, empty); // bin 23 |
| stats.noteBatchSocketRead(1000, 0, 0, 0, 0, empty); // bin 24 |
| stats.noteBatchSocketRead(1199, 1, 2, 3, 4, m1199); // bin 24 |
| stats.noteBatchSocketRead(1200, 5, 6, 7, 8, m1200); // bin 25 |
| stats.noteBatchSocketRead(1800, 0, 0, 0, 0, empty); // bin 28 |
| stats.noteBatchSocketRead(1999, 0, 0, 0, 0, empty); // bin 28 |
| stats.noteBatchSocketRead(2000, 0, 0, 0, 0, empty); // bin 29 |
| stats.noteBatchSocketRead(120000, 10, INT64_MAX, 50, INT64_MAX, m120000); // bin 29 |
| |
| StatsdStatsReport report = getStatsdStatsReport(stats, /* reset stats */ false); |
| EXPECT_THAT(report.socket_read_stats().batched_read_size(), |
| ElementsAre(0, 1, 2, 0, 1, 3, 2, 0, 3, 0, 0, 0, 0, 0, 2, 3, 2, 0, 0, 0, 0, 0, 0, 1, |
| 2, 1, 0, 0, 2, 2)); |
| |
| // Check the large batch stats |
| ASSERT_EQ(report.socket_read_stats().large_batch_read_stats_size(), 7); |
| auto largeBatchStats = report.socket_read_stats().large_batch_read_stats(1); // 1199 |
| EXPECT_EQ(largeBatchStats.total_atoms_read(), 1199); |
| EXPECT_EQ(largeBatchStats.last_read_time_elapsed_ns(), 1); |
| EXPECT_EQ(largeBatchStats.curr_read_time_elapsed_ns(), 2); |
| EXPECT_EQ(largeBatchStats.min_atom_time_elapsed_ns(), 3); |
| EXPECT_EQ(largeBatchStats.max_atom_time_elapsed_ns(), 4); |
| ASSERT_EQ(largeBatchStats.atom_stats_size(), 1); |
| EXPECT_EQ(largeBatchStats.atom_stats(0).atom_id(), 2); |
| EXPECT_EQ(largeBatchStats.atom_stats(0).count(), 1190); |
| |
| largeBatchStats = report.socket_read_stats().large_batch_read_stats(2); // 1200 |
| EXPECT_EQ(largeBatchStats.total_atoms_read(), 1200); |
| EXPECT_EQ(largeBatchStats.last_read_time_elapsed_ns(), 5); |
| EXPECT_EQ(largeBatchStats.curr_read_time_elapsed_ns(), 6); |
| EXPECT_EQ(largeBatchStats.min_atom_time_elapsed_ns(), 7); |
| EXPECT_EQ(largeBatchStats.max_atom_time_elapsed_ns(), 8); |
| ASSERT_EQ(largeBatchStats.atom_stats_size(), 0); |
| |
| largeBatchStats = report.socket_read_stats().large_batch_read_stats(6); // 120000 |
| EXPECT_EQ(largeBatchStats.total_atoms_read(), 120000); |
| EXPECT_EQ(largeBatchStats.last_read_time_elapsed_ns(), 10); |
| EXPECT_EQ(largeBatchStats.curr_read_time_elapsed_ns(), INT64_MAX); |
| EXPECT_EQ(largeBatchStats.min_atom_time_elapsed_ns(), 50); |
| EXPECT_EQ(largeBatchStats.max_atom_time_elapsed_ns(), INT64_MAX); |
| ASSERT_EQ(largeBatchStats.atom_stats_size(), 3); |
| EXPECT_EQ(largeBatchStats.atom_stats(0).atom_id(), 3); |
| EXPECT_EQ(largeBatchStats.atom_stats(0).count(), 800); |
| EXPECT_EQ(largeBatchStats.atom_stats(1).atom_id(), 2); |
| EXPECT_EQ(largeBatchStats.atom_stats(1).count(), 2000); |
| EXPECT_EQ(largeBatchStats.atom_stats(2).atom_id(), 1); |
| EXPECT_EQ(largeBatchStats.atom_stats(2).count(), 1000); |
| |
| stats.reset(); |
| report = getStatsdStatsReport(stats, /* reset stats */ false); |
| EXPECT_THAT(report.socket_read_stats().batched_read_size(), |
| AllOf(SizeIs(StatsdStats::kNumBinsInSocketBatchReadHistogram), Each(0))); |
| ASSERT_EQ(report.socket_read_stats().large_batch_read_stats_size(), 0); |
| } |
| |
| TEST_P(StatsdStatsTest_GetAtomDimensionKeySizeLimit_InMap, TestGetAtomDimensionKeySizeLimits) { |
| const auto& [atomId, defaultHardLimit] = GetParam(); |
| EXPECT_EQ(StatsdStats::getAtomDimensionKeySizeLimits(atomId, defaultHardLimit), |
| StatsdStats::kAtomDimensionKeySizeLimitMap.at(atomId)); |
| } |
| |
| TEST_P(StatsdStatsTest_GetAtomDimensionKeySizeLimit_NotInMap, TestGetAtomDimensionKeySizeLimits) { |
| const auto& [atomId, defaultHardLimit] = GetParam(); |
| EXPECT_EQ( |
| StatsdStats::getAtomDimensionKeySizeLimits(atomId, defaultHardLimit), |
| (std::pair<size_t, size_t>(StatsdStats::kDimensionKeySizeSoftLimit, defaultHardLimit))); |
| } |
| |
| } // namespace statsd |
| } // namespace os |
| } // namespace android |
| #else |
| GTEST_LOG_(INFO) << "This test does nothing.\n"; |
| #endif |
