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_default_pull_packages("AID_ROOT"); // Fake puller is registered with root.
41 auto atomMatcher = CreateSimpleAtomMatcher("TestMatcher", ATOM_TAG);
42 *config.add_atom_matcher() = atomMatcher;
43 *config.add_atom_matcher() = CreateScreenTurnedOnAtomMatcher();
44 *config.add_atom_matcher() = CreateScreenTurnedOffAtomMatcher();
45
46 auto screenIsOffPredicate = CreateScreenIsOffPredicate();
47 *config.add_predicate() = screenIsOffPredicate;
48
49 auto gaugeMetric = config.add_gauge_metric();
50 gaugeMetric->set_id(metricId);
51 gaugeMetric->set_what(atomMatcher.id());
52 if (useCondition) {
53 gaugeMetric->set_condition(screenIsOffPredicate.id());
54 }
55 gaugeMetric->set_sampling_type(sampling_type);
56 *gaugeMetric->mutable_dimensions_in_what() =
57 CreateDimensions(ATOM_TAG, {1 /* subsystem name */});
58 gaugeMetric->set_bucket(FIVE_MINUTES);
59 gaugeMetric->set_max_pull_delay_sec(INT_MAX);
60 config.set_hash_strings_in_metric_report(false);
61 gaugeMetric->set_split_bucket_for_app_upgrade(true);
62 gaugeMetric->set_min_bucket_size_nanos(1000);
63
64 return config;
65 }
66
67 } // namespaces
68
TEST(GaugeMetricE2ePulledTest,TestRandomSamplePulledEvents)69 TEST(GaugeMetricE2ePulledTest, TestRandomSamplePulledEvents) {
70 auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE);
71 int64_t baseTimeNs = getElapsedRealtimeNs();
72 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
73 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
74
75 ConfigKey cfgKey;
76 auto processor =
77 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
78 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
79 ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
80 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
81 processor->mPullerManager->ForceClearPullerCache();
82
83 int startBucketNum = processor->mMetricsManagers.begin()
84 ->second->mAllMetricProducers[0]
85 ->getCurrentBucketNum();
86 EXPECT_GT(startBucketNum, (int64_t)0);
87
88 // When creating the config, the gauge metric producer should register the alarm at the
89 // end of the current bucket.
90 ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
91 EXPECT_EQ(bucketSizeNs,
92 processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
93 int64_t& nextPullTimeNs =
94 processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
95 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
96
97 auto screenOffEvent =
98 CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
99 processor->OnLogEvent(screenOffEvent.get());
100
101 // Pulling alarm arrives on time and reset the sequential pulling alarm.
102 processor->informPullAlarmFired(nextPullTimeNs + 1);
103 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
104
105 auto screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
106 android::view::DISPLAY_STATE_ON);
107 processor->OnLogEvent(screenOnEvent.get());
108
109 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 100,
110 android::view::DISPLAY_STATE_OFF);
111 processor->OnLogEvent(screenOffEvent.get());
112
113 processor->informPullAlarmFired(nextPullTimeNs + 1);
114 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs);
115
116 processor->informPullAlarmFired(nextPullTimeNs + 1);
117 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs);
118
119 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 2,
120 android::view::DISPLAY_STATE_ON);
121 processor->OnLogEvent(screenOnEvent.get());
122
123 processor->informPullAlarmFired(nextPullTimeNs + 3);
124 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
125
126 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 1,
127 android::view::DISPLAY_STATE_OFF);
128 processor->OnLogEvent(screenOffEvent.get());
129
130 processor->informPullAlarmFired(nextPullTimeNs + 2);
131 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, nextPullTimeNs);
132
133 processor->informPullAlarmFired(nextPullTimeNs + 2);
134
135 ConfigMetricsReportList reports;
136 vector<uint8_t> buffer;
137 processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
138 ADB_DUMP, FAST, &buffer);
139 EXPECT_TRUE(buffer.size() > 0);
140 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
141 backfillDimensionPath(&reports);
142 backfillStringInReport(&reports);
143 backfillStartEndTimestamp(&reports);
144 backfillAggregatedAtoms(&reports);
145 ASSERT_EQ(1, reports.reports_size());
146 ASSERT_EQ(1, reports.reports(0).metrics_size());
147 EXPECT_TRUE(reports.reports(0).metrics(0).has_estimated_data_bytes());
148 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
149 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
150 ASSERT_GT((int)gaugeMetrics.data_size(), 1);
151
152 auto data = gaugeMetrics.data(0);
153 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
154 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
155 EXPECT_EQ(1 /* subsystem name field */,
156 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
157 EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
158 ASSERT_EQ(6, data.bucket_info_size());
159
160 ASSERT_EQ(1, data.bucket_info(0).atom_size());
161 ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
162 EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
163 ASSERT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
164 EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
165 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
166 EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
167 EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
168
169 ASSERT_EQ(1, data.bucket_info(1).atom_size());
170 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0));
171 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0));
172 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
173 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
174 EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
175 EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
176
177 ASSERT_EQ(1, data.bucket_info(2).atom_size());
178 ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
179 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, data.bucket_info(2).elapsed_timestamp_nanos(0));
180 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
181 EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
182 EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
183 EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
184
185 ASSERT_EQ(1, data.bucket_info(3).atom_size());
186 ASSERT_EQ(1, data.bucket_info(3).elapsed_timestamp_nanos_size());
187 EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 1, data.bucket_info(3).elapsed_timestamp_nanos(0));
188 EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(3).start_bucket_elapsed_nanos());
189 EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(3).end_bucket_elapsed_nanos());
190 EXPECT_TRUE(data.bucket_info(3).atom(0).subsystem_sleep_state().subsystem_name().empty());
191 EXPECT_GT(data.bucket_info(3).atom(0).subsystem_sleep_state().time_millis(), 0);
192
193 ASSERT_EQ(1, data.bucket_info(4).atom_size());
194 ASSERT_EQ(1, data.bucket_info(4).elapsed_timestamp_nanos_size());
195 EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, data.bucket_info(4).elapsed_timestamp_nanos(0));
196 EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(4).start_bucket_elapsed_nanos());
197 EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(4).end_bucket_elapsed_nanos());
198 EXPECT_TRUE(data.bucket_info(4).atom(0).subsystem_sleep_state().subsystem_name().empty());
199 EXPECT_GT(data.bucket_info(4).atom(0).subsystem_sleep_state().time_millis(), 0);
200
201 ASSERT_EQ(1, data.bucket_info(5).atom_size());
202 ASSERT_EQ(1, data.bucket_info(5).elapsed_timestamp_nanos_size());
203 EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs + 2, data.bucket_info(5).elapsed_timestamp_nanos(0));
204 EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(5).start_bucket_elapsed_nanos());
205 EXPECT_EQ(baseTimeNs + 9 * bucketSizeNs, data.bucket_info(5).end_bucket_elapsed_nanos());
206 EXPECT_TRUE(data.bucket_info(5).atom(0).subsystem_sleep_state().subsystem_name().empty());
207 EXPECT_GT(data.bucket_info(5).atom(0).subsystem_sleep_state().time_millis(), 0);
208 }
209
TEST(GaugeMetricE2ePulledTest,TestFirstNSamplesPulledNoTrigger)210 TEST(GaugeMetricE2ePulledTest, TestFirstNSamplesPulledNoTrigger) {
211 StatsdConfig config = CreateStatsdConfig(GaugeMetric::FIRST_N_SAMPLES);
212 auto gaugeMetric = config.mutable_gauge_metric(0);
213 gaugeMetric->set_max_num_gauge_atoms_per_bucket(3);
214 int64_t baseTimeNs = getElapsedRealtimeNs();
215 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
216 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
217
218 ConfigKey cfgKey;
219 auto processor =
220 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
221 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
222 ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
223 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
224 processor->mPullerManager->ForceClearPullerCache();
225
226 // When creating the config, the gauge metric producer should register the alarm at the
227 // end of the current bucket.
228 ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
229 EXPECT_EQ(bucketSizeNs,
230 processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
231 int64_t& nextPullTimeNs =
232 processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
233
234 auto screenOffEvent =
235 CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
236 processor->OnLogEvent(screenOffEvent.get());
237
238 auto screenOnEvent =
239 CreateScreenStateChangedEvent(configAddedTimeNs + 100, android::view::DISPLAY_STATE_ON);
240 processor->OnLogEvent(screenOnEvent.get());
241
242 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 150,
243 android::view::DISPLAY_STATE_OFF);
244 processor->OnLogEvent(screenOffEvent.get());
245
246 screenOnEvent =
247 CreateScreenStateChangedEvent(configAddedTimeNs + 200, android::view::DISPLAY_STATE_ON);
248 processor->OnLogEvent(screenOnEvent.get());
249
250 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 250,
251 android::view::DISPLAY_STATE_OFF);
252 processor->OnLogEvent(screenOffEvent.get());
253
254 screenOnEvent =
255 CreateScreenStateChangedEvent(configAddedTimeNs + 300, android::view::DISPLAY_STATE_ON);
256 processor->OnLogEvent(screenOnEvent.get());
257
258 // Not logged. max_num_gauge_atoms_per_bucket already hit.
259 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 325,
260 android::view::DISPLAY_STATE_OFF);
261 processor->OnLogEvent(screenOffEvent.get());
262
263 // Pulling alarm arrives on time and reset the sequential pulling alarm.
264 processor->informPullAlarmFired(nextPullTimeNs + 1);
265
266 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
267 android::view::DISPLAY_STATE_ON);
268 processor->OnLogEvent(screenOnEvent.get());
269
270 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 100,
271 android::view::DISPLAY_STATE_OFF);
272 processor->OnLogEvent(screenOffEvent.get());
273
274 processor->informPullAlarmFired(nextPullTimeNs + 2);
275
276 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + (3 * bucketSizeNs) + 15,
277 android::view::DISPLAY_STATE_ON);
278 processor->OnLogEvent(screenOnEvent.get());
279
280 processor->informPullAlarmFired(nextPullTimeNs + 4);
281
282 ConfigMetricsReportList reports;
283 vector<uint8_t> buffer;
284 processor->onDumpReport(cfgKey, configAddedTimeNs + (4 * bucketSizeNs) + 10, false, true,
285 ADB_DUMP, FAST, &buffer);
286 EXPECT_TRUE(buffer.size() > 0);
287 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
288 backfillDimensionPath(&reports);
289 backfillStringInReport(&reports);
290 backfillStartEndTimestamp(&reports);
291 backfillAggregatedAtoms(&reports);
292 ASSERT_EQ(1, reports.reports_size());
293 ASSERT_EQ(1, reports.reports(0).metrics_size());
294 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
295 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
296 ASSERT_GT((int)gaugeMetrics.data_size(), 1);
297
298 auto data = gaugeMetrics.data(1);
299 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
300 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
301 EXPECT_EQ(1 /* subsystem name field */,
302 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
303 EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
304 ASSERT_EQ(3, data.bucket_info_size());
305
306 ASSERT_EQ(3, data.bucket_info(0).atom_size());
307 ASSERT_EQ(3, data.bucket_info(0).elapsed_timestamp_nanos_size());
308 ValidateGaugeBucketTimes(data.bucket_info(0),
309 /*startTimeNs=*/configAddedTimeNs,
310 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
311 /*eventTimesNs=*/
312 {(int64_t)(configAddedTimeNs + 55), (int64_t)(configAddedTimeNs + 150),
313 (int64_t)(configAddedTimeNs + 250)});
314
315 ASSERT_EQ(2, data.bucket_info(1).atom_size());
316 ASSERT_EQ(2, data.bucket_info(1).elapsed_timestamp_nanos_size());
317 ValidateGaugeBucketTimes(data.bucket_info(1),
318 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
319 /*endTimeNs=*/configAddedTimeNs + (2 * bucketSizeNs),
320 /*eventTimesNs=*/
321 {(int64_t)(configAddedTimeNs + bucketSizeNs + 1),
322 (int64_t)(configAddedTimeNs + bucketSizeNs + 100)});
323
324 ASSERT_EQ(1, data.bucket_info(2).atom_size());
325 ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
326 ValidateGaugeBucketTimes(
327 data.bucket_info(2), /*startTimeNs=*/configAddedTimeNs + (2 * bucketSizeNs),
328 /*endTimeNs=*/configAddedTimeNs + (3 * bucketSizeNs),
329 /*eventTimesNs=*/{(int64_t)(configAddedTimeNs + (2 * bucketSizeNs) + 2)});
330 }
331
TEST(GaugeMetricE2ePulledTest,TestConditionChangeToTrueSamplePulledEvents)332 TEST(GaugeMetricE2ePulledTest, TestConditionChangeToTrueSamplePulledEvents) {
333 auto config = CreateStatsdConfig(GaugeMetric::CONDITION_CHANGE_TO_TRUE);
334 int64_t baseTimeNs = getElapsedRealtimeNs();
335 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
336 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
337
338 ConfigKey cfgKey;
339 auto processor =
340 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
341 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
342 ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
343 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
344 processor->mPullerManager->ForceClearPullerCache();
345
346 int startBucketNum = processor->mMetricsManagers.begin()
347 ->second->mAllMetricProducers[0]
348 ->getCurrentBucketNum();
349 EXPECT_GT(startBucketNum, (int64_t)0);
350
351 auto screenOffEvent =
352 CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
353 processor->OnLogEvent(screenOffEvent.get());
354
355 auto screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
356 android::view::DISPLAY_STATE_ON);
357 processor->OnLogEvent(screenOnEvent.get());
358
359 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 100,
360 android::view::DISPLAY_STATE_OFF);
361 processor->OnLogEvent(screenOffEvent.get());
362
363 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 2,
364 android::view::DISPLAY_STATE_ON);
365 processor->OnLogEvent(screenOnEvent.get());
366
367 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 1,
368 android::view::DISPLAY_STATE_OFF);
369 processor->OnLogEvent(screenOffEvent.get());
370 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 3,
371 android::view::DISPLAY_STATE_ON);
372 processor->OnLogEvent(screenOnEvent.get());
373 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 5 * bucketSizeNs + 10,
374 android::view::DISPLAY_STATE_OFF);
375 processor->OnLogEvent(screenOffEvent.get());
376
377 ConfigMetricsReportList reports;
378 vector<uint8_t> buffer;
379 processor->onDumpReport(cfgKey, configAddedTimeNs + 8 * bucketSizeNs + 10, false, true,
380 ADB_DUMP, FAST, &buffer);
381 EXPECT_TRUE(buffer.size() > 0);
382 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
383 backfillDimensionPath(&reports);
384 backfillStringInReport(&reports);
385 backfillStartEndTimestamp(&reports);
386 backfillAggregatedAtoms(&reports);
387 ASSERT_EQ(1, reports.reports_size());
388 ASSERT_EQ(1, reports.reports(0).metrics_size());
389 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
390 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
391 ASSERT_GT((int)gaugeMetrics.data_size(), 1);
392
393 auto data = gaugeMetrics.data(0);
394 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
395 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
396 EXPECT_EQ(1 /* subsystem name field */,
397 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
398 EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
399 ASSERT_EQ(3, data.bucket_info_size());
400
401 ASSERT_EQ(1, data.bucket_info(0).atom_size());
402 ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
403 EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
404 ASSERT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
405 EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
406 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
407 EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
408 EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
409
410 ASSERT_EQ(1, data.bucket_info(1).atom_size());
411 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 100, data.bucket_info(1).elapsed_timestamp_nanos(0));
412 EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
413 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
414 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
415 EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
416 EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
417
418 ASSERT_EQ(2, data.bucket_info(2).atom_size());
419 ASSERT_EQ(2, data.bucket_info(2).elapsed_timestamp_nanos_size());
420 EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 1, data.bucket_info(2).elapsed_timestamp_nanos(0));
421 EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs + 10, data.bucket_info(2).elapsed_timestamp_nanos(1));
422 EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
423 EXPECT_EQ(baseTimeNs + 8 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
424 EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
425 EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
426 EXPECT_TRUE(data.bucket_info(2).atom(1).subsystem_sleep_state().subsystem_name().empty());
427 EXPECT_GT(data.bucket_info(2).atom(1).subsystem_sleep_state().time_millis(), 0);
428 }
429
TEST(GaugeMetricE2ePulledTest,TestRandomSamplePulledEvent_LateAlarm)430 TEST(GaugeMetricE2ePulledTest, TestRandomSamplePulledEvent_LateAlarm) {
431 auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE);
432 int64_t baseTimeNs = getElapsedRealtimeNs();
433 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
434 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
435
436 ConfigKey cfgKey;
437 auto processor =
438 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
439 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
440 ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
441 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
442 processor->mPullerManager->ForceClearPullerCache();
443
444 int startBucketNum = processor->mMetricsManagers.begin()
445 ->second->mAllMetricProducers[0]
446 ->getCurrentBucketNum();
447 EXPECT_GT(startBucketNum, (int64_t)0);
448
449 // When creating the config, the gauge metric producer should register the alarm at the
450 // end of the current bucket.
451 ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
452 EXPECT_EQ(bucketSizeNs,
453 processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
454 int64_t& nextPullTimeNs =
455 processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
456 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
457
458 auto screenOffEvent =
459 CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
460 processor->OnLogEvent(screenOffEvent.get());
461
462 auto screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
463 android::view::DISPLAY_STATE_ON);
464 processor->OnLogEvent(screenOnEvent.get());
465
466 // Pulling alarm arrives one bucket size late.
467 processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs);
468 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs);
469
470 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 11,
471 android::view::DISPLAY_STATE_OFF);
472 processor->OnLogEvent(screenOffEvent.get());
473
474 // Pulling alarm arrives more than one bucket size late.
475 processor->informPullAlarmFired(nextPullTimeNs + bucketSizeNs + 12);
476 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
477
478 ConfigMetricsReportList reports;
479 vector<uint8_t> buffer;
480 processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
481 ADB_DUMP, FAST, &buffer);
482 EXPECT_TRUE(buffer.size() > 0);
483 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
484 backfillDimensionPath(&reports);
485 backfillStringInReport(&reports);
486 backfillStartEndTimestamp(&reports);
487 backfillAggregatedAtoms(&reports);
488 ASSERT_EQ(1, reports.reports_size());
489 ASSERT_EQ(1, reports.reports(0).metrics_size());
490 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
491 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
492 ASSERT_GT((int)gaugeMetrics.data_size(), 1);
493
494 auto data = gaugeMetrics.data(0);
495 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
496 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
497 EXPECT_EQ(1 /* subsystem name field */,
498 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
499 EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
500 ASSERT_EQ(3, data.bucket_info_size());
501
502 ASSERT_EQ(1, data.bucket_info(0).atom_size());
503 ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
504 EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
505 EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
506 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
507 EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
508 EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
509
510 ASSERT_EQ(1, data.bucket_info(1).atom_size());
511 EXPECT_EQ(configAddedTimeNs + 3 * bucketSizeNs + 11,
512 data.bucket_info(1).elapsed_timestamp_nanos(0));
513 EXPECT_EQ(configAddedTimeNs + 55, data.bucket_info(0).elapsed_timestamp_nanos(0));
514 EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
515 EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
516 EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
517 EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
518
519 ASSERT_EQ(1, data.bucket_info(2).atom_size());
520 ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
521 EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs + 12, data.bucket_info(2).elapsed_timestamp_nanos(0));
522 EXPECT_EQ(baseTimeNs + 6 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
523 EXPECT_EQ(baseTimeNs + 7 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
524 EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
525 EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
526 }
527
TEST(GaugeMetricE2ePulledTest,TestRandomSamplePulledEventsWithActivation)528 TEST(GaugeMetricE2ePulledTest, TestRandomSamplePulledEventsWithActivation) {
529 auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);
530
531 int64_t baseTimeNs = getElapsedRealtimeNs();
532 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
533 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
534
535 auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher();
536 *config.add_atom_matcher() = batterySaverStartMatcher;
537 const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets.
538 auto metric_activation = config.add_metric_activation();
539 metric_activation->set_metric_id(metricId);
540 metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY);
541 auto event_activation = metric_activation->add_event_activation();
542 event_activation->set_atom_matcher_id(batterySaverStartMatcher.id());
543 event_activation->set_ttl_seconds(ttlNs / 1000000000);
544
545 StatsdStats::getInstance().reset();
546
547 ConfigKey cfgKey;
548 auto processor =
549 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
550 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
551 ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
552 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
553 processor->mPullerManager->ForceClearPullerCache();
554
555 const int startBucketNum = processor->mMetricsManagers.begin()
556 ->second->mAllMetricProducers[0]
557 ->getCurrentBucketNum();
558 EXPECT_EQ(startBucketNum, 2);
559 EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
560
561 // When creating the config, the gauge metric producer should register the alarm at the
562 // end of the current bucket.
563 ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
564 EXPECT_EQ(bucketSizeNs,
565 processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
566 int64_t& nextPullTimeNs =
567 processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
568 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
569
570 // Check no pull occurred on metric initialization when it's not active.
571 const int64_t metricInitTimeNs = configAddedTimeNs + 1; // 10 mins + 1 ns.
572 processor->onStatsdInitCompleted(metricInitTimeNs);
573 StatsdStatsReport_PulledAtomStats pulledAtomStats =
574 getPulledAtomStats(util::SUBSYSTEM_SLEEP_STATE);
575 EXPECT_EQ(pulledAtomStats.atom_id(), ATOM_TAG);
576 EXPECT_EQ(pulledAtomStats.total_pull(), 0);
577
578 // Check no pull occurred on app upgrade when metric is not active.
579 const int64_t appUpgradeTimeNs = metricInitTimeNs + 1; // 10 mins + 2 ns.
580 processor->notifyAppUpgrade(appUpgradeTimeNs, "appName", 1000 /* uid */, 2 /* version */);
581 pulledAtomStats = getPulledAtomStats(util::SUBSYSTEM_SLEEP_STATE);
582 EXPECT_EQ(pulledAtomStats.atom_id(), ATOM_TAG);
583 EXPECT_EQ(pulledAtomStats.total_pull(), 0);
584
585 // Check skipped bucket is not added when metric is not active.
586 int64_t dumpReportTimeNs = appUpgradeTimeNs + 1; // 10 mins + 3 ns.
587 vector<uint8_t> buffer;
588 processor->onDumpReport(cfgKey, dumpReportTimeNs, true /* include_current_partial_bucket */,
589 true /* erase_data */, ADB_DUMP, NO_TIME_CONSTRAINTS, &buffer);
590 ConfigMetricsReportList reports;
591 EXPECT_TRUE(buffer.size() > 0);
592 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
593 ASSERT_EQ(1, reports.reports_size());
594 ASSERT_EQ(1, reports.reports(0).metrics_size());
595 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics =
596 reports.reports(0).metrics(0).gauge_metrics();
597 EXPECT_EQ(gaugeMetrics.skipped_size(), 0);
598
599 // Pulling alarm arrives on time and reset the sequential pulling alarm.
600 // Event should not be kept.
601 processor->informPullAlarmFired(nextPullTimeNs + 1); // 15 mins + 1 ns.
602 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
603 EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
604
605 // Activate the metric. A pull occurs upon activation. The event is kept. 1 total
606 // 15 mins + 2 ms
607 const int64_t activationNs = configAddedTimeNs + bucketSizeNs + (2 * 1000 * 1000); // 2 millis.
608 auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs);
609 processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 2 ms.
610 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
611
612 // This event should be kept. 2 total.
613 processor->informPullAlarmFired(nextPullTimeNs + 1); // 20 mins + 1 ns.
614 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs, nextPullTimeNs);
615
616 // This event should be kept. 3 total.
617 processor->informPullAlarmFired(nextPullTimeNs + 2); // 25 mins + 2 ns.
618 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 4 * bucketSizeNs, nextPullTimeNs);
619
620 // Create random event to deactivate metric.
621 // A pull should not occur here. 3 total.
622 // 25 mins + 2 ms + 1 ns.
623 const int64_t deactivationNs = activationNs + ttlNs + 1;
624 auto deactivationEvent = CreateScreenBrightnessChangedEvent(deactivationNs, 50);
625 processor->OnLogEvent(deactivationEvent.get());
626 EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
627
628 // Event should not be kept. 3 total.
629 // 30 mins + 3 ns.
630 processor->informPullAlarmFired(nextPullTimeNs + 3);
631 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 5 * bucketSizeNs, nextPullTimeNs);
632
633 // Event should not be kept. 3 total.
634 // 35 mins + 2 ns.
635 processor->informPullAlarmFired(nextPullTimeNs + 2);
636 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 6 * bucketSizeNs, nextPullTimeNs);
637
638 buffer.clear();
639 // 40 mins + 10 ns.
640 processor->onDumpReport(cfgKey, configAddedTimeNs + 6 * bucketSizeNs + 10,
641 false /* include_current_partial_bucket */, true /* erase_data */,
642 ADB_DUMP, FAST, &buffer);
643 EXPECT_TRUE(buffer.size() > 0);
644 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
645 backfillDimensionPath(&reports);
646 backfillStringInReport(&reports);
647 backfillStartEndTimestamp(&reports);
648 backfillAggregatedAtoms(&reports);
649 ASSERT_EQ(1, reports.reports_size());
650 ASSERT_EQ(1, reports.reports(0).metrics_size());
651 gaugeMetrics = StatsLogReport::GaugeMetricDataWrapper();
652 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
653 ASSERT_GT((int)gaugeMetrics.data_size(), 0);
654
655 auto data = gaugeMetrics.data(0);
656 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
657 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
658 EXPECT_EQ(1 /* subsystem name field */,
659 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
660 EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
661 ASSERT_EQ(3, data.bucket_info_size());
662
663 auto bucketInfo = data.bucket_info(0);
664 ASSERT_EQ(1, bucketInfo.atom_size());
665 ASSERT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
666 EXPECT_EQ(activationNs, bucketInfo.elapsed_timestamp_nanos(0));
667 ASSERT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
668 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
669 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
670 EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
671 EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
672
673 bucketInfo = data.bucket_info(1);
674 ASSERT_EQ(1, bucketInfo.atom_size());
675 ASSERT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
676 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 1, bucketInfo.elapsed_timestamp_nanos(0));
677 ASSERT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
678 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, bucketInfo.start_bucket_elapsed_nanos());
679 EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, bucketInfo.end_bucket_elapsed_nanos());
680 EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
681 EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
682
683 bucketInfo = data.bucket_info(2);
684 ASSERT_EQ(1, bucketInfo.atom_size());
685 ASSERT_EQ(1, bucketInfo.elapsed_timestamp_nanos_size());
686 EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs + 2, bucketInfo.elapsed_timestamp_nanos(0));
687 ASSERT_EQ(0, bucketInfo.wall_clock_timestamp_nanos_size());
688 EXPECT_EQ(MillisToNano(NanoToMillis(baseTimeNs + 5 * bucketSizeNs)),
689 bucketInfo.start_bucket_elapsed_nanos());
690 EXPECT_EQ(MillisToNano(NanoToMillis(deactivationNs)), bucketInfo.end_bucket_elapsed_nanos());
691 EXPECT_TRUE(bucketInfo.atom(0).subsystem_sleep_state().subsystem_name().empty());
692 EXPECT_GT(bucketInfo.atom(0).subsystem_sleep_state().time_millis(), 0);
693
694 // Check skipped bucket is not added after deactivation.
695 dumpReportTimeNs = configAddedTimeNs + 8 * bucketSizeNs + 10;
696 buffer.clear();
697 processor->onDumpReport(cfgKey, dumpReportTimeNs, true /* include_current_partial_bucket */,
698 true /* erase_data */, ADB_DUMP, NO_TIME_CONSTRAINTS, &buffer);
699 EXPECT_TRUE(buffer.size() > 0);
700 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
701 ASSERT_EQ(1, reports.reports_size());
702 ASSERT_EQ(1, reports.reports(0).metrics_size());
703 gaugeMetrics = reports.reports(0).metrics(0).gauge_metrics();
704 EXPECT_EQ(gaugeMetrics.skipped_size(), 0);
705 }
706
TEST(GaugeMetricE2ePulledTest,TestFirstNSamplesPulledNoTriggerWithActivation)707 TEST(GaugeMetricE2ePulledTest, TestFirstNSamplesPulledNoTriggerWithActivation) {
708 StatsdConfig config = CreateStatsdConfig(GaugeMetric::FIRST_N_SAMPLES);
709 auto gaugeMetric = config.mutable_gauge_metric(0);
710 gaugeMetric->set_max_num_gauge_atoms_per_bucket(2);
711 int64_t baseTimeNs = getElapsedRealtimeNs();
712 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
713 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
714
715 auto batterySaverStartMatcher = CreateBatterySaverModeStartAtomMatcher();
716 *config.add_atom_matcher() = batterySaverStartMatcher;
717 const int64_t ttlNs = 2 * bucketSizeNs; // Two buckets.
718 auto metric_activation = config.add_metric_activation();
719 metric_activation->set_metric_id(metricId);
720 metric_activation->set_activation_type(ACTIVATE_IMMEDIATELY);
721 auto event_activation = metric_activation->add_event_activation();
722 event_activation->set_atom_matcher_id(batterySaverStartMatcher.id());
723 event_activation->set_ttl_seconds(ttlNs / NS_PER_SEC);
724
725 StatsdStats::getInstance().reset();
726
727 ConfigKey cfgKey;
728 auto processor =
729 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
730 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
731 ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
732 processor->mPullerManager->ForceClearPullerCache();
733
734 EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
735
736 // When creating the config, the gauge metric producer should register the alarm at the
737 // end of the current bucket.
738 ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
739 EXPECT_EQ(bucketSizeNs,
740 processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
741 int64_t& nextPullTimeNs =
742 processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
743
744 // Condition true but Active false
745 auto screenOffEvent =
746 CreateScreenStateChangedEvent(configAddedTimeNs + 55, android::view::DISPLAY_STATE_OFF);
747 processor->OnLogEvent(screenOffEvent.get());
748
749 auto screenOnEvent =
750 CreateScreenStateChangedEvent(configAddedTimeNs + 100, android::view::DISPLAY_STATE_ON);
751 processor->OnLogEvent(screenOnEvent.get());
752
753 // Pulling alarm arrives on time and reset the sequential pulling alarm.
754 // Event should not be kept.
755 processor->informPullAlarmFired(nextPullTimeNs + 1); // 15 mins + 1 ns.
756 EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
757
758 // Activate the metric. A pull occurs upon activation. The event is not kept. 0 total
759 // 15 mins + 1000 ns.
760 const int64_t activationNs = configAddedTimeNs + bucketSizeNs + 1000;
761 auto batterySaverOnEvent = CreateBatterySaverOnEvent(activationNs);
762 processor->OnLogEvent(batterySaverOnEvent.get()); // 15 mins + 1000 ns.
763 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
764
765 // A pull occurs upon condition change. The event is kept. 1 total. 1 in bucket
766 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 150,
767 android::view::DISPLAY_STATE_OFF);
768 processor->OnLogEvent(screenOffEvent.get());
769
770 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 200,
771 android::view::DISPLAY_STATE_ON);
772 processor->OnLogEvent(screenOnEvent.get());
773
774 // A pull occurs upon condition change. The event is kept. 1 total. 2 in bucket
775 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 250,
776 android::view::DISPLAY_STATE_OFF);
777 processor->OnLogEvent(screenOffEvent.get());
778
779 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 300,
780 android::view::DISPLAY_STATE_ON);
781 processor->OnLogEvent(screenOnEvent.get());
782
783 // A pull occurs upon condition change. The event is not kept due to
784 // max_num_gauge_atoms_per_bucket. 1 total. 2 total in bucket
785 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 325,
786 android::view::DISPLAY_STATE_OFF);
787 processor->OnLogEvent(screenOffEvent.get());
788
789 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 375,
790 android::view::DISPLAY_STATE_ON);
791 processor->OnLogEvent(screenOnEvent.get());
792 // Condition false but Active true
793
794 // This event should not be kept. 1 total.
795 processor->informPullAlarmFired(nextPullTimeNs + 1); // 20 mins + 1 ns.
796
797 // This event should not be kept. 1 total.
798 processor->informPullAlarmFired(nextPullTimeNs + 2); // 25 mins + 2 ns.
799
800 // A pull occurs upon condition change. The event is kept. 2 total. 1 in bucket
801 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 50,
802 android::view::DISPLAY_STATE_OFF);
803 processor->OnLogEvent(screenOffEvent.get());
804 // Condition true but Active true
805
806 // Create random event to deactivate metric.
807 // A pull should not occur here. 2 total. 1 in bucket.
808 // 25 mins + 1000 ns + 1 ns.
809 const int64_t deactivationNs = activationNs + ttlNs + 1;
810 auto deactivationEvent = CreateScreenBrightnessChangedEvent(deactivationNs, 50);
811 processor->OnLogEvent(deactivationEvent.get());
812 EXPECT_FALSE(processor->mMetricsManagers.begin()->second->mAllMetricProducers[0]->isActive());
813 // Condition true but Active false
814
815 screenOnEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 50,
816 android::view::DISPLAY_STATE_ON);
817 processor->OnLogEvent(screenOnEvent.get());
818
819 screenOffEvent = CreateScreenStateChangedEvent(configAddedTimeNs + 3 * bucketSizeNs + 100,
820 android::view::DISPLAY_STATE_OFF);
821 processor->OnLogEvent(screenOffEvent.get());
822
823 vector<uint8_t> buffer;
824 // 30 mins + 10 ns.
825 processor->onDumpReport(cfgKey, configAddedTimeNs + 4 * bucketSizeNs + 10,
826 false /* include_current_partial_bucket */, true /* erase_data */,
827 ADB_DUMP, FAST, &buffer);
828 ConfigMetricsReportList reports;
829 EXPECT_TRUE(buffer.size() > 0);
830 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
831 backfillDimensionPath(&reports);
832 backfillStringInReport(&reports);
833 backfillStartEndTimestamp(&reports);
834 backfillAggregatedAtoms(&reports);
835 ASSERT_EQ(1, reports.reports_size());
836 ASSERT_EQ(1, reports.reports(0).metrics_size());
837 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics = StatsLogReport::GaugeMetricDataWrapper();
838 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
839 ASSERT_GT((int)gaugeMetrics.data_size(), 0);
840
841 auto data = gaugeMetrics.data(0);
842 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
843 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
844 EXPECT_EQ(1 /* subsystem name field */,
845 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
846 EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
847 ASSERT_EQ(2, data.bucket_info_size());
848
849 ASSERT_EQ(2, data.bucket_info(0).atom_size());
850 ASSERT_EQ(2, data.bucket_info(0).elapsed_timestamp_nanos_size());
851 ValidateGaugeBucketTimes(data.bucket_info(0),
852 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
853 /*endTimeNs=*/configAddedTimeNs + (2 * bucketSizeNs),
854 /*eventTimesNs=*/
855 {(int64_t)(configAddedTimeNs + bucketSizeNs + 150),
856 (int64_t)(configAddedTimeNs + bucketSizeNs + 250)});
857
858 ASSERT_EQ(1, data.bucket_info(1).atom_size());
859 ASSERT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size());
860 ValidateGaugeBucketTimes(data.bucket_info(1),
861 /*startTimeNs=*/
862 MillisToNano(NanoToMillis(configAddedTimeNs + (3 * bucketSizeNs))),
863 /*endTimeNs=*/MillisToNano(NanoToMillis(deactivationNs)),
864 /*eventTimesNs=*/
865 {(int64_t)(configAddedTimeNs + (3 * bucketSizeNs) + 50)});
866 }
867
TEST(GaugeMetricE2ePulledTest,TestRandomSamplePulledEventsNoCondition)868 TEST(GaugeMetricE2ePulledTest, TestRandomSamplePulledEventsNoCondition) {
869 auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);
870
871 int64_t baseTimeNs = getElapsedRealtimeNs();
872 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
873 int64_t bucketSizeNs =
874 TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
875
876 ConfigKey cfgKey;
877 auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
878 SharedRefBase::make<FakeSubsystemSleepCallback>(),
879 ATOM_TAG);
880 ASSERT_EQ(processor->mMetricsManagers.size(), 1u);
881 EXPECT_TRUE(processor->mMetricsManagers.begin()->second->isConfigValid());
882 processor->mPullerManager->ForceClearPullerCache();
883
884 int startBucketNum = processor->mMetricsManagers.begin()->second->
885 mAllMetricProducers[0]->getCurrentBucketNum();
886 EXPECT_GT(startBucketNum, (int64_t)0);
887
888 // When creating the config, the gauge metric producer should register the alarm at the
889 // end of the current bucket.
890 ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
891 EXPECT_EQ(bucketSizeNs,
892 processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
893 int64_t& nextPullTimeNs =
894 processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
895 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + bucketSizeNs, nextPullTimeNs);
896
897 // Pulling alarm arrives on time and reset the sequential pulling alarm.
898 processor->informPullAlarmFired(nextPullTimeNs + 1);
899 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 2 * bucketSizeNs, nextPullTimeNs);
900
901 processor->informPullAlarmFired(nextPullTimeNs + 4);
902 EXPECT_EQ(baseTimeNs + startBucketNum * bucketSizeNs + 3 * bucketSizeNs,
903 nextPullTimeNs);
904
905 ConfigMetricsReportList reports;
906 vector<uint8_t> buffer;
907 processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
908 ADB_DUMP, FAST, &buffer);
909 EXPECT_TRUE(buffer.size() > 0);
910 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
911 backfillDimensionPath(&reports);
912 backfillStringInReport(&reports);
913 backfillStartEndTimestamp(&reports);
914 backfillAggregatedAtoms(&reports);
915 ASSERT_EQ(1, reports.reports_size());
916 ASSERT_EQ(1, reports.reports(0).metrics_size());
917 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
918 sortMetricDataByDimensionsValue(
919 reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
920 ASSERT_GT((int)gaugeMetrics.data_size(), 0);
921
922 auto data = gaugeMetrics.data(0);
923 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
924 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
925 EXPECT_EQ(1 /* subsystem name field */,
926 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
927 EXPECT_FALSE(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str().empty());
928 ASSERT_EQ(3, data.bucket_info_size());
929
930 ASSERT_EQ(1, data.bucket_info(0).atom_size());
931 ASSERT_EQ(1, data.bucket_info(0).elapsed_timestamp_nanos_size());
932 EXPECT_EQ(configAddedTimeNs, data.bucket_info(0).elapsed_timestamp_nanos(0));
933 ASSERT_EQ(0, data.bucket_info(0).wall_clock_timestamp_nanos_size());
934 EXPECT_EQ(baseTimeNs + 2 * bucketSizeNs, data.bucket_info(0).start_bucket_elapsed_nanos());
935 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(0).end_bucket_elapsed_nanos());
936 EXPECT_TRUE(data.bucket_info(0).atom(0).subsystem_sleep_state().subsystem_name().empty());
937 EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
938
939 ASSERT_EQ(1, data.bucket_info(1).atom_size());
940 ASSERT_EQ(1, data.bucket_info(1).elapsed_timestamp_nanos_size());
941 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs + 1, data.bucket_info(1).elapsed_timestamp_nanos(0));
942 ASSERT_EQ(0, data.bucket_info(1).wall_clock_timestamp_nanos_size());
943 EXPECT_EQ(baseTimeNs + 3 * bucketSizeNs, data.bucket_info(1).start_bucket_elapsed_nanos());
944 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(1).end_bucket_elapsed_nanos());
945 EXPECT_TRUE(data.bucket_info(1).atom(0).subsystem_sleep_state().subsystem_name().empty());
946 EXPECT_GT(data.bucket_info(1).atom(0).subsystem_sleep_state().time_millis(), 0);
947
948 ASSERT_EQ(1, data.bucket_info(2).atom_size());
949 ASSERT_EQ(1, data.bucket_info(2).elapsed_timestamp_nanos_size());
950 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs + 4, data.bucket_info(2).elapsed_timestamp_nanos(0));
951 ASSERT_EQ(0, data.bucket_info(2).wall_clock_timestamp_nanos_size());
952 EXPECT_EQ(baseTimeNs + 4 * bucketSizeNs, data.bucket_info(2).start_bucket_elapsed_nanos());
953 EXPECT_EQ(baseTimeNs + 5 * bucketSizeNs, data.bucket_info(2).end_bucket_elapsed_nanos());
954 EXPECT_TRUE(data.bucket_info(2).atom(0).subsystem_sleep_state().subsystem_name().empty());
955 EXPECT_GT(data.bucket_info(2).atom(0).subsystem_sleep_state().time_millis(), 0);
956 }
957
TEST(GaugeMetricE2ePulledTest,TestGaugeMetricPullProbabilityWithTriggerEvent)958 TEST(GaugeMetricE2ePulledTest, TestGaugeMetricPullProbabilityWithTriggerEvent) {
959 // Initiating StatsdStats at the start of this test, so it doesn't call rand() during the test.
960 StatsdStats::getInstance();
961 // Set srand seed to make rand deterministic for testing.
962 srand(0);
963
964 auto config = CreateStatsdConfig(GaugeMetric::FIRST_N_SAMPLES, /*useCondition=*/false);
965 auto gaugeMetric = config.mutable_gauge_metric(0);
966 gaugeMetric->set_pull_probability(50);
967 auto triggerEventMatcher = CreateScreenTurnedOnAtomMatcher();
968 gaugeMetric->set_trigger_event(triggerEventMatcher.id());
969 gaugeMetric->set_max_num_gauge_atoms_per_bucket(200);
970 gaugeMetric->set_bucket(ONE_HOUR);
971
972 int64_t configAddedTimeNs = 60 * NS_PER_SEC;
973 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
974
975 ConfigKey cfgKey;
976 auto processor =
977 CreateStatsLogProcessor(configAddedTimeNs, configAddedTimeNs, config, cfgKey,
978 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
979
980 std::vector<std::unique_ptr<LogEvent>> events;
981 // First bucket events.
982 for (int i = 0; i < 30; i++) {
983 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + (i * 10 * NS_PER_SEC),
984 android::view::DISPLAY_STATE_ON));
985 }
986 // Second bucket events.
987 for (int i = 0; i < 30; i++) {
988 events.push_back(CreateScreenStateChangedEvent(
989 configAddedTimeNs + bucketSizeNs + (i * 10 * NS_PER_SEC),
990 android::view::DISPLAY_STATE_ON));
991 }
992
993 // Send log events to StatsLogProcessor.
994 for (auto& event : events) {
995 processor->OnLogEvent(event.get());
996 }
997
998 ConfigMetricsReportList reports;
999 vector<uint8_t> buffer;
1000 processor->onDumpReport(cfgKey, configAddedTimeNs + 7 * bucketSizeNs + 10, false, true,
1001 ADB_DUMP, FAST, &buffer);
1002
1003 EXPECT_TRUE(buffer.size() > 0);
1004 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1005 backfillDimensionPath(&reports);
1006 backfillStringInReport(&reports);
1007 backfillStartEndTimestamp(&reports);
1008 backfillAggregatedAtoms(&reports);
1009 ASSERT_EQ(1, reports.reports_size());
1010 ASSERT_EQ(1, reports.reports(0).metrics_size());
1011 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1012 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1013 ASSERT_EQ((int)gaugeMetrics.data_size(), 2); // 2 sets of data for each pull.
1014
1015 // Data 1
1016 auto data = gaugeMetrics.data(0);
1017 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
1018 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1019 EXPECT_EQ(1 /* subsystem name field */,
1020 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1021 EXPECT_EQ("subsystem_name_1",
1022 data.dimensions_in_what().value_tuple().dimensions_value(0).value_str());
1023 ASSERT_EQ(2, data.bucket_info_size());
1024
1025 // Data 1, Bucket 1
1026 ASSERT_EQ(13, data.bucket_info(0).atom_size());
1027 ValidateGaugeBucketTimes(
1028 data.bucket_info(0), configAddedTimeNs, configAddedTimeNs + bucketSizeNs,
1029 {(int64_t)60 * NS_PER_SEC, (int64_t)80 * NS_PER_SEC, (int64_t)90 * NS_PER_SEC,
1030 (int64_t)130 * NS_PER_SEC, (int64_t)150 * NS_PER_SEC, (int64_t)170 * NS_PER_SEC,
1031 (int64_t)190 * NS_PER_SEC, (int64_t)200 * NS_PER_SEC, (int64_t)240 * NS_PER_SEC,
1032 (int64_t)250 * NS_PER_SEC, (int64_t)300 * NS_PER_SEC, (int64_t)330 * NS_PER_SEC,
1033 (int64_t)340 * NS_PER_SEC});
1034
1035 // Data 1, Bucket 2
1036 ASSERT_EQ(18, data.bucket_info(1).atom_size());
1037 ValidateGaugeBucketTimes(
1038 data.bucket_info(1), configAddedTimeNs + bucketSizeNs,
1039 configAddedTimeNs + 2 * bucketSizeNs,
1040 {(int64_t)3660 * NS_PER_SEC, (int64_t)3680 * NS_PER_SEC, (int64_t)3700 * NS_PER_SEC,
1041 (int64_t)3710 * NS_PER_SEC, (int64_t)3720 * NS_PER_SEC, (int64_t)3740 * NS_PER_SEC,
1042 (int64_t)3780 * NS_PER_SEC, (int64_t)3790 * NS_PER_SEC, (int64_t)3820 * NS_PER_SEC,
1043 (int64_t)3850 * NS_PER_SEC, (int64_t)3860 * NS_PER_SEC, (int64_t)3870 * NS_PER_SEC,
1044 (int64_t)3880 * NS_PER_SEC, (int64_t)3900 * NS_PER_SEC, (int64_t)3910 * NS_PER_SEC,
1045 (int64_t)3920 * NS_PER_SEC, (int64_t)3930 * NS_PER_SEC, (int64_t)3940 * NS_PER_SEC});
1046
1047 // Data 2
1048 data = gaugeMetrics.data(1);
1049 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
1050 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1051 EXPECT_EQ(1 /* subsystem name field */,
1052 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1053 EXPECT_EQ("subsystem_name_2",
1054 data.dimensions_in_what().value_tuple().dimensions_value(0).value_str());
1055 ASSERT_EQ(2, data.bucket_info_size());
1056
1057 // Data 2, Bucket 1
1058 ASSERT_EQ(13, data.bucket_info(0).atom_size());
1059 ValidateGaugeBucketTimes(
1060 data.bucket_info(0), configAddedTimeNs, configAddedTimeNs + bucketSizeNs,
1061 {(int64_t)60 * NS_PER_SEC, (int64_t)80 * NS_PER_SEC, (int64_t)90 * NS_PER_SEC,
1062 (int64_t)130 * NS_PER_SEC, (int64_t)150 * NS_PER_SEC, (int64_t)170 * NS_PER_SEC,
1063 (int64_t)190 * NS_PER_SEC, (int64_t)200 * NS_PER_SEC, (int64_t)240 * NS_PER_SEC,
1064 (int64_t)250 * NS_PER_SEC, (int64_t)300 * NS_PER_SEC, (int64_t)330 * NS_PER_SEC,
1065 (int64_t)340 * NS_PER_SEC});
1066
1067 // Data 2, Bucket 2
1068 ASSERT_EQ(18, data.bucket_info(1).atom_size());
1069 ValidateGaugeBucketTimes(
1070 data.bucket_info(1), configAddedTimeNs + bucketSizeNs,
1071 configAddedTimeNs + 2 * bucketSizeNs,
1072 {(int64_t)3660 * NS_PER_SEC, (int64_t)3680 * NS_PER_SEC, (int64_t)3700 * NS_PER_SEC,
1073 (int64_t)3710 * NS_PER_SEC, (int64_t)3720 * NS_PER_SEC, (int64_t)3740 * NS_PER_SEC,
1074 (int64_t)3780 * NS_PER_SEC, (int64_t)3790 * NS_PER_SEC, (int64_t)3820 * NS_PER_SEC,
1075 (int64_t)3850 * NS_PER_SEC, (int64_t)3860 * NS_PER_SEC, (int64_t)3870 * NS_PER_SEC,
1076 (int64_t)3880 * NS_PER_SEC, (int64_t)3900 * NS_PER_SEC, (int64_t)3910 * NS_PER_SEC,
1077 (int64_t)3920 * NS_PER_SEC, (int64_t)3930 * NS_PER_SEC, (int64_t)3940 * NS_PER_SEC});
1078 }
1079
TEST(GaugeMetricE2ePulledTest,TestGaugeMetricPullProbabilityWithBucketBoundaryAlarm)1080 TEST(GaugeMetricE2ePulledTest, TestGaugeMetricPullProbabilityWithBucketBoundaryAlarm) {
1081 // Initiating StatsdStats at the start of this test, so it doesn't call rand() during the test.
1082 StatsdStats::getInstance();
1083 // Set srand seed to make rand deterministic for testing.
1084 srand(0);
1085
1086 auto config = CreateStatsdConfig(GaugeMetric::FIRST_N_SAMPLES, /*useCondition=*/false);
1087 auto gaugeMetric = config.mutable_gauge_metric(0);
1088 gaugeMetric->set_pull_probability(50);
1089 gaugeMetric->set_max_num_gauge_atoms_per_bucket(200);
1090
1091 int64_t baseTimeNs = 5 * 60 * NS_PER_SEC;
1092 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC;
1093 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
1094
1095 ConfigKey cfgKey;
1096 auto processor =
1097 CreateStatsLogProcessor(configAddedTimeNs, configAddedTimeNs, config, cfgKey,
1098 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
1099
1100 // Pulling alarm arrives on time and resets the sequential pulling alarm.
1101 for (int i = 1; i < 31; i++) {
1102 processor->informPullAlarmFired(configAddedTimeNs + i * bucketSizeNs);
1103 }
1104
1105 ConfigMetricsReportList reports;
1106 vector<uint8_t> buffer;
1107 processor->onDumpReport(cfgKey, configAddedTimeNs + 32 * bucketSizeNs + 10, false, true,
1108 ADB_DUMP, FAST, &buffer);
1109 EXPECT_TRUE(buffer.size() > 0);
1110 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1111 backfillDimensionPath(&reports);
1112 backfillStringInReport(&reports);
1113 backfillStartEndTimestamp(&reports);
1114 backfillAggregatedAtoms(&reports);
1115 ASSERT_EQ(1, reports.reports_size());
1116 ASSERT_EQ(1, reports.reports(0).metrics_size());
1117 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1118 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1119 ASSERT_EQ((int)gaugeMetrics.data_size(), 2);
1120
1121 // Data 1
1122 auto data = gaugeMetrics.data(0);
1123 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
1124 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1125 EXPECT_EQ(1 /* subsystem name field */,
1126 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1127 EXPECT_EQ("subsystem_name_1",
1128 data.dimensions_in_what().value_tuple().dimensions_value(0).value_str());
1129 ASSERT_EQ(14, data.bucket_info_size());
1130
1131 EXPECT_EQ(1, data.bucket_info(0).atom_size());
1132 ValidateGaugeBucketTimes(data.bucket_info(0), configAddedTimeNs,
1133 configAddedTimeNs + bucketSizeNs, {configAddedTimeNs});
1134
1135 EXPECT_EQ(1, data.bucket_info(1).atom_size());
1136 ValidateGaugeBucketTimes(data.bucket_info(1), configAddedTimeNs + 2 * bucketSizeNs,
1137 configAddedTimeNs + 3 * bucketSizeNs,
1138 {configAddedTimeNs + 2 * bucketSizeNs}); // 1200000000000ns
1139
1140 EXPECT_EQ(1, data.bucket_info(2).atom_size());
1141 ValidateGaugeBucketTimes(data.bucket_info(2), configAddedTimeNs + 3 * bucketSizeNs,
1142 configAddedTimeNs + 4 * bucketSizeNs,
1143 {(int64_t)configAddedTimeNs + 3 * bucketSizeNs}); // 1500000000000ns
1144
1145 EXPECT_EQ(1, data.bucket_info(3).atom_size());
1146 ValidateGaugeBucketTimes(data.bucket_info(3), configAddedTimeNs + 7 * bucketSizeNs,
1147 configAddedTimeNs + 8 * bucketSizeNs,
1148 {configAddedTimeNs + 7 * bucketSizeNs}); // 2700000000000ns
1149
1150 EXPECT_EQ(1, data.bucket_info(4).atom_size());
1151 ValidateGaugeBucketTimes(data.bucket_info(4), configAddedTimeNs + 9 * bucketSizeNs,
1152 configAddedTimeNs + 10 * bucketSizeNs,
1153 {configAddedTimeNs + 9 * bucketSizeNs}); // 3300000000000ns
1154
1155 EXPECT_EQ(1, data.bucket_info(5).atom_size());
1156 ValidateGaugeBucketTimes(data.bucket_info(5), configAddedTimeNs + 11 * bucketSizeNs,
1157 configAddedTimeNs + 12 * bucketSizeNs,
1158 {configAddedTimeNs + 11 * bucketSizeNs}); // 3900000000000ns
1159
1160 EXPECT_EQ(1, data.bucket_info(6).atom_size());
1161 ValidateGaugeBucketTimes(data.bucket_info(6), configAddedTimeNs + 13 * bucketSizeNs,
1162 configAddedTimeNs + 14 * bucketSizeNs,
1163 {configAddedTimeNs + 13 * bucketSizeNs}); // 4500000000000ns
1164
1165 EXPECT_EQ(1, data.bucket_info(7).atom_size());
1166 ValidateGaugeBucketTimes(data.bucket_info(7), configAddedTimeNs + 14 * bucketSizeNs,
1167 configAddedTimeNs + 15 * bucketSizeNs,
1168 {configAddedTimeNs + 14 * bucketSizeNs}); // 4800000000000ns
1169
1170 EXPECT_EQ(1, data.bucket_info(8).atom_size());
1171 ValidateGaugeBucketTimes(data.bucket_info(8), configAddedTimeNs + 18 * bucketSizeNs,
1172 configAddedTimeNs + 19 * bucketSizeNs,
1173 {configAddedTimeNs + 18 * bucketSizeNs}); // 6000000000000ns
1174
1175 EXPECT_EQ(1, data.bucket_info(9).atom_size());
1176 ValidateGaugeBucketTimes(data.bucket_info(9), configAddedTimeNs + 19 * bucketSizeNs,
1177 configAddedTimeNs + 20 * bucketSizeNs,
1178 {configAddedTimeNs + 19 * bucketSizeNs}); // 6300000000000ns
1179
1180 EXPECT_EQ(1, data.bucket_info(10).atom_size());
1181 ValidateGaugeBucketTimes(data.bucket_info(10), configAddedTimeNs + 24 * bucketSizeNs,
1182 configAddedTimeNs + 25 * bucketSizeNs,
1183 {configAddedTimeNs + 24 * bucketSizeNs}); // 7800000000000ns
1184
1185 EXPECT_EQ(1, data.bucket_info(11).atom_size());
1186 ValidateGaugeBucketTimes(data.bucket_info(11), configAddedTimeNs + 27 * bucketSizeNs,
1187 configAddedTimeNs + 28 * bucketSizeNs,
1188 {configAddedTimeNs + 27 * bucketSizeNs}); // 8700000000000ns
1189
1190 EXPECT_EQ(1, data.bucket_info(12).atom_size());
1191 ValidateGaugeBucketTimes(data.bucket_info(12), configAddedTimeNs + 28 * bucketSizeNs,
1192 configAddedTimeNs + 29 * bucketSizeNs,
1193 {configAddedTimeNs + 28 * bucketSizeNs}); // 9000000000000ns
1194
1195 EXPECT_EQ(1, data.bucket_info(13).atom_size());
1196 ValidateGaugeBucketTimes(data.bucket_info(13), configAddedTimeNs + 30 * bucketSizeNs,
1197 configAddedTimeNs + 31 * bucketSizeNs,
1198 {configAddedTimeNs + 30 * bucketSizeNs}); // 9600000000000ns
1199
1200 // Data 2
1201 data = gaugeMetrics.data(1);
1202 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
1203 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1204 EXPECT_EQ(1 /* subsystem name field */,
1205 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1206 EXPECT_EQ("subsystem_name_2",
1207 data.dimensions_in_what().value_tuple().dimensions_value(0).value_str());
1208 ASSERT_EQ(14, data.bucket_info_size());
1209
1210 EXPECT_EQ(1, data.bucket_info(0).atom_size());
1211 ValidateGaugeBucketTimes(data.bucket_info(0), configAddedTimeNs,
1212 configAddedTimeNs + bucketSizeNs, {configAddedTimeNs});
1213
1214 EXPECT_EQ(1, data.bucket_info(1).atom_size());
1215 ValidateGaugeBucketTimes(data.bucket_info(1), configAddedTimeNs + 2 * bucketSizeNs,
1216 configAddedTimeNs + 3 * bucketSizeNs,
1217 {configAddedTimeNs + 2 * bucketSizeNs});
1218
1219 EXPECT_EQ(1, data.bucket_info(2).atom_size());
1220 ValidateGaugeBucketTimes(data.bucket_info(2), configAddedTimeNs + 3 * bucketSizeNs,
1221 configAddedTimeNs + 4 * bucketSizeNs,
1222 {(int64_t)configAddedTimeNs + 3 * bucketSizeNs});
1223
1224 EXPECT_EQ(1, data.bucket_info(3).atom_size());
1225 ValidateGaugeBucketTimes(data.bucket_info(3), configAddedTimeNs + 7 * bucketSizeNs,
1226 configAddedTimeNs + 8 * bucketSizeNs,
1227 {configAddedTimeNs + 7 * bucketSizeNs});
1228
1229 EXPECT_EQ(1, data.bucket_info(4).atom_size());
1230 ValidateGaugeBucketTimes(data.bucket_info(4), configAddedTimeNs + 9 * bucketSizeNs,
1231 configAddedTimeNs + 10 * bucketSizeNs,
1232 {configAddedTimeNs + 9 * bucketSizeNs});
1233
1234 EXPECT_EQ(1, data.bucket_info(5).atom_size());
1235 ValidateGaugeBucketTimes(data.bucket_info(5), configAddedTimeNs + 11 * bucketSizeNs,
1236 configAddedTimeNs + 12 * bucketSizeNs,
1237 {configAddedTimeNs + 11 * bucketSizeNs});
1238
1239 EXPECT_EQ(1, data.bucket_info(6).atom_size());
1240 ValidateGaugeBucketTimes(data.bucket_info(6), configAddedTimeNs + 13 * bucketSizeNs,
1241 configAddedTimeNs + 14 * bucketSizeNs,
1242 {configAddedTimeNs + 13 * bucketSizeNs});
1243
1244 EXPECT_EQ(1, data.bucket_info(7).atom_size());
1245 ValidateGaugeBucketTimes(data.bucket_info(7), configAddedTimeNs + 14 * bucketSizeNs,
1246 configAddedTimeNs + 15 * bucketSizeNs,
1247 {configAddedTimeNs + 14 * bucketSizeNs});
1248
1249 EXPECT_EQ(1, data.bucket_info(8).atom_size());
1250 ValidateGaugeBucketTimes(data.bucket_info(8), configAddedTimeNs + 18 * bucketSizeNs,
1251 configAddedTimeNs + 19 * bucketSizeNs,
1252 {configAddedTimeNs + 18 * bucketSizeNs});
1253
1254 EXPECT_EQ(1, data.bucket_info(9).atom_size());
1255 ValidateGaugeBucketTimes(data.bucket_info(9), configAddedTimeNs + 19 * bucketSizeNs,
1256 configAddedTimeNs + 20 * bucketSizeNs,
1257 {configAddedTimeNs + 19 * bucketSizeNs});
1258
1259 EXPECT_EQ(1, data.bucket_info(10).atom_size());
1260 ValidateGaugeBucketTimes(data.bucket_info(10), configAddedTimeNs + 24 * bucketSizeNs,
1261 configAddedTimeNs + 25 * bucketSizeNs,
1262 {configAddedTimeNs + 24 * bucketSizeNs});
1263
1264 EXPECT_EQ(1, data.bucket_info(11).atom_size());
1265 ValidateGaugeBucketTimes(data.bucket_info(11), configAddedTimeNs + 27 * bucketSizeNs,
1266 configAddedTimeNs + 28 * bucketSizeNs,
1267 {configAddedTimeNs + 27 * bucketSizeNs});
1268
1269 EXPECT_EQ(1, data.bucket_info(12).atom_size());
1270 ValidateGaugeBucketTimes(data.bucket_info(12), configAddedTimeNs + 28 * bucketSizeNs,
1271 configAddedTimeNs + 29 * bucketSizeNs,
1272 {configAddedTimeNs + 28 * bucketSizeNs});
1273
1274 EXPECT_EQ(1, data.bucket_info(13).atom_size());
1275 ValidateGaugeBucketTimes(data.bucket_info(13), configAddedTimeNs + 30 * bucketSizeNs,
1276 configAddedTimeNs + 31 * bucketSizeNs,
1277 {configAddedTimeNs + 30 * bucketSizeNs});
1278 }
1279
TEST(GaugeMetricE2ePulledTest,TestGaugeMetricPullProbabilityWithCondition)1280 TEST(GaugeMetricE2ePulledTest, TestGaugeMetricPullProbabilityWithCondition) {
1281 // Initiating StatsdStats at the start of this test, so it doesn't call rand() during the test.
1282 StatsdStats::getInstance();
1283 // Set srand seed to make rand deterministic for testing.
1284 srand(0);
1285
1286 auto config = CreateStatsdConfig(GaugeMetric::CONDITION_CHANGE_TO_TRUE, /*useCondition=*/true);
1287 auto gaugeMetric = config.mutable_gauge_metric(0);
1288 gaugeMetric->set_pull_probability(50);
1289 gaugeMetric->set_max_num_gauge_atoms_per_bucket(200);
1290 gaugeMetric->set_bucket(ONE_HOUR);
1291
1292 int64_t configAddedTimeNs = 60 * NS_PER_SEC;
1293 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
1294
1295 ConfigKey cfgKey;
1296 auto processor =
1297 CreateStatsLogProcessor(configAddedTimeNs, configAddedTimeNs, config, cfgKey,
1298 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
1299
1300 std::vector<std::unique_ptr<LogEvent>> events;
1301 // First bucket events.
1302 for (int i = 0; i < 30; i++) {
1303 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + (i * 10 * NS_PER_SEC),
1304 android::view::DISPLAY_STATE_OFF));
1305 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + (i * 11 * NS_PER_SEC),
1306 android::view::DISPLAY_STATE_ON));
1307 }
1308
1309 // Send log events to StatsLogProcessor.
1310 for (auto& event : events) {
1311 processor->OnLogEvent(event.get());
1312 }
1313
1314 ConfigMetricsReportList reports;
1315 vector<uint8_t> buffer;
1316 processor->onDumpReport(cfgKey, configAddedTimeNs + 2 * bucketSizeNs, false, true, ADB_DUMP,
1317 FAST, &buffer);
1318
1319 EXPECT_TRUE(buffer.size() > 0);
1320 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1321 backfillDimensionPath(&reports);
1322 backfillStringInReport(&reports);
1323 backfillStartEndTimestamp(&reports);
1324 backfillAggregatedAtoms(&reports);
1325 ASSERT_EQ(1, reports.reports_size());
1326 ASSERT_EQ(1, reports.reports(0).metrics_size());
1327 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1328 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1329 ASSERT_EQ((int)gaugeMetrics.data_size(), 2); // 2 sets of data for each pull.
1330
1331 // Data 1
1332 auto data = gaugeMetrics.data(0);
1333 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
1334 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1335 EXPECT_EQ(1 /* subsystem name field */,
1336 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1337 EXPECT_EQ("subsystem_name_1",
1338 data.dimensions_in_what().value_tuple().dimensions_value(0).value_str());
1339 ASSERT_EQ(1, data.bucket_info_size());
1340
1341 // Data 1, Bucket 1
1342 ASSERT_EQ(13, data.bucket_info(0).atom_size());
1343 ValidateGaugeBucketTimes(
1344 data.bucket_info(0), configAddedTimeNs, configAddedTimeNs + bucketSizeNs,
1345 {(int64_t)60 * NS_PER_SEC, (int64_t)80 * NS_PER_SEC, (int64_t)90 * NS_PER_SEC,
1346 (int64_t)130 * NS_PER_SEC, (int64_t)150 * NS_PER_SEC, (int64_t)170 * NS_PER_SEC,
1347 (int64_t)190 * NS_PER_SEC, (int64_t)200 * NS_PER_SEC, (int64_t)240 * NS_PER_SEC,
1348 (int64_t)250 * NS_PER_SEC, (int64_t)300 * NS_PER_SEC, (int64_t)330 * NS_PER_SEC,
1349 (int64_t)340 * NS_PER_SEC});
1350
1351 // Data 2
1352 data = gaugeMetrics.data(1);
1353 EXPECT_EQ(ATOM_TAG, data.dimensions_in_what().field());
1354 ASSERT_EQ(1, data.dimensions_in_what().value_tuple().dimensions_value_size());
1355 EXPECT_EQ(1 /* subsystem name field */,
1356 data.dimensions_in_what().value_tuple().dimensions_value(0).field());
1357 EXPECT_EQ("subsystem_name_2",
1358 data.dimensions_in_what().value_tuple().dimensions_value(0).value_str());
1359 ASSERT_EQ(1, data.bucket_info_size());
1360
1361 // Data 2, Bucket 1
1362 ASSERT_EQ(13, data.bucket_info(0).atom_size());
1363 ValidateGaugeBucketTimes(
1364 data.bucket_info(0), configAddedTimeNs, configAddedTimeNs + bucketSizeNs,
1365 {(int64_t)60 * NS_PER_SEC, (int64_t)80 * NS_PER_SEC, (int64_t)90 * NS_PER_SEC,
1366 (int64_t)130 * NS_PER_SEC, (int64_t)150 * NS_PER_SEC, (int64_t)170 * NS_PER_SEC,
1367 (int64_t)190 * NS_PER_SEC, (int64_t)200 * NS_PER_SEC, (int64_t)240 * NS_PER_SEC,
1368 (int64_t)250 * NS_PER_SEC, (int64_t)300 * NS_PER_SEC, (int64_t)330 * NS_PER_SEC,
1369 (int64_t)340 * NS_PER_SEC});
1370 }
1371
TEST(GaugeMetricE2ePulledTest,TestSliceByStates)1372 TEST(GaugeMetricE2ePulledTest, TestSliceByStates) {
1373 StatsdConfig config =
1374 CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /*useCondition=*/false);
1375 auto gaugeMetric = config.mutable_gauge_metric(0);
1376
1377 auto state = CreateScreenState();
1378 *config.add_state() = state;
1379 gaugeMetric->add_slice_by_state(state.id());
1380
1381 int64_t baseTimeNs = getElapsedRealtimeNs();
1382 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
1383 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
1384
1385 ConfigKey cfgKey;
1386 auto processor =
1387 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
1388 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
1389 processor->mPullerManager->ForceClearPullerCache();
1390
1391 // When creating the config, the gauge metric producer should register the alarm at the
1392 // end of the current bucket.
1393 ASSERT_EQ((size_t)1, processor->mPullerManager->mReceivers.size());
1394 EXPECT_EQ(bucketSizeNs,
1395 processor->mPullerManager->mReceivers.begin()->second.front().intervalNs);
1396 int64_t& nextPullTimeNs =
1397 processor->mPullerManager->mReceivers.begin()->second.front().nextPullTimeNs;
1398
1399 std::vector<std::unique_ptr<LogEvent>> events;
1400 // First Bucket
1401 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + 55,
1402 android::view::DISPLAY_STATE_OFF));
1403 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + 100,
1404 android::view::DISPLAY_STATE_ON));
1405 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + 150,
1406 android::view::DISPLAY_STATE_OFF));
1407
1408 // Send log events to StatsLogProcessor.
1409 for (auto& event : events) {
1410 processor->OnLogEvent(event.get());
1411 }
1412
1413 // Pulling alarm arrives on time and reset the sequential pulling alarm.
1414 processor->informPullAlarmFired(nextPullTimeNs + 1);
1415
1416 ConfigMetricsReportList reports;
1417 vector<uint8_t> buffer;
1418 processor->onDumpReport(cfgKey, configAddedTimeNs + (2 * bucketSizeNs) + 10, false, true,
1419 ADB_DUMP, FAST, &buffer);
1420 EXPECT_TRUE(buffer.size() > 0);
1421 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1422 backfillDimensionPath(&reports);
1423 backfillStringInReport(&reports);
1424 backfillStartEndTimestamp(&reports);
1425 backfillAggregatedAtoms(&reports);
1426 ASSERT_EQ(reports.reports_size(), 1);
1427 ASSERT_EQ(reports.reports(0).metrics_size(), 1);
1428 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1429 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1430 EXPECT_EQ((int)gaugeMetrics.data_size(), 4);
1431
1432 // Data 0, StateTracker::kStateUnknown, subsystem_name_1
1433 auto data = gaugeMetrics.data(0);
1434 EXPECT_EQ(data.dimensions_in_what().field(), ATOM_TAG);
1435 ASSERT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1);
1436 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(),
1437 1 /* subsystem name field */);
1438 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1439 "subsystem_name_1");
1440 ASSERT_EQ(data.bucket_info_size(), 1);
1441 ASSERT_EQ(data.slice_by_state_size(), 1);
1442 EXPECT_EQ(data.slice_by_state(0).atom_id(), SCREEN_STATE_ATOM_ID);
1443 EXPECT_EQ(data.slice_by_state(0).value(), -1 /* StateTracker::kStateUnknown */);
1444 ValidateGaugeBucketTimes(data.bucket_info(0),
1445 /*startTimeNs=*/configAddedTimeNs,
1446 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1447 /*eventTimesNs=*/
1448 {(int64_t)(configAddedTimeNs)});
1449
1450 // Data 1, DISPLAY_STATE_OFF, subsystem_name_1
1451 data = gaugeMetrics.data(1);
1452 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1453 "subsystem_name_1");
1454 ASSERT_EQ(data.bucket_info_size(), 1);
1455 EXPECT_EQ(data.slice_by_state(0).value(), android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
1456 // Second Bucket
1457 ValidateGaugeBucketTimes(data.bucket_info(0),
1458 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
1459 /*endTimeNs=*/configAddedTimeNs + 2 * bucketSizeNs,
1460 /*eventTimesNs=*/
1461 {(int64_t)(configAddedTimeNs + bucketSizeNs + 1)});
1462
1463 // Data 2, StateTracker::kStateUnknown, subsystem_name_2
1464 data = gaugeMetrics.data(2);
1465 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1466 "subsystem_name_2");
1467 EXPECT_EQ(data.slice_by_state(0).value(), -1 /* StateTracker::kStateUnknown */);
1468 ValidateGaugeBucketTimes(data.bucket_info(0),
1469 /*startTimeNs=*/configAddedTimeNs,
1470 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1471 /*eventTimesNs=*/
1472 {(int64_t)(configAddedTimeNs)});
1473
1474 // Data 3, DISPLAY_STATE_OFF, subsystem_name_2
1475 data = gaugeMetrics.data(3);
1476 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1477 "subsystem_name_2");
1478 EXPECT_EQ(data.slice_by_state(0).value(), android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
1479 // Second Bucket
1480 ValidateGaugeBucketTimes(data.bucket_info(0),
1481 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
1482 /*endTimeNs=*/configAddedTimeNs + 2 * bucketSizeNs,
1483 /*eventTimesNs=*/
1484 {(int64_t)(configAddedTimeNs + bucketSizeNs + 1)});
1485 }
1486
TEST(GaugeMetricE2ePulledTest,TestSliceByStatesWithTriggerAndCondition)1487 TEST(GaugeMetricE2ePulledTest, TestSliceByStatesWithTriggerAndCondition) {
1488 StatsdConfig config = CreateStatsdConfig(GaugeMetric::FIRST_N_SAMPLES, /*useCondition=*/false);
1489 auto gaugeMetric = config.mutable_gauge_metric(0);
1490
1491 *config.add_atom_matcher() = CreateBatteryStateNoneMatcher();
1492 *config.add_atom_matcher() = CreateBatteryStateUsbMatcher();
1493 auto deviceUnpluggedPredicate = CreateDeviceUnpluggedPredicate();
1494 *config.add_predicate() = deviceUnpluggedPredicate;
1495 gaugeMetric->set_condition(deviceUnpluggedPredicate.id());
1496
1497 auto triggerEventMatcher = CreateBatterySaverModeStartAtomMatcher();
1498 *config.add_atom_matcher() = triggerEventMatcher;
1499 gaugeMetric->set_trigger_event(triggerEventMatcher.id());
1500
1501 auto state = CreateScreenState();
1502 *config.add_state() = state;
1503 gaugeMetric->add_slice_by_state(state.id());
1504
1505 int64_t baseTimeNs = getElapsedRealtimeNs();
1506 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
1507 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
1508
1509 ConfigKey cfgKey;
1510 auto processor =
1511 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
1512 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
1513 processor->mPullerManager->ForceClearPullerCache();
1514
1515 std::vector<std::unique_ptr<LogEvent>> events;
1516 // First Bucket
1517 // Condition True
1518 events.push_back(CreateBatteryStateChangedEvent(configAddedTimeNs + 10,
1519 BatteryPluggedStateEnum::BATTERY_PLUGGED_NONE));
1520 // State Changed - No Pull
1521 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + 50,
1522 android::view::DISPLAY_STATE_OFF));
1523 // Trigger Event - Pull
1524 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 100));
1525 // Condition False
1526 events.push_back(CreateBatteryStateChangedEvent(configAddedTimeNs + 150,
1527 BatteryPluggedStateEnum::BATTERY_PLUGGED_USB));
1528 // State Changed - No Pull
1529 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + 200,
1530 android::view::DISPLAY_STATE_ON));
1531 // Trigger Event - No Pull
1532 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 250));
1533 // Condition True
1534 events.push_back(CreateBatteryStateChangedEvent(configAddedTimeNs + 300,
1535 BatteryPluggedStateEnum::BATTERY_PLUGGED_NONE));
1536
1537 // Second Bucket
1538 // Trigger Event - Pull
1539 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + bucketSizeNs + 50));
1540
1541 // Send log events to StatsLogProcessor.
1542 for (auto& event : events) {
1543 processor->OnLogEvent(event.get());
1544 }
1545
1546 ConfigMetricsReportList reports;
1547 vector<uint8_t> buffer;
1548 processor->onDumpReport(cfgKey, configAddedTimeNs + (2 * bucketSizeNs) + 10, false, true,
1549 ADB_DUMP, FAST, &buffer);
1550 EXPECT_TRUE(buffer.size() > 0);
1551 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1552 backfillDimensionPath(&reports);
1553 backfillStringInReport(&reports);
1554 backfillStartEndTimestamp(&reports);
1555 backfillAggregatedAtoms(&reports);
1556 ASSERT_EQ(reports.reports_size(), 1);
1557 ASSERT_EQ(reports.reports(0).metrics_size(), 1);
1558 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1559 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1560 EXPECT_EQ((int)gaugeMetrics.data_size(), 4);
1561 // Data Size is 4: 2 states (DISPLAY_STATE_ON, DISPLAY_STATE_OFF) and 2 dim_in_what
1562 // (subsystem_name_1, subsystem_name_2). The latter 2 entries are the same as the first 2 but
1563 // for subsystem_name_2
1564
1565 // Data 0, DISPLAY_STATE_OFF, subsystem_name_1
1566 auto data = gaugeMetrics.data(0);
1567 EXPECT_EQ(data.dimensions_in_what().field(), ATOM_TAG);
1568 ASSERT_EQ(data.dimensions_in_what().value_tuple().dimensions_value_size(), 1);
1569 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).field(),
1570 1 /* subsystem name field */);
1571 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1572 "subsystem_name_1");
1573 ASSERT_EQ(data.bucket_info_size(), 1);
1574 ASSERT_EQ(data.slice_by_state_size(), 1);
1575 EXPECT_EQ(data.slice_by_state(0).atom_id(), SCREEN_STATE_ATOM_ID);
1576 EXPECT_EQ(data.slice_by_state(0).value(), android::view::DisplayStateEnum::DISPLAY_STATE_OFF);
1577 ValidateGaugeBucketTimes(data.bucket_info(0),
1578 /*startTimeNs=*/configAddedTimeNs,
1579 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1580 /*eventTimesNs=*/
1581 {(int64_t)(configAddedTimeNs + 100)});
1582
1583 // Data 1, DISPLAY_STATE_ON, subsystem_name_1
1584 data = gaugeMetrics.data(1);
1585 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1586 "subsystem_name_1");
1587 ASSERT_EQ(data.bucket_info_size(), 1);
1588 EXPECT_EQ(data.slice_by_state(0).value(), android::view::DisplayStateEnum::DISPLAY_STATE_ON);
1589 ValidateGaugeBucketTimes(data.bucket_info(0),
1590 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
1591 /*endTimeNs=*/configAddedTimeNs + 2 * bucketSizeNs,
1592 /*eventTimesNs=*/
1593 {(int64_t)(configAddedTimeNs + bucketSizeNs + 50)});
1594 }
1595
TEST(GaugeMetricE2ePulledTest,TestSliceByStatesWithMapAndTrigger)1596 TEST(GaugeMetricE2ePulledTest, TestSliceByStatesWithMapAndTrigger) {
1597 StatsdConfig config = CreateStatsdConfig(GaugeMetric::FIRST_N_SAMPLES, /*useCondition=*/false);
1598 auto gaugeMetric = config.mutable_gauge_metric(0);
1599
1600 auto triggerEventMatcher = CreateBatterySaverModeStartAtomMatcher();
1601 *config.add_atom_matcher() = triggerEventMatcher;
1602 gaugeMetric->set_trigger_event(triggerEventMatcher.id());
1603
1604 int64_t screenOnId = 4444;
1605 int64_t screenOffId = 9876;
1606 auto state = CreateScreenStateWithOnOffMap(screenOnId, screenOffId);
1607 *config.add_state() = state;
1608 gaugeMetric->add_slice_by_state(state.id());
1609
1610 int64_t baseTimeNs = getElapsedRealtimeNs();
1611 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
1612 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
1613
1614 ConfigKey cfgKey;
1615 auto processor =
1616 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
1617 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
1618 processor->mPullerManager->ForceClearPullerCache();
1619
1620 std::vector<std::unique_ptr<LogEvent>> events;
1621 // First Bucket
1622 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 50));
1623
1624 events.push_back(CreateScreenStateChangedEvent(configAddedTimeNs + 100,
1625 android::view::DISPLAY_STATE_ON));
1626 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 110));
1627
1628 events.push_back(CreateScreenStateChangedEvent(
1629 configAddedTimeNs + 150, android::view::DisplayStateEnum::DISPLAY_STATE_DOZE));
1630 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 160));
1631
1632 events.push_back(CreateScreenStateChangedEvent(
1633 configAddedTimeNs + 200, android::view::DisplayStateEnum::DISPLAY_STATE_OFF));
1634 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 210));
1635
1636 // Second Bucket
1637 events.push_back(
1638 CreateScreenStateChangedEvent(configAddedTimeNs + bucketSizeNs + 10,
1639 android::view::DisplayStateEnum::DISPLAY_STATE_VR));
1640 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + bucketSizeNs + 50));
1641
1642 // Send log events to StatsLogProcessor.
1643 for (auto& event : events) {
1644 processor->OnLogEvent(event.get());
1645 }
1646
1647 ConfigMetricsReportList reports;
1648 vector<uint8_t> buffer;
1649 processor->onDumpReport(cfgKey, configAddedTimeNs + (2 * bucketSizeNs) + 10, false, true,
1650 ADB_DUMP, FAST, &buffer);
1651 EXPECT_TRUE(buffer.size() > 0);
1652 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1653 backfillDimensionPath(&reports);
1654 backfillStringInReport(&reports);
1655 backfillStartEndTimestamp(&reports);
1656 backfillAggregatedAtoms(&reports);
1657 ASSERT_EQ(reports.reports_size(), 1);
1658 ASSERT_EQ(reports.reports(0).metrics_size(), 1);
1659 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1660 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1661 EXPECT_EQ((int)gaugeMetrics.data_size(), 6);
1662 // Data Size is 6: 3 states (kStateUnknown, screenOn, screenOff) and 2 dim_in_what
1663 // (subsystem_name_1, subsystem_name_2). The latter 3 are same as the first 3 but for
1664 // subsystem_name_2
1665
1666 // Data 0, StateTracker::kStateUnknown, subsystem_name_1
1667 auto data = gaugeMetrics.data(0);
1668 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1669 "subsystem_name_1");
1670 ASSERT_EQ(data.bucket_info_size(), 1);
1671 EXPECT_EQ(data.slice_by_state(0).value(), -1 /* StateTracker::kStateUnknown */);
1672 // First Bucket
1673 ValidateGaugeBucketTimes(data.bucket_info(0),
1674 /*startTimeNs=*/configAddedTimeNs,
1675 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1676 /*eventTimesNs=*/
1677 {(int64_t)(configAddedTimeNs + 50)});
1678
1679 // Data 1, State Group Screen On, subsystem_name_1
1680 data = gaugeMetrics.data(1);
1681 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1682 "subsystem_name_1");
1683 ASSERT_EQ(data.bucket_info_size(), 2);
1684 EXPECT_EQ(data.slice_by_state(0).group_id(), screenOnId);
1685 // First Bucket
1686 ValidateGaugeBucketTimes(data.bucket_info(0),
1687 /*startTimeNs=*/configAddedTimeNs,
1688 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1689 /*eventTimesNs=*/
1690 {(int64_t)(configAddedTimeNs + 110)});
1691 // Second Bucket
1692 ValidateGaugeBucketTimes(data.bucket_info(1),
1693 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
1694 /*endTimeNs=*/configAddedTimeNs + 2 * bucketSizeNs,
1695 /*eventTimesNs=*/
1696 {(int64_t)(configAddedTimeNs + bucketSizeNs + 50)});
1697
1698 // Data 2, State Group Screen Off, subsystem_name_1
1699 data = gaugeMetrics.data(2);
1700 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_str(),
1701 "subsystem_name_1");
1702 ASSERT_EQ(data.bucket_info_size(), 1);
1703 EXPECT_EQ(data.slice_by_state(0).group_id(), screenOffId);
1704 // First Bucket
1705 ValidateGaugeBucketTimes(
1706 data.bucket_info(0),
1707 /*startTimeNs=*/configAddedTimeNs,
1708 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1709 /*eventTimesNs=*/
1710 {(int64_t)(configAddedTimeNs + 160), (int64_t)(configAddedTimeNs + 210)});
1711 }
1712
TEST(GaugeMetricE2ePulledTest,TestSliceByStatesWithPrimaryFieldsAndTrigger)1713 TEST(GaugeMetricE2ePulledTest, TestSliceByStatesWithPrimaryFieldsAndTrigger) {
1714 StatsdConfig config;
1715 config.add_default_pull_packages("AID_ROOT"); // Fake puller is registered with root.
1716 auto cpuTimePerUidMatcher =
1717 CreateSimpleAtomMatcher("CpuTimePerUidMatcher", util::CPU_TIME_PER_UID);
1718 *config.add_atom_matcher() = cpuTimePerUidMatcher;
1719
1720 auto gaugeMetric = config.add_gauge_metric();
1721 gaugeMetric->set_id(metricId);
1722 gaugeMetric->set_what(cpuTimePerUidMatcher.id());
1723 gaugeMetric->set_sampling_type(GaugeMetric::FIRST_N_SAMPLES);
1724 *gaugeMetric->mutable_dimensions_in_what() =
1725 CreateDimensions(util::CPU_TIME_PER_UID, {1 /* uid */});
1726 gaugeMetric->set_bucket(FIVE_MINUTES);
1727 gaugeMetric->set_max_pull_delay_sec(INT_MAX);
1728 config.set_hash_strings_in_metric_report(false);
1729 gaugeMetric->set_split_bucket_for_app_upgrade(true);
1730 gaugeMetric->set_min_bucket_size_nanos(1000);
1731
1732 auto triggerEventMatcher = CreateBatterySaverModeStartAtomMatcher();
1733 *config.add_atom_matcher() = triggerEventMatcher;
1734 gaugeMetric->set_trigger_event(triggerEventMatcher.id());
1735
1736 auto state = CreateUidProcessState();
1737 *config.add_state() = state;
1738 gaugeMetric->add_slice_by_state(state.id());
1739
1740 MetricStateLink* stateLink = gaugeMetric->add_state_link();
1741 stateLink->set_state_atom_id(UID_PROCESS_STATE_ATOM_ID);
1742 auto fieldsInWhat = stateLink->mutable_fields_in_what();
1743 *fieldsInWhat = CreateDimensions(util::CPU_TIME_PER_UID, {1 /* uid */});
1744 auto fieldsInState = stateLink->mutable_fields_in_state();
1745 *fieldsInState = CreateDimensions(UID_PROCESS_STATE_ATOM_ID, {1 /* uid */});
1746
1747 int64_t baseTimeNs = getElapsedRealtimeNs();
1748 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
1749 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
1750
1751 ConfigKey cfgKey;
1752 auto processor = CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
1753 SharedRefBase::make<FakeCpuTimeCallback>(),
1754 util::CPU_TIME_PER_UID);
1755 processor->mPullerManager->ForceClearPullerCache();
1756
1757 std::vector<std::unique_ptr<LogEvent>> events;
1758 // First Bucket
1759 events.push_back(CreateUidProcessStateChangedEvent(
1760 configAddedTimeNs + 55, 1 /*uid*/,
1761 android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND));
1762 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 80));
1763
1764 events.push_back(CreateUidProcessStateChangedEvent(
1765 configAddedTimeNs + 100, 2 /*uid*/, android::app::ProcessStateEnum::PROCESS_STATE_TOP));
1766 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 150));
1767
1768 events.push_back(CreateUidProcessStateChangedEvent(
1769 configAddedTimeNs + 200, 1 /*uid*/,
1770 android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND));
1771 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + 250));
1772
1773 // Second Bucket
1774 events.push_back(CreateUidProcessStateChangedEvent(
1775 configAddedTimeNs + bucketSizeNs + 50, 1 /*uid*/,
1776 android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND));
1777 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + bucketSizeNs + 150));
1778
1779 events.push_back(CreateUidProcessStateChangedEvent(
1780 configAddedTimeNs + bucketSizeNs + 200, 2 /*uid*/,
1781 android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND));
1782 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + bucketSizeNs + 220));
1783
1784 events.push_back(
1785 CreateUidProcessStateChangedEvent(configAddedTimeNs + bucketSizeNs + 250, 2 /*uid*/,
1786 android::app::ProcessStateEnum::PROCESS_STATE_TOP));
1787 events.push_back(CreateBatterySaverOnEvent(configAddedTimeNs + bucketSizeNs + 300));
1788
1789 // Send log events to StatsLogProcessor.
1790 for (auto& event : events) {
1791 processor->OnLogEvent(event.get());
1792 }
1793
1794 ConfigMetricsReportList reports;
1795 vector<uint8_t> buffer;
1796 processor->onDumpReport(cfgKey, configAddedTimeNs + (2 * bucketSizeNs) + 10, false, true,
1797 ADB_DUMP, FAST, &buffer);
1798 EXPECT_TRUE(buffer.size() > 0);
1799 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1800 backfillDimensionPath(&reports);
1801 backfillStringInReport(&reports);
1802 backfillStartEndTimestamp(&reports);
1803 backfillAggregatedAtoms(&reports);
1804 ASSERT_EQ(reports.reports_size(), 1);
1805 ASSERT_EQ(reports.reports(0).metrics_size(), 1);
1806 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1807 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1808 EXPECT_EQ((int)gaugeMetrics.data_size(), 5);
1809
1810 // Data 0, PROCESS_STATE_IMPORTANT_FOREGROUND, UID 1
1811 auto data = gaugeMetrics.data(0);
1812 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(),
1813 1 /* uid value */);
1814 ASSERT_EQ(data.bucket_info_size(), 2);
1815 EXPECT_EQ(data.slice_by_state(0).value(),
1816 android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND);
1817 // First Bucket
1818 ValidateGaugeBucketTimes(
1819 data.bucket_info(0),
1820 /*startTimeNs=*/configAddedTimeNs,
1821 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1822 /*eventTimesNs=*/
1823 {(int64_t)(configAddedTimeNs + 80), (int64_t)(configAddedTimeNs + 150)});
1824 // Second Bucket
1825 ValidateGaugeBucketTimes(data.bucket_info(1),
1826 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
1827 /*endTimeNs=*/configAddedTimeNs + 2 * bucketSizeNs,
1828 /*eventTimesNs=*/
1829 {(int64_t)(configAddedTimeNs + bucketSizeNs + 150),
1830 (int64_t)(configAddedTimeNs + bucketSizeNs + 220),
1831 (int64_t)(configAddedTimeNs + bucketSizeNs + 300)});
1832
1833 // Data 1, PROCESS_STATE_IMPORTANT_BACKGROUND, UID 1
1834 data = gaugeMetrics.data(1);
1835 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(),
1836 1 /* uid value */);
1837 ASSERT_EQ(data.bucket_info_size(), 1);
1838 EXPECT_EQ(data.slice_by_state(0).value(),
1839 android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_BACKGROUND);
1840 // First Bucket
1841 ValidateGaugeBucketTimes(data.bucket_info(0),
1842 /*startTimeNs=*/configAddedTimeNs,
1843 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1844 /*eventTimesNs=*/
1845 {(int64_t)(configAddedTimeNs + 250)});
1846
1847 // Data 2, StateTracker::kStateUnknown, UID 2
1848 data = gaugeMetrics.data(2);
1849 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(),
1850 2 /* uid value */);
1851 ASSERT_EQ(data.bucket_info_size(), 1);
1852 EXPECT_EQ(data.slice_by_state(0).value(), -1 /* StateTracker::kStateUnknown */);
1853 // First Bucket
1854 ValidateGaugeBucketTimes(data.bucket_info(0),
1855 /*startTimeNs=*/configAddedTimeNs,
1856 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1857 /*eventTimesNs=*/
1858 {(int64_t)(configAddedTimeNs + 80)});
1859
1860 // Data 3, PROCESS_STATE_TOP, UID 2
1861 data = gaugeMetrics.data(3);
1862 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(),
1863 2 /* uid value */);
1864 ASSERT_EQ(data.bucket_info_size(), 2);
1865 EXPECT_EQ(data.slice_by_state(0).value(), android::app::ProcessStateEnum::PROCESS_STATE_TOP);
1866 // First Bucket
1867 ValidateGaugeBucketTimes(
1868 data.bucket_info(0),
1869 /*startTimeNs=*/configAddedTimeNs,
1870 /*endTimeNs=*/configAddedTimeNs + bucketSizeNs,
1871 /*eventTimesNs=*/
1872 {(int64_t)(configAddedTimeNs + 150), (int64_t)(configAddedTimeNs + 250)});
1873 // Second Bucket
1874 ValidateGaugeBucketTimes(data.bucket_info(1),
1875 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
1876 /*endTimeNs=*/configAddedTimeNs + 2 * bucketSizeNs,
1877 /*eventTimesNs=*/
1878 {(int64_t)(configAddedTimeNs + bucketSizeNs + 150),
1879 (int64_t)(configAddedTimeNs + bucketSizeNs + 300)});
1880
1881 // Data 4, PROCESS_STATE_IMPORTANT_FOREGROUND, UID 2
1882 data = gaugeMetrics.data(4);
1883 EXPECT_EQ(data.dimensions_in_what().value_tuple().dimensions_value(0).value_int(),
1884 2 /* uid value */);
1885 ASSERT_EQ(data.bucket_info_size(), 1);
1886 EXPECT_EQ(data.slice_by_state(0).value(),
1887 android::app::ProcessStateEnum::PROCESS_STATE_IMPORTANT_FOREGROUND);
1888 // Second Bucket Only
1889 ValidateGaugeBucketTimes(data.bucket_info(0),
1890 /*startTimeNs=*/configAddedTimeNs + bucketSizeNs,
1891 /*endTimeNs=*/configAddedTimeNs + 2 * bucketSizeNs,
1892 /*eventTimesNs=*/
1893 {(int64_t)(configAddedTimeNs + bucketSizeNs + 220)});
1894 }
1895
TEST(GaugeMetricE2ePulledTest,TestFieldFilterOmit)1896 TEST(GaugeMetricE2ePulledTest, TestFieldFilterOmit) {
1897 auto config = CreateStatsdConfig(GaugeMetric::RANDOM_ONE_SAMPLE, /* useCondition */ false);
1898 config.mutable_gauge_metric(0)->mutable_gauge_fields_filter()->mutable_omit_fields()->set_field(
1899 ATOM_TAG);
1900 config.mutable_gauge_metric(0)
1901 ->mutable_gauge_fields_filter()
1902 ->mutable_omit_fields()
1903 ->add_child()
1904 ->set_field(2); // subsystem_subname
1905 int64_t baseTimeNs = getElapsedRealtimeNs();
1906 int64_t configAddedTimeNs = 10 * 60 * NS_PER_SEC + baseTimeNs;
1907 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(config.gauge_metric(0).bucket()) * 1000000;
1908
1909 ConfigKey cfgKey;
1910 auto processor =
1911 CreateStatsLogProcessor(baseTimeNs, configAddedTimeNs, config, cfgKey,
1912 SharedRefBase::make<FakeSubsystemSleepCallback>(), ATOM_TAG);
1913
1914 processor->informPullAlarmFired(baseTimeNs + bucketSizeNs * 2 + 1);
1915
1916 ConfigMetricsReportList reports;
1917 vector<uint8_t> buffer;
1918 processor->onDumpReport(cfgKey, configAddedTimeNs + 3 * bucketSizeNs + 10, false, true,
1919 ADB_DUMP, FAST, &buffer);
1920 EXPECT_TRUE(buffer.size() > 0);
1921 EXPECT_TRUE(reports.ParseFromArray(&buffer[0], buffer.size()));
1922 backfillDimensionPath(&reports);
1923 backfillStringInReport(&reports);
1924 backfillStartEndTimestamp(&reports);
1925 backfillAggregatedAtoms(&reports);
1926 ASSERT_EQ(1, reports.reports_size());
1927 ASSERT_EQ(1, reports.reports(0).metrics_size());
1928 StatsLogReport::GaugeMetricDataWrapper gaugeMetrics;
1929 sortMetricDataByDimensionsValue(reports.reports(0).metrics(0).gauge_metrics(), &gaugeMetrics);
1930 ASSERT_GT((int)gaugeMetrics.data_size(), 1);
1931
1932 auto data = gaugeMetrics.data(0);
1933 ASSERT_EQ(data.bucket_info_size(), 1);
1934 ASSERT_EQ(data.bucket_info(0).atom_size(), 1);
1935 EXPECT_FALSE(data.bucket_info(0).atom(0).subsystem_sleep_state().has_subname());
1936 EXPECT_EQ(data.bucket_info(0).atom(0).subsystem_sleep_state().count(), 1);
1937 EXPECT_GT(data.bucket_info(0).atom(0).subsystem_sleep_state().time_millis(), 0);
1938 }
1939 #else
1940 GTEST_LOG_(INFO) << "This test does nothing.\n";
1941 #endif
1942
1943 } // namespace statsd
1944 } // namespace os
1945 } // namespace android
1946