1659 lines
83 KiB
C++
1659 lines
83 KiB
C++
// Copyright (C) 2019 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 <gtest/gtest.h>
|
|
|
|
#include <vector>
|
|
|
|
#include "src/StatsLogProcessor.h"
|
|
#include "src/state/StateTracker.h"
|
|
#include "src/stats_log_util.h"
|
|
#include "tests/statsd_test_util.h"
|
|
|
|
namespace android {
|
|
namespace os {
|
|
namespace statsd {
|
|
|
|
#ifdef __ANDROID__
|
|
|
|
TEST(DurationMetricE2eTest, TestOneBucket) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
|
|
auto screenOffMatcher = CreateScreenTurnedOffAtomMatcher();
|
|
*config.add_atom_matcher() = screenOnMatcher;
|
|
*config.add_atom_matcher() = screenOffMatcher;
|
|
|
|
auto durationPredicate = CreateScreenIsOnPredicate();
|
|
*config.add_predicate() = durationPredicate;
|
|
|
|
int64_t metricId = 123456;
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(metricId);
|
|
durationMetric->set_what(durationPredicate.id());
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
durationMetric->set_aggregation_type(DurationMetric_AggregationType_SUM);
|
|
|
|
const int64_t baseTimeNs = 0; // 0:00
|
|
const int64_t configAddedTimeNs = baseTimeNs + 1 * NS_PER_SEC; // 0:01
|
|
const int64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000LL * 1000LL;
|
|
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
|
|
auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey);
|
|
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
|
|
std::unique_ptr<LogEvent> event;
|
|
|
|
// Screen is off at start of bucket.
|
|
event = CreateScreenStateChangedEvent(configAddedTimeNs,
|
|
android::view::DISPLAY_STATE_OFF); // 0:01
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn screen on.
|
|
const int64_t durationStartNs = configAddedTimeNs + 10 * NS_PER_SEC; // 0:11
|
|
event = CreateScreenStateChangedEvent(durationStartNs, android::view::DISPLAY_STATE_ON);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn off screen 30 seconds after turning on.
|
|
const int64_t durationEndNs = durationStartNs + 30 * NS_PER_SEC; // 0:41
|
|
event = CreateScreenStateChangedEvent(durationEndNs, android::view::DISPLAY_STATE_OFF);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateScreenBrightnessChangedEvent(durationEndNs + 1 * NS_PER_SEC, 64); // 0:42
|
|
processor->OnLogEvent(event.get());
|
|
|
|
ConfigMetricsReportList reports;
|
|
vector<uint8_t> buffer;
|
|
processor->onDumpReport(cfgKey, configAddedTimeNs + bucketSizeNs + 1 * NS_PER_SEC, false, true,
|
|
ADB_DUMP, FAST, &buffer); // 5:01
|
|
EXPECT_TRUE(buffer.size() > 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(durationEndNs - durationStartNs, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(configAddedTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(baseTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestTwoBuckets) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
|
|
auto screenOffMatcher = CreateScreenTurnedOffAtomMatcher();
|
|
*config.add_atom_matcher() = screenOnMatcher;
|
|
*config.add_atom_matcher() = screenOffMatcher;
|
|
|
|
auto durationPredicate = CreateScreenIsOnPredicate();
|
|
*config.add_predicate() = durationPredicate;
|
|
|
|
int64_t metricId = 123456;
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(metricId);
|
|
durationMetric->set_what(durationPredicate.id());
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
durationMetric->set_aggregation_type(DurationMetric_AggregationType_SUM);
|
|
|
|
const int64_t baseTimeNs = 0; // 0:00
|
|
const int64_t configAddedTimeNs = baseTimeNs + 1 * NS_PER_SEC; // 0:01
|
|
const int64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000LL * 1000LL;
|
|
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
|
|
auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey);
|
|
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
|
|
std::unique_ptr<LogEvent> event;
|
|
|
|
// Screen is off at start of bucket.
|
|
event = CreateScreenStateChangedEvent(configAddedTimeNs,
|
|
android::view::DISPLAY_STATE_OFF); // 0:01
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn screen on.
|
|
const int64_t durationStartNs = configAddedTimeNs + 10 * NS_PER_SEC; // 0:11
|
|
event = CreateScreenStateChangedEvent(durationStartNs, android::view::DISPLAY_STATE_ON);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn off screen 30 seconds after turning on.
|
|
const int64_t durationEndNs = durationStartNs + 30 * NS_PER_SEC; // 0:41
|
|
event = CreateScreenStateChangedEvent(durationEndNs, android::view::DISPLAY_STATE_OFF);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateScreenBrightnessChangedEvent(durationEndNs + 1 * NS_PER_SEC, 64); // 0:42
|
|
processor->OnLogEvent(event.get());
|
|
|
|
ConfigMetricsReportList reports;
|
|
vector<uint8_t> buffer;
|
|
processor->onDumpReport(cfgKey, configAddedTimeNs + 2 * bucketSizeNs + 1 * NS_PER_SEC, false,
|
|
true, ADB_DUMP, FAST, &buffer); // 10:01
|
|
EXPECT_TRUE(buffer.size() > 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
|
|
auto bucketInfo = data.bucket_info(0);
|
|
EXPECT_EQ(0, bucketInfo.bucket_num());
|
|
EXPECT_EQ(durationEndNs - durationStartNs, bucketInfo.duration_nanos());
|
|
EXPECT_EQ(configAddedTimeNs, bucketInfo.start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(baseTimeNs + bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithActivation) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
|
|
auto screenOffMatcher = CreateScreenTurnedOffAtomMatcher();
|
|
auto crashMatcher = CreateProcessCrashAtomMatcher();
|
|
*config.add_atom_matcher() = screenOnMatcher;
|
|
*config.add_atom_matcher() = screenOffMatcher;
|
|
*config.add_atom_matcher() = crashMatcher;
|
|
|
|
auto durationPredicate = CreateScreenIsOnPredicate();
|
|
*config.add_predicate() = durationPredicate;
|
|
|
|
int64_t metricId = 123456;
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(metricId);
|
|
durationMetric->set_what(durationPredicate.id());
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
durationMetric->set_aggregation_type(DurationMetric_AggregationType_SUM);
|
|
|
|
auto metric_activation1 = config.add_metric_activation();
|
|
metric_activation1->set_metric_id(metricId);
|
|
auto event_activation1 = metric_activation1->add_event_activation();
|
|
event_activation1->set_atom_matcher_id(crashMatcher.id());
|
|
event_activation1->set_ttl_seconds(30); // 30 secs.
|
|
|
|
const int64_t bucketStartTimeNs = 10000000000;
|
|
const int64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000LL * 1000LL;
|
|
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
|
|
sp<UidMap> m = new UidMap();
|
|
sp<StatsPullerManager> pullerManager = new StatsPullerManager();
|
|
sp<AlarmMonitor> anomalyAlarmMonitor;
|
|
sp<AlarmMonitor> subscriberAlarmMonitor;
|
|
vector<int64_t> activeConfigsBroadcast;
|
|
|
|
int broadcastCount = 0;
|
|
StatsLogProcessor processor(
|
|
m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, bucketStartTimeNs,
|
|
[](const ConfigKey& key) { return true; },
|
|
[&uid, &broadcastCount, &activeConfigsBroadcast](const int& broadcastUid,
|
|
const vector<int64_t>& activeConfigs) {
|
|
broadcastCount++;
|
|
EXPECT_EQ(broadcastUid, uid);
|
|
activeConfigsBroadcast.clear();
|
|
activeConfigsBroadcast.insert(activeConfigsBroadcast.end(), activeConfigs.begin(),
|
|
activeConfigs.end());
|
|
return true;
|
|
});
|
|
|
|
processor.OnConfigUpdated(bucketStartTimeNs, cfgKey, config); // 0:00
|
|
|
|
ASSERT_EQ(processor.mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor.mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
auto& eventActivationMap = metricProducer->mEventActivationMap;
|
|
|
|
EXPECT_FALSE(metricsManager->isActive());
|
|
EXPECT_FALSE(metricProducer->mIsActive);
|
|
ASSERT_EQ(eventActivationMap.size(), 1u);
|
|
EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end());
|
|
EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
|
|
EXPECT_EQ(eventActivationMap[2]->start_ns, 0);
|
|
EXPECT_EQ(eventActivationMap[2]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
std::unique_ptr<LogEvent> event;
|
|
|
|
// Turn screen off.
|
|
event = CreateScreenStateChangedEvent(bucketStartTimeNs + 2 * NS_PER_SEC,
|
|
android::view::DISPLAY_STATE_OFF); // 0:02
|
|
processor.OnLogEvent(event.get(), bucketStartTimeNs + 2 * NS_PER_SEC);
|
|
|
|
// Turn screen on.
|
|
const int64_t durationStartNs = bucketStartTimeNs + 5 * NS_PER_SEC; // 0:05
|
|
event = CreateScreenStateChangedEvent(durationStartNs, android::view::DISPLAY_STATE_ON);
|
|
processor.OnLogEvent(event.get(), durationStartNs);
|
|
|
|
// Activate metric.
|
|
const int64_t activationStartNs = bucketStartTimeNs + 5 * NS_PER_SEC; // 0:10
|
|
const int64_t activationEndNs =
|
|
activationStartNs + event_activation1->ttl_seconds() * NS_PER_SEC; // 0:40
|
|
event = CreateAppCrashEvent(activationStartNs, 111);
|
|
processor.OnLogEvent(event.get(), activationStartNs);
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
EXPECT_EQ(broadcastCount, 1);
|
|
ASSERT_EQ(activeConfigsBroadcast.size(), 1);
|
|
EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
|
|
EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
|
|
EXPECT_EQ(eventActivationMap[2]->start_ns, activationStartNs);
|
|
EXPECT_EQ(eventActivationMap[2]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
// Expire activation.
|
|
const int64_t expirationNs = activationEndNs + 7 * NS_PER_SEC;
|
|
event = CreateScreenBrightnessChangedEvent(expirationNs, 64); // 0:47
|
|
processor.OnLogEvent(event.get(), expirationNs);
|
|
EXPECT_FALSE(metricsManager->isActive());
|
|
EXPECT_FALSE(metricProducer->mIsActive);
|
|
EXPECT_EQ(broadcastCount, 2);
|
|
ASSERT_EQ(activeConfigsBroadcast.size(), 0);
|
|
ASSERT_EQ(eventActivationMap.size(), 1u);
|
|
EXPECT_TRUE(eventActivationMap.find(2) != eventActivationMap.end());
|
|
EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kNotActive);
|
|
EXPECT_EQ(eventActivationMap[2]->start_ns, activationStartNs);
|
|
EXPECT_EQ(eventActivationMap[2]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
// Turn off screen 10 seconds after activation expiration.
|
|
const int64_t durationEndNs = activationEndNs + 10 * NS_PER_SEC; // 0:50
|
|
event = CreateScreenStateChangedEvent(durationEndNs, android::view::DISPLAY_STATE_OFF);
|
|
processor.OnLogEvent(event.get(), durationEndNs);
|
|
|
|
// Turn screen on.
|
|
const int64_t duration2StartNs = durationEndNs + 5 * NS_PER_SEC; // 0:55
|
|
event = CreateScreenStateChangedEvent(duration2StartNs, android::view::DISPLAY_STATE_ON);
|
|
processor.OnLogEvent(event.get(), duration2StartNs);
|
|
|
|
// Turn off screen.
|
|
const int64_t duration2EndNs = duration2StartNs + 10 * NS_PER_SEC; // 1:05
|
|
event = CreateScreenStateChangedEvent(duration2EndNs, android::view::DISPLAY_STATE_OFF);
|
|
processor.OnLogEvent(event.get(), duration2EndNs);
|
|
|
|
// Activate metric.
|
|
const int64_t activation2StartNs = duration2EndNs + 5 * NS_PER_SEC; // 1:10
|
|
const int64_t activation2EndNs =
|
|
activation2StartNs + event_activation1->ttl_seconds() * NS_PER_SEC; // 1:40
|
|
event = CreateAppCrashEvent(activation2StartNs, 211);
|
|
processor.OnLogEvent(event.get(), activation2StartNs);
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
EXPECT_EQ(broadcastCount, 3);
|
|
ASSERT_EQ(activeConfigsBroadcast.size(), 1);
|
|
EXPECT_EQ(activeConfigsBroadcast[0], cfgId);
|
|
EXPECT_EQ(eventActivationMap[2]->state, ActivationState::kActive);
|
|
EXPECT_EQ(eventActivationMap[2]->start_ns, activation2StartNs);
|
|
EXPECT_EQ(eventActivationMap[2]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
ConfigMetricsReportList reports;
|
|
vector<uint8_t> buffer;
|
|
processor.onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs + 1 * NS_PER_SEC, false, true,
|
|
ADB_DUMP, FAST, &buffer); // 5:01
|
|
EXPECT_TRUE(buffer.size() > 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
|
|
auto bucketInfo = data.bucket_info(0);
|
|
EXPECT_EQ(0, bucketInfo.bucket_num());
|
|
EXPECT_EQ(bucketStartTimeNs, bucketInfo.start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(expirationNs, bucketInfo.end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(expirationNs - durationStartNs, bucketInfo.duration_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithCondition) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
*config.add_atom_matcher() = CreateAcquireWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateReleaseWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateMoveToBackgroundAtomMatcher();
|
|
*config.add_atom_matcher() = CreateMoveToForegroundAtomMatcher();
|
|
|
|
auto holdingWakelockPredicate = CreateHoldingWakelockPredicate();
|
|
*config.add_predicate() = holdingWakelockPredicate;
|
|
|
|
auto isInBackgroundPredicate = CreateIsInBackgroundPredicate();
|
|
*config.add_predicate() = isInBackgroundPredicate;
|
|
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("WakelockDuration"));
|
|
durationMetric->set_what(holdingWakelockPredicate.id());
|
|
durationMetric->set_condition(isInBackgroundPredicate.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
ConfigKey cfgKey;
|
|
uint64_t bucketStartTimeNs = 10000000000;
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
auto& eventActivationMap = metricProducer->mEventActivationMap;
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
EXPECT_TRUE(eventActivationMap.empty());
|
|
|
|
int appUid = 123;
|
|
vector<int> attributionUids1 = {appUid};
|
|
vector<string> attributionTags1 = {"App1"};
|
|
|
|
auto event = CreateAcquireWakelockEvent(bucketStartTimeNs + 10 * NS_PER_SEC, attributionUids1,
|
|
attributionTags1,
|
|
"wl1"); // 0:10
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateMoveToBackgroundEvent(bucketStartTimeNs + 22 * NS_PER_SEC, appUid); // 0:22
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateMoveToForegroundEvent(bucketStartTimeNs + (3 * 60 + 15) * NS_PER_SEC,
|
|
appUid); // 3:15
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateReleaseWakelockEvent(bucketStartTimeNs + 4 * 60 * NS_PER_SEC, attributionUids1,
|
|
attributionTags1,
|
|
"wl1"); // 4:00
|
|
processor->OnLogEvent(event.get());
|
|
|
|
vector<uint8_t> buffer;
|
|
ConfigMetricsReportList reports;
|
|
processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs + 1, false, true, ADB_DUMP,
|
|
FAST, &buffer);
|
|
ASSERT_GT(buffer.size(), 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStringInReport(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
|
|
// Validate bucket info.
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
|
|
auto bucketInfo = data.bucket_info(0);
|
|
EXPECT_EQ(bucketStartTimeNs, bucketInfo.start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
|
|
EXPECT_EQ((2 * 60 + 53) * NS_PER_SEC, bucketInfo.duration_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithSlicedCondition) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
|
|
*config.add_atom_matcher() = CreateAcquireWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateReleaseWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateMoveToBackgroundAtomMatcher();
|
|
*config.add_atom_matcher() = CreateMoveToForegroundAtomMatcher();
|
|
|
|
auto holdingWakelockPredicate = CreateHoldingWakelockPredicate();
|
|
// The predicate is dimensioning by first attribution node by uid.
|
|
FieldMatcher dimensions = CreateAttributionUidDimensions(util::WAKELOCK_STATE_CHANGED,
|
|
{Position::FIRST});
|
|
*holdingWakelockPredicate.mutable_simple_predicate()->mutable_dimensions() = dimensions;
|
|
*config.add_predicate() = holdingWakelockPredicate;
|
|
|
|
auto isInBackgroundPredicate = CreateIsInBackgroundPredicate();
|
|
*isInBackgroundPredicate.mutable_simple_predicate()->mutable_dimensions() =
|
|
CreateDimensions(util::ACTIVITY_FOREGROUND_STATE_CHANGED, {Position::FIRST});
|
|
*config.add_predicate() = isInBackgroundPredicate;
|
|
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("WakelockDuration"));
|
|
durationMetric->set_what(holdingWakelockPredicate.id());
|
|
durationMetric->set_condition(isInBackgroundPredicate.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
// The metric is dimensioning by first attribution node and only by uid.
|
|
*durationMetric->mutable_dimensions_in_what() = CreateAttributionUidDimensions(
|
|
util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
// Links between wakelock state atom and condition of app is in background.
|
|
auto links = durationMetric->add_links();
|
|
links->set_condition(isInBackgroundPredicate.id());
|
|
*links->mutable_fields_in_what() =
|
|
CreateAttributionUidDimensions(util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
|
|
auto dimensionCondition = links->mutable_fields_in_condition();
|
|
dimensionCondition->set_field(util::ACTIVITY_FOREGROUND_STATE_CHANGED);
|
|
dimensionCondition->add_child()->set_field(1); // uid field.
|
|
|
|
ConfigKey cfgKey;
|
|
uint64_t bucketStartTimeNs = 10000000000;
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
auto& eventActivationMap = metricProducer->mEventActivationMap;
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
EXPECT_TRUE(eventActivationMap.empty());
|
|
|
|
int appUid = 123;
|
|
std::vector<int> attributionUids1 = {appUid};
|
|
std::vector<string> attributionTags1 = {"App1"};
|
|
|
|
auto event = CreateAcquireWakelockEvent(bucketStartTimeNs + 10 * NS_PER_SEC, attributionUids1,
|
|
attributionTags1, "wl1"); // 0:10
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateMoveToBackgroundEvent(bucketStartTimeNs + 22 * NS_PER_SEC, appUid); // 0:22
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateReleaseWakelockEvent(bucketStartTimeNs + 60 * NS_PER_SEC, attributionUids1,
|
|
attributionTags1, "wl1"); // 1:00
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateMoveToForegroundEvent(bucketStartTimeNs + (3 * 60 + 15) * NS_PER_SEC,
|
|
appUid); // 3:15
|
|
processor->OnLogEvent(event.get());
|
|
|
|
vector<uint8_t> buffer;
|
|
ConfigMetricsReportList reports;
|
|
processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs + 1, false, true, ADB_DUMP,
|
|
FAST, &buffer);
|
|
ASSERT_GT(buffer.size(), 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStringInReport(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
// Validate dimension value.
|
|
ValidateAttributionUidDimension(data.dimensions_in_what(),
|
|
util::WAKELOCK_STATE_CHANGED, appUid);
|
|
// Validate bucket info.
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
|
|
auto bucketInfo = data.bucket_info(0);
|
|
EXPECT_EQ(bucketStartTimeNs, bucketInfo.start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(38 * NS_PER_SEC, bucketInfo.duration_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithActivationAndSlicedCondition) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
|
|
*config.add_atom_matcher() = CreateAcquireWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateReleaseWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateMoveToBackgroundAtomMatcher();
|
|
*config.add_atom_matcher() = CreateMoveToForegroundAtomMatcher();
|
|
*config.add_atom_matcher() = screenOnMatcher;
|
|
|
|
auto holdingWakelockPredicate = CreateHoldingWakelockPredicate();
|
|
// The predicate is dimensioning by first attribution node by uid.
|
|
FieldMatcher dimensions = CreateAttributionUidDimensions(util::WAKELOCK_STATE_CHANGED,
|
|
{Position::FIRST});
|
|
*holdingWakelockPredicate.mutable_simple_predicate()->mutable_dimensions() = dimensions;
|
|
*config.add_predicate() = holdingWakelockPredicate;
|
|
|
|
auto isInBackgroundPredicate = CreateIsInBackgroundPredicate();
|
|
*isInBackgroundPredicate.mutable_simple_predicate()->mutable_dimensions() =
|
|
CreateDimensions(util::ACTIVITY_FOREGROUND_STATE_CHANGED, {Position::FIRST});
|
|
*config.add_predicate() = isInBackgroundPredicate;
|
|
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("WakelockDuration"));
|
|
durationMetric->set_what(holdingWakelockPredicate.id());
|
|
durationMetric->set_condition(isInBackgroundPredicate.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
// The metric is dimensioning by first attribution node and only by uid.
|
|
*durationMetric->mutable_dimensions_in_what() = CreateAttributionUidDimensions(
|
|
util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
// Links between wakelock state atom and condition of app is in background.
|
|
auto links = durationMetric->add_links();
|
|
links->set_condition(isInBackgroundPredicate.id());
|
|
*links->mutable_fields_in_what() =
|
|
CreateAttributionUidDimensions(util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
|
|
auto dimensionCondition = links->mutable_fields_in_condition();
|
|
dimensionCondition->set_field(util::ACTIVITY_FOREGROUND_STATE_CHANGED);
|
|
dimensionCondition->add_child()->set_field(1); // uid field.
|
|
|
|
auto metric_activation1 = config.add_metric_activation();
|
|
metric_activation1->set_metric_id(durationMetric->id());
|
|
auto event_activation1 = metric_activation1->add_event_activation();
|
|
event_activation1->set_atom_matcher_id(screenOnMatcher.id());
|
|
event_activation1->set_ttl_seconds(60 * 2); // 2 minutes.
|
|
|
|
ConfigKey cfgKey;
|
|
uint64_t bucketStartTimeNs = 10000000000;
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
auto& eventActivationMap = metricProducer->mEventActivationMap;
|
|
EXPECT_FALSE(metricsManager->isActive());
|
|
EXPECT_FALSE(metricProducer->mIsActive);
|
|
ASSERT_EQ(eventActivationMap.size(), 1u);
|
|
EXPECT_TRUE(eventActivationMap.find(4) != eventActivationMap.end());
|
|
EXPECT_EQ(eventActivationMap[4]->state, ActivationState::kNotActive);
|
|
EXPECT_EQ(eventActivationMap[4]->start_ns, 0);
|
|
EXPECT_EQ(eventActivationMap[4]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
int appUid = 123;
|
|
std::vector<int> attributionUids1 = {appUid};
|
|
std::vector<string> attributionTags1 = {"App1"};
|
|
|
|
auto event = CreateAcquireWakelockEvent(bucketStartTimeNs + 10 * NS_PER_SEC, attributionUids1,
|
|
attributionTags1, "wl1"); // 0:10
|
|
processor->OnLogEvent(event.get());
|
|
EXPECT_FALSE(metricsManager->isActive());
|
|
EXPECT_FALSE(metricProducer->mIsActive);
|
|
EXPECT_EQ(eventActivationMap[4]->state, ActivationState::kNotActive);
|
|
EXPECT_EQ(eventActivationMap[4]->start_ns, 0);
|
|
EXPECT_EQ(eventActivationMap[4]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
event = CreateMoveToBackgroundEvent(bucketStartTimeNs + 22 * NS_PER_SEC, appUid); // 0:22
|
|
processor->OnLogEvent(event.get());
|
|
EXPECT_FALSE(metricsManager->isActive());
|
|
EXPECT_FALSE(metricProducer->mIsActive);
|
|
EXPECT_EQ(eventActivationMap[4]->state, ActivationState::kNotActive);
|
|
EXPECT_EQ(eventActivationMap[4]->start_ns, 0);
|
|
EXPECT_EQ(eventActivationMap[4]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
const int64_t durationStartNs = bucketStartTimeNs + 30 * NS_PER_SEC; // 0:30
|
|
event = CreateScreenStateChangedEvent(durationStartNs, android::view::DISPLAY_STATE_ON);
|
|
processor->OnLogEvent(event.get());
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
EXPECT_EQ(eventActivationMap[4]->state, ActivationState::kActive);
|
|
EXPECT_EQ(eventActivationMap[4]->start_ns, durationStartNs);
|
|
EXPECT_EQ(eventActivationMap[4]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
const int64_t durationEndNs =
|
|
durationStartNs + (event_activation1->ttl_seconds() + 30) * NS_PER_SEC; // 3:00
|
|
event = CreateAppCrashEvent(durationEndNs, 333);
|
|
processor->OnLogEvent(event.get());
|
|
EXPECT_FALSE(metricsManager->isActive());
|
|
EXPECT_FALSE(metricProducer->mIsActive);
|
|
EXPECT_EQ(eventActivationMap[4]->state, ActivationState::kNotActive);
|
|
EXPECT_EQ(eventActivationMap[4]->start_ns, durationStartNs);
|
|
EXPECT_EQ(eventActivationMap[4]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
event = CreateMoveToForegroundEvent(bucketStartTimeNs + (3 * 60 + 15) * NS_PER_SEC,
|
|
appUid); // 3:15
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateReleaseWakelockEvent(bucketStartTimeNs + (4 * 60 + 17) * NS_PER_SEC,
|
|
attributionUids1, attributionTags1, "wl1"); // 4:17
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateMoveToBackgroundEvent(bucketStartTimeNs + (4 * 60 + 20) * NS_PER_SEC,
|
|
appUid); // 4:20
|
|
processor->OnLogEvent(event.get());
|
|
|
|
event = CreateAcquireWakelockEvent(bucketStartTimeNs + (4 * 60 + 25) * NS_PER_SEC,
|
|
attributionUids1, attributionTags1, "wl1"); // 4:25
|
|
processor->OnLogEvent(event.get());
|
|
|
|
const int64_t duration2StartNs = bucketStartTimeNs + (4 * 60 + 30) * NS_PER_SEC; // 4:30
|
|
event = CreateScreenStateChangedEvent(duration2StartNs, android::view::DISPLAY_STATE_ON);
|
|
processor->OnLogEvent(event.get());
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
EXPECT_EQ(eventActivationMap[4]->state, ActivationState::kActive);
|
|
EXPECT_EQ(eventActivationMap[4]->start_ns, duration2StartNs);
|
|
EXPECT_EQ(eventActivationMap[4]->ttl_ns, event_activation1->ttl_seconds() * NS_PER_SEC);
|
|
|
|
vector<uint8_t> buffer;
|
|
ConfigMetricsReportList reports;
|
|
processor->onDumpReport(cfgKey, bucketStartTimeNs + bucketSizeNs + 1, false, true, ADB_DUMP,
|
|
FAST, &buffer);
|
|
ASSERT_GT(buffer.size(), 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStringInReport(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
// Validate dimension value.
|
|
ValidateAttributionUidDimension(data.dimensions_in_what(),
|
|
util::WAKELOCK_STATE_CHANGED, appUid);
|
|
// Validate bucket info.
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
|
|
auto bucketInfo = data.bucket_info(0);
|
|
EXPECT_EQ(bucketStartTimeNs, bucketInfo.start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(durationEndNs, bucketInfo.end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(durationEndNs - durationStartNs, bucketInfo.duration_nanos());
|
|
|
|
bucketInfo = data.bucket_info(1);
|
|
EXPECT_EQ(durationEndNs, bucketInfo.start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - duration2StartNs, bucketInfo.duration_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithSlicedState) {
|
|
// Initialize config.
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
*config.add_atom_matcher() = CreateBatterySaverModeStartAtomMatcher();
|
|
*config.add_atom_matcher() = CreateBatterySaverModeStopAtomMatcher();
|
|
|
|
auto batterySaverModePredicate = CreateBatterySaverModePredicate();
|
|
*config.add_predicate() = batterySaverModePredicate;
|
|
|
|
auto screenState = CreateScreenState();
|
|
*config.add_state() = screenState;
|
|
|
|
// Create duration metric that slices by screen state.
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("DurationBatterySaverModeSliceScreen"));
|
|
durationMetric->set_what(batterySaverModePredicate.id());
|
|
durationMetric->add_slice_by_state(screenState.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
// Initialize StatsLogProcessor.
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
uint64_t bucketStartTimeNs = 10000000000; // 0:10
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1);
|
|
EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID);
|
|
ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0);
|
|
|
|
// Check that StateTrackers were initialized correctly.
|
|
EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
|
|
EXPECT_EQ(1, StateManager::getInstance().getListenersCount(SCREEN_STATE_ATOM_ID));
|
|
|
|
/*
|
|
bucket #1 bucket #2
|
|
| 1 2 3 4 5 6 7 8 9 10 (minutes)
|
|
|-----------------------------|-----------------------------|--
|
|
ON OFF ON (BatterySaverMode)
|
|
| | | (ScreenIsOnEvent)
|
|
| | (ScreenIsOffEvent)
|
|
| (ScreenDozeEvent)
|
|
*/
|
|
// Initialize log events.
|
|
std::vector<std::unique_ptr<LogEvent>> events;
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 10 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 0:20
|
|
events.push_back(CreateBatterySaverOnEvent(bucketStartTimeNs + 20 * NS_PER_SEC)); // 0:30
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 50 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_OFF)); // 1:00
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 80 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_DOZE)); // 1:30
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 120 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 2:10
|
|
events.push_back(CreateBatterySaverOffEvent(bucketStartTimeNs + 200 * NS_PER_SEC)); // 3:30
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 250 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_OFF)); // 4:20
|
|
events.push_back(CreateBatterySaverOnEvent(bucketStartTimeNs + 280 * NS_PER_SEC)); // 4:50
|
|
|
|
// Bucket boundary.
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 310 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 5:20
|
|
|
|
// Send log events to StatsLogProcessor.
|
|
for (auto& event : events) {
|
|
processor->OnLogEvent(event.get());
|
|
}
|
|
|
|
// Check dump report.
|
|
vector<uint8_t> buffer;
|
|
ConfigMetricsReportList reports;
|
|
processor->onDumpReport(cfgKey, bucketStartTimeNs + 360 * NS_PER_SEC,
|
|
true /* include current partial bucket */, true, ADB_DUMP, FAST,
|
|
&buffer); // 6:10
|
|
ASSERT_GT(buffer.size(), 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStringInReport(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(3, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, data.slice_by_state(0).value());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(50 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(370 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(1);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, data.slice_by_state(0).value());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(110 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(50 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(370 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(2);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_DOZE, data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(40 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithConditionAndSlicedState) {
|
|
// Initialize config.
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
*config.add_atom_matcher() = CreateBatterySaverModeStartAtomMatcher();
|
|
*config.add_atom_matcher() = CreateBatterySaverModeStopAtomMatcher();
|
|
*config.add_atom_matcher() = CreateBatteryStateNoneMatcher();
|
|
*config.add_atom_matcher() = CreateBatteryStateUsbMatcher();
|
|
|
|
auto batterySaverModePredicate = CreateBatterySaverModePredicate();
|
|
*config.add_predicate() = batterySaverModePredicate;
|
|
|
|
auto deviceUnpluggedPredicate = CreateDeviceUnpluggedPredicate();
|
|
*config.add_predicate() = deviceUnpluggedPredicate;
|
|
|
|
auto screenState = CreateScreenState();
|
|
*config.add_state() = screenState;
|
|
|
|
// Create duration metric that has a condition and slices by screen state.
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("DurationBatterySaverModeOnBatterySliceScreen"));
|
|
durationMetric->set_what(batterySaverModePredicate.id());
|
|
durationMetric->set_condition(deviceUnpluggedPredicate.id());
|
|
durationMetric->add_slice_by_state(screenState.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
// Initialize StatsLogProcessor.
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
uint64_t bucketStartTimeNs = 10000000000; // 0:10
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1);
|
|
EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID);
|
|
ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0);
|
|
|
|
// Check that StateTrackers were initialized correctly.
|
|
EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
|
|
EXPECT_EQ(1, StateManager::getInstance().getListenersCount(SCREEN_STATE_ATOM_ID));
|
|
|
|
/*
|
|
bucket #1 bucket #2
|
|
| 1 2 3 4 5 6 7 8 (minutes)
|
|
|---------------------------------------|------------------
|
|
ON OFF ON (BatterySaverMode)
|
|
T F T (DeviceUnpluggedPredicate)
|
|
| | | (ScreenIsOnEvent)
|
|
| | | (ScreenIsOffEvent)
|
|
| (ScreenDozeEvent)
|
|
*/
|
|
// Initialize log events.
|
|
std::vector<std::unique_ptr<LogEvent>> events;
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 20 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 0:30
|
|
events.push_back(CreateBatterySaverOnEvent(bucketStartTimeNs + 60 * NS_PER_SEC)); // 1:10
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 80 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_OFF)); // 1:30
|
|
events.push_back(
|
|
CreateBatteryStateChangedEvent(bucketStartTimeNs + 110 * NS_PER_SEC,
|
|
BatteryPluggedStateEnum::BATTERY_PLUGGED_NONE)); // 2:00
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 145 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 2:35
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 170 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_OFF)); // 3:00
|
|
events.push_back(
|
|
CreateBatteryStateChangedEvent(bucketStartTimeNs + 180 * NS_PER_SEC,
|
|
BatteryPluggedStateEnum::BATTERY_PLUGGED_USB)); // 3:10
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 200 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_DOZE)); // 3:30
|
|
events.push_back(
|
|
CreateBatteryStateChangedEvent(bucketStartTimeNs + 230 * NS_PER_SEC,
|
|
BatteryPluggedStateEnum::BATTERY_PLUGGED_NONE)); // 4:00
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 260 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 4:30
|
|
events.push_back(CreateBatterySaverOffEvent(bucketStartTimeNs + 280 * NS_PER_SEC)); // 4:50
|
|
|
|
// Bucket boundary.
|
|
events.push_back(CreateBatterySaverOnEvent(bucketStartTimeNs + 320 * NS_PER_SEC)); // 5:30
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 380 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_OFF)); // 6:30
|
|
|
|
// Send log events to StatsLogProcessor.
|
|
for (auto& event : events) {
|
|
processor->OnLogEvent(event.get());
|
|
}
|
|
|
|
// Check dump report.
|
|
vector<uint8_t> buffer;
|
|
ConfigMetricsReportList reports;
|
|
processor->onDumpReport(cfgKey, bucketStartTimeNs + 410 * NS_PER_SEC,
|
|
true /* include current partial bucket */, true, ADB_DUMP, FAST,
|
|
&buffer);
|
|
ASSERT_GT(buffer.size(), 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStringInReport(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(3, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_OFF, data.slice_by_state(0).value());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(45 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(30 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(420 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(1);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_ON, data.slice_by_state(0).value());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(45 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(60 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(420 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(2);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::view::DisplayStateEnum::DISPLAY_STATE_DOZE, data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(30 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithSlicedStateMapped) {
|
|
// Initialize config.
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
*config.add_atom_matcher() = CreateBatterySaverModeStartAtomMatcher();
|
|
*config.add_atom_matcher() = CreateBatterySaverModeStopAtomMatcher();
|
|
|
|
auto batterySaverModePredicate = CreateBatterySaverModePredicate();
|
|
*config.add_predicate() = batterySaverModePredicate;
|
|
|
|
int64_t screenOnId = 4444;
|
|
int64_t screenOffId = 9876;
|
|
auto screenStateWithMap = CreateScreenStateWithOnOffMap(screenOnId, screenOffId);
|
|
*config.add_state() = screenStateWithMap;
|
|
|
|
// Create duration metric that slices by mapped screen state.
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("DurationBatterySaverModeSliceScreenMapped"));
|
|
durationMetric->set_what(batterySaverModePredicate.id());
|
|
durationMetric->add_slice_by_state(screenStateWithMap.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
// Initialize StatsLogProcessor.
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
uint64_t bucketStartTimeNs = 10000000000; // 0:10
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1);
|
|
EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), SCREEN_STATE_ATOM_ID);
|
|
ASSERT_EQ(metricProducer->mStateGroupMap.size(), 1);
|
|
|
|
// Check that StateTrackers were initialized correctly.
|
|
EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
|
|
EXPECT_EQ(1, StateManager::getInstance().getListenersCount(SCREEN_STATE_ATOM_ID));
|
|
|
|
/*
|
|
bucket #1 bucket #2
|
|
| 1 2 3 4 5 6 7 8 9 10 (minutes)
|
|
|-----------------------------|-----------------------------|--
|
|
ON OFF ON (BatterySaverMode)
|
|
---------------------------------------------------------SCREEN_OFF events
|
|
| | (ScreenStateOffEvent = 1)
|
|
| (ScreenStateDozeEvent = 3)
|
|
| (ScreenStateDozeSuspendEvent = 4)
|
|
---------------------------------------------------------SCREEN_ON events
|
|
| | | (ScreenStateOnEvent = 2)
|
|
| (ScreenStateVrEvent = 5)
|
|
| (ScreenStateOnSuspendEvent = 6)
|
|
*/
|
|
// Initialize log events.
|
|
std::vector<std::unique_ptr<LogEvent>> events;
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 10 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 0:20
|
|
events.push_back(CreateBatterySaverOnEvent(bucketStartTimeNs + 20 * NS_PER_SEC)); // 0:30
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 70 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_OFF)); // 1:20
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 100 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_DOZE)); // 1:50
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 120 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 2:10
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 170 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_VR)); // 3:00
|
|
events.push_back(CreateBatterySaverOffEvent(bucketStartTimeNs + 200 * NS_PER_SEC)); // 3:30
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 250 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_OFF)); // 4:20
|
|
events.push_back(CreateBatterySaverOnEvent(bucketStartTimeNs + 280 * NS_PER_SEC)); // 4:50
|
|
|
|
// Bucket boundary 5:10.
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 320 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON)); // 5:30
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 390 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_ON_SUSPEND)); // 6:40
|
|
events.push_back(CreateScreenStateChangedEvent(
|
|
bucketStartTimeNs + 430 * NS_PER_SEC,
|
|
android::view::DisplayStateEnum::DISPLAY_STATE_DOZE_SUSPEND)); // 7:20
|
|
// Send log events to StatsLogProcessor.
|
|
for (auto& event : events) {
|
|
processor->OnLogEvent(event.get());
|
|
}
|
|
|
|
// Check dump report.
|
|
vector<uint8_t> buffer;
|
|
ConfigMetricsReportList reports;
|
|
processor->onDumpReport(cfgKey, bucketStartTimeNs + 490 * NS_PER_SEC,
|
|
true /* include current partial bucket */, true, ADB_DUMP, FAST,
|
|
&buffer);
|
|
ASSERT_GT(buffer.size(), 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStringInReport(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(2, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_group_id());
|
|
EXPECT_EQ(screenOnId, data.slice_by_state(0).group_id());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(130 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(110 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(500 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(1);
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(SCREEN_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_group_id());
|
|
EXPECT_EQ(screenOffId, data.slice_by_state(0).group_id());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(70 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(80 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(500 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestSlicedStatePrimaryFieldsNotSubsetDimInWhat) {
|
|
// Initialize config.
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
*config.add_atom_matcher() = CreateAcquireWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateReleaseWakelockAtomMatcher();
|
|
|
|
auto holdingWakelockPredicate = CreateHoldingWakelockPredicate();
|
|
*config.add_predicate() = holdingWakelockPredicate;
|
|
|
|
auto uidProcessState = CreateUidProcessState();
|
|
*config.add_state() = uidProcessState;
|
|
|
|
// Create duration metric that slices by uid process state.
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("DurationHoldingWakelockSliceUidProcessState"));
|
|
durationMetric->set_what(holdingWakelockPredicate.id());
|
|
durationMetric->add_slice_by_state(uidProcessState.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
// The state has only one primary field (uid).
|
|
auto stateLink = durationMetric->add_state_link();
|
|
stateLink->set_state_atom_id(UID_PROCESS_STATE_ATOM_ID);
|
|
auto fieldsInWhat = stateLink->mutable_fields_in_what();
|
|
*fieldsInWhat = CreateAttributionUidDimensions(util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
|
|
auto fieldsInState = stateLink->mutable_fields_in_state();
|
|
*fieldsInState = CreateDimensions(UID_PROCESS_STATE_ATOM_ID, {1 /* uid */});
|
|
|
|
// Initialize StatsLogProcessor.
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
uint64_t bucketStartTimeNs = 10000000000; // 0:10
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
|
|
// This config is rejected because the dimension in what fields are not a superset of the sliced
|
|
// state primary fields.
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 0);
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestWithSlicedStatePrimaryFieldsSubset) {
|
|
// Initialize config.
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
*config.add_atom_matcher() = CreateAcquireWakelockAtomMatcher();
|
|
*config.add_atom_matcher() = CreateReleaseWakelockAtomMatcher();
|
|
|
|
auto holdingWakelockPredicate = CreateHoldingWakelockPredicate();
|
|
*(holdingWakelockPredicate.mutable_simple_predicate()->mutable_dimensions()) =
|
|
CreateAttributionUidAndOtherDimensions(util::WAKELOCK_STATE_CHANGED, {Position::FIRST},
|
|
{3 /* tag */});
|
|
*config.add_predicate() = holdingWakelockPredicate;
|
|
|
|
auto uidProcessState = CreateUidProcessState();
|
|
*config.add_state() = uidProcessState;
|
|
|
|
// Create duration metric that slices by uid process state.
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(StringToId("DurationPartialWakelockPerTagUidSliceProcessState"));
|
|
durationMetric->set_what(holdingWakelockPredicate.id());
|
|
durationMetric->add_slice_by_state(uidProcessState.id());
|
|
durationMetric->set_aggregation_type(DurationMetric::SUM);
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
|
|
// The metric is dimensioning by first uid of attribution node and tag.
|
|
*durationMetric->mutable_dimensions_in_what() = CreateAttributionUidAndOtherDimensions(
|
|
util::WAKELOCK_STATE_CHANGED, {Position::FIRST}, {3 /* tag */});
|
|
// The state has only one primary field (uid).
|
|
auto stateLink = durationMetric->add_state_link();
|
|
stateLink->set_state_atom_id(UID_PROCESS_STATE_ATOM_ID);
|
|
auto fieldsInWhat = stateLink->mutable_fields_in_what();
|
|
*fieldsInWhat = CreateAttributionUidDimensions(util::WAKELOCK_STATE_CHANGED, {Position::FIRST});
|
|
auto fieldsInState = stateLink->mutable_fields_in_state();
|
|
*fieldsInState = CreateDimensions(UID_PROCESS_STATE_ATOM_ID, {1 /* uid */});
|
|
|
|
// Initialize StatsLogProcessor.
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
uint64_t bucketStartTimeNs = 10000000000; // 0:10
|
|
uint64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000000LL;
|
|
auto processor = CreateStatsLogProcessor(bucketStartTimeNs, bucketStartTimeNs, config, cfgKey);
|
|
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
ASSERT_EQ(metricProducer->mSlicedStateAtoms.size(), 1);
|
|
EXPECT_EQ(metricProducer->mSlicedStateAtoms.at(0), UID_PROCESS_STATE_ATOM_ID);
|
|
ASSERT_EQ(metricProducer->mStateGroupMap.size(), 0);
|
|
|
|
// Check that StateTrackers were initialized correctly.
|
|
EXPECT_EQ(1, StateManager::getInstance().getStateTrackersCount());
|
|
EXPECT_EQ(1, StateManager::getInstance().getListenersCount(UID_PROCESS_STATE_ATOM_ID));
|
|
|
|
// Initialize log events.
|
|
int appUid1 = 1001;
|
|
int appUid2 = 1002;
|
|
std::vector<int> attributionUids1 = {appUid1};
|
|
std::vector<string> attributionTags1 = {"App1"};
|
|
|
|
std::vector<int> attributionUids2 = {appUid2};
|
|
std::vector<string> attributionTags2 = {"App2"};
|
|
|
|
std::vector<std::unique_ptr<LogEvent>> events;
|
|
events.push_back(CreateUidProcessStateChangedEvent(
|
|
bucketStartTimeNs + 10 * NS_PER_SEC, appUid1,
|
|
android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND)); // 0:20
|
|
events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 20 * NS_PER_SEC,
|
|
attributionUids1, attributionTags1,
|
|
"wakelock1")); // 0:30
|
|
events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 25 * NS_PER_SEC,
|
|
attributionUids1, attributionTags1,
|
|
"wakelock2")); // 0:35
|
|
events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 30 * NS_PER_SEC,
|
|
attributionUids2, attributionTags2,
|
|
"wakelock1")); // 0:40
|
|
events.push_back(CreateAcquireWakelockEvent(bucketStartTimeNs + 35 * NS_PER_SEC,
|
|
attributionUids2, attributionTags2,
|
|
"wakelock2")); // 0:45
|
|
events.push_back(CreateUidProcessStateChangedEvent(
|
|
bucketStartTimeNs + 50 * NS_PER_SEC, appUid2,
|
|
android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND)); // 1:00
|
|
events.push_back(CreateUidProcessStateChangedEvent(
|
|
bucketStartTimeNs + 60 * NS_PER_SEC, appUid1,
|
|
android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND)); // 1:10
|
|
events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 100 * NS_PER_SEC,
|
|
attributionUids2, attributionTags2,
|
|
"wakelock1")); // 1:50
|
|
events.push_back(CreateUidProcessStateChangedEvent(
|
|
bucketStartTimeNs + 120 * NS_PER_SEC, appUid2,
|
|
android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE)); // 2:10
|
|
events.push_back(CreateReleaseWakelockEvent(bucketStartTimeNs + 200 * NS_PER_SEC,
|
|
attributionUids1, attributionTags1,
|
|
"wakelock2")); // 3:30
|
|
|
|
// Send log events to StatsLogProcessor.
|
|
for (auto& event : events) {
|
|
processor->OnLogEvent(event.get());
|
|
}
|
|
|
|
// Check dump report.
|
|
vector<uint8_t> buffer;
|
|
ConfigMetricsReportList reports;
|
|
processor->onDumpReport(cfgKey, bucketStartTimeNs + 320 * NS_PER_SEC,
|
|
true /* include current partial bucket */, true, ADB_DUMP, FAST,
|
|
&buffer);
|
|
ASSERT_GT(buffer.size(), 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStringInReport(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(9, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1,
|
|
"wakelock1");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND,
|
|
data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(40 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(1);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1,
|
|
"wakelock1");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND,
|
|
data.slice_by_state(0).value());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(240 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(20 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(330 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(2);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1,
|
|
"wakelock2");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND,
|
|
data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(35 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(3);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid1,
|
|
"wakelock2");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND,
|
|
data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(140 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(4);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2,
|
|
"wakelock1");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(-1 /* StateTracker:: kStateUnknown */, data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(20 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(5);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2,
|
|
"wakelock1");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND,
|
|
data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(50 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(6);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2,
|
|
"wakelock2");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(-1 /* StateTracker:: kStateUnknown */, data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(15 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(7);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2,
|
|
"wakelock2");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_FOREGROUND_SERVICE,
|
|
data.slice_by_state(0).value());
|
|
ASSERT_EQ(2, data.bucket_info_size());
|
|
EXPECT_EQ(180 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
EXPECT_EQ(20 * NS_PER_SEC, data.bucket_info(1).duration_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(1).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(330 * NS_PER_SEC, data.bucket_info(1).end_bucket_elapsed_nanos());
|
|
|
|
data = durationMetrics.data(8);
|
|
ValidateWakelockAttributionUidAndTagDimension(data.dimensions_in_what(), 10, appUid2,
|
|
"wakelock2");
|
|
ASSERT_EQ(1, data.slice_by_state_size());
|
|
EXPECT_EQ(UID_PROCESS_STATE_ATOM_ID, data.slice_by_state(0).atom_id());
|
|
EXPECT_TRUE(data.slice_by_state(0).has_value());
|
|
EXPECT_EQ(android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND,
|
|
data.slice_by_state(0).value());
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(70 * NS_PER_SEC, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(10 * NS_PER_SEC, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(310 * NS_PER_SEC, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestUploadThreshold) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
auto screenOnMatcher = CreateScreenTurnedOnAtomMatcher();
|
|
auto screenOffMatcher = CreateScreenTurnedOffAtomMatcher();
|
|
*config.add_atom_matcher() = screenOnMatcher;
|
|
*config.add_atom_matcher() = screenOffMatcher;
|
|
|
|
auto durationPredicate = CreateScreenIsOnPredicate();
|
|
*config.add_predicate() = durationPredicate;
|
|
|
|
int64_t thresholdDurationNs = 30 * 1000 * 1000 * 1000LL; // 30 seconds
|
|
UploadThreshold threshold;
|
|
threshold.set_gt_int(thresholdDurationNs);
|
|
|
|
int64_t metricId = 123456;
|
|
auto durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(metricId);
|
|
durationMetric->set_what(durationPredicate.id());
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
durationMetric->set_aggregation_type(DurationMetric_AggregationType_SUM);
|
|
*durationMetric->mutable_threshold() = threshold;
|
|
|
|
const int64_t baseTimeNs = 0; // 0:00
|
|
const int64_t configAddedTimeNs = baseTimeNs + 1 * NS_PER_SEC; // 0:01
|
|
const int64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000LL * 1000LL;
|
|
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
|
|
auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey);
|
|
|
|
ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
|
|
sp<MetricsManager> metricsManager = processor->mMetricsManagers.begin()->second;
|
|
EXPECT_TRUE(metricsManager->isConfigValid());
|
|
ASSERT_EQ(metricsManager->mAllMetricProducers.size(), 1);
|
|
sp<MetricProducer> metricProducer = metricsManager->mAllMetricProducers[0];
|
|
EXPECT_TRUE(metricsManager->isActive());
|
|
EXPECT_TRUE(metricProducer->mIsActive);
|
|
|
|
std::unique_ptr<LogEvent> event;
|
|
|
|
// Screen is off at start of first bucket.
|
|
event = CreateScreenStateChangedEvent(configAddedTimeNs,
|
|
android::view::DISPLAY_STATE_OFF); // 0:01
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn screen on.
|
|
const int64_t durationStartNs = configAddedTimeNs + 10 * NS_PER_SEC; // 0:11
|
|
event = CreateScreenStateChangedEvent(durationStartNs, android::view::DISPLAY_STATE_ON);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn off screen 30 seconds after turning on.
|
|
const int64_t durationEndNs = durationStartNs + 30 * NS_PER_SEC; // 0:41
|
|
event = CreateScreenStateChangedEvent(durationEndNs, android::view::DISPLAY_STATE_OFF);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn screen on in second bucket.
|
|
const int64_t duration2StartNs = configAddedTimeNs + bucketSizeNs + 10 * NS_PER_SEC; // 5:11
|
|
event = CreateScreenStateChangedEvent(duration2StartNs, android::view::DISPLAY_STATE_ON);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
// Turn off screen 31 seconds after turning on.
|
|
const int64_t duration2EndNs = duration2StartNs + 31 * NS_PER_SEC; // 5:42
|
|
event = CreateScreenStateChangedEvent(duration2EndNs, android::view::DISPLAY_STATE_OFF);
|
|
processor->OnLogEvent(event.get());
|
|
|
|
ConfigMetricsReportList reports;
|
|
vector<uint8_t> buffer;
|
|
processor->onDumpReport(cfgKey, configAddedTimeNs + bucketSizeNs * 2 + 1 * NS_PER_SEC, false,
|
|
true, ADB_DUMP, FAST, &buffer); // 10:01
|
|
EXPECT_TRUE(buffer.size() > 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(duration2EndNs - duration2StartNs, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(baseTimeNs + bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(baseTimeNs + bucketSizeNs * 2, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
TEST(DurationMetricE2eTest, TestConditionOnRepeatedEnumField) {
|
|
StatsdConfig config;
|
|
config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
|
|
|
|
AtomMatcher repeatedStateFirstOffAtomMatcher = CreateTestAtomRepeatedStateFirstOffAtomMatcher();
|
|
AtomMatcher repeatedStateFirstOnAtomMatcher = CreateTestAtomRepeatedStateFirstOnAtomMatcher();
|
|
*config.add_atom_matcher() = repeatedStateFirstOffAtomMatcher;
|
|
*config.add_atom_matcher() = repeatedStateFirstOnAtomMatcher;
|
|
|
|
Predicate durationPredicate = CreateTestAtomRepeatedStateFirstOffPredicate();
|
|
*config.add_predicate() = durationPredicate;
|
|
|
|
int64_t metricId = 123456;
|
|
DurationMetric* durationMetric = config.add_duration_metric();
|
|
durationMetric->set_id(metricId);
|
|
durationMetric->set_what(durationPredicate.id());
|
|
durationMetric->set_bucket(FIVE_MINUTES);
|
|
durationMetric->set_aggregation_type(DurationMetric_AggregationType_SUM);
|
|
|
|
const int64_t baseTimeNs = 0; // 0:00
|
|
const int64_t configAddedTimeNs = baseTimeNs + 1 * NS_PER_SEC; // 0:01
|
|
const int64_t bucketSizeNs =
|
|
TimeUnitToBucketSizeInMillis(config.duration_metric(0).bucket()) * 1000LL * 1000LL;
|
|
|
|
int uid = 12345;
|
|
int64_t cfgId = 98765;
|
|
ConfigKey cfgKey(uid, cfgId);
|
|
|
|
sp<StatsLogProcessor> processor =
|
|
CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey);
|
|
|
|
vector<int> intArray = {3, 6};
|
|
vector<int64_t> longArray = {1000L, 10002L};
|
|
vector<float> floatArray = {0.3f, 0.09f};
|
|
vector<string> stringArray = {"str1", "str2"};
|
|
int boolArrayLength = 2;
|
|
bool boolArray[boolArrayLength];
|
|
boolArray[0] = 1;
|
|
boolArray[1] = 0;
|
|
vector<int> enumArrayOff = {TestAtomReported::OFF, TestAtomReported::ON};
|
|
vector<int> enumArrayOn = {TestAtomReported::ON, TestAtomReported::OFF};
|
|
|
|
std::vector<std::unique_ptr<LogEvent>> events;
|
|
uint64_t falseDurationStartNs = configAddedTimeNs + 10 * NS_PER_SEC;
|
|
uint64_t durationStartNs = configAddedTimeNs + 20 * NS_PER_SEC;
|
|
uint64_t durationEndNs = durationStartNs + 50 * NS_PER_SEC;
|
|
|
|
// Condition false
|
|
events.push_back(CreateTestAtomReportedEventVariableRepeatedFields(falseDurationStartNs, {}, {},
|
|
{}, {}, {}, 0, enumArrayOn));
|
|
// Condition true - start collecting duration.
|
|
events.push_back(CreateTestAtomReportedEventVariableRepeatedFields(durationStartNs, {}, {}, {},
|
|
{}, {}, 0, enumArrayOff));
|
|
// Condition false - stop collecting duration.
|
|
events.push_back(CreateTestAtomReportedEventVariableRepeatedFields(durationEndNs, {}, {}, {},
|
|
{}, {}, 0, enumArrayOn));
|
|
|
|
// Send log events to StatsLogProcessor.
|
|
for (auto& event : events) {
|
|
processor->OnLogEvent(event.get());
|
|
}
|
|
|
|
ConfigMetricsReportList reports;
|
|
vector<uint8_t> buffer;
|
|
processor->onDumpReport(cfgKey, configAddedTimeNs + bucketSizeNs + 1 * NS_PER_SEC, false, true,
|
|
ADB_DUMP, FAST, &buffer); // 10:01
|
|
EXPECT_TRUE(buffer.size() > 0);
|
|
EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
|
|
backfillDimensionPath(&reports);
|
|
backfillStartEndTimestamp(&reports);
|
|
ASSERT_EQ(1, reports.reports_size());
|
|
ASSERT_EQ(1, reports.reports(0).metrics_size());
|
|
EXPECT_EQ(metricId, reports.reports(0).metrics(0).metric_id());
|
|
EXPECT_TRUE(reports.reports(0).metrics(0).has_duration_metrics());
|
|
|
|
StatsLogReport::DurationMetricDataWrapper durationMetrics;
|
|
sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).duration_metrics(),
|
|
&durationMetrics);
|
|
ASSERT_EQ(1, durationMetrics.data_size());
|
|
|
|
DurationMetricData data = durationMetrics.data(0);
|
|
ASSERT_EQ(1, data.bucket_info_size());
|
|
EXPECT_EQ(durationEndNs - durationStartNs, data.bucket_info(0).duration_nanos());
|
|
EXPECT_EQ(configAddedTimeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
|
|
EXPECT_EQ(baseTimeNs + bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
|
|
}
|
|
|
|
#else
|
|
GTEST_LOG_(INFO) << "This test does nothing.\n";
|
|
#endif
|
|
|
|
} // namespace statsd
|
|
} // namespace os
|
|
} // namespace android
|