1 /*
2  * Copyright (C) 2017 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef COUNT_METRIC_PRODUCER_H
18 #define COUNT_METRIC_PRODUCER_H
19 
20 #include <android/util/ProtoOutputStream.h>
21 #include <gtest/gtest_prod.h>
22 
23 #include <unordered_map>
24 
25 #include "MetricProducer.h"
26 #include "anomaly/AnomalyTracker.h"
27 #include "condition/ConditionTracker.h"
28 #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h"
29 #include "matchers/matcher_util.h"
30 #include "stats_util.h"
31 
32 namespace android {
33 namespace os {
34 namespace statsd {
35 
36 struct CountBucket {
37     int64_t mBucketStartNs;
38     int64_t mBucketEndNs;
39     int64_t mCount;
40 };
41 
42 class CountMetricProducer : public MetricProducer {
43 public:
44     CountMetricProducer(
45             const ConfigKey& key, const CountMetric& countMetric, const int conditionIndex,
46             const vector<ConditionState>& initialConditionCache, const sp<ConditionWizard>& wizard,
47             const int64_t timeBaseNs, const int64_t startTimeNs,
48             const std::unordered_map<int, std::shared_ptr<Activation>>& eventActivationMap = {},
49             const std::unordered_map<int, std::vector<std::shared_ptr<Activation>>>&
50                     eventDeactivationMap = {},
51             const vector<int>& slicedStateAtoms = {},
52             const unordered_map<int, unordered_map<int, int64_t>>& stateGroupMap = {});
53 
54     virtual ~CountMetricProducer();
55 
56     void onStateChanged(const int64_t eventTimeNs, const int32_t atomId,
57                         const HashableDimensionKey& primaryKey, const FieldValue& oldState,
58                         const FieldValue& newState) override;
59 
60 protected:
61     void onMatchedLogEventInternalLocked(
62             const size_t matcherIndex, const MetricDimensionKey& eventKey,
63             const ConditionKey& conditionKey, bool condition, const LogEvent& event,
64             const std::map<int, HashableDimensionKey>& statePrimaryKeys) override;
65 
66 private:
67 
68     void onDumpReportLocked(const int64_t dumpTimeNs,
69                             const bool include_current_partial_bucket,
70                             const bool erase_data,
71                             const DumpLatency dumpLatency,
72                             std::set<string> *str_set,
73                             android::util::ProtoOutputStream* protoOutput) override;
74 
75     void clearPastBucketsLocked(const int64_t dumpTimeNs) override;
76 
77     // Internal interface to handle condition change.
78     void onConditionChangedLocked(const bool conditionMet, const int64_t eventTime) override;
79 
80     // Internal interface to handle sliced condition change.
81     void onSlicedConditionMayChangeLocked(bool overallCondition, const int64_t eventTime) override;
82 
83     // Internal function to calculate the current used bytes.
84     size_t byteSizeLocked() const override;
85 
86     void dumpStatesLocked(FILE* out, bool verbose) const override;
87 
88     void dropDataLocked(const int64_t dropTimeNs) override;
89 
90     // Util function to flush the old packet.
91     void flushIfNeededLocked(const int64_t& newEventTime) override;
92 
93     void flushCurrentBucketLocked(const int64_t& eventTimeNs,
94                                   const int64_t& nextBucketStartTimeNs) override;
95 
96     std::unordered_map<MetricDimensionKey, std::vector<CountBucket>> mPastBuckets;
97 
98     // The current bucket (may be a partial bucket).
99     std::shared_ptr<DimToValMap> mCurrentSlicedCounter = std::make_shared<DimToValMap>();
100 
101     // The sum of previous partial buckets in the current full bucket (excluding the current
102     // partial bucket). This is only updated while flushing the current bucket.
103     std::shared_ptr<DimToValMap> mCurrentFullCounters = std::make_shared<DimToValMap>();
104 
105     static const size_t kBucketSize = sizeof(CountBucket{});
106 
107     bool hitGuardRailLocked(const MetricDimensionKey& newKey);
108 
109     FRIEND_TEST(CountMetricProducerTest, TestNonDimensionalEvents);
110     FRIEND_TEST(CountMetricProducerTest, TestEventsWithNonSlicedCondition);
111     FRIEND_TEST(CountMetricProducerTest, TestEventsWithSlicedCondition);
112     FRIEND_TEST(CountMetricProducerTest, TestAnomalyDetectionUnSliced);
113     FRIEND_TEST(CountMetricProducerTest, TestFirstBucket);
114     FRIEND_TEST(CountMetricProducerTest, TestOneWeekTimeUnit);
115 
116     FRIEND_TEST(CountMetricProducerTest_PartialBucket, TestSplitInCurrentBucket);
117     FRIEND_TEST(CountMetricProducerTest_PartialBucket, TestSplitInNextBucket);
118 };
119 
120 }  // namespace statsd
121 }  // namespace os
122 }  // namespace android
123 #endif  // COUNT_METRIC_PRODUCER_H
124