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 "src/metrics/DurationMetricProducer.h"
16
17 #include <gmock/gmock.h>
18 #include <gtest/gtest.h>
19 #include <stdio.h>
20
21 #include <set>
22 #include <unordered_map>
23 #include <vector>
24
25 #include "metrics_test_helper.h"
26 #include "src/condition/ConditionWizard.h"
27 #include "src/stats_log_util.h"
28 #include "stats_event.h"
29 #include "tests/statsd_test_util.h"
30
31 using namespace android::os::statsd;
32 using namespace testing;
33 using android::sp;
34 using std::set;
35 using std::unordered_map;
36 using std::vector;
37
38 #ifdef __ANDROID__
39
40 namespace android {
41 namespace os {
42 namespace statsd {
43
44
45 namespace {
46
47 const ConfigKey kConfigKey(0, 12345);
48 const uint64_t protoHash = 0x1234567890;
makeLogEvent(LogEvent * logEvent,int64_t timestampNs,int atomId)49 void makeLogEvent(LogEvent* logEvent, int64_t timestampNs, int atomId) {
50 AStatsEvent* statsEvent = AStatsEvent_obtain();
51 AStatsEvent_setAtomId(statsEvent, atomId);
52 AStatsEvent_overwriteTimestamp(statsEvent, timestampNs);
53
54 parseStatsEventToLogEvent(statsEvent, logEvent);
55 }
56
57 } // namespace
58
59 // Setup for parameterized tests.
60 class DurationMetricProducerTest_PartialBucket : public TestWithParam<BucketSplitEvent> {};
61
62 INSTANTIATE_TEST_SUITE_P(DurationMetricProducerTest_PartialBucket,
63 DurationMetricProducerTest_PartialBucket,
64 testing::Values(APP_UPGRADE, BOOT_COMPLETE));
65
TEST(DurationMetricTrackerTest,TestFirstBucket)66 TEST(DurationMetricTrackerTest, TestFirstBucket) {
67 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
68 DurationMetric metric;
69 metric.set_id(1);
70 metric.set_bucket(ONE_MINUTE);
71 metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
72
73 FieldMatcher dimensions;
74
75 DurationMetricProducer durationProducer(
76 kConfigKey, metric, -1 /*no condition*/, {}, -1 /*what index not needed*/,
77 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/,
78 wizard, protoHash, dimensions, 5, 600 * NS_PER_SEC + NS_PER_SEC / 2);
79
80 EXPECT_EQ(600500000000, durationProducer.mCurrentBucketStartTimeNs);
81 EXPECT_EQ(10, durationProducer.mCurrentBucketNum);
82 EXPECT_EQ(660000000005, durationProducer.getCurrentBucketEndTimeNs());
83 }
84
TEST(DurationMetricTrackerTest,TestNoCondition)85 TEST(DurationMetricTrackerTest, TestNoCondition) {
86 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
87 int64_t bucketStartTimeNs = 10000000000;
88 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
89
90 DurationMetric metric;
91 metric.set_id(1);
92 metric.set_bucket(ONE_MINUTE);
93 metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
94
95 int tagId = 1;
96 LogEvent event1(/*uid=*/0, /*pid=*/0);
97 makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
98 LogEvent event2(/*uid=*/0, /*pid=*/0);
99 makeLogEvent(&event2, bucketStartTimeNs + bucketSizeNs + 2, tagId);
100
101 FieldMatcher dimensions;
102
103 DurationMetricProducer durationProducer(
104 kConfigKey, metric, -1 /*no condition*/, {}, -1 /*what index not needed*/,
105 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/,
106 wizard, protoHash, dimensions, bucketStartTimeNs, bucketStartTimeNs);
107
108 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
109 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
110 durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
111 ASSERT_EQ(1UL, durationProducer.mPastBuckets.size());
112 EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
113 durationProducer.mPastBuckets.end());
114 const auto& buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
115 ASSERT_EQ(2UL, buckets.size());
116 EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
117 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs);
118 EXPECT_EQ(bucketSizeNs - 1LL, buckets[0].mDuration);
119 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketStartNs);
120 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[1].mBucketEndNs);
121 EXPECT_EQ(2LL, buckets[1].mDuration);
122 }
123
TEST(DurationMetricTrackerTest,TestNonSlicedCondition)124 TEST(DurationMetricTrackerTest, TestNonSlicedCondition) {
125 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
126 int64_t bucketStartTimeNs = 10000000000;
127 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
128
129 DurationMetric metric;
130 metric.set_id(1);
131 metric.set_bucket(ONE_MINUTE);
132 metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
133
134 int tagId = 1;
135 LogEvent event1(/*uid=*/0, /*pid=*/0);
136 makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
137 LogEvent event2(/*uid=*/0, /*pid=*/0);
138 makeLogEvent(&event2, bucketStartTimeNs + 2, tagId);
139 LogEvent event3(/*uid=*/0, /*pid=*/0);
140 makeLogEvent(&event3, bucketStartTimeNs + bucketSizeNs + 1, tagId);
141 LogEvent event4(/*uid=*/0, /*pid=*/0);
142 makeLogEvent(&event4, bucketStartTimeNs + bucketSizeNs + 3, tagId);
143
144 FieldMatcher dimensions;
145
146 DurationMetricProducer durationProducer(
147 kConfigKey, metric, 0 /* condition index */, {ConditionState::kUnknown},
148 -1 /*what index not needed*/, 1 /* start index */, 2 /* stop index */,
149 3 /* stop_all index */, false /*nesting*/, wizard, protoHash, dimensions,
150 bucketStartTimeNs, bucketStartTimeNs);
151 durationProducer.mCondition = ConditionState::kFalse;
152
153 EXPECT_FALSE(durationProducer.mCondition);
154 EXPECT_FALSE(durationProducer.isConditionSliced());
155
156 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
157 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
158 durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
159 ASSERT_EQ(0UL, durationProducer.mPastBuckets.size());
160
161 durationProducer.onMatchedLogEvent(1 /* start index*/, event3);
162 durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2);
163 durationProducer.onMatchedLogEvent(2 /* stop index*/, event4);
164 durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
165 ASSERT_EQ(1UL, durationProducer.mPastBuckets.size());
166 EXPECT_TRUE(durationProducer.mPastBuckets.find(DEFAULT_METRIC_DIMENSION_KEY) !=
167 durationProducer.mPastBuckets.end());
168 const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
169 ASSERT_EQ(1UL, buckets2.size());
170 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs);
171 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs);
172 EXPECT_EQ(1LL, buckets2[0].mDuration);
173 }
174
TEST(DurationMetricTrackerTest,TestNonSlicedConditionUnknownState)175 TEST(DurationMetricTrackerTest, TestNonSlicedConditionUnknownState) {
176 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
177 int64_t bucketStartTimeNs = 10000000000;
178 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
179
180 DurationMetric metric;
181 metric.set_id(1);
182 metric.set_bucket(ONE_MINUTE);
183 metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
184
185 int tagId = 1;
186 LogEvent event1(/*uid=*/0, /*pid=*/0);
187 makeLogEvent(&event1, bucketStartTimeNs + 1, tagId);
188 LogEvent event2(/*uid=*/0, /*pid=*/0);
189 makeLogEvent(&event2, bucketStartTimeNs + 2, tagId);
190 LogEvent event3(/*uid=*/0, /*pid=*/0);
191 makeLogEvent(&event3, bucketStartTimeNs + bucketSizeNs + 1, tagId);
192 LogEvent event4(/*uid=*/0, /*pid=*/0);
193 makeLogEvent(&event4, bucketStartTimeNs + bucketSizeNs + 3, tagId);
194
195 FieldMatcher dimensions;
196
197 DurationMetricProducer durationProducer(
198 kConfigKey, metric, 0 /* condition index */, {ConditionState::kUnknown},
199 -1 /*what index not needed*/, 1 /* start index */, 2 /* stop index */,
200 3 /* stop_all index */, false /*nesting*/, wizard, protoHash, dimensions,
201 bucketStartTimeNs, bucketStartTimeNs);
202
203 EXPECT_EQ(ConditionState::kUnknown, durationProducer.mCondition);
204 EXPECT_FALSE(durationProducer.isConditionSliced());
205
206 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
207 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
208 durationProducer.flushIfNeededLocked(bucketStartTimeNs + bucketSizeNs + 1);
209 ASSERT_EQ(0UL, durationProducer.mPastBuckets.size());
210
211 durationProducer.onMatchedLogEvent(1 /* start index*/, event3);
212 durationProducer.onConditionChanged(true /* condition */, bucketStartTimeNs + bucketSizeNs + 2);
213 durationProducer.onMatchedLogEvent(2 /* stop index*/, event4);
214 durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
215 ASSERT_EQ(1UL, durationProducer.mPastBuckets.size());
216 const auto& buckets2 = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
217 ASSERT_EQ(1UL, buckets2.size());
218 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets2[0].mBucketStartNs);
219 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets2[0].mBucketEndNs);
220 EXPECT_EQ(1LL, buckets2[0].mDuration);
221 }
222
TEST_P(DurationMetricProducerTest_PartialBucket,TestSumDuration)223 TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDuration) {
224 /**
225 * The duration starts from the first bucket, through the two partial buckets (10-70sec),
226 * another bucket, and ends at the beginning of the next full bucket.
227 * Expected buckets:
228 * - [10,25]: 14 secs
229 * - [25,70]: All 45 secs
230 * - [70,130]: All 60 secs
231 * - [130, 210]: Only 5 secs (event ended at 135sec)
232 */
233 int64_t bucketStartTimeNs = 10000000000;
234 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
235 int tagId = 1;
236
237 DurationMetric metric;
238 metric.set_id(1);
239 metric.set_bucket(ONE_MINUTE);
240 metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
241 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
242 FieldMatcher dimensions;
243
244 DurationMetricProducer durationProducer(
245 kConfigKey, metric, -1 /* no condition */, {}, -1 /*what index not needed*/,
246 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/,
247 wizard, protoHash, dimensions, bucketStartTimeNs, bucketStartTimeNs);
248
249 int64_t startTimeNs = bucketStartTimeNs + 1 * NS_PER_SEC;
250 LogEvent event1(/*uid=*/0, /*pid=*/0);
251 makeLogEvent(&event1, startTimeNs, tagId);
252 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
253 ASSERT_EQ(0UL, durationProducer.mPastBuckets.size());
254 EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
255
256 int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
257 switch (GetParam()) {
258 case APP_UPGRADE:
259 durationProducer.notifyAppUpgrade(partialBucketSplitTimeNs);
260 break;
261 case BOOT_COMPLETE:
262 durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs);
263 break;
264 }
265 ASSERT_EQ(1UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
266 std::vector<DurationBucket> buckets =
267 durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
268 EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
269 EXPECT_EQ(partialBucketSplitTimeNs, buckets[0].mBucketEndNs);
270 EXPECT_EQ(partialBucketSplitTimeNs - startTimeNs, buckets[0].mDuration);
271 EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs);
272 EXPECT_EQ(0, durationProducer.getCurrentBucketNum());
273
274 // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
275 int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC;
276 LogEvent event2(/*uid=*/0, /*pid=*/0);
277 makeLogEvent(&event2, endTimeNs, tagId);
278 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
279 buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
280 ASSERT_EQ(3UL, buckets.size());
281 EXPECT_EQ(partialBucketSplitTimeNs, buckets[1].mBucketStartNs);
282 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketEndNs);
283 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - partialBucketSplitTimeNs, buckets[1].mDuration);
284 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[2].mBucketStartNs);
285 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[2].mBucketEndNs);
286 EXPECT_EQ(bucketSizeNs, buckets[2].mDuration);
287 }
288
TEST_P(DurationMetricProducerTest_PartialBucket,TestSumDurationWithSplitInFollowingBucket)289 TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDurationWithSplitInFollowingBucket) {
290 /**
291 * Expected buckets (start at 11s, upgrade at 75s, end at 135s):
292 * - [10,70]: 59 secs
293 * - [70,75]: 5 sec
294 * - [75,130]: 55 secs
295 */
296 int64_t bucketStartTimeNs = 10000000000;
297 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
298 int tagId = 1;
299
300 DurationMetric metric;
301 metric.set_id(1);
302 metric.set_bucket(ONE_MINUTE);
303 metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
304 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
305 FieldMatcher dimensions;
306
307 DurationMetricProducer durationProducer(
308 kConfigKey, metric, -1 /* no condition */, {}, -1 /*what index not needed*/,
309 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/,
310 wizard, protoHash, dimensions, bucketStartTimeNs, bucketStartTimeNs);
311
312 int64_t startTimeNs = bucketStartTimeNs + 1 * NS_PER_SEC;
313 LogEvent event1(/*uid=*/0, /*pid=*/0);
314 makeLogEvent(&event1, startTimeNs, tagId);
315 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
316 ASSERT_EQ(0UL, durationProducer.mPastBuckets.size());
317 EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
318
319 int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC;
320 switch (GetParam()) {
321 case APP_UPGRADE:
322 durationProducer.notifyAppUpgrade(partialBucketSplitTimeNs);
323 break;
324 case BOOT_COMPLETE:
325 durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs);
326 break;
327 }
328 ASSERT_EQ(2UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
329 std::vector<DurationBucket> buckets =
330 durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
331 EXPECT_EQ(bucketStartTimeNs, buckets[0].mBucketStartNs);
332 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[0].mBucketEndNs);
333 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - startTimeNs, buckets[0].mDuration);
334 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs, buckets[1].mBucketStartNs);
335 EXPECT_EQ(partialBucketSplitTimeNs, buckets[1].mBucketEndNs);
336 EXPECT_EQ(partialBucketSplitTimeNs - (bucketStartTimeNs + bucketSizeNs), buckets[1].mDuration);
337 EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs);
338 EXPECT_EQ(1, durationProducer.getCurrentBucketNum());
339
340 // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
341 int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC;
342 LogEvent event2(/*uid=*/0, /*pid=*/0);
343 makeLogEvent(&event2, endTimeNs, tagId);
344 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
345 buckets = durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
346 ASSERT_EQ(3UL, buckets.size());
347 EXPECT_EQ(partialBucketSplitTimeNs, buckets[2].mBucketStartNs);
348 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[2].mBucketEndNs);
349 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs - partialBucketSplitTimeNs,
350 buckets[2].mDuration);
351 }
352
TEST_P(DurationMetricProducerTest_PartialBucket,TestSumDurationAnomaly)353 TEST_P(DurationMetricProducerTest_PartialBucket, TestSumDurationAnomaly) {
354 sp<AlarmMonitor> alarmMonitor;
355 int64_t bucketStartTimeNs = 10000000000;
356 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
357 int tagId = 1;
358
359 // Setup metric with alert.
360 DurationMetric metric;
361 metric.set_id(1);
362 metric.set_bucket(ONE_MINUTE);
363 metric.set_aggregation_type(DurationMetric_AggregationType_SUM);
364 Alert alert;
365 alert.set_num_buckets(3);
366 alert.set_trigger_if_sum_gt(2);
367
368 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
369 FieldMatcher dimensions;
370
371 DurationMetricProducer durationProducer(
372 kConfigKey, metric, -1 /* no condition */, {}, -1 /*what index not needed*/,
373 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/,
374 wizard, protoHash, dimensions, bucketStartTimeNs, bucketStartTimeNs);
375
376 sp<AnomalyTracker> anomalyTracker =
377 durationProducer.addAnomalyTracker(alert, alarmMonitor, UPDATE_NEW, bucketStartTimeNs);
378 EXPECT_TRUE(anomalyTracker != nullptr);
379
380 int64_t startTimeNs = bucketStartTimeNs + 1;
381 LogEvent event1(/*uid=*/0, /*pid=*/0);
382 makeLogEvent(&event1, startTimeNs, tagId);
383 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
384
385 int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
386 switch (GetParam()) {
387 case APP_UPGRADE:
388 durationProducer.notifyAppUpgrade(partialBucketSplitTimeNs);
389 break;
390 case BOOT_COMPLETE:
391 durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs);
392 break;
393 }
394
395 // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
396 int64_t endTimeNs = startTimeNs + 65 * NS_PER_SEC;
397 LogEvent event2(/*uid=*/0, /*pid=*/0);
398 makeLogEvent(&event2, endTimeNs, tagId);
399 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
400
401 EXPECT_EQ(bucketStartTimeNs + bucketSizeNs - startTimeNs,
402 anomalyTracker->getSumOverPastBuckets(DEFAULT_METRIC_DIMENSION_KEY));
403 }
404
TEST_P(DurationMetricProducerTest_PartialBucket,TestMaxDuration)405 TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDuration) {
406 int64_t bucketStartTimeNs = 10000000000;
407 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
408 int tagId = 1;
409
410 DurationMetric metric;
411 metric.set_id(1);
412 metric.set_bucket(ONE_MINUTE);
413 metric.set_aggregation_type(DurationMetric_AggregationType_MAX_SPARSE);
414
415 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
416 FieldMatcher dimensions;
417
418 DurationMetricProducer durationProducer(
419 kConfigKey, metric, -1 /* no condition */, {}, -1 /*what index not needed*/,
420 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/,
421 wizard, protoHash, dimensions, bucketStartTimeNs, bucketStartTimeNs);
422
423 int64_t startTimeNs = bucketStartTimeNs + 1;
424 LogEvent event1(/*uid=*/0, /*pid=*/0);
425 makeLogEvent(&event1, startTimeNs, tagId);
426 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
427 ASSERT_EQ(0UL, durationProducer.mPastBuckets.size());
428 EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
429
430 int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 15 * NS_PER_SEC;
431 switch (GetParam()) {
432 case APP_UPGRADE:
433 durationProducer.notifyAppUpgrade(partialBucketSplitTimeNs);
434 break;
435 case BOOT_COMPLETE:
436 durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs);
437 break;
438 }
439 ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
440 EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs);
441 EXPECT_EQ(0, durationProducer.getCurrentBucketNum());
442
443 // We skip ahead one bucket, so we fill in the first two partial buckets and one full bucket.
444 int64_t endTimeNs = startTimeNs + 125 * NS_PER_SEC;
445 LogEvent event2(/*uid=*/0, /*pid=*/0);
446 makeLogEvent(&event2, endTimeNs, tagId);
447 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
448 ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
449
450 durationProducer.flushIfNeededLocked(bucketStartTimeNs + 3 * bucketSizeNs + 1);
451 std::vector<DurationBucket> buckets =
452 durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
453 ASSERT_EQ(1UL, buckets.size());
454 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketStartNs);
455 EXPECT_EQ(bucketStartTimeNs + 3 * bucketSizeNs, buckets[0].mBucketEndNs);
456 EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration);
457 }
458
TEST_P(DurationMetricProducerTest_PartialBucket,TestMaxDurationWithSplitInNextBucket)459 TEST_P(DurationMetricProducerTest_PartialBucket, TestMaxDurationWithSplitInNextBucket) {
460 int64_t bucketStartTimeNs = 10000000000;
461 int64_t bucketSizeNs = TimeUnitToBucketSizeInMillis(ONE_MINUTE) * 1000000LL;
462 int tagId = 1;
463
464 DurationMetric metric;
465 metric.set_id(1);
466 metric.set_bucket(ONE_MINUTE);
467 metric.set_aggregation_type(DurationMetric_AggregationType_MAX_SPARSE);
468
469 sp<MockConditionWizard> wizard = new NaggyMock<MockConditionWizard>();
470 FieldMatcher dimensions;
471
472 DurationMetricProducer durationProducer(
473 kConfigKey, metric, -1 /* no condition */, {}, -1 /*what index not needed*/,
474 1 /* start index */, 2 /* stop index */, 3 /* stop_all index */, false /*nesting*/,
475 wizard, protoHash, dimensions, bucketStartTimeNs, bucketStartTimeNs);
476
477 int64_t startTimeNs = bucketStartTimeNs + 1;
478 LogEvent event1(/*uid=*/0, /*pid=*/0);
479 makeLogEvent(&event1, startTimeNs, tagId);
480 durationProducer.onMatchedLogEvent(1 /* start index*/, event1);
481 ASSERT_EQ(0UL, durationProducer.mPastBuckets.size());
482 EXPECT_EQ(bucketStartTimeNs, durationProducer.mCurrentBucketStartTimeNs);
483
484 int64_t partialBucketSplitTimeNs = bucketStartTimeNs + 65 * NS_PER_SEC;
485 switch (GetParam()) {
486 case APP_UPGRADE:
487 durationProducer.notifyAppUpgrade(partialBucketSplitTimeNs);
488 break;
489 case BOOT_COMPLETE:
490 durationProducer.onStatsdInitCompleted(partialBucketSplitTimeNs);
491 break;
492 }
493 ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
494 EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs);
495 EXPECT_EQ(1, durationProducer.getCurrentBucketNum());
496
497 // Stop occurs in the same partial bucket as created for the app upgrade.
498 int64_t endTimeNs = startTimeNs + 115 * NS_PER_SEC;
499 LogEvent event2(/*uid=*/0, /*pid=*/0);
500 makeLogEvent(&event2, endTimeNs, tagId);
501 durationProducer.onMatchedLogEvent(2 /* stop index*/, event2);
502 ASSERT_EQ(0UL, durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY].size());
503 EXPECT_EQ(partialBucketSplitTimeNs, durationProducer.mCurrentBucketStartTimeNs);
504
505 durationProducer.flushIfNeededLocked(bucketStartTimeNs + 2 * bucketSizeNs + 1);
506 std::vector<DurationBucket> buckets =
507 durationProducer.mPastBuckets[DEFAULT_METRIC_DIMENSION_KEY];
508 ASSERT_EQ(1UL, buckets.size());
509 EXPECT_EQ(partialBucketSplitTimeNs, buckets[0].mBucketStartNs);
510 EXPECT_EQ(bucketStartTimeNs + 2 * bucketSizeNs, buckets[0].mBucketEndNs);
511 EXPECT_EQ(endTimeNs - startTimeNs, buckets[0].mDuration);
512 }
513
514 } // namespace statsd
515 } // namespace os
516 } // namespace android
517 #else
518 GTEST_LOG_(INFO) << "This test does nothing.\n";
519 #endif
520