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(const GaugeMetric::SamplingType sampling_type,bool useCondition=true)33 StatsdConfig CreateStatsdConfig(const GaugeMetric::SamplingType sampling_type,
34                                 bool useCondition = true) {
35     StatsdConfig config;
36     config.add_allowed_log_source("AID_ROOT"); // LogEvent defaults to UID of root.
37     auto atomMatcher = CreateSimpleAtomMatcher("TestMatcher", android::util::SUBSYSTEM_SLEEP_STATE);
38     *config.add_atom_matcher() = atomMatcher;
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 gaugeMetric = config.add_gauge_metric();
46     gaugeMetric->set_id(metricId);
47     gaugeMetric->set_what(atomMatcher.id());
48     if (useCondition) {
49         gaugeMetric->set_condition(screenIsOffPredicate.id());
50     }
51     gaugeMetric->set_sampling_type(sampling_type);
52     gaugeMetric->mutable_gauge_fields_filter()->set_include_all(true);
53     *gaugeMetric->mutable_dimensions_in_what() =
54             CreateDimensions(android::util::SUBSYSTEM_SLEEP_STATE, {1 /* subsystem name */});
55     gaugeMetric->set_bucket(FIVE_MINUTES);
56     gaugeMetric->set_max_pull_delay_sec(INT_MAX);
57     config.set_hash_strings_in_metric_report(false);
58 
59     return config;
60 }
61 
62 }  // namespace
63 
TEST(GaugeMetricE2eTest,TestRandomSamplePulledEvents)64 TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvents) {
65     auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE);
66     int64_t baseTimeNs = getElapsedRealtimeNs();
67     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
68     int64_t bucketSizeNs =
69         TimeUnitToBucketSizeInMillis(config.gauge_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 gauge 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& nextPullTimeNs =
88             processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
89     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
90 
91     auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
92                                                         configAddedTimeNs + 55);
93     processor->OnLogEvent(screenOffEvent.get());
94 
95     // Pulling alarm arrives on time and reset the sequential pulling alarm.
96     processor->informPullAlarmFired(nextPullTimeNs + 1);
97     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
98 
99     auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
100                                                        configAddedTimeNs + bucketSizeNs + 10);
101     processor->OnLogEvent(screenOnEvent.get());
102 
103     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
104                                                    configAddedTimeNs + bucketSizeNs + 100);
105     processor->OnLogEvent(screenOffEvent.get());
106 
107     processor->informPullAlarmFired(nextPullTimeNs + 1);
108     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs,
109               nextPullTimeNs);
110 
111     processor->informPullAlarmFired(nextPullTimeNs + 1);
112     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs);
113 
114     screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
115                                                   configAddedTimeNs + 3 * bucketSizeNs + 2);
116     processor->OnLogEvent(screenOnEvent.get());
117 
118     processor->informPullAlarmFired(nextPullTimeNs + 3);
119     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
120 
121     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
122                                                   configAddedTimeNs + 5 * bucketSizeNs + 1);
123     processor->OnLogEvent(screenOffEvent.get());
124 
125     processor->informPullAlarmFired(nextPullTimeNs + 2);
126     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, nextPullTimeNs);
127 
128     processor->informPullAlarmFired(nextPullTimeNs + 2);
129 
130     ConfigMetricsReportList reports;
131     vector<uint8_t> buffer;
132     processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
133                             ADB_DUMP, FAST, &buffer);
134     EXPECT_TRUE(buffer.size() > 0);
135     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
136     backfillDimensionPath(&reports);
137     backfillStringInReport(&reports);
138     backfillStartEndTimestamp(&reports);
139     EXPECT_EQ(1, reports.reports_size());
140     EXPECT_EQ(1, reports.reports(0).metrics_size());
141     StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
142     sortMetricDataByDimensionsValue(
143             reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
144     EXPECT_GT((int)gaugeMetrics.data_size(), 1);
145 
146     auto data = gaugeMetrics.data(0);
147     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
148     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
149     EXPECT_EQ(1 /* subsystem name field */,
150               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
151     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
152     EXPECT_EQ(6, data.bucket_info_size());
153 
154     EXPECT_EQ(1, data.bucket_info(0).atom_size());
155     EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
156     EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
157     EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
158     EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
159     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
160     EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
161     EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
162 
163     EXPECT_EQ(1, data.bucket_info(1).atom_size());
164     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1,
165               data.bucket_info(1).elapsed_timestamp_nanos(0));
166     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0));
167     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
168     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
169     EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
170     EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
171 
172     EXPECT_EQ(1, data.bucket_info(2).atom_size());
173     EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
174     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1,
175               data.bucket_info(2).elapsed_timestamp_nanos(0));
176     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
177     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
178     EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
179     EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
180 
181     EXPECT_EQ(1, data.bucket_info(3).atom_size());
182     EXPECT_EQ(1, data.bucket_info(3).elapsed_timestamp_nanos_size());
183     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 1,
184               data.bucket_info(3).elapsed_timestamp_nanos(0));
185     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos());
186     EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos());
187     EXPECT_TRUE(data.bucket_info(3).atom(0).subsystem_sleep_state().subsystem_name().empty());
188     EXPECT_GT(data.bucket_info(3).atom(0).subsystem_sleep_state().time_millis(), 0);
189 
190     EXPECT_EQ(1, data.bucket_info(4).atom_size());
191     EXPECT_EQ(1, data.bucket_info(4).elapsed_timestamp_nanos_size());
192     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1,
193               data.bucket_info(4).elapsed_timestamp_nanos(0));
194     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(4).start_bucket_elapsed_nanos());
195     EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(4).end_bucket_elapsed_nanos());
196     EXPECT_TRUE(data.bucket_info(4).atom(0).subsystem_sleep_state().subsystem_name().empty());
197     EXPECT_GT(data.bucket_info(4).atom(0).subsystem_sleep_state().time_millis(), 0);
198 
199     EXPECT_EQ(1, data.bucket_info(5).atom_size());
200     EXPECT_EQ(1, data.bucket_info(5).elapsed_timestamp_nanos_size());
201     EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs + 2,
202               data.bucket_info(5).elapsed_timestamp_nanos(0));
203     EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(5).start_bucket_elapsed_nanos());
204     EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(5).end_bucket_elapsed_nanos());
205     EXPECT_TRUE(data.bucket_info(5).atom(0).subsystem_sleep_state().subsystem_name().empty());
206     EXPECT_GT(data.bucket_info(5).atom(0).subsystem_sleep_state().time_millis(), 0);
207 }
208 
TEST(GaugeMetricE2eTest,TestConditionChangeToTrueSamplePulledEvents)209 TEST(GaugeMetricE2eTest, TestConditionChangeToTrueSamplePulledEvents) {
210     auto config = CreateStatsdConfig(GaugeMetric::CONDITION_CHANGE_TO_TRUE);
211     int64_t baseTimeNs = getElapsedRealtimeNs();
212     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
213     int64_t bucketSizeNs =
214         TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
215 
216     ConfigKey cfgKey;
217     auto processor = CreateStatsLogProcessor(
218         baseTimeNs, configAddedTimeNs, config, cfgKey);
219     EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
220     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
221     processor->mPullerManager->ForceClearPullerCache();
222 
223     int startBucketNum = processor->mMetricsManagers.begin()->second->
224             mAllMetricProducers[0]->getCurrentBucketNum();
225     EXPECT_GT(startBucketNum, (int64_t)0);
226 
227     auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
228                                                         configAddedTimeNs + 55);
229     processor->OnLogEvent(screenOffEvent.get());
230 
231     auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
232                                                        configAddedTimeNs + bucketSizeNs + 10);
233     processor->OnLogEvent(screenOnEvent.get());
234 
235     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
236                                                    configAddedTimeNs + bucketSizeNs + 100);
237     processor->OnLogEvent(screenOffEvent.get());
238 
239     screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
240                                                   configAddedTimeNs + 3 * bucketSizeNs + 2);
241     processor->OnLogEvent(screenOnEvent.get());
242 
243     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
244                                                   configAddedTimeNs + 5 * bucketSizeNs + 1);
245     processor->OnLogEvent(screenOffEvent.get());
246     screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
247                                                   configAddedTimeNs + 5 * bucketSizeNs + 3);
248     processor->OnLogEvent(screenOnEvent.get());
249     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
250                                                   configAddedTimeNs + 5 * bucketSizeNs + 10);
251     processor->OnLogEvent(screenOffEvent.get());
252 
253     ConfigMetricsReportList reports;
254     vector<uint8_t> buffer;
255     processor->onDumpReport(cfgKey, configAddedTimeNs + 8 * bucketSizeNs + 10, false, true,
256                             ADB_DUMP, FAST, &buffer);
257     EXPECT_TRUE(buffer.size() > 0);
258     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
259     backfillDimensionPath(&reports);
260     backfillStringInReport(&reports);
261     backfillStartEndTimestamp(&reports);
262     EXPECT_EQ(1, reports.reports_size());
263     EXPECT_EQ(1, reports.reports(0).metrics_size());
264     StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
265     sortMetricDataByDimensionsValue(
266             reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
267     EXPECT_GT((int)gaugeMetrics.data_size(), 1);
268 
269     auto data = gaugeMetrics.data(0);
270     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
271     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
272     EXPECT_EQ(1 /* subsystem name field */,
273               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
274     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
275     EXPECT_EQ(3, data.bucket_info_size());
276 
277     EXPECT_EQ(1, data.bucket_info(0).atom_size());
278     EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
279     EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
280     EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
281     EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
282     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
283     EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
284     EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
285 
286     EXPECT_EQ(1, data.bucket_info(1).atom_size());
287     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 100,
288               data.bucket_info(1).elapsed_timestamp_nanos(0));
289     EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
290     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
291     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
292     EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
293     EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
294 
295     EXPECT_EQ(2, data.bucket_info(2).atom_size());
296     EXPECT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size());
297     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1,
298               data.bucket_info(2).elapsed_timestamp_nanos(0));
299     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 10,
300               data.bucket_info(2).elapsed_timestamp_nanos(1));
301     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
302     EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
303     EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
304     EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
305     EXPECT_TRUE(data.bucket_info(2).atom(1).subsystem_sleep_state().subsystem_name().empty());
306     EXPECT_GT(data.bucket_info(2).atom(1).subsystem_sleep_state().time_millis(), 0);
307 }
308 
309 
TEST(GaugeMetricE2eTest,TestRandomSamplePulledEvent_LateAlarm)310 TEST(GaugeMetricE2eTest, TestRandomSamplePulledEvent_LateAlarm) {
311     auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE);
312     int64_t baseTimeNs = getElapsedRealtimeNs();
313     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
314     int64_t bucketSizeNs =
315         TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
316 
317     ConfigKey cfgKey;
318     auto processor = CreateStatsLogProcessor(
319         baseTimeNs, configAddedTimeNs, config, cfgKey);
320     EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
321     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
322     processor->mPullerManager->ForceClearPullerCache();
323 
324     int startBucketNum = processor->mMetricsManagers.begin()->second->
325             mAllMetricProducers[0]->getCurrentBucketNum();
326     EXPECT_GT(startBucketNum, (int64_t)0);
327 
328     // When creating the config, the gauge metric producer should register the alarm at the
329     // end of the current bucket.
330     EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
331     EXPECT_EQ(bucketSizeNs,
332               processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
333     int64_t& nextPullTimeNs =
334             processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
335     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
336 
337     auto screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
338                                                         configAddedTimeNs + 55);
339     processor->OnLogEvent(screenOffEvent.get());
340 
341     auto screenOnEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_ON,
342                                                        configAddedTimeNs + bucketSizeNs + 10);
343     processor->OnLogEvent(screenOnEvent.get());
344 
345     // Pulling alarm arrives one bucket size late.
346     processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs);
347     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs);
348 
349     screenOffEvent = CreateScreenStateChangedEvent(android::view::DISPLAY_STATE_OFF,
350                                                    configAddedTimeNs + 3 * bucketSizeNs + 11);
351     processor->OnLogEvent(screenOffEvent.get());
352 
353     // Pulling alarm arrives more than one bucket size late.
354     processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs + 12);
355     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
356 
357     ConfigMetricsReportList reports;
358     vector<uint8_t> buffer;
359     processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
360                             ADB_DUMP, FAST, &buffer);
361     EXPECT_TRUE(buffer.size() > 0);
362     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
363     backfillDimensionPath(&reports);
364     backfillStringInReport(&reports);
365     backfillStartEndTimestamp(&reports);
366     EXPECT_EQ(1, reports.reports_size());
367     EXPECT_EQ(1, reports.reports(0).metrics_size());
368     StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
369     sortMetricDataByDimensionsValue(
370             reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
371     EXPECT_GT((int)gaugeMetrics.data_size(), 1);
372 
373     auto data = gaugeMetrics.data(0);
374     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
375     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
376     EXPECT_EQ(1 /* subsystem name field */,
377               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
378     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
379     EXPECT_EQ(3, data.bucket_info_size());
380 
381     EXPECT_EQ(1, data.bucket_info(0).atom_size());
382     EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
383     EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
384     EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
385     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
386     EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
387     EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
388 
389     EXPECT_EQ(1, data.bucket_info(1).atom_size());
390     EXPECT_EQ(configAddedTimeNs + 3 * bucketSizeNs + 11,
391               data.bucket_info(1).elapsed_timestamp_nanos(0));
392     EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
393     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
394     EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
395     EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
396     EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
397 
398     EXPECT_EQ(1, data.bucket_info(2).atom_size());
399     EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
400     EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs + 12,
401               data.bucket_info(2).elapsed_timestamp_nanos(0));
402     EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
403     EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
404     EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
405     EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
406 }
407 
TEST(GaugeMetricE2eTest,TestRandomSamplePulledEventsWithActivation)408 TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsWithActivation) {
409     auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);
410 
411     int64_t baseTimeNs = getElapsedRealtimeNs();
412     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
413     int64_t bucketSizeNs =
414         TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
415 
416     auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher();
417     *config.add_atom_matcher() = batterySaverStartMatcher;
418     const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets.
419     auto metric_activation = config.add_metric_activation();
420     metric_activation->set_metric_id(metricId);
421     metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY);
422     auto event_activation = metric_activation->add_event_activation();
423     event_activation->set_atom_matcher_id(batterySaverStartMatcher.id());
424     event_activation->set_ttl_seconds(ttlNs / 1000000000);
425 
426     ConfigKey cfgKey;
427     auto processor = CreateStatsLogProcessor(
428         baseTimeNs, configAddedTimeNs, config, cfgKey);
429     EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
430     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
431     processor->mPullerManager->ForceClearPullerCache();
432 
433     int startBucketNum = processor->mMetricsManagers.begin()->second->
434             mAllMetricProducers[0]->getCurrentBucketNum();
435     EXPECT_GT(startBucketNum, (int64_t)0);
436     EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
437 
438     // When creating the config, the gauge metric producer should register the alarm at the
439     // end of the current bucket.
440     EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
441     EXPECT_EQ(bucketSizeNs,
442               processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
443     int64_t& nextPullTimeNs =
444             processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
445     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
446 
447     // Pulling alarm arrives on time and reset the sequential pulling alarm.
448     // Event should not be kept.
449     processor->informPullAlarmFired(nextPullTimeNs + 1); // 15 mins + 1 ns.
450     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
451     EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
452 
453     // Activate the metric. A pull occurs upon activation.
454     const int64_t activationNs = configAddedTimeNs + bucketSizeNs + (2 * 1000 * 1000); // 2 millis.
455     auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs);
456     processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 2 ms.
457     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
458 
459     // This event should be kept. 2 total.
460     processor->informPullAlarmFired(nextPullTimeNs + 1); // 20 mins + 1 ns.
461     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs,
462               nextPullTimeNs);
463 
464     // This event should be kept. 3 total.
465     processor->informPullAlarmFired(nextPullTimeNs + 2); // 25 mins + 2 ns.
466     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs);
467 
468     // Create random event to deactivate metric.
469     auto deactivationEvent = CreateScreenBrightnessChangedEvent(50, activationNs + ttlNs + 1);
470     processor->OnLogEvent(deactivationEvent.get());
471     EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
472 
473     // Event should not be kept. 3 total.
474     processor->informPullAlarmFired(nextPullTimeNs + 3);
475     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
476 
477     processor->informPullAlarmFired(nextPullTimeNs + 2);
478 
479     ConfigMetricsReportList reports;
480     vector<uint8_t> buffer;
481     processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
482                             ADB_DUMP, FAST, &buffer);
483     EXPECT_TRUE(buffer.size() > 0);
484     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
485     backfillDimensionPath(&reports);
486     backfillStringInReport(&reports);
487     backfillStartEndTimestamp(&reports);
488     EXPECT_EQ(1, reports.reports_size());
489     EXPECT_EQ(1, reports.reports(0).metrics_size());
490     StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
491     sortMetricDataByDimensionsValue(
492             reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
493     EXPECT_GT((int)gaugeMetrics.data_size(), 0);
494 
495     auto data = gaugeMetrics.data(0);
496     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
497     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
498     EXPECT_EQ(1 /* subsystem name field */,
499               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
500     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
501     EXPECT_EQ(3, data.bucket_info_size());
502 
503     auto bucketInfo = data.bucket_info(0);
504     EXPECT_EQ(1, bucketInfo.atom_size());
505     EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
506     EXPECT_EQ(activationNs, bucketInfo.elapsed_timestamp_nanos(0));
507     EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
508     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
509     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
510     EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
511     EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
512 
513     bucketInfo = data.bucket_info(1);
514     EXPECT_EQ(1, bucketInfo.atom_size());
515     EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
516     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, bucketInfo.elapsed_timestamp_nanos(0));
517     EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
518     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
519     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
520     EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
521     EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
522 
523     bucketInfo = data.bucket_info(2);
524     EXPECT_EQ(1, bucketInfo.atom_size());
525     EXPECT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
526     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 2, bucketInfo.elapsed_timestamp_nanos(0));
527     EXPECT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
528     EXPECT_EQ(MillisToNano(NanoToMillis(baseTimeNs + 5 * bucketSizeNs)),
529             bucketInfo.start_bucket_elapsed_nanos());
530     EXPECT_EQ(MillisToNano(NanoToMillis(activationNs + ttlNs + 1)),
531             bucketInfo.end_bucket_elapsed_nanos());
532     EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
533     EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
534 }
535 
TEST(GaugeMetricE2eTest,TestRandomSamplePulledEventsNoCondition)536 TEST(GaugeMetricE2eTest, TestRandomSamplePulledEventsNoCondition) {
537     auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);
538 
539     int64_t baseTimeNs = getElapsedRealtimeNs();
540     int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
541     int64_t bucketSizeNs =
542         TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
543 
544     ConfigKey cfgKey;
545     auto processor = CreateStatsLogProcessor(
546         baseTimeNs, configAddedTimeNs, config, cfgKey);
547     EXPECT_EQ(processor->mMetricsManagers.size(), 1u);
548     EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
549     processor->mPullerManager->ForceClearPullerCache();
550 
551     int startBucketNum = processor->mMetricsManagers.begin()->second->
552             mAllMetricProducers[0]->getCurrentBucketNum();
553     EXPECT_GT(startBucketNum, (int64_t)0);
554 
555     // When creating the config, the gauge metric producer should register the alarm at the
556     // end of the current bucket.
557     EXPECT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
558     EXPECT_EQ(bucketSizeNs,
559               processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
560     int64_t& nextPullTimeNs =
561             processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
562     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
563 
564     // Pulling alarm arrives on time and reset the sequential pulling alarm.
565     processor->informPullAlarmFired(nextPullTimeNs + 1);
566     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
567 
568     processor->informPullAlarmFired(nextPullTimeNs + 4);
569     EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs,
570               nextPullTimeNs);
571 
572     ConfigMetricsReportList reports;
573     vector<uint8_t> buffer;
574     processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
575                             ADB_DUMP, FAST, &buffer);
576     EXPECT_TRUE(buffer.size() > 0);
577     EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
578     backfillDimensionPath(&reports);
579     backfillStringInReport(&reports);
580     backfillStartEndTimestamp(&reports);
581     EXPECT_EQ(1, reports.reports_size());
582     EXPECT_EQ(1, reports.reports(0).metrics_size());
583     StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
584     sortMetricDataByDimensionsValue(
585             reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
586     EXPECT_GT((int)gaugeMetrics.data_size(), 0);
587 
588     auto data = gaugeMetrics.data(0);
589     EXPECT_EQ(android::util::SUBSYSTEM_SLEEP_STATE, data.dimensions_in_what().field());
590     EXPECT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
591     EXPECT_EQ(1 /* subsystem name field */,
592               data.dimensions_in_what().value_tuple().dimensions_value(0).field());
593     EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
594     EXPECT_EQ(3, data.bucket_info_size());
595 
596     EXPECT_EQ(1, data.bucket_info(0).atom_size());
597     EXPECT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
598     EXPECT_EQ(configAddedTimeNs, data.bucket_info(0).elapsed_timestamp_nanos(0));
599     EXPECT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
600     EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
601     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
602     EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
603     EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
604 
605     EXPECT_EQ(1, data.bucket_info(1).atom_size());
606     EXPECT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size());
607     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0));
608     EXPECT_EQ(0, data.bucket_info(1).wall_clock_timestamp_nanos_size());
609     EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
610     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
611     EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
612     EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
613 
614     EXPECT_EQ(1, data.bucket_info(2).atom_size());
615     EXPECT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
616     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 4, data.bucket_info(2).elapsed_timestamp_nanos(0));
617     EXPECT_EQ(0, data.bucket_info(2).wall_clock_timestamp_nanos_size());
618     EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
619     EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
620     EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
621     EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
622 }
623 
624 #else
625 GTEST_LOG_(INFO) << "This test does nothing.\n";
626 #endif
627 
628 }  // namespace statsd
629 }  // namespace os
630 }  // namespace android
631