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