1 // Copyright (C) 2017 The Android Open Source Project
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License");
4 // you may not use this file except in compliance with the License.
5 // You may obtain a copy of the License at
6 //
7 //      http://www.apache.org/licenses/LICENSE-2.0
8 //
9 // Unless required by applicable law or agreed to in writing, software
10 // distributed under the License is distributed on an "AS IS" BASIS,
11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 // See the License for the specific language governing permissions and
13 // limitations under the License.
14 
15 #include <gtest/gtest.h>
16 
17 #include "src/StatsLogProcessor.h"
18 #include "src/stats_log_util.h"
19 #include "tests/statsd_test_util.h"
20 
21 #include <vector>
22 
23 namespace android {
24 namespace os {
25 namespace statsd {
26 
27 #ifdef __ANDROID__
28 
29 namespace {
30 
31 const int64_t metricId = 123456;
32 
CreateStatsdConfig(bool useCondition=true)33 StatsdConfig CreateStatsdConfig(bool useCondition = true) {
34     StatsdConfig config;
35     config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
36     auto pulledAtomMatcher =
37             CreateSimpleAtomMatcher("TestMatcher", android::util::SUBSYSTEM_SLEEP_STATE);
38     *config.add_atom_matcher() = pulledAtomMatcher;
39     *config.add_atom_matcher() = CreateScreenTurnedOnAtomMatcher();
40     *config.add_atom_matcher() = CreateScreenTurnedOffAtomMatcher();
41 
42     auto screenIsOffPredicate = CreateScreenIsOffPredicate();
43     *config.add_predicate() = screenIsOffPredicate;
44 
45     auto valueMetric = config.add_value_metric();
46     valueMetric->set_id(metricId);
47     valueMetric->set_what(pulledAtomMatcher.id());
48     if (useCondition) {
49         valueMetric->set_condition(screenIsOffPredicate.id());
50     }
51     *valueMetric->mutable_value_field() =
52             CreateDimensions(android::util::SUBSYSTEM_SLEEP_STATE, {4 /* time sleeping field */});
53     *valueMetric->mutable_dimensions_in_what() =
54             CreateDimensions(android::util::SUBSYSTEM_SLEEP_STATE, {1 /* subsystem name */});
55     valueMetric->set_bucket(FIVE_MINUTES);
56     valueMetric->set_use_absolute_value_on_reset(true);
57     valueMetric->set_skip_zero_diff_output(false);
58     valueMetric->set_max_pull_delay_sec(INT_MAX);
59     return config;
60 }
61 
62 }  // namespace
63 
TEST(ValueMetricE2eTest,TestPulledEvents)64 TEST(ValueMetricE2eTest, TestPulledEvents) {
65     auto config = CreateStatsdConfig();
66     int64_t baseTimeNs = getElapsedRealtimeNs();
67     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
68     int64_t bucketSizeNs =
69         TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000;
70 
71     ConfigKey cfgKey;
72     auto processor = CreateStatsLogProcessor(
73         baseTimeNs, configAddedTimeNs, config, cfgKey);
74     EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
75     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
76     processor->mPullerManager->ForceClearPullerCache();
77 
78     int startBucketNum = processor->mMetricsManagers.begin()->second->
79             mAllMetricProducers[0]->getCurrentBucketNum();
80     EXPECT_GT(startBucketNum, (int64_t)0);
81 
82     // When creating the config, the value metric producer should register the alarm at the
83     // end of the current bucket.
84     EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
85     EXPECT_EQ(bucketSizeNs,
86               processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
87     int64_t& expectedPullTimeNs =
88             processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
89     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs);
90 
91     auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
92                                                         configAddedTimeNs + 55);
93     processor->OnLogEvent(screenOffEvent.get());
94 
95     auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
96                                                        configAddedTimeNs + 65);
97     processor->OnLogEvent(screenOnEvent.get());
98 
99     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
100                                                    configAddedTimeNs + 75);
101     processor->OnLogEvent(screenOffEvent.get());
102 
103     // Pulling alarm arrives on time and reset the sequential pulling alarm.
104     processor->informPullAlarmFired(expectedPullTimeNs + 1);
105     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, expectedPullTimeNs);
106 
107     processor->informPullAlarmFired(expectedPullTimeNs + 1);
108 
109     screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
110                                                        configAddedTimeNs + 2 * bucketSizeNs + 15);
111     processor->OnLogEvent(screenOnEvent.get());
112 
113     processor->informPullAlarmFired(expectedPullTimeNs + 1);
114 
115     processor->informPullAlarmFired(expectedPullTimeNs + 1);
116 
117     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
118                                                    configAddedTimeNs + 4 * bucketSizeNs + 11);
119     processor->OnLogEvent(screenOffEvent.get());
120 
121     processor->informPullAlarmFired(expectedPullTimeNs + 1);
122 
123     processor->informPullAlarmFired(expectedPullTimeNs + 1);
124 
125     ConfigMetricsReportList reports;
126     vector<uint8_t> buffer;
127     processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
128                             ADB_DUMP, FAST, &buffer);
129     EXPECT_TRUE(buffer.size() > 0);
130     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
131     backfillDimensionPath(&reports);
132     backfillStringInReport(&reports);
133     backfillStartEndTimestamp(&reports);
134     EXPECT_EQ(1, reports.reports_size());
135     EXPECT_EQ(1, reports.reports(0).metrics_size());
136     StatsLogReport::ValueMetricDataWrapper valueMetrics;
137     sortMetricDataByDimensionsValue(
138             reports.reports(0).metrics(0).value_metrics(), &valueMetrics);
139     EXPECT_GT((int)valueMetrics.data_size(), 1);
140 
141     auto data = valueMetrics.data(0);
142     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
143     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
144     EXPECT_EQ(1 /* subsystem name field */,
145               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
146     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
147     // We have 4 buckets, the first one was incomplete since the condition was unknown.
148     EXPECT_EQ(4, data.bucket_info_size());
149 
150     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
151     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
152     EXPECT_EQ(1, data.bucket_info(0).values_size());
153 
154     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
155     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
156     EXPECT_EQ(1, data.bucket_info(1).values_size());
157 
158     EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
159     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
160     EXPECT_EQ(1, data.bucket_info(2).values_size());
161 
162     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos());
163     EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos());
164     EXPECT_EQ(1, data.bucket_info(3).values_size());
165 }
166 
TEST(ValueMetricE2eTest,TestPulledEvents_LateAlarm)167 TEST(ValueMetricE2eTest, TestPulledEvents_LateAlarm) {
168     auto config = CreateStatsdConfig();
169     int64_t baseTimeNs = getElapsedRealtimeNs();
170     // 10 mins == 2 bucket durations.
171     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
172     int64_t bucketSizeNs =
173         TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000;
174 
175     ConfigKey cfgKey;
176     auto processor = CreateStatsLogProcessor(
177         baseTimeNs, configAddedTimeNs, config, cfgKey);
178     EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
179     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
180     processor->mPullerManager->ForceClearPullerCache();
181 
182     int startBucketNum = processor->mMetricsManagers.begin()->second->
183             mAllMetricProducers[0]->getCurrentBucketNum();
184     EXPECT_GT(startBucketNum, (int64_t)0);
185 
186     // When creating the config, the value metric producer should register the alarm at the
187     // end of the current bucket.
188     EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
189     EXPECT_EQ(bucketSizeNs,
190               processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
191     int64_t& expectedPullTimeNs =
192             processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
193     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs);
194 
195     // Screen off/on/off events.
196     auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
197                                                         configAddedTimeNs + 55);
198     processor->OnLogEvent(screenOffEvent.get());
199 
200     auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
201                                                        configAddedTimeNs + 65);
202     processor->OnLogEvent(screenOnEvent.get());
203 
204     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
205                                                    configAddedTimeNs + 75);
206     processor->OnLogEvent(screenOffEvent.get());
207 
208     // Pulling alarm arrives late by 2 buckets and 1 ns. 2 buckets late is too far away in the
209     // future, data will be skipped.
210     processor->informPullAlarmFired(expectedPullTimeNs + 2 * bucketSizeNs + 1);
211     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, expectedPullTimeNs);
212 
213     // This screen state change will start a new bucket.
214     screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
215                                                        configAddedTimeNs + 4 * bucketSizeNs + 65);
216     processor->OnLogEvent(screenOnEvent.get());
217 
218     // The alarm is delayed but we already created a bucket thanks to the screen state condition.
219     // This bucket does not have to be skipped since the alarm arrives in time for the next bucket.
220     processor->informPullAlarmFired(expectedPullTimeNs + bucketSizeNs + 21);
221     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, expectedPullTimeNs);
222 
223     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
224                                                    configAddedTimeNs + 6 * bucketSizeNs + 31);
225     processor->OnLogEvent(screenOffEvent.get());
226 
227     processor->informPullAlarmFired(expectedPullTimeNs + bucketSizeNs + 21);
228     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 8 * bucketSizeNs, expectedPullTimeNs);
229 
230     processor->informPullAlarmFired(expectedPullTimeNs + 1);
231     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 9 * bucketSizeNs, expectedPullTimeNs);
232 
233     ConfigMetricsReportList reports;
234     vector<uint8_t> buffer;
235     processor->onDumpReport(cfgKey, configAddedTimeNs + 9 * bucketSizeNs + 10, false, true,
236                             ADB_DUMP, FAST, &buffer);
237     EXPECT_TRUE(buffer.size() > 0);
238     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
239     backfillDimensionPath(&reports);
240     backfillStringInReport(&reports);
241     backfillStartEndTimestamp(&reports);
242     EXPECT_EQ(1, reports.reports_size());
243     EXPECT_EQ(1, reports.reports(0).metrics_size());
244     StatsLogReport::ValueMetricDataWrapper valueMetrics;
245     sortMetricDataByDimensionsValue(
246             reports.reports(0).metrics(0).value_metrics(), &valueMetrics);
247     EXPECT_GT((int)valueMetrics.data_size(), 1);
248 
249     auto data = valueMetrics.data(0);
250     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
251     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
252     EXPECT_EQ(1 /* subsystem name field */,
253               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
254     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
255     EXPECT_EQ(3, data.bucket_info_size());
256 
257     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
258     EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
259     EXPECT_EQ(1, data.bucket_info(0).values_size());
260 
261     EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
262     EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
263     EXPECT_EQ(1, data.bucket_info(1).values_size());
264 
265     EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
266     EXPECT_EQ(baseTimeNs + 10 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
267     EXPECT_EQ(1, data.bucket_info(2).values_size());
268 }
269 
TEST(ValueMetricE2eTest,TestPulledEvents_WithActivation)270 TEST(ValueMetricE2eTest, TestPulledEvents_WithActivation) {
271     auto config = CreateStatsdConfig(false);
272     int64_t baseTimeNs = getElapsedRealtimeNs();
273     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
274     int64_t bucketSizeNs =
275         TimeUnitToBucketSizeInMillis(config.value_metric(0).bucket()) * 1000000;
276 
277     auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher();
278     *config.add_atom_matcher() = batterySaverStartMatcher;
279     const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets.
280     auto metric_activation = config.add_metric_activation();
281     metric_activation->set_metric_id(metricId);
282     metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY);
283     auto event_activation = metric_activation->add_event_activation();
284     event_activation->set_atom_matcher_id(batterySaverStartMatcher.id());
285     event_activation->set_ttl_seconds(ttlNs / 1000000000);
286 
287     ConfigKey cfgKey;
288     auto processor = CreateStatsLogProcessor(
289         baseTimeNs, configAddedTimeNs, config, cfgKey);
290     EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
291     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
292     processor->mPullerManager->ForceClearPullerCache();
293 
294     int startBucketNum = processor->mMetricsManagers.begin()->second->
295             mAllMetricProducers[0]->getCurrentBucketNum();
296     EXPECT_GT(startBucketNum, (int64_t)0);
297     EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
298 
299     // When creating the config, the value metric producer should register the alarm at the
300     // end of the current bucket.
301     EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
302     EXPECT_EQ(bucketSizeNs,
303               processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
304     int64_t& expectedPullTimeNs =
305             processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
306     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, expectedPullTimeNs);
307 
308     // Pulling alarm arrives on time and reset the sequential pulling alarm.
309     processor->informPullAlarmFired(expectedPullTimeNs + 1); // 15 mins + 1 ns.
310     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, expectedPullTimeNs);
311     EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
312 
313     // Activate the metric. A pull occurs here
314     const int64_t activationNs = configAddedTimeNs + bucketSizeNs + (2 * 1000 * 1000); // 2 millis.
315     auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs);
316     processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 2 ms.
317     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
318 
319     processor->informPullAlarmFired(expectedPullTimeNs + 1); // 20 mins + 1 ns.
320     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, expectedPullTimeNs);
321 
322     processor->informPullAlarmFired(expectedPullTimeNs + 2); // 25 mins + 2 ns.
323     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, expectedPullTimeNs);
324 
325     // Create random event to deactivate metric.
326     auto deactivationEvent = CreateScreenBrightnessChangedEvent(50, activationNs + ttlNs + 1);
327     processor->OnLogEvent(deactivationEvent.get());
328     EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
329 
330     processor->informPullAlarmFired(expectedPullTimeNs + 3);
331     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, expectedPullTimeNs);
332 
333     processor->informPullAlarmFired(expectedPullTimeNs + 4);
334     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, expectedPullTimeNs);
335 
336     ConfigMetricsReportList reports;
337     vector<uint8_t> buffer;
338     processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
339                             ADB_DUMP, FAST, &buffer);
340     EXPECT_TRUE(buffer.size() > 0);
341     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
342     backfillDimensionPath(&reports);
343     backfillStringInReport(&reports);
344     backfillStartEndTimestamp(&reports);
345     EXPECT_EQ(1, reports.reports_size());
346     EXPECT_EQ(1, reports.reports(0).metrics_size());
347     StatsLogReport::ValueMetricDataWrapper valueMetrics;
348     sortMetricDataByDimensionsValue(
349             reports.reports(0).metrics(0).value_metrics(), &valueMetrics);
350     EXPECT_GT((int)valueMetrics.data_size(), 0);
351 
352     auto data = valueMetrics.data(0);
353     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
354     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
355     EXPECT_EQ(1 /* subsystem name field */,
356               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
357     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
358     // We have 2 full buckets, the two surrounding the activation are dropped.
359     EXPECT_EQ(2, data.bucket_info_size());
360 
361     auto bucketInfo = data.bucket_info(0);
362     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
363     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
364     EXPECT_EQ(1, bucketInfo.values_size());
365 
366     bucketInfo = data.bucket_info(1);
367     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
368     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
369     EXPECT_EQ(1, bucketInfo.values_size());
370 }
371 
372 #else
373 GTEST_LOG_(INFO) << "This test does nothing.\n";
374 #endif
375 
376 }  // namespace statsd
377 }  // namespace os
378 }  // namespace android
379