diff options
Diffstat (limited to 'cmds')
27 files changed, 449 insertions, 422 deletions
diff --git a/cmds/incidentd/tests/section_list.cpp b/cmds/incidentd/tests/section_list.cpp index 3a45af028518..60f7fb788837 100644 --- a/cmds/incidentd/tests/section_list.cpp +++ b/cmds/incidentd/tests/section_list.cpp @@ -1,4 +1,4 @@ -// This file is a dummy section_list.cpp used for test only. +// This file is a stub section_list.cpp used for test only. #include "section_list.h" #include "frameworks/base/cmds/incidentd/tests/test_proto.pb.h" diff --git a/cmds/statsd/Android.bp b/cmds/statsd/Android.bp index 7c419519a558..88db1d84df8e 100644 --- a/cmds/statsd/Android.bp +++ b/cmds/statsd/Android.bp @@ -73,10 +73,10 @@ cc_defaults { "src/HashableDimensionKey.cpp", "src/logd/LogEvent.cpp", "src/logd/LogEventQueue.cpp", - "src/matchers/CombinationLogMatchingTracker.cpp", + "src/matchers/CombinationAtomMatchingTracker.cpp", "src/matchers/EventMatcherWizard.cpp", "src/matchers/matcher_util.cpp", - "src/matchers/SimpleLogMatchingTracker.cpp", + "src/matchers/SimpleAtomMatchingTracker.cpp", "src/metadata_util.cpp", "src/metrics/CountMetricProducer.cpp", "src/metrics/duration_helper/MaxDurationTracker.cpp", diff --git a/cmds/statsd/src/condition/CombinationConditionTracker.cpp b/cmds/statsd/src/condition/CombinationConditionTracker.cpp index e9875baf58c7..7a1ece94fd3e 100644 --- a/cmds/statsd/src/condition/CombinationConditionTracker.cpp +++ b/cmds/statsd/src/condition/CombinationConditionTracker.cpp @@ -92,8 +92,8 @@ bool CombinationConditionTracker::init(const vector<Predicate>& allConditionConf mUnSlicedChildren.push_back(childIndex); } mChildren.push_back(childIndex); - mTrackerIndex.insert(childTracker->getLogTrackerIndex().begin(), - childTracker->getLogTrackerIndex().end()); + mTrackerIndex.insert(childTracker->getAtomMatchingTrackerIndex().begin(), + childTracker->getAtomMatchingTrackerIndex().end()); } mUnSlicedPartCondition = evaluateCombinationCondition(mUnSlicedChildren, mLogicalOperation, diff --git a/cmds/statsd/src/condition/ConditionTracker.h b/cmds/statsd/src/condition/ConditionTracker.h index 62736c8160bb..9da1af427e5f 100644 --- a/cmds/statsd/src/condition/ConditionTracker.h +++ b/cmds/statsd/src/condition/ConditionTracker.h @@ -18,7 +18,7 @@ #include "condition/condition_util.h" #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" -#include "matchers/LogMatchingTracker.h" +#include "matchers/AtomMatchingTracker.h" #include "matchers/matcher_util.h" #include <utils/RefBase.h> @@ -60,9 +60,9 @@ public: // evaluate current condition given the new event. // event: the new log event - // eventMatcherValues: the results of the LogMatcherTrackers. LogMatcherTrackers always process - // event before ConditionTrackers, because ConditionTracker depends on - // LogMatchingTrackers. + // eventMatcherValues: the results of the AtomMatchingTrackers. AtomMatchingTrackers always + // process event before ConditionTrackers, because ConditionTracker depends + // on AtomMatchingTrackers. // mAllConditions: the list of all ConditionTracker // conditionCache: the cached non-sliced condition of the ConditionTrackers for this new event. // conditionChanged: the bit map to record whether the condition has changed. @@ -88,8 +88,8 @@ public: const bool isPartialLink, std::vector<ConditionState>& conditionCache) const = 0; - // return the list of LogMatchingTracker index that this ConditionTracker uses. - virtual const std::set<int>& getLogTrackerIndex() const { + // return the list of AtomMatchingTracker index that this ConditionTracker uses. + virtual const std::set<int>& getAtomMatchingTrackerIndex() const { return mTrackerIndex; } @@ -136,7 +136,7 @@ protected: // if it's properly initialized. bool mInitialized; - // the list of LogMatchingTracker index that this ConditionTracker uses. + // the list of AtomMatchingTracker index that this ConditionTracker uses. std::set<int> mTrackerIndex; // This variable is only used for CombinationConditionTrackers. diff --git a/cmds/statsd/src/matchers/LogMatchingTracker.h b/cmds/statsd/src/matchers/AtomMatchingTracker.h index 49a41add4560..5194f9970766 100644 --- a/cmds/statsd/src/matchers/LogMatchingTracker.h +++ b/cmds/statsd/src/matchers/AtomMatchingTracker.h @@ -14,8 +14,8 @@ * limitations under the License. */ -#ifndef LOG_MATCHING_TRACKER_H -#define LOG_MATCHING_TRACKER_H +#ifndef ATOM_MATCHING_TRACKER_H +#define ATOM_MATCHING_TRACKER_H #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" #include "logd/LogEvent.h" @@ -31,35 +31,36 @@ namespace android { namespace os { namespace statsd { -class LogMatchingTracker : public virtual RefBase { +class AtomMatchingTracker : public virtual RefBase { public: - LogMatchingTracker(const int64_t& id, const int index, const uint64_t protoHash) + AtomMatchingTracker(const int64_t& id, const int index, const uint64_t protoHash) : mId(id), mIndex(index), mInitialized(false), mProtoHash(protoHash){}; - virtual ~LogMatchingTracker(){}; + virtual ~AtomMatchingTracker(){}; - // Initialize this LogMatchingTracker. - // allLogMatchers: the list of the AtomMatcher proto config. This is needed because we don't - // store the proto object in memory. We only need it during initilization. - // allTrackers: the list of the LogMatchingTracker objects. It's a one-to-one mapping with - // allLogMatchers. This is needed because the initialization is done recursively - // for CombinationLogMatchingTrackers using DFS. + // Initialize this AtomMatchingTracker. + // allAtomMatchers: the list of the AtomMatcher proto config. This is needed because we don't + // store the proto object in memory. We only need it during initilization. + // allAtomMatchingTrackers: the list of the AtomMatchingTracker objects. It's a one-to-one + // mapping with allAtomMatchers. This is needed because the + // initialization is done recursively for + // CombinationAtomMatchingTrackers using DFS. // stack: a bit map to record which matcher has been visited on the stack. This is for detecting // circle dependency. - virtual bool init(const std::vector<AtomMatcher>& allLogMatchers, - const std::vector<sp<LogMatchingTracker>>& allTrackers, + virtual bool init(const std::vector<AtomMatcher>& allAtomMatchers, + const std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, const std::unordered_map<int64_t, int>& matcherMap, std::vector<bool>& stack) = 0; // Called when a log event comes. // event: the log event. - // allTrackers: the list of all LogMatchingTrackers. This is needed because the log processing - // is done recursively. + // allAtomMatchingTrackers: the list of all AtomMatchingTrackers. This is needed because the log + // processing is done recursively. // matcherResults: The cached results for all matchers for this event. Parent matchers can // directly access the children's matching results if they have been evaluated. // Otherwise, call children matchers' onLogEvent. virtual void onLogEvent(const LogEvent& event, - const std::vector<sp<LogMatchingTracker>>& allTrackers, + const std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, std::vector<MatchingState>& matcherResults) = 0; // Get the tagIds that this matcher cares about. The combined collection is stored @@ -81,23 +82,23 @@ protected: // Name of this matching. We don't really need the name, but it makes log message easy to debug. const int64_t mId; - // Index of this LogMatchingTracker in MetricsManager's container. + // Index of this AtomMatchingTracker in MetricsManager's container. const int mIndex; - // Whether this LogMatchingTracker has been properly initialized. + // Whether this AtomMatchingTracker has been properly initialized. bool mInitialized; - // The collection of the event tag ids that this LogMatchingTracker cares. So we can quickly + // The collection of the event tag ids that this AtomMatchingTracker cares. So we can quickly // return kNotMatched when we receive an event with an id not in the list. This is especially - // useful when we have a complex CombinationLogMatcherTracker. + // useful when we have a complex CombinationAtomMatchingTracker. std::set<int> mAtomIds; // Hash of the AtomMatcher's proto bytes from StatsdConfig. // Used to determine if the definition of this matcher has changed across a config update. const uint64_t mProtoHash; - FRIEND_TEST(MetricsManagerTest, TestCreateLogTrackerSimple); - FRIEND_TEST(MetricsManagerTest, TestCreateLogTrackerCombination); + FRIEND_TEST(MetricsManagerTest, TestCreateAtomMatchingTrackerSimple); + FRIEND_TEST(MetricsManagerTest, TestCreateAtomMatchingTrackerCombination); FRIEND_TEST(ConfigUpdateTest, TestUpdateMatchers); }; @@ -105,4 +106,4 @@ protected: } // namespace os } // namespace android -#endif // LOG_MATCHING_TRACKER_H +#endif // ATOM_MATCHING_TRACKER_H diff --git a/cmds/statsd/src/matchers/CombinationLogMatchingTracker.cpp b/cmds/statsd/src/matchers/CombinationAtomMatchingTracker.cpp index 60bcc26f0873..19637a449c44 100644 --- a/cmds/statsd/src/matchers/CombinationLogMatchingTracker.cpp +++ b/cmds/statsd/src/matchers/CombinationAtomMatchingTracker.cpp @@ -16,7 +16,8 @@ #include "Log.h" -#include "CombinationLogMatchingTracker.h" +#include "CombinationAtomMatchingTracker.h" + #include "matchers/matcher_util.h" namespace android { @@ -27,18 +28,18 @@ using std::set; using std::unordered_map; using std::vector; -CombinationLogMatchingTracker::CombinationLogMatchingTracker(const int64_t& id, const int index, - const uint64_t protoHash) - : LogMatchingTracker(id, index, protoHash) { +CombinationAtomMatchingTracker::CombinationAtomMatchingTracker(const int64_t& id, const int index, + const uint64_t protoHash) + : AtomMatchingTracker(id, index, protoHash) { } -CombinationLogMatchingTracker::~CombinationLogMatchingTracker() { +CombinationAtomMatchingTracker::~CombinationAtomMatchingTracker() { } -bool CombinationLogMatchingTracker::init(const vector<AtomMatcher>& allLogMatchers, - const vector<sp<LogMatchingTracker>>& allTrackers, - const unordered_map<int64_t, int>& matcherMap, - vector<bool>& stack) { +bool CombinationAtomMatchingTracker::init( + const vector<AtomMatcher>& allAtomMatchers, + const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + const unordered_map<int64_t, int>& matcherMap, vector<bool>& stack) { if (mInitialized) { return true; } @@ -46,7 +47,7 @@ bool CombinationLogMatchingTracker::init(const vector<AtomMatcher>& allLogMatche // mark this node as visited in the recursion stack. stack[mIndex] = true; - AtomMatcher_Combination matcher = allLogMatchers[mIndex].combination(); + AtomMatcher_Combination matcher = allAtomMatchers[mIndex].combination(); // LogicalOperation is missing in the config if (!matcher.has_operation()) { @@ -74,14 +75,15 @@ bool CombinationLogMatchingTracker::init(const vector<AtomMatcher>& allLogMatche return false; } - if (!allTrackers[childIndex]->init(allLogMatchers, allTrackers, matcherMap, stack)) { + if (!allAtomMatchingTrackers[childIndex]->init(allAtomMatchers, allAtomMatchingTrackers, + matcherMap, stack)) { ALOGW("child matcher init failed %lld", (long long)child); return false; } mChildren.push_back(childIndex); - const set<int>& childTagIds = allTrackers[childIndex]->getAtomIds(); + const set<int>& childTagIds = allAtomMatchingTrackers[childIndex]->getAtomIds(); mAtomIds.insert(childTagIds.begin(), childTagIds.end()); } @@ -91,9 +93,9 @@ bool CombinationLogMatchingTracker::init(const vector<AtomMatcher>& allLogMatche return true; } -void CombinationLogMatchingTracker::onLogEvent(const LogEvent& event, - const vector<sp<LogMatchingTracker>>& allTrackers, - vector<MatchingState>& matcherResults) { +void CombinationAtomMatchingTracker::onLogEvent( + const LogEvent& event, const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + vector<MatchingState>& matcherResults) { // this event has been processed. if (matcherResults[mIndex] != MatchingState::kNotComputed) { return; @@ -107,8 +109,8 @@ void CombinationLogMatchingTracker::onLogEvent(const LogEvent& event, // evaluate children matchers if they haven't been evaluated. for (const int childIndex : mChildren) { if (matcherResults[childIndex] == MatchingState::kNotComputed) { - const sp<LogMatchingTracker>& child = allTrackers[childIndex]; - child->onLogEvent(event, allTrackers, matcherResults); + const sp<AtomMatchingTracker>& child = allAtomMatchingTrackers[childIndex]; + child->onLogEvent(event, allAtomMatchingTrackers, matcherResults); } } diff --git a/cmds/statsd/src/matchers/CombinationLogMatchingTracker.h b/cmds/statsd/src/matchers/CombinationAtomMatchingTracker.h index 6b8a7fb19cf0..06a4932804f5 100644 --- a/cmds/statsd/src/matchers/CombinationLogMatchingTracker.h +++ b/cmds/statsd/src/matchers/CombinationAtomMatchingTracker.h @@ -13,12 +13,13 @@ * See the License for the specific language governing permissions and * limitations under the License. */ -#ifndef COMBINATION_LOG_MATCHING_TRACKER_H -#define COMBINATION_LOG_MATCHING_TRACKER_H +#ifndef COMBINATION_ATOM_MATCHING_TRACKER_H +#define COMBINATION_ATOM_MATCHING_TRACKER_H #include <unordered_map> #include <vector> -#include "LogMatchingTracker.h" + +#include "AtomMatchingTracker.h" #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" namespace android { @@ -26,19 +27,18 @@ namespace os { namespace statsd { // Represents a AtomMatcher_Combination in the StatsdConfig. -class CombinationLogMatchingTracker : public virtual LogMatchingTracker { +class CombinationAtomMatchingTracker : public virtual AtomMatchingTracker { public: - CombinationLogMatchingTracker(const int64_t& id, const int index, const uint64_t protoHash); + CombinationAtomMatchingTracker(const int64_t& id, const int index, const uint64_t protoHash); - bool init(const std::vector<AtomMatcher>& allLogMatchers, - const std::vector<sp<LogMatchingTracker>>& allTrackers, - const std::unordered_map<int64_t, int>& matcherMap, - std::vector<bool>& stack); + bool init(const std::vector<AtomMatcher>& allAtomMatchers, + const std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + const std::unordered_map<int64_t, int>& matcherMap, std::vector<bool>& stack); - ~CombinationLogMatchingTracker(); + ~CombinationAtomMatchingTracker(); void onLogEvent(const LogEvent& event, - const std::vector<sp<LogMatchingTracker>>& allTrackers, + const std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, std::vector<MatchingState>& matcherResults) override; private: @@ -50,4 +50,4 @@ private: } // namespace statsd } // namespace os } // namespace android -#endif // COMBINATION_LOG_MATCHING_TRACKER_H +#endif // COMBINATION_ATOM_MATCHING_TRACKER_H diff --git a/cmds/statsd/src/matchers/EventMatcherWizard.h b/cmds/statsd/src/matchers/EventMatcherWizard.h index 57ec2b35ba32..5d780f2423d8 100644 --- a/cmds/statsd/src/matchers/EventMatcherWizard.h +++ b/cmds/statsd/src/matchers/EventMatcherWizard.h @@ -16,7 +16,7 @@ #pragma once -#include "LogMatchingTracker.h" +#include "AtomMatchingTracker.h" namespace android { namespace os { @@ -25,7 +25,7 @@ namespace statsd { class EventMatcherWizard : public virtual android::RefBase { public: EventMatcherWizard(){}; // for testing - EventMatcherWizard(const std::vector<sp<LogMatchingTracker>>& eventTrackers) + EventMatcherWizard(const std::vector<sp<AtomMatchingTracker>>& eventTrackers) : mAllEventMatchers(eventTrackers){}; virtual ~EventMatcherWizard(){}; @@ -33,7 +33,7 @@ public: MatchingState matchLogEvent(const LogEvent& event, int matcher_index); private: - std::vector<sp<LogMatchingTracker>> mAllEventMatchers; + std::vector<sp<AtomMatchingTracker>> mAllEventMatchers; }; } // namespace statsd diff --git a/cmds/statsd/src/matchers/SimpleLogMatchingTracker.cpp b/cmds/statsd/src/matchers/SimpleAtomMatchingTracker.cpp index ff47d35b36cc..86b148dd8657 100644 --- a/cmds/statsd/src/matchers/SimpleLogMatchingTracker.cpp +++ b/cmds/statsd/src/matchers/SimpleAtomMatchingTracker.cpp @@ -17,7 +17,7 @@ #define DEBUG false // STOPSHIP if true #include "Log.h" -#include "SimpleLogMatchingTracker.h" +#include "SimpleAtomMatchingTracker.h" namespace android { namespace os { @@ -26,11 +26,11 @@ namespace statsd { using std::unordered_map; using std::vector; -SimpleLogMatchingTracker::SimpleLogMatchingTracker(const int64_t& id, const int index, - const uint64_t protoHash, - const SimpleAtomMatcher& matcher, - const sp<UidMap>& uidMap) - : LogMatchingTracker(id, index, protoHash), mMatcher(matcher), mUidMap(uidMap) { +SimpleAtomMatchingTracker::SimpleAtomMatchingTracker(const int64_t& id, const int index, + const uint64_t protoHash, + const SimpleAtomMatcher& matcher, + const sp<UidMap>& uidMap) + : AtomMatchingTracker(id, index, protoHash), mMatcher(matcher), mUidMap(uidMap) { if (!matcher.has_atom_id()) { mInitialized = false; } else { @@ -39,20 +39,20 @@ SimpleLogMatchingTracker::SimpleLogMatchingTracker(const int64_t& id, const int } } -SimpleLogMatchingTracker::~SimpleLogMatchingTracker() { +SimpleAtomMatchingTracker::~SimpleAtomMatchingTracker() { } -bool SimpleLogMatchingTracker::init(const vector<AtomMatcher>& allLogMatchers, - const vector<sp<LogMatchingTracker>>& allTrackers, - const unordered_map<int64_t, int>& matcherMap, - vector<bool>& stack) { +bool SimpleAtomMatchingTracker::init(const vector<AtomMatcher>& allAtomMatchers, + const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + const unordered_map<int64_t, int>& matcherMap, + vector<bool>& stack) { // no need to do anything. return mInitialized; } -void SimpleLogMatchingTracker::onLogEvent(const LogEvent& event, - const vector<sp<LogMatchingTracker>>& allTrackers, - vector<MatchingState>& matcherResults) { +void SimpleAtomMatchingTracker::onLogEvent( + const LogEvent& event, const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + vector<MatchingState>& matcherResults) { if (matcherResults[mIndex] != MatchingState::kNotComputed) { VLOG("Matcher %lld already evaluated ", (long long)mId); return; @@ -65,7 +65,7 @@ void SimpleLogMatchingTracker::onLogEvent(const LogEvent& event, bool matched = matchesSimple(mUidMap, mMatcher, event); matcherResults[mIndex] = matched ? MatchingState::kMatched : MatchingState::kNotMatched; - VLOG("Stats SimpleLogMatcher %lld matched? %d", (long long)mId, matched); + VLOG("Stats SimpleAtomMatcher %lld matched? %d", (long long)mId, matched); } } // namespace statsd diff --git a/cmds/statsd/src/matchers/SimpleLogMatchingTracker.h b/cmds/statsd/src/matchers/SimpleAtomMatchingTracker.h index e58e01252ade..49cbe09f8482 100644 --- a/cmds/statsd/src/matchers/SimpleLogMatchingTracker.h +++ b/cmds/statsd/src/matchers/SimpleAtomMatchingTracker.h @@ -14,12 +14,13 @@ * limitations under the License. */ -#ifndef SIMPLE_LOG_MATCHING_TRACKER_H -#define SIMPLE_LOG_MATCHING_TRACKER_H +#ifndef SIMPLE_ATOM_MATCHING_TRACKER_H +#define SIMPLE_ATOM_MATCHING_TRACKER_H #include <unordered_map> #include <vector> -#include "LogMatchingTracker.h" + +#include "AtomMatchingTracker.h" #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" #include "packages/UidMap.h" @@ -27,20 +28,20 @@ namespace android { namespace os { namespace statsd { -class SimpleLogMatchingTracker : public virtual LogMatchingTracker { +class SimpleAtomMatchingTracker : public virtual AtomMatchingTracker { public: - SimpleLogMatchingTracker(const int64_t& id, const int index, const uint64_t protoHash, - const SimpleAtomMatcher& matcher, const sp<UidMap>& uidMap); + SimpleAtomMatchingTracker(const int64_t& id, const int index, const uint64_t protoHash, + const SimpleAtomMatcher& matcher, const sp<UidMap>& uidMap); - ~SimpleLogMatchingTracker(); + ~SimpleAtomMatchingTracker(); - bool init(const std::vector<AtomMatcher>& allLogMatchers, - const std::vector<sp<LogMatchingTracker>>& allTrackers, + bool init(const std::vector<AtomMatcher>& allAtomMatchers, + const std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, const std::unordered_map<int64_t, int>& matcherMap, std::vector<bool>& stack) override; void onLogEvent(const LogEvent& event, - const std::vector<sp<LogMatchingTracker>>& allTrackers, + const std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, std::vector<MatchingState>& matcherResults) override; private: @@ -51,4 +52,4 @@ private: } // namespace statsd } // namespace os } // namespace android -#endif // SIMPLE_LOG_MATCHING_TRACKER_H +#endif // SIMPLE_ATOM_MATCHING_TRACKER_H diff --git a/cmds/statsd/src/matchers/matcher_util.cpp b/cmds/statsd/src/matchers/matcher_util.cpp index e6d91223308d..a7454c5d923b 100644 --- a/cmds/statsd/src/matchers/matcher_util.cpp +++ b/cmds/statsd/src/matchers/matcher_util.cpp @@ -17,7 +17,7 @@ #include "Log.h" #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" -#include "matchers/LogMatchingTracker.h" +#include "matchers/AtomMatchingTracker.h" #include "matchers/matcher_util.h" #include "stats_util.h" diff --git a/cmds/statsd/src/metrics/GaugeMetricProducer.h b/cmds/statsd/src/metrics/GaugeMetricProducer.h index 2fc772b6b641..ef3a24a43dcc 100644 --- a/cmds/statsd/src/metrics/GaugeMetricProducer.h +++ b/cmds/statsd/src/metrics/GaugeMetricProducer.h @@ -170,14 +170,14 @@ private: // for each slice with the latest value. void updateCurrentSlicedBucketForAnomaly(); - // Whitelist of fields to report. Empty means all are reported. + // Allowlist of fields to report. Empty means all are reported. std::vector<Matcher> mFieldMatchers; GaugeMetric::SamplingType mSamplingType; const int64_t mMaxPullDelayNs; - // apply a whitelist on the original input + // apply an allowlist on the original input std::shared_ptr<vector<FieldValue>> getGaugeFields(const LogEvent& event); // Util function to check whether the specified dimension hits the guardrail. diff --git a/cmds/statsd/src/metrics/MetricsManager.cpp b/cmds/statsd/src/metrics/MetricsManager.cpp index 2c3deca40fa0..5a520326116a 100644 --- a/cmds/statsd/src/metrics/MetricsManager.cpp +++ b/cmds/statsd/src/metrics/MetricsManager.cpp @@ -24,8 +24,8 @@ #include "condition/CombinationConditionTracker.h" #include "condition/SimpleConditionTracker.h" #include "guardrail/StatsdStats.h" -#include "matchers/CombinationLogMatchingTracker.h" -#include "matchers/SimpleLogMatchingTracker.h" +#include "matchers/CombinationAtomMatchingTracker.h" +#include "matchers/SimpleAtomMatchingTracker.h" #include "parsing_utils/config_update_utils.h" #include "parsing_utils/metrics_manager_util.h" #include "state/StateManager.h" @@ -77,14 +77,14 @@ MetricsManager::MetricsManager(const ConfigKey& key, const StatsdConfig& config, // Init the ttl end timestamp. refreshTtl(timeBaseNs); - mConfigValid = - initStatsdConfig(key, config, uidMap, pullerManager, anomalyAlarmMonitor, - periodicAlarmMonitor, timeBaseNs, currentTimeNs, mTagIds, - mAllAtomMatchers, mLogTrackerMap, mAllConditionTrackers, - mAllMetricProducers, mAllAnomalyTrackers, mAllPeriodicAlarmTrackers, - mConditionToMetricMap, mTrackerToMetricMap, mTrackerToConditionMap, - mActivationAtomTrackerToMetricMap, mDeactivationAtomTrackerToMetricMap, - mAlertTrackerMap, mMetricIndexesWithActivation, mNoReportMetricIds); + mConfigValid = initStatsdConfig( + key, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, + timeBaseNs, currentTimeNs, mTagIds, mAllAtomMatchingTrackers, mAtomMatchingTrackerMap, + mAllConditionTrackers, mAllMetricProducers, mAllAnomalyTrackers, + mAllPeriodicAlarmTrackers, mConditionToMetricMap, mTrackerToMetricMap, + mTrackerToConditionMap, mActivationAtomTrackerToMetricMap, + mDeactivationAtomTrackerToMetricMap, mAlertTrackerMap, mMetricIndexesWithActivation, + mNoReportMetricIds); mHashStringsInReport = config.hash_strings_in_metric_report(); mVersionStringsInReport = config.version_strings_in_metric_report(); @@ -93,7 +93,7 @@ MetricsManager::MetricsManager(const ConfigKey& key, const StatsdConfig& config, // Init allowed pushed atom uids. if (config.allowed_log_source_size() == 0) { mConfigValid = false; - ALOGE("Log source whitelist is empty! This config won't get any data. Suggest adding at " + ALOGE("Log source allowlist is empty! This config won't get any data. Suggest adding at " "least AID_SYSTEM and AID_STATSD to the allowed_log_source field."); } else { for (const auto& source : config.allowed_log_source()) { @@ -155,7 +155,7 @@ MetricsManager::MetricsManager(const ConfigKey& key, const StatsdConfig& config, // Guardrail. Reject the config if it's too big. if (mAllMetricProducers.size() > StatsdStats::kMaxMetricCountPerConfig || mAllConditionTrackers.size() > StatsdStats::kMaxConditionCountPerConfig || - mAllAtomMatchers.size() > StatsdStats::kMaxMatcherCountPerConfig) { + mAllAtomMatchingTrackers.size() > StatsdStats::kMaxMatcherCountPerConfig) { ALOGE("This config is too big! Reject!"); mConfigValid = false; } @@ -175,8 +175,9 @@ MetricsManager::MetricsManager(const ConfigKey& key, const StatsdConfig& config, // no matter whether this config is valid, log it in the stats. StatsdStats::getInstance().noteConfigReceived( - key, mAllMetricProducers.size(), mAllConditionTrackers.size(), mAllAtomMatchers.size(), - mAllAnomalyTrackers.size(), mAnnotations, mConfigValid); + key, mAllMetricProducers.size(), mAllConditionTrackers.size(), + mAllAtomMatchingTrackers.size(), mAllAnomalyTrackers.size(), mAnnotations, + mConfigValid); // Check active for (const auto& metric : mAllMetricProducers) { if (metric->isActive()) { @@ -201,15 +202,15 @@ bool MetricsManager::updateConfig(const StatsdConfig& config, const int64_t time const int64_t currentTimeNs, const sp<AlarmMonitor>& anomalyAlarmMonitor, const sp<AlarmMonitor>& periodicAlarmMonitor) { - vector<sp<LogMatchingTracker>> newAtomMatchers; - unordered_map<int64_t, int> newLogTrackerMap; + vector<sp<AtomMatchingTracker>> newAtomMatchingTrackers; + unordered_map<int64_t, int> newAtomMatchingTrackerMap; mTagIds.clear(); - mConfigValid = - updateStatsdConfig(mConfigKey, config, mUidMap, mPullerManager, anomalyAlarmMonitor, - periodicAlarmMonitor, timeBaseNs, currentTimeNs, mAllAtomMatchers, - mLogTrackerMap, mTagIds, newAtomMatchers, newLogTrackerMap); - mAllAtomMatchers = newAtomMatchers; - mLogTrackerMap = newLogTrackerMap; + mConfigValid = updateStatsdConfig( + mConfigKey, config, mUidMap, mPullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, + timeBaseNs, currentTimeNs, mAllAtomMatchingTrackers, mAtomMatchingTrackerMap, mTagIds, + newAtomMatchingTrackers, newAtomMatchingTrackerMap); + mAllAtomMatchingTrackers = newAtomMatchingTrackers; + mAtomMatchingTrackerMap = newAtomMatchingTrackerMap; return mConfigValid; } @@ -502,11 +503,12 @@ void MetricsManager::onLogEvent(const LogEvent& event) { return; } - vector<MatchingState> matcherCache(mAllAtomMatchers.size(), MatchingState::kNotComputed); + vector<MatchingState> matcherCache(mAllAtomMatchingTrackers.size(), + MatchingState::kNotComputed); // Evaluate all atom matchers. - for (auto& matcher : mAllAtomMatchers) { - matcher->onLogEvent(event, mAllAtomMatchers, matcherCache); + for (auto& matcher : mAllAtomMatchingTrackers) { + matcher->onLogEvent(event, mAllAtomMatchingTrackers, matcherCache); } // Set of metrics that received an activation cancellation. @@ -596,10 +598,10 @@ void MetricsManager::onLogEvent(const LogEvent& event) { } // For matched AtomMatchers, tell relevant metrics that a matched event has come. - for (size_t i = 0; i < mAllAtomMatchers.size(); i++) { + for (size_t i = 0; i < mAllAtomMatchingTrackers.size(); i++) { if (matcherCache[i] == MatchingState::kMatched) { StatsdStats::getInstance().noteMatcherMatched(mConfigKey, - mAllAtomMatchers[i]->getId()); + mAllAtomMatchingTrackers[i]->getId()); auto pair = mTrackerToMetricMap.find(i); if (pair != mTrackerToMetricMap.end()) { auto& metricList = pair->second; diff --git a/cmds/statsd/src/metrics/MetricsManager.h b/cmds/statsd/src/metrics/MetricsManager.h index 6f9a23362033..6f4b2d7e9fa4 100644 --- a/cmds/statsd/src/metrics/MetricsManager.h +++ b/cmds/statsd/src/metrics/MetricsManager.h @@ -25,7 +25,7 @@ #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" #include "frameworks/base/cmds/statsd/src/statsd_metadata.pb.h" #include "logd/LogEvent.h" -#include "matchers/LogMatchingTracker.h" +#include "matchers/AtomMatchingTracker.h" #include "metrics/MetricProducer.h" #include "packages/UidMap.h" @@ -217,7 +217,7 @@ private: // All event tags that are interesting to my metrics. std::set<int> mTagIds; - // We only store the sp of LogMatchingTracker, MetricProducer, and ConditionTracker in + // We only store the sp of AtomMatchingTracker, MetricProducer, and ConditionTracker in // MetricsManager. There are relationships between them, and the relationships are denoted by // index instead of pointers. The reasons for this are: (1) the relationship between them are // complicated, so storing index instead of pointers reduces the risk that A holds B's sp, and B @@ -225,7 +225,7 @@ private: // the related results from a cache using the index. // Hold all the atom matchers from the config. - std::vector<sp<LogMatchingTracker>> mAllAtomMatchers; + std::vector<sp<AtomMatchingTracker>> mAllAtomMatchingTrackers; // Hold all the conditions from the config. std::vector<sp<ConditionTracker>> mAllConditionTrackers; @@ -239,29 +239,29 @@ private: // Hold all periodic alarm trackers. std::vector<sp<AlarmTracker>> mAllPeriodicAlarmTrackers; - // To make updating configs faster, we map the id of a LogMatchingTracker, MetricProducer, and + // To make updating configs faster, we map the id of a AtomMatchingTracker, MetricProducer, and // ConditionTracker to its index in the corresponding vector. - // Maps the id of an atom matcher to its index in mAllAtomMatchers. - std::unordered_map<int64_t, int> mLogTrackerMap; + // Maps the id of an atom matcher to its index in mAllAtomMatchingTrackers. + std::unordered_map<int64_t, int> mAtomMatchingTrackerMap; // To make the log processing more efficient, we want to do as much filtering as possible // before we go into individual trackers and conditions to match. // 1st filter: check if the event tag id is in mTagIds. // 2nd filter: if it is, we parse the event because there is at least one member is interested. - // then pass to all LogMatchingTrackers (itself also filter events by ids). - // 3nd filter: for LogMatchingTrackers that matched this event, we pass this event to the + // then pass to all AtomMatchingTrackers (itself also filter events by ids). + // 3nd filter: for AtomMatchingTrackers that matched this event, we pass this event to the // ConditionTrackers and MetricProducers that use this matcher. // 4th filter: for ConditionTrackers that changed value due to this event, we pass // new conditions to metrics that use this condition. // The following map is initialized from the statsd_config. - // Maps from the index of the LogMatchingTracker to index of MetricProducer. + // Maps from the index of the AtomMatchingTracker to index of MetricProducer. std::unordered_map<int, std::vector<int>> mTrackerToMetricMap; - // Maps from LogMatchingTracker to ConditionTracker + // Maps from AtomMatchingTracker to ConditionTracker std::unordered_map<int, std::vector<int>> mTrackerToConditionMap; // Maps from ConditionTracker to MetricProducer diff --git a/cmds/statsd/src/metrics/parsing_utils/config_update_utils.cpp b/cmds/statsd/src/metrics/parsing_utils/config_update_utils.cpp index 562e29124187..a9ae5a4e854d 100644 --- a/cmds/statsd/src/metrics/parsing_utils/config_update_utils.cpp +++ b/cmds/statsd/src/metrics/parsing_utils/config_update_utils.cpp @@ -29,9 +29,9 @@ namespace statsd { // Recursive function to determine if a matcher needs to be updated. Populates matcherToUpdate. // Returns whether the function was successful or not. bool determineMatcherUpdateStatus(const StatsdConfig& config, const int matcherIdx, - const unordered_map<int64_t, int>& oldLogTrackerMap, - const vector<sp<LogMatchingTracker>>& oldAtomMatchers, - const unordered_map<int64_t, int>& newLogTrackerMap, + const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap, + const vector<sp<AtomMatchingTracker>>& oldAtomMatchingTrackers, + const unordered_map<int64_t, int>& newAtomMatchingTrackerMap, vector<UpdateStatus>& matchersToUpdate, vector<bool>& cycleTracker) { // Have already examined this matcher. @@ -42,8 +42,8 @@ bool determineMatcherUpdateStatus(const StatsdConfig& config, const int matcherI const AtomMatcher& matcher = config.atom_matcher(matcherIdx); int64_t id = matcher.id(); // Check if new matcher. - const auto& oldLogTrackerIt = oldLogTrackerMap.find(id); - if (oldLogTrackerIt == oldLogTrackerMap.end()) { + const auto& oldAtomMatchingTrackerIt = oldAtomMatchingTrackerMap.find(id); + if (oldAtomMatchingTrackerIt == oldAtomMatchingTrackerMap.end()) { matchersToUpdate[matcherIdx] = UPDATE_REPLACE; return true; } @@ -55,7 +55,7 @@ bool determineMatcherUpdateStatus(const StatsdConfig& config, const int matcherI return false; } uint64_t newProtoHash = Hash64(serializedMatcher); - if (newProtoHash != oldAtomMatchers[oldLogTrackerIt->second]->getProtoHash()) { + if (newProtoHash != oldAtomMatchingTrackers[oldAtomMatchingTrackerIt->second]->getProtoHash()) { matchersToUpdate[matcherIdx] = UPDATE_REPLACE; return true; } @@ -70,8 +70,8 @@ bool determineMatcherUpdateStatus(const StatsdConfig& config, const int matcherI cycleTracker[matcherIdx] = true; UpdateStatus status = UPDATE_PRESERVE; for (const int64_t childMatcherId : matcher.combination().matcher()) { - const auto& childIt = newLogTrackerMap.find(childMatcherId); - if (childIt == newLogTrackerMap.end()) { + const auto& childIt = newAtomMatchingTrackerMap.find(childMatcherId); + if (childIt == newAtomMatchingTrackerMap.end()) { ALOGW("Matcher %lld not found in the config", (long long)childMatcherId); return false; } @@ -80,9 +80,9 @@ bool determineMatcherUpdateStatus(const StatsdConfig& config, const int matcherI ALOGE("Cycle detected in matcher config"); return false; } - if (!determineMatcherUpdateStatus(config, childIdx, oldLogTrackerMap, - oldAtomMatchers, newLogTrackerMap, - matchersToUpdate, cycleTracker)) { + if (!determineMatcherUpdateStatus( + config, childIdx, oldAtomMatchingTrackerMap, oldAtomMatchingTrackers, + newAtomMatchingTrackerMap, matchersToUpdate, cycleTracker)) { return false; } @@ -103,25 +103,25 @@ bool determineMatcherUpdateStatus(const StatsdConfig& config, const int matcherI return true; } -bool updateLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, - const unordered_map<int64_t, int>& oldLogTrackerMap, - const vector<sp<LogMatchingTracker>>& oldAtomMatchers, set<int>& allTagIds, - unordered_map<int64_t, int>& newLogTrackerMap, - vector<sp<LogMatchingTracker>>& newAtomMatchers) { +bool updateAtomTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, + const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap, + const vector<sp<AtomMatchingTracker>>& oldAtomMatchingTrackers, + set<int>& allTagIds, unordered_map<int64_t, int>& newAtomMatchingTrackerMap, + vector<sp<AtomMatchingTracker>>& newAtomMatchingTrackers) { const int atomMatcherCount = config.atom_matcher_size(); vector<AtomMatcher> matcherProtos; matcherProtos.reserve(atomMatcherCount); - newAtomMatchers.reserve(atomMatcherCount); + newAtomMatchingTrackers.reserve(atomMatcherCount); // Maps matcher id to their position in the config. For fast lookup of dependencies. for (int i = 0; i < atomMatcherCount; i++) { const AtomMatcher& matcher = config.atom_matcher(i); - if (newLogTrackerMap.find(matcher.id()) != newLogTrackerMap.end()) { + if (newAtomMatchingTrackerMap.find(matcher.id()) != newAtomMatchingTrackerMap.end()) { ALOGE("Duplicate atom matcher found for id %lld", (long long)matcher.id()); return false; } - newLogTrackerMap[matcher.id()] = i; + newAtomMatchingTrackerMap[matcher.id()] = i; matcherProtos.push_back(matcher); } @@ -129,8 +129,9 @@ bool updateLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, vector<UpdateStatus> matchersToUpdate(atomMatcherCount, UPDATE_UNKNOWN); vector<bool> cycleTracker(atomMatcherCount, false); for (int i = 0; i < atomMatcherCount; i++) { - if (!determineMatcherUpdateStatus(config, i, oldLogTrackerMap, oldAtomMatchers, - newLogTrackerMap, matchersToUpdate, cycleTracker)) { + if (!determineMatcherUpdateStatus(config, i, oldAtomMatchingTrackerMap, + oldAtomMatchingTrackers, newAtomMatchingTrackerMap, + matchersToUpdate, cycleTracker)) { return false; } } @@ -140,23 +141,23 @@ bool updateLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, const int64_t id = matcher.id(); switch (matchersToUpdate[i]) { case UPDATE_PRESERVE: { - const auto& oldLogTrackerIt = oldLogTrackerMap.find(id); - if (oldLogTrackerIt == oldLogTrackerMap.end()) { + const auto& oldAtomMatchingTrackerIt = oldAtomMatchingTrackerMap.find(id); + if (oldAtomMatchingTrackerIt == oldAtomMatchingTrackerMap.end()) { ALOGE("Could not find AtomMatcher %lld in the previous config, but expected it " "to be there", (long long)id); return false; } - const int oldIndex = oldLogTrackerIt->second; - newAtomMatchers.push_back(oldAtomMatchers[oldIndex]); + const int oldIndex = oldAtomMatchingTrackerIt->second; + newAtomMatchingTrackers.push_back(oldAtomMatchingTrackers[oldIndex]); break; } case UPDATE_REPLACE: { - sp<LogMatchingTracker> tracker = createLogTracker(matcher, i, uidMap); + sp<AtomMatchingTracker> tracker = createAtomMatchingTracker(matcher, i, uidMap); if (tracker == nullptr) { return false; } - newAtomMatchers.push_back(tracker); + newAtomMatchingTrackers.push_back(tracker); break; } default: { @@ -168,8 +169,9 @@ bool updateLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, } std::fill(cycleTracker.begin(), cycleTracker.end(), false); - for (auto& matcher : newAtomMatchers) { - if (!matcher->init(matcherProtos, newAtomMatchers, newLogTrackerMap, cycleTracker)) { + for (auto& matcher : newAtomMatchingTrackers) { + if (!matcher->init(matcherProtos, newAtomMatchingTrackers, newAtomMatchingTrackerMap, + cycleTracker)) { return false; } // Collect all the tag ids that are interesting. TagIds exist in leaf nodes only. @@ -185,13 +187,14 @@ bool updateStatsdConfig(const ConfigKey& key, const StatsdConfig& config, const const sp<AlarmMonitor>& anomalyAlarmMonitor, const sp<AlarmMonitor>& periodicAlarmMonitor, const int64_t timeBaseNs, const int64_t currentTimeNs, - const vector<sp<LogMatchingTracker>>& oldAtomMatchers, - const unordered_map<int64_t, int>& oldLogTrackerMap, set<int>& allTagIds, - vector<sp<LogMatchingTracker>>& newAtomMatchers, - unordered_map<int64_t, int>& newLogTrackerMap) { - if (!updateLogTrackers(config, uidMap, oldLogTrackerMap, oldAtomMatchers, allTagIds, - newLogTrackerMap, newAtomMatchers)) { - ALOGE("updateLogMatchingTrackers failed"); + const vector<sp<AtomMatchingTracker>>& oldAtomMatchingTrackers, + const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap, + set<int>& allTagIds, + vector<sp<AtomMatchingTracker>>& newAtomMatchingTrackers, + unordered_map<int64_t, int>& newAtomMatchingTrackerMap) { + if (!updateAtomTrackers(config, uidMap, oldAtomMatchingTrackerMap, oldAtomMatchingTrackers, + allTagIds, newAtomMatchingTrackerMap, newAtomMatchingTrackers)) { + ALOGE("updateAtomMatchingTrackers failed"); return false; } @@ -200,4 +203,4 @@ bool updateStatsdConfig(const ConfigKey& key, const StatsdConfig& config, const } // namespace statsd } // namespace os -} // namespace android
\ No newline at end of file +} // namespace android diff --git a/cmds/statsd/src/metrics/parsing_utils/config_update_utils.h b/cmds/statsd/src/metrics/parsing_utils/config_update_utils.h index 951ab03cee47..ae7b2162e034 100644 --- a/cmds/statsd/src/metrics/parsing_utils/config_update_utils.h +++ b/cmds/statsd/src/metrics/parsing_utils/config_update_utils.h @@ -20,7 +20,7 @@ #include "anomaly/AlarmMonitor.h" #include "external/StatsPullerManager.h" -#include "matchers/LogMatchingTracker.h" +#include "matchers/AtomMatchingTracker.h" namespace android { namespace os { @@ -42,34 +42,34 @@ enum UpdateStatus { // input: // [config]: the input StatsdConfig // [matcherIdx]: the index of the current matcher to be updated -// [newLogTrackerMap]: matcher id to index mapping in the input StatsdConfig -// [oldLogTrackerMap]: matcher id to index mapping in the existing MetricsManager -// [oldAtomMatchers]: stores the existing LogMatchingTrackers +// [newAtomMatchingTrackerMap]: matcher id to index mapping in the input StatsdConfig +// [oldAtomMatchingTrackerMap]: matcher id to index mapping in the existing MetricsManager +// [oldAtomMatchingTrackers]: stores the existing AtomMatchingTrackers // output: // [matchersToUpdate]: vector of the update status of each matcher. The matcherIdx index will // be updated from UPDATE_UNKNOWN after this call. // [cycleTracker]: intermediate param used during recursion. bool determineMatcherUpdateStatus(const StatsdConfig& config, const int matcherIdx, - const unordered_map<int64_t, int>& oldLogTrackerMap, - const vector<sp<LogMatchingTracker>>& oldAtomMatchers, - const unordered_map<int64_t, int>& newLogTrackerMap, + const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap, + const vector<sp<AtomMatchingTracker>>& oldAtomMatchingTrackers, + const unordered_map<int64_t, int>& newAtomMatchingTrackerMap, vector<UpdateStatus>& matchersToUpdate, vector<bool>& cycleTracker); -// Updates the LogMatchingTrackers. +// Updates the AtomMatchingTrackers. // input: // [config]: the input StatsdConfig -// [oldLogTrackerMap]: existing matcher id to index mapping -// [oldAtomMatchers]: stores the existing LogMatchingTrackers +// [oldAtomMatchingTrackerMap]: existing matcher id to index mapping +// [oldAtomMatchingTrackers]: stores the existing AtomMatchingTrackers // output: // [allTagIds]: contains the set of all interesting tag ids to this config. -// [newLogTrackerMap]: new matcher id to index mapping -// [newAtomMatchers]: stores the new LogMatchingTrackers -bool updateLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, - const unordered_map<int64_t, int>& oldLogTrackerMap, - const vector<sp<LogMatchingTracker>>& oldAtomMatchers, set<int>& allTagIds, - unordered_map<int64_t, int>& newLogTrackerMap, - vector<sp<LogMatchingTracker>>& newAtomMatchers); +// [newAtomMatchingTrackerMap]: new matcher id to index mapping +// [newAtomMatchers]: stores the new AtomMatchingTrackers +bool updateAtomTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, + const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap, + const vector<sp<AtomMatchingTracker>>& oldAtomMatchingTrackers, + set<int>& allTagIds, unordered_map<int64_t, int>& newAtomMatchingTrackerMap, + vector<sp<AtomMatchingTracker>>& newAtomMatchingTrackers); // Updates the existing MetricsManager from a new StatsdConfig. // Parameters are the members of MetricsManager. See MetricsManager for declaration. @@ -78,12 +78,12 @@ bool updateStatsdConfig(const ConfigKey& key, const StatsdConfig& config, const const sp<AlarmMonitor>& anomalyAlarmMonitor, const sp<AlarmMonitor>& periodicAlarmMonitor, const int64_t timeBaseNs, const int64_t currentTimeNs, - const std::vector<sp<LogMatchingTracker>>& oldAtomMatchers, - const unordered_map<int64_t, int>& oldLogTrackerMap, + const std::vector<sp<AtomMatchingTracker>>& oldAtomMatchingTrackers, + const unordered_map<int64_t, int>& oldAtomMatchingTrackerMap, std::set<int>& allTagIds, - std::vector<sp<LogMatchingTracker>>& newAtomMatchers, - unordered_map<int64_t, int>& newLogTrackerMap); + std::vector<sp<AtomMatchingTracker>>& newAtomMatchingTrackers, + unordered_map<int64_t, int>& newAtomMatchingTrackerMap); } // namespace statsd } // namespace os -} // namespace android
\ No newline at end of file +} // namespace android diff --git a/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.cpp b/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.cpp index 9d3943fe8260..daf67e93557c 100644 --- a/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.cpp +++ b/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.cpp @@ -26,9 +26,9 @@ #include "condition/SimpleConditionTracker.h" #include "external/StatsPullerManager.h" #include "hash.h" -#include "matchers/CombinationLogMatchingTracker.h" +#include "matchers/CombinationAtomMatchingTracker.h" #include "matchers/EventMatcherWizard.h" -#include "matchers/SimpleLogMatchingTracker.h" +#include "matchers/SimpleAtomMatchingTracker.h" #include "metrics/CountMetricProducer.h" #include "metrics/DurationMetricProducer.h" #include "metrics/EventMetricProducer.h" @@ -62,8 +62,8 @@ bool hasLeafNode(const FieldMatcher& matcher) { } // namespace -sp<LogMatchingTracker> createLogTracker(const AtomMatcher& logMatcher, const int index, - const sp<UidMap>& uidMap) { +sp<AtomMatchingTracker> createAtomMatchingTracker(const AtomMatcher& logMatcher, const int index, + const sp<UidMap>& uidMap) { string serializedMatcher; if (!logMatcher.SerializeToString(&serializedMatcher)) { ALOGE("Unable to serialize matcher %lld", (long long)logMatcher.id()); @@ -72,11 +72,11 @@ sp<LogMatchingTracker> createLogTracker(const AtomMatcher& logMatcher, const int uint64_t protoHash = Hash64(serializedMatcher); switch (logMatcher.contents_case()) { case AtomMatcher::ContentsCase::kSimpleAtomMatcher: - return new SimpleLogMatchingTracker(logMatcher.id(), index, protoHash, - logMatcher.simple_atom_matcher(), uidMap); + return new SimpleAtomMatchingTracker(logMatcher.id(), index, protoHash, + logMatcher.simple_atom_matcher(), uidMap); break; case AtomMatcher::ContentsCase::kCombination: - return new CombinationLogMatchingTracker(logMatcher.id(), index, protoHash); + return new CombinationAtomMatchingTracker(logMatcher.id(), index, protoHash); break; default: ALOGE("Matcher \"%lld\" malformed", (long long)logMatcher.id()); @@ -84,18 +84,18 @@ sp<LogMatchingTracker> createLogTracker(const AtomMatcher& logMatcher, const int } } -bool handleMetricWithLogTrackers(const int64_t what, const int metricIndex, - const bool usedForDimension, - const vector<sp<LogMatchingTracker>>& allAtomMatchers, - const unordered_map<int64_t, int>& logTrackerMap, - unordered_map<int, std::vector<int>>& trackerToMetricMap, - int& logTrackerIndex) { - auto logTrackerIt = logTrackerMap.find(what); - if (logTrackerIt == logTrackerMap.end()) { +bool handleMetricWithAtomMatchingTrackers( + const int64_t what, const int metricIndex, const bool usedForDimension, + const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + const unordered_map<int64_t, int>& atomMatchingTrackerMap, + unordered_map<int, std::vector<int>>& trackerToMetricMap, int& logTrackerIndex) { + auto logTrackerIt = atomMatchingTrackerMap.find(what); + if (logTrackerIt == atomMatchingTrackerMap.end()) { ALOGW("cannot find the AtomMatcher \"%lld\" in config", (long long)what); return false; } - if (usedForDimension && allAtomMatchers[logTrackerIt->second]->getAtomIds().size() > 1) { + if (usedForDimension && + allAtomMatchingTrackers[logTrackerIt->second]->getAtomIds().size() > 1) { ALOGE("AtomMatcher \"%lld\" has more than one tag ids. When a metric has dimension, " "the \"what\" can only about one atom type.", (long long)what); @@ -107,17 +107,17 @@ bool handleMetricWithLogTrackers(const int64_t what, const int metricIndex, return true; } -bool handlePullMetricTriggerWithLogTrackers( +bool handlePullMetricTriggerWithAtomMatchingTrackers( const int64_t trigger, const int metricIndex, - const vector<sp<LogMatchingTracker>>& allAtomMatchers, - const unordered_map<int64_t, int>& logTrackerMap, + const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + const unordered_map<int64_t, int>& atomMatchingTrackerMap, unordered_map<int, std::vector<int>>& trackerToMetricMap, int& logTrackerIndex) { - auto logTrackerIt = logTrackerMap.find(trigger); - if (logTrackerIt == logTrackerMap.end()) { + auto logTrackerIt = atomMatchingTrackerMap.find(trigger); + if (logTrackerIt == atomMatchingTrackerMap.end()) { ALOGW("cannot find the AtomMatcher \"%lld\" in config", (long long)trigger); return false; } - if (allAtomMatchers[logTrackerIt->second]->getAtomIds().size() > 1) { + if (allAtomMatchingTrackers[logTrackerIt->second]->getAtomIds().size() > 1) { ALOGE("AtomMatcher \"%lld\" has more than one tag ids." "Trigger can only be one atom type.", (long long)trigger); @@ -207,7 +207,7 @@ bool handleMetricWithStateLink(const FieldMatcher& stateMatcher, bool handleMetricActivation( const StatsdConfig& config, const int64_t metricId, const int metricIndex, const unordered_map<int64_t, int>& metricToActivationMap, - const unordered_map<int64_t, int>& logTrackerMap, + const unordered_map<int64_t, int>& atomMatchingTrackerMap, unordered_map<int, vector<int>>& activationAtomTrackerToMetricMap, unordered_map<int, vector<int>>& deactivationAtomTrackerToMetricMap, vector<int>& metricsWithActivation, @@ -223,8 +223,8 @@ bool handleMetricActivation( for (int i = 0; i < metricActivation.event_activation_size(); i++) { const EventActivation& activation = metricActivation.event_activation(i); - auto itr = logTrackerMap.find(activation.atom_matcher_id()); - if (itr == logTrackerMap.end()) { + auto itr = atomMatchingTrackerMap.find(activation.atom_matcher_id()); + if (itr == atomMatchingTrackerMap.end()) { ALOGE("Atom matcher not found for event activation."); return false; } @@ -240,8 +240,8 @@ bool handleMetricActivation( eventActivationMap.emplace(atomMatcherIndex, activationWrapper); if (activation.has_deactivation_atom_matcher_id()) { - itr = logTrackerMap.find(activation.deactivation_atom_matcher_id()); - if (itr == logTrackerMap.end()) { + itr = atomMatchingTrackerMap.find(activation.deactivation_atom_matcher_id()); + if (itr == atomMatchingTrackerMap.end()) { ALOGE("Atom matcher not found for event deactivation."); return false; } @@ -255,33 +255,35 @@ bool handleMetricActivation( return true; } -bool initLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, - unordered_map<int64_t, int>& logTrackerMap, - vector<sp<LogMatchingTracker>>& allAtomMatchers, set<int>& allTagIds) { +bool initAtomMatchingTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, + unordered_map<int64_t, int>& atomMatchingTrackerMap, + vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + set<int>& allTagIds) { vector<AtomMatcher> matcherConfigs; const int atomMatcherCount = config.atom_matcher_size(); matcherConfigs.reserve(atomMatcherCount); - allAtomMatchers.reserve(atomMatcherCount); + allAtomMatchingTrackers.reserve(atomMatcherCount); for (int i = 0; i < atomMatcherCount; i++) { const AtomMatcher& logMatcher = config.atom_matcher(i); - int index = allAtomMatchers.size(); - sp<LogMatchingTracker> tracker = createLogTracker(logMatcher, index, uidMap); + int index = allAtomMatchingTrackers.size(); + sp<AtomMatchingTracker> tracker = createAtomMatchingTracker(logMatcher, index, uidMap); if (tracker == nullptr) { return false; } - allAtomMatchers.push_back(tracker); - if (logTrackerMap.find(logMatcher.id()) != logTrackerMap.end()) { + allAtomMatchingTrackers.push_back(tracker); + if (atomMatchingTrackerMap.find(logMatcher.id()) != atomMatchingTrackerMap.end()) { ALOGE("Duplicate AtomMatcher found!"); return false; } - logTrackerMap[logMatcher.id()] = index; + atomMatchingTrackerMap[logMatcher.id()] = index; matcherConfigs.push_back(logMatcher); } - vector<bool> stackTracker2(allAtomMatchers.size(), false); - for (auto& matcher : allAtomMatchers) { - if (!matcher->init(matcherConfigs, allAtomMatchers, logTrackerMap, stackTracker2)) { + vector<bool> stackTracker2(allAtomMatchingTrackers.size(), false); + for (auto& matcher : allAtomMatchingTrackers) { + if (!matcher->init(matcherConfigs, allAtomMatchingTrackers, atomMatchingTrackerMap, + stackTracker2)) { return false; } // Collect all the tag ids that are interesting. TagIds exist in leaf nodes only. @@ -292,7 +294,7 @@ bool initLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, } bool initConditions(const ConfigKey& key, const StatsdConfig& config, - const unordered_map<int64_t, int>& logTrackerMap, + const unordered_map<int64_t, int>& atomMatchingTrackerMap, unordered_map<int64_t, int>& conditionTrackerMap, vector<sp<ConditionTracker>>& allConditionTrackers, unordered_map<int, std::vector<int>>& trackerToConditionMap, @@ -310,7 +312,8 @@ bool initConditions(const ConfigKey& key, const StatsdConfig& config, switch (condition.contents_case()) { case Predicate::ContentsCase::kSimplePredicate: { allConditionTrackers.push_back(new SimpleConditionTracker( - key, condition.id(), index, condition.simple_predicate(), logTrackerMap)); + key, condition.id(), index, condition.simple_predicate(), + atomMatchingTrackerMap)); break; } case Predicate::ContentsCase::kCombination: { @@ -337,7 +340,7 @@ bool initConditions(const ConfigKey& key, const StatsdConfig& config, stackTracker, initialConditionCache)) { return false; } - for (const int trackerIndex : conditionTracker->getLogTrackerIndex()) { + for (const int trackerIndex : conditionTracker->getAtomMatchingTrackerIndex()) { auto& conditionList = trackerToConditionMap[trackerIndex]; conditionList.push_back(i); } @@ -365,9 +368,9 @@ bool initStates(const StatsdConfig& config, unordered_map<int64_t, int>& stateAt bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t timeBaseTimeNs, const int64_t currentTimeNs, const sp<StatsPullerManager>& pullerManager, - const unordered_map<int64_t, int>& logTrackerMap, + const unordered_map<int64_t, int>& atomMatchingTrackerMap, const unordered_map<int64_t, int>& conditionTrackerMap, - const vector<sp<LogMatchingTracker>>& allAtomMatchers, + const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, const unordered_map<int64_t, int>& stateAtomIdMap, const unordered_map<int64_t, unordered_map<int, int64_t>>& allStateGroupMaps, vector<sp<ConditionTracker>>& allConditionTrackers, @@ -380,7 +383,7 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t unordered_map<int, vector<int>>& deactivationAtomTrackerToMetricMap, vector<int>& metricsWithActivation) { sp<ConditionWizard> wizard = new ConditionWizard(allConditionTrackers); - sp<EventMatcherWizard> matcherWizard = new EventMatcherWizard(allAtomMatchers); + sp<EventMatcherWizard> matcherWizard = new EventMatcherWizard(allAtomMatchingTrackers); const int allMetricsCount = config.count_metric_size() + config.duration_metric_size() + config.event_metric_size() + config.gauge_metric_size() + config.value_metric_size(); @@ -411,9 +414,10 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t int metricIndex = allMetricProducers.size(); metricMap.insert({metric.id(), metricIndex}); int trackerIndex; - if (!handleMetricWithLogTrackers(metric.what(), metricIndex, - metric.has_dimensions_in_what(), allAtomMatchers, - logTrackerMap, trackerToMetricMap, trackerIndex)) { + if (!handleMetricWithAtomMatchingTrackers(metric.what(), metricIndex, + metric.has_dimensions_in_what(), + allAtomMatchingTrackers, atomMatchingTrackerMap, + trackerToMetricMap, trackerIndex)) { return false; } @@ -448,7 +452,7 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t unordered_map<int, shared_ptr<Activation>> eventActivationMap; unordered_map<int, vector<shared_ptr<Activation>>> eventDeactivationMap; bool success = handleMetricActivation( - config, metric.id(), metricIndex, metricToActivationMap, logTrackerMap, + config, metric.id(), metricIndex, metricToActivationMap, atomMatchingTrackerMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, metricsWithActivation, eventActivationMap, eventDeactivationMap); if (!success) return false; @@ -485,24 +489,27 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t int trackerIndices[3] = {-1, -1, -1}; if (!simplePredicate.has_start() || - !handleMetricWithLogTrackers(simplePredicate.start(), metricIndex, - metric.has_dimensions_in_what(), allAtomMatchers, - logTrackerMap, trackerToMetricMap, trackerIndices[0])) { + !handleMetricWithAtomMatchingTrackers(simplePredicate.start(), metricIndex, + metric.has_dimensions_in_what(), + allAtomMatchingTrackers, atomMatchingTrackerMap, + trackerToMetricMap, trackerIndices[0])) { ALOGE("Duration metrics must specify a valid the start event matcher"); return false; } if (simplePredicate.has_stop() && - !handleMetricWithLogTrackers(simplePredicate.stop(), metricIndex, - metric.has_dimensions_in_what(), allAtomMatchers, - logTrackerMap, trackerToMetricMap, trackerIndices[1])) { + !handleMetricWithAtomMatchingTrackers(simplePredicate.stop(), metricIndex, + metric.has_dimensions_in_what(), + allAtomMatchingTrackers, atomMatchingTrackerMap, + trackerToMetricMap, trackerIndices[1])) { return false; } if (simplePredicate.has_stop_all() && - !handleMetricWithLogTrackers(simplePredicate.stop_all(), metricIndex, - metric.has_dimensions_in_what(), allAtomMatchers, - logTrackerMap, trackerToMetricMap, trackerIndices[2])) { + !handleMetricWithAtomMatchingTrackers(simplePredicate.stop_all(), metricIndex, + metric.has_dimensions_in_what(), + allAtomMatchingTrackers, atomMatchingTrackerMap, + trackerToMetricMap, trackerIndices[2])) { return false; } @@ -554,7 +561,7 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t unordered_map<int, shared_ptr<Activation>> eventActivationMap; unordered_map<int, vector<shared_ptr<Activation>>> eventDeactivationMap; bool success = handleMetricActivation( - config, metric.id(), metricIndex, metricToActivationMap, logTrackerMap, + config, metric.id(), metricIndex, metricToActivationMap, atomMatchingTrackerMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, metricsWithActivation, eventActivationMap, eventDeactivationMap); if (!success) return false; @@ -578,8 +585,9 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t return false; } int trackerIndex; - if (!handleMetricWithLogTrackers(metric.what(), metricIndex, false, allAtomMatchers, - logTrackerMap, trackerToMetricMap, trackerIndex)) { + if (!handleMetricWithAtomMatchingTrackers(metric.what(), metricIndex, false, + allAtomMatchingTrackers, atomMatchingTrackerMap, + trackerToMetricMap, trackerIndex)) { return false; } @@ -601,7 +609,7 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t unordered_map<int, shared_ptr<Activation>> eventActivationMap; unordered_map<int, vector<shared_ptr<Activation>>> eventDeactivationMap; bool success = handleMetricActivation( - config, metric.id(), metricIndex, metricToActivationMap, logTrackerMap, + config, metric.id(), metricIndex, metricToActivationMap, atomMatchingTrackerMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, metricsWithActivation, eventActivationMap, eventDeactivationMap); if (!success) return false; @@ -634,13 +642,14 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t int metricIndex = allMetricProducers.size(); metricMap.insert({metric.id(), metricIndex}); int trackerIndex; - if (!handleMetricWithLogTrackers(metric.what(), metricIndex, - metric.has_dimensions_in_what(), allAtomMatchers, - logTrackerMap, trackerToMetricMap, trackerIndex)) { + if (!handleMetricWithAtomMatchingTrackers(metric.what(), metricIndex, + metric.has_dimensions_in_what(), + allAtomMatchingTrackers, atomMatchingTrackerMap, + trackerToMetricMap, trackerIndex)) { return false; } - sp<LogMatchingTracker> atomMatcher = allAtomMatchers.at(trackerIndex); + sp<AtomMatchingTracker> atomMatcher = allAtomMatchingTrackers.at(trackerIndex); // If it is pulled atom, it should be simple matcher with one tagId. if (atomMatcher->getAtomIds().size() != 1) { return false; @@ -689,7 +698,7 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t unordered_map<int, shared_ptr<Activation>> eventActivationMap; unordered_map<int, vector<shared_ptr<Activation>>> eventDeactivationMap; bool success = handleMetricActivation( - config, metric.id(), metricIndex, metricToActivationMap, logTrackerMap, + config, metric.id(), metricIndex, metricToActivationMap, atomMatchingTrackerMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, metricsWithActivation, eventActivationMap, eventDeactivationMap); if (!success) return false; @@ -725,13 +734,14 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t int metricIndex = allMetricProducers.size(); metricMap.insert({metric.id(), metricIndex}); int trackerIndex; - if (!handleMetricWithLogTrackers(metric.what(), metricIndex, - metric.has_dimensions_in_what(), allAtomMatchers, - logTrackerMap, trackerToMetricMap, trackerIndex)) { + if (!handleMetricWithAtomMatchingTrackers(metric.what(), metricIndex, + metric.has_dimensions_in_what(), + allAtomMatchingTrackers, atomMatchingTrackerMap, + trackerToMetricMap, trackerIndex)) { return false; } - sp<LogMatchingTracker> atomMatcher = allAtomMatchers.at(trackerIndex); + sp<AtomMatchingTracker> atomMatcher = allAtomMatchingTrackers.at(trackerIndex); // For GaugeMetric atom, it should be simple matcher with one tagId. if (atomMatcher->getAtomIds().size() != 1) { return false; @@ -750,12 +760,13 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t if (metric.sampling_type() != GaugeMetric::FIRST_N_SAMPLES) { return false; } - if (!handlePullMetricTriggerWithLogTrackers(metric.trigger_event(), metricIndex, - allAtomMatchers, logTrackerMap, - trackerToMetricMap, triggerTrackerIndex)) { + if (!handlePullMetricTriggerWithAtomMatchingTrackers( + metric.trigger_event(), metricIndex, allAtomMatchingTrackers, + atomMatchingTrackerMap, trackerToMetricMap, triggerTrackerIndex)) { return false; } - sp<LogMatchingTracker> triggerAtomMatcher = allAtomMatchers.at(triggerTrackerIndex); + sp<AtomMatchingTracker> triggerAtomMatcher = + allAtomMatchingTrackers.at(triggerTrackerIndex); triggerAtomId = *(triggerAtomMatcher->getAtomIds().begin()); } @@ -783,7 +794,7 @@ bool initMetrics(const ConfigKey& key, const StatsdConfig& config, const int64_t unordered_map<int, shared_ptr<Activation>> eventActivationMap; unordered_map<int, vector<shared_ptr<Activation>>> eventDeactivationMap; bool success = handleMetricActivation( - config, metric.id(), metricIndex, metricToActivationMap, logTrackerMap, + config, metric.id(), metricIndex, metricToActivationMap, atomMatchingTrackerMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, metricsWithActivation, eventActivationMap, eventDeactivationMap); if (!success) return false; @@ -921,8 +932,8 @@ bool initStatsdConfig(const ConfigKey& key, const StatsdConfig& config, const sp const sp<AlarmMonitor>& anomalyAlarmMonitor, const sp<AlarmMonitor>& periodicAlarmMonitor, const int64_t timeBaseNs, const int64_t currentTimeNs, set<int>& allTagIds, - vector<sp<LogMatchingTracker>>& allAtomMatchers, - unordered_map<int64_t, int>& logTrackerMap, + vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + unordered_map<int64_t, int>& atomMatchingTrackerMap, vector<sp<ConditionTracker>>& allConditionTrackers, vector<sp<MetricProducer>>& allMetricProducers, vector<sp<AnomalyTracker>>& allAnomalyTrackers, @@ -940,14 +951,15 @@ bool initStatsdConfig(const ConfigKey& key, const StatsdConfig& config, const sp unordered_map<int64_t, int> stateAtomIdMap; unordered_map<int64_t, unordered_map<int, int64_t>> allStateGroupMaps; - if (!initLogTrackers(config, uidMap, logTrackerMap, allAtomMatchers, allTagIds)) { - ALOGE("initLogMatchingTrackers failed"); + if (!initAtomMatchingTrackers(config, uidMap, atomMatchingTrackerMap, allAtomMatchingTrackers, + allTagIds)) { + ALOGE("initAtomMatchingTrackers failed"); return false; } - VLOG("initLogMatchingTrackers succeed..."); + VLOG("initAtomMatchingTrackers succeed..."); - if (!initConditions(key, config, logTrackerMap, conditionTrackerMap, allConditionTrackers, - trackerToConditionMap, initialConditionCache)) { + if (!initConditions(key, config, atomMatchingTrackerMap, conditionTrackerMap, + allConditionTrackers, trackerToConditionMap, initialConditionCache)) { ALOGE("initConditionTrackers failed"); return false; } @@ -956,12 +968,12 @@ bool initStatsdConfig(const ConfigKey& key, const StatsdConfig& config, const sp ALOGE("initStates failed"); return false; } - if (!initMetrics(key, config, timeBaseNs, currentTimeNs, pullerManager, logTrackerMap, - conditionTrackerMap, allAtomMatchers, stateAtomIdMap, allStateGroupMaps, - allConditionTrackers, initialConditionCache, allMetricProducers, - conditionToMetricMap, trackerToMetricMap, metricProducerMap, noReportMetricIds, - activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, - metricsWithActivation)) { + if (!initMetrics(key, config, timeBaseNs, currentTimeNs, pullerManager, atomMatchingTrackerMap, + conditionTrackerMap, allAtomMatchingTrackers, stateAtomIdMap, + allStateGroupMaps, allConditionTrackers, initialConditionCache, + allMetricProducers, conditionToMetricMap, trackerToMetricMap, + metricProducerMap, noReportMetricIds, activationAtomTrackerToMetricMap, + deactivationAtomTrackerToMetricMap, metricsWithActivation)) { ALOGE("initMetricProducers failed"); return false; } diff --git a/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.h b/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.h index ed9951fd5ee6..4cfd1b0465ea 100644 --- a/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.h +++ b/cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.h @@ -23,7 +23,7 @@ #include "anomaly/AlarmTracker.h" #include "condition/ConditionTracker.h" #include "external/StatsPullerManager.h" -#include "matchers/LogMatchingTracker.h" +#include "matchers/AtomMatchingTracker.h" #include "metrics/MetricProducer.h" namespace android { @@ -33,14 +33,14 @@ namespace statsd { // Helper functions for creating individual config components from StatsdConfig. // Should only be called from metrics_manager_util and config_update_utils. -// Create a LogMatchingTracker. +// Create a AtomMatchingTracker. // input: // [logMatcher]: the input AtomMatcher from the StatsdConfig // [index]: the index of the matcher // output: -// new LogMatchingTracker, or null if the tracker is unable to be created -sp<LogMatchingTracker> createLogTracker(const AtomMatcher& logMatcher, const int index, - const sp<UidMap>& uidMap); +// new AtomMatchingTracker, or null if the tracker is unable to be created +sp<AtomMatchingTracker> createAtomMatchingTracker(const AtomMatcher& logMatcher, const int index, + const sp<UidMap>& uidMap); // Helper functions for MetricsManager to initialize from StatsdConfig. // *Note*: only initStatsdConfig() should be called from outside. @@ -48,24 +48,24 @@ sp<LogMatchingTracker> createLogTracker(const AtomMatcher& logMatcher, const int // steps, created to make unit tests easier. And most of the parameters in these // functions are temporary objects in the initialization phase. -// Initialize the LogMatchingTrackers. +// Initialize the AtomMatchingTrackers. // input: // [key]: the config key that this config belongs to // [config]: the input StatsdConfig // output: -// [logTrackerMap]: this map should contain matcher name to index mapping -// [allAtomMatchers]: should store the sp to all the LogMatchingTracker +// [atomMatchingTrackerMap]: this map should contain matcher name to index mapping +// [allAtomMatchingTrackers]: should store the sp to all the AtomMatchingTracker // [allTagIds]: contains the set of all interesting tag ids to this config. -bool initLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, - std::unordered_map<int64_t, int>& logTrackerMap, - std::vector<sp<LogMatchingTracker>>& allAtomMatchers, - std::set<int>& allTagIds); +bool initAtomMatchingTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, + std::unordered_map<int64_t, int>& atomMatchingTrackerMap, + std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + std::set<int>& allTagIds); // Initialize ConditionTrackers // input: // [key]: the config key that this config belongs to // [config]: the input config -// [logTrackerMap]: LogMatchingTracker name to index mapping from previous step. +// [atomMatchingTrackerMap]: AtomMatchingTracker name to index mapping from previous step. // output: // [conditionTrackerMap]: this map should contain condition name to index mapping // [allConditionTrackers]: stores the sp to all the ConditionTrackers @@ -73,7 +73,7 @@ bool initLogTrackers(const StatsdConfig& config, const sp<UidMap>& uidMap, // log tracker to condition trackers that use the log tracker // [initialConditionCache]: stores the initial conditions for each ConditionTracker bool initConditions(const ConfigKey& key, const StatsdConfig& config, - const std::unordered_map<int64_t, int>& logTrackerMap, + const std::unordered_map<int64_t, int>& atomMatchingTrackerMap, std::unordered_map<int64_t, int>& conditionTrackerMap, std::vector<sp<ConditionTracker>>& allConditionTrackers, std::unordered_map<int, std::vector<int>>& trackerToConditionMap, @@ -96,7 +96,7 @@ bool initStates(const StatsdConfig& config, unordered_map<int64_t, int>& stateAt // [key]: the config key that this config belongs to // [config]: the input config // [timeBaseSec]: start time base for all metrics -// [logTrackerMap]: LogMatchingTracker name to index mapping from previous step. +// [atomMatchingTrackerMap]: AtomMatchingTracker name to index mapping from previous step. // [conditionTrackerMap]: condition name to index mapping // [stateAtomIdMap]: contains the mapping from state ids to atom ids // [allStateGroupMaps]: contains the mapping from atom ids and state values to @@ -109,10 +109,10 @@ bool initStates(const StatsdConfig& config, unordered_map<int64_t, int>& stateAt bool initMetrics( const ConfigKey& key, const StatsdConfig& config, const int64_t timeBaseTimeNs, const int64_t currentTimeNs, const sp<StatsPullerManager>& pullerManager, - const std::unordered_map<int64_t, int>& logTrackerMap, + const std::unordered_map<int64_t, int>& atomMatchingTrackerMap, const std::unordered_map<int64_t, int>& conditionTrackerMap, const std::unordered_map<int, std::vector<MetricConditionLink>>& eventConditionLinks, - const vector<sp<LogMatchingTracker>>& allAtomMatchers, + const vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, const unordered_map<int64_t, int>& stateAtomIdMap, const unordered_map<int64_t, unordered_map<int, int64_t>>& allStateGroupMaps, vector<sp<ConditionTracker>>& allConditionTrackers, @@ -132,8 +132,8 @@ bool initStatsdConfig(const ConfigKey& key, const StatsdConfig& config, const sp const sp<AlarmMonitor>& anomalyAlarmMonitor, const sp<AlarmMonitor>& periodicAlarmMonitor, const int64_t timeBaseNs, const int64_t currentTimeNs, std::set<int>& allTagIds, - std::vector<sp<LogMatchingTracker>>& allAtomMatchers, - std::unordered_map<int64_t, int>& logTrackerMap, + std::vector<sp<AtomMatchingTracker>>& allAtomMatchingTrackers, + std::unordered_map<int64_t, int>& atomMatchingTrackerMap, std::vector<sp<ConditionTracker>>& allConditionTrackers, std::vector<sp<MetricProducer>>& allMetricProducers, vector<sp<AnomalyTracker>>& allAnomalyTrackers, diff --git a/cmds/statsd/src/stats_log_util.h b/cmds/statsd/src/stats_log_util.h index eb65dc6979c5..10e065e4113f 100644 --- a/cmds/statsd/src/stats_log_util.h +++ b/cmds/statsd/src/stats_log_util.h @@ -97,7 +97,7 @@ bool parseProtoOutputStream(ProtoOutputStream& protoOutput, T* message) { return message->ParseFromArray(pbBytes.c_str(), pbBytes.size()); } -// Checks the truncate timestamp annotation as well as the blacklisted range of 300,000 - 304,999. +// Checks the truncate timestamp annotation as well as the restricted range of 300,000 - 304,999. // Returns the truncated timestamp to the nearest 5 minutes if needed. int64_t truncateTimestampIfNecessary(const LogEvent& event); diff --git a/cmds/statsd/tests/MetricsManager_test.cpp b/cmds/statsd/tests/MetricsManager_test.cpp index 8dd608347064..2dd774e7dfc9 100644 --- a/cmds/statsd/tests/MetricsManager_test.cpp +++ b/cmds/statsd/tests/MetricsManager_test.cpp @@ -23,7 +23,7 @@ #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" #include "metrics/metrics_test_helper.h" #include "src/condition/ConditionTracker.h" -#include "src/matchers/LogMatchingTracker.h" +#include "src/matchers/AtomMatchingTracker.h" #include "src/metrics/CountMetricProducer.h" #include "src/metrics/GaugeMetricProducer.h" #include "src/metrics/MetricProducer.h" diff --git a/cmds/statsd/tests/StatsLogProcessor_test.cpp b/cmds/statsd/tests/StatsLogProcessor_test.cpp index 1e6680c47567..1409b621fdf6 100644 --- a/cmds/statsd/tests/StatsLogProcessor_test.cpp +++ b/cmds/statsd/tests/StatsLogProcessor_test.cpp @@ -68,7 +68,7 @@ TEST(StatsLogProcessorTest, TestRateLimitByteSize) { sp<StatsPullerManager> pullerManager = new StatsPullerManager(); sp<AlarmMonitor> anomalyAlarmMonitor; sp<AlarmMonitor> periodicAlarmMonitor; - // Construct the processor with a dummy sendBroadcast function that does nothing. + // Construct the processor with a no-op sendBroadcast function that does nothing. StatsLogProcessor p(m, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, 0, [](const ConfigKey& key) { return true; }, [](const int&, const vector<int64_t>&) {return true;}); @@ -896,8 +896,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_TRUE(metricProducer2->isActive()); int i = 0; - for (; i < metricsManager1->mAllAtomMatchers.size(); i++) { - if (metricsManager1->mAllAtomMatchers[i]->getId() == + for (; i < metricsManager1->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManager1->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger1->atom_matcher_id()) { break; } @@ -908,8 +908,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_EQ(kNotActive, activation1->state); i = 0; - for (; i < metricsManager1->mAllAtomMatchers.size(); i++) { - if (metricsManager1->mAllAtomMatchers[i]->getId() == + for (; i < metricsManager1->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManager1->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger2->atom_matcher_id()) { break; } @@ -981,8 +981,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_TRUE(metricProducer1002->isActive()); i = 0; - for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) { - if (metricsManager1001->mAllAtomMatchers[i]->getId() == + for (; i < metricsManager1001->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManager1001->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger1->atom_matcher_id()) { break; } @@ -993,8 +993,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_EQ(kNotActive, activation1001_1->state); i = 0; - for (; i < metricsManager1001->mAllAtomMatchers.size(); i++) { - if (metricsManager1001->mAllAtomMatchers[i]->getId() == + for (; i < metricsManager1001->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManager1001->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger2->atom_matcher_id()) { break; } @@ -1082,8 +1082,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_TRUE(metricProducerTimeBase3_2->isActive()); i = 0; - for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) { - if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() == + for (; i < metricsManagerTimeBase3->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManagerTimeBase3->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger1->atom_matcher_id()) { break; } @@ -1094,8 +1094,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_EQ(kNotActive, activationTimeBase3_1->state); i = 0; - for (; i < metricsManagerTimeBase3->mAllAtomMatchers.size(); i++) { - if (metricsManagerTimeBase3->mAllAtomMatchers[i]->getId() == + for (; i < metricsManagerTimeBase3->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManagerTimeBase3->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger2->atom_matcher_id()) { break; } @@ -1184,8 +1184,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_TRUE(metricProducerTimeBase4_2->isActive()); i = 0; - for (; i < metricsManagerTimeBase4->mAllAtomMatchers.size(); i++) { - if (metricsManagerTimeBase4->mAllAtomMatchers[i]->getId() == + for (; i < metricsManagerTimeBase4->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManagerTimeBase4->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger1->atom_matcher_id()) { break; } @@ -1196,8 +1196,8 @@ TEST(StatsLogProcessorTest, TestActivationOnBootMultipleActivations) { EXPECT_EQ(kNotActive, activationTimeBase4_1->state); i = 0; - for (; i < metricsManagerTimeBase4->mAllAtomMatchers.size(); i++) { - if (metricsManagerTimeBase4->mAllAtomMatchers[i]->getId() == + for (; i < metricsManagerTimeBase4->mAllAtomMatchingTrackers.size(); i++) { + if (metricsManagerTimeBase4->mAllAtomMatchingTrackers[i]->getId() == metric1ActivationTrigger2->atom_matcher_id()) { break; } @@ -1585,8 +1585,8 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { EXPECT_TRUE(metricProducer3->isActive()); // Check event activations. - ASSERT_EQ(metricsManager1->mAllAtomMatchers.size(), 4); - EXPECT_EQ(metricsManager1->mAllAtomMatchers[0]->getId(), + ASSERT_EQ(metricsManager1->mAllAtomMatchingTrackers.size(), 4); + EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[0]->getId(), metric1ActivationTrigger1->atom_matcher_id()); const auto& activation1 = metricProducer1->mEventActivationMap.at(0); EXPECT_EQ(100 * NS_PER_SEC, activation1->ttl_ns); @@ -1594,7 +1594,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { EXPECT_EQ(kNotActive, activation1->state); EXPECT_EQ(ACTIVATE_ON_BOOT, activation1->activationType); - EXPECT_EQ(metricsManager1->mAllAtomMatchers[1]->getId(), + EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[1]->getId(), metric1ActivationTrigger2->atom_matcher_id()); const auto& activation2 = metricProducer1->mEventActivationMap.at(1); EXPECT_EQ(200 * NS_PER_SEC, activation2->ttl_ns); @@ -1602,7 +1602,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { EXPECT_EQ(kNotActive, activation2->state); EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation2->activationType); - EXPECT_EQ(metricsManager1->mAllAtomMatchers[2]->getId(), + EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[2]->getId(), metric2ActivationTrigger1->atom_matcher_id()); const auto& activation3 = metricProducer2->mEventActivationMap.at(2); EXPECT_EQ(100 * NS_PER_SEC, activation3->ttl_ns); @@ -1610,7 +1610,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { EXPECT_EQ(kNotActive, activation3->state); EXPECT_EQ(ACTIVATE_ON_BOOT, activation3->activationType); - EXPECT_EQ(metricsManager1->mAllAtomMatchers[3]->getId(), + EXPECT_EQ(metricsManager1->mAllAtomMatchingTrackers[3]->getId(), metric2ActivationTrigger2->atom_matcher_id()); const auto& activation4 = metricProducer2->mEventActivationMap.at(3); EXPECT_EQ(200 * NS_PER_SEC, activation4->ttl_ns); @@ -1685,8 +1685,8 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { // Activation 1 is kActiveOnBoot. // Activation 2 and 3 are not active. // Activation 4 is active. - ASSERT_EQ(metricsManager2->mAllAtomMatchers.size(), 4); - EXPECT_EQ(metricsManager2->mAllAtomMatchers[0]->getId(), + ASSERT_EQ(metricsManager2->mAllAtomMatchingTrackers.size(), 4); + EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[0]->getId(), metric1ActivationTrigger1->atom_matcher_id()); const auto& activation1001 = metricProducer1001->mEventActivationMap.at(0); EXPECT_EQ(100 * NS_PER_SEC, activation1001->ttl_ns); @@ -1694,7 +1694,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { EXPECT_EQ(kActiveOnBoot, activation1001->state); EXPECT_EQ(ACTIVATE_ON_BOOT, activation1001->activationType); - EXPECT_EQ(metricsManager2->mAllAtomMatchers[1]->getId(), + EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[1]->getId(), metric1ActivationTrigger2->atom_matcher_id()); const auto& activation1002 = metricProducer1001->mEventActivationMap.at(1); EXPECT_EQ(200 * NS_PER_SEC, activation1002->ttl_ns); @@ -1702,7 +1702,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { EXPECT_EQ(kNotActive, activation1002->state); EXPECT_EQ(ACTIVATE_IMMEDIATELY, activation1002->activationType); - EXPECT_EQ(metricsManager2->mAllAtomMatchers[2]->getId(), + EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[2]->getId(), metric2ActivationTrigger1->atom_matcher_id()); const auto& activation1003 = metricProducer1002->mEventActivationMap.at(2); EXPECT_EQ(100 * NS_PER_SEC, activation1003->ttl_ns); @@ -1710,7 +1710,7 @@ TEST(StatsLogProcessorTest, TestActivationsPersistAcrossSystemServerRestart) { EXPECT_EQ(kNotActive, activation1003->state); EXPECT_EQ(ACTIVATE_ON_BOOT, activation1003->activationType); - EXPECT_EQ(metricsManager2->mAllAtomMatchers[3]->getId(), + EXPECT_EQ(metricsManager2->mAllAtomMatchingTrackers[3]->getId(), metric2ActivationTrigger2->atom_matcher_id()); const auto& activation1004 = metricProducer1002->mEventActivationMap.at(3); EXPECT_EQ(200 * NS_PER_SEC, activation1004->ttl_ns); diff --git a/cmds/statsd/tests/UidMap_test.cpp b/cmds/statsd/tests/UidMap_test.cpp index 293e8ed1c44c..33bdc64333e0 100644 --- a/cmds/statsd/tests/UidMap_test.cpp +++ b/cmds/statsd/tests/UidMap_test.cpp @@ -44,7 +44,7 @@ TEST(UidMapTest, TestIsolatedUID) { sp<StatsPullerManager> pullerManager = new StatsPullerManager(); sp<AlarmMonitor> anomalyAlarmMonitor; sp<AlarmMonitor> subscriberAlarmMonitor; - // Construct the processor with a dummy sendBroadcast function that does nothing. + // Construct the processor with a no-op sendBroadcast function that does nothing. StatsLogProcessor p( m, pullerManager, anomalyAlarmMonitor, subscriberAlarmMonitor, 0, [](const ConfigKey& key) { return true; }, diff --git a/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp b/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp index d96ff8a1925b..ba919f1e0ad8 100644 --- a/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp +++ b/cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp @@ -23,7 +23,7 @@ #include "logd/LogEvent.h" #include "metrics_test_helper.h" -#include "src/matchers/SimpleLogMatchingTracker.h" +#include "src/matchers/SimpleAtomMatchingTracker.h" #include "src/metrics/MetricProducer.h" #include "src/stats_log_util.h" #include "stats_event.h" diff --git a/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp b/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp index 5524ebc86b36..1000aea14868 100644 --- a/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp +++ b/cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp @@ -22,7 +22,7 @@ #include <vector> #include "metrics_test_helper.h" -#include "src/matchers/SimpleLogMatchingTracker.h" +#include "src/matchers/SimpleAtomMatchingTracker.h" #include "src/metrics/MetricProducer.h" #include "src/stats_log_util.h" #include "tests/statsd_test_util.h" diff --git a/cmds/statsd/tests/metrics/parsing_utils/config_update_utils_test.cpp b/cmds/statsd/tests/metrics/parsing_utils/config_update_utils_test.cpp index 6b50fe5387d7..f6d30618ee15 100644 --- a/cmds/statsd/tests/metrics/parsing_utils/config_update_utils_test.cpp +++ b/cmds/statsd/tests/metrics/parsing_utils/config_update_utils_test.cpp @@ -49,8 +49,8 @@ sp<StatsPullerManager> pullerManager = new StatsPullerManager(); sp<AlarmMonitor> anomalyAlarmMonitor; sp<AlarmMonitor> periodicAlarmMonitor; set<int> allTagIds; -vector<sp<LogMatchingTracker>> oldAtomMatchers; -unordered_map<int64_t, int> oldLogTrackerMap; +vector<sp<AtomMatchingTracker>> oldAtomMatchingTrackers; +unordered_map<int64_t, int> oldAtomMatchingTrackerMap; vector<sp<ConditionTracker>> oldConditionTrackers; vector<sp<MetricProducer>> oldMetricProducers; std::vector<sp<AnomalyTracker>> oldAnomalyTrackers; @@ -71,8 +71,8 @@ public: void SetUp() override { allTagIds.clear(); - oldAtomMatchers.clear(); - oldLogTrackerMap.clear(); + oldAtomMatchingTrackers.clear(); + oldAtomMatchingTrackerMap.clear(); oldConditionTrackers.clear(); oldMetricProducers.clear(); oldAnomalyTrackers.clear(); @@ -89,13 +89,13 @@ public: }; bool initConfig(const StatsdConfig& config) { - return initStatsdConfig(key, config, uidMap, pullerManager, anomalyAlarmMonitor, - periodicAlarmMonitor, timeBaseNs, timeBaseNs, allTagIds, - oldAtomMatchers, oldLogTrackerMap, oldConditionTrackers, - oldMetricProducers, oldAnomalyTrackers, oldAlarmTrackers, - conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, - activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, - alertTrackerMap, metricsWithActivation, noReportMetricIds); + return initStatsdConfig( + key, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, + timeBaseNs, timeBaseNs, allTagIds, oldAtomMatchingTrackers, oldAtomMatchingTrackerMap, + oldConditionTrackers, oldMetricProducers, oldAnomalyTrackers, oldAlarmTrackers, + conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, + activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, + metricsWithActivation, noReportMetricIds); } } // anonymous namespace @@ -111,10 +111,11 @@ TEST_F(ConfigUpdateTest, TestSimpleMatcherPreserve) { vector<UpdateStatus> matchersToUpdate(1, UPDATE_UNKNOWN); vector<bool> cycleTracker(1, false); - unordered_map<int64_t, int> newLogTrackerMap; - newLogTrackerMap[matcherId] = 0; - EXPECT_TRUE(determineMatcherUpdateStatus(config, 0, oldLogTrackerMap, oldAtomMatchers, - newLogTrackerMap, matchersToUpdate, cycleTracker)); + unordered_map<int64_t, int> newAtomMatchingTrackerMap; + newAtomMatchingTrackerMap[matcherId] = 0; + EXPECT_TRUE(determineMatcherUpdateStatus(config, 0, oldAtomMatchingTrackerMap, + oldAtomMatchingTrackers, newAtomMatchingTrackerMap, + matchersToUpdate, cycleTracker)); EXPECT_EQ(matchersToUpdate[0], UPDATE_PRESERVE); } @@ -134,10 +135,11 @@ TEST_F(ConfigUpdateTest, TestSimpleMatcherReplace) { vector<UpdateStatus> matchersToUpdate(1, UPDATE_UNKNOWN); vector<bool> cycleTracker(1, false); - unordered_map<int64_t, int> newLogTrackerMap; - newLogTrackerMap[matcherId] = 0; - EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 0, oldLogTrackerMap, oldAtomMatchers, - newLogTrackerMap, matchersToUpdate, cycleTracker)); + unordered_map<int64_t, int> newAtomMatchingTrackerMap; + newAtomMatchingTrackerMap[matcherId] = 0; + EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 0, oldAtomMatchingTrackerMap, + oldAtomMatchingTrackers, newAtomMatchingTrackerMap, + matchersToUpdate, cycleTracker)); EXPECT_EQ(matchersToUpdate[0], UPDATE_REPLACE); } @@ -163,20 +165,21 @@ TEST_F(ConfigUpdateTest, TestCombinationMatcherPreserve) { EXPECT_TRUE(initConfig(config)); StatsdConfig newConfig; - unordered_map<int64_t, int> newLogTrackerMap; + unordered_map<int64_t, int> newAtomMatchingTrackerMap; // Same matchers, different order, all should be preserved. *newConfig.add_atom_matcher() = matcher2; - newLogTrackerMap[matcher2Id] = 0; + newAtomMatchingTrackerMap[matcher2Id] = 0; *newConfig.add_atom_matcher() = matcher3; - newLogTrackerMap[matcher3Id] = 1; + newAtomMatchingTrackerMap[matcher3Id] = 1; *newConfig.add_atom_matcher() = matcher1; - newLogTrackerMap[matcher1Id] = 2; + newAtomMatchingTrackerMap[matcher1Id] = 2; vector<UpdateStatus> matchersToUpdate(3, UPDATE_UNKNOWN); vector<bool> cycleTracker(3, false); // Only update the combination. It should recurse the two child matchers and preserve all 3. - EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 1, oldLogTrackerMap, oldAtomMatchers, - newLogTrackerMap, matchersToUpdate, cycleTracker)); + EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 1, oldAtomMatchingTrackerMap, + oldAtomMatchingTrackers, newAtomMatchingTrackerMap, + matchersToUpdate, cycleTracker)); EXPECT_EQ(matchersToUpdate[0], UPDATE_PRESERVE); EXPECT_EQ(matchersToUpdate[1], UPDATE_PRESERVE); EXPECT_EQ(matchersToUpdate[2], UPDATE_PRESERVE); @@ -207,19 +210,20 @@ TEST_F(ConfigUpdateTest, TestCombinationMatcherReplace) { matcher3.mutable_combination()->set_operation(LogicalOperation::AND); StatsdConfig newConfig; - unordered_map<int64_t, int> newLogTrackerMap; + unordered_map<int64_t, int> newAtomMatchingTrackerMap; *newConfig.add_atom_matcher() = matcher2; - newLogTrackerMap[matcher2Id] = 0; + newAtomMatchingTrackerMap[matcher2Id] = 0; *newConfig.add_atom_matcher() = matcher3; - newLogTrackerMap[matcher3Id] = 1; + newAtomMatchingTrackerMap[matcher3Id] = 1; *newConfig.add_atom_matcher() = matcher1; - newLogTrackerMap[matcher1Id] = 2; + newAtomMatchingTrackerMap[matcher1Id] = 2; vector<UpdateStatus> matchersToUpdate(3, UPDATE_UNKNOWN); vector<bool> cycleTracker(3, false); // Only update the combination. The simple matchers should not be evaluated. - EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 1, oldLogTrackerMap, oldAtomMatchers, - newLogTrackerMap, matchersToUpdate, cycleTracker)); + EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 1, oldAtomMatchingTrackerMap, + oldAtomMatchingTrackers, newAtomMatchingTrackerMap, + matchersToUpdate, cycleTracker)); EXPECT_EQ(matchersToUpdate[0], UPDATE_UNKNOWN); EXPECT_EQ(matchersToUpdate[1], UPDATE_REPLACE); EXPECT_EQ(matchersToUpdate[2], UPDATE_UNKNOWN); @@ -250,19 +254,20 @@ TEST_F(ConfigUpdateTest, TestCombinationMatcherDepsChange) { matcher2.mutable_simple_atom_matcher()->set_atom_id(12); StatsdConfig newConfig; - unordered_map<int64_t, int> newLogTrackerMap; + unordered_map<int64_t, int> newAtomMatchingTrackerMap; *newConfig.add_atom_matcher() = matcher2; - newLogTrackerMap[matcher2Id] = 0; + newAtomMatchingTrackerMap[matcher2Id] = 0; *newConfig.add_atom_matcher() = matcher3; - newLogTrackerMap[matcher3Id] = 1; + newAtomMatchingTrackerMap[matcher3Id] = 1; *newConfig.add_atom_matcher() = matcher1; - newLogTrackerMap[matcher1Id] = 2; + newAtomMatchingTrackerMap[matcher1Id] = 2; vector<UpdateStatus> matchersToUpdate(3, UPDATE_UNKNOWN); vector<bool> cycleTracker(3, false); // Only update the combination. - EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 1, oldLogTrackerMap, oldAtomMatchers, - newLogTrackerMap, matchersToUpdate, cycleTracker)); + EXPECT_TRUE(determineMatcherUpdateStatus(newConfig, 1, oldAtomMatchingTrackerMap, + oldAtomMatchingTrackers, newAtomMatchingTrackerMap, + matchersToUpdate, cycleTracker)); // Matcher 2 and matcher3 must be reevaluated. Matcher 1 might, but does not need to be. EXPECT_EQ(matchersToUpdate[0], UPDATE_REPLACE); EXPECT_EQ(matchersToUpdate[1], UPDATE_REPLACE); @@ -330,47 +335,48 @@ TEST_F(ConfigUpdateTest, TestUpdateMatchers) { *newConfig.add_atom_matcher() = combination1; set<int> newTagIds; - unordered_map<int64_t, int> newLogTrackerMap; - vector<sp<LogMatchingTracker>> newAtomMatchers; - EXPECT_TRUE(updateLogTrackers(newConfig, uidMap, oldLogTrackerMap, oldAtomMatchers, newTagIds, - newLogTrackerMap, newAtomMatchers)); + unordered_map<int64_t, int> newAtomMatchingTrackerMap; + vector<sp<AtomMatchingTracker>> newAtomMatchingTrackers; + EXPECT_TRUE(updateAtomTrackers(newConfig, uidMap, oldAtomMatchingTrackerMap, + oldAtomMatchingTrackers, newTagIds, newAtomMatchingTrackerMap, + newAtomMatchingTrackers)); ASSERT_EQ(newTagIds.size(), 3); EXPECT_EQ(newTagIds.count(10), 1); EXPECT_EQ(newTagIds.count(111), 1); EXPECT_EQ(newTagIds.count(13), 1); - ASSERT_EQ(newLogTrackerMap.size(), 6); - EXPECT_EQ(newLogTrackerMap.at(combination3Id), 0); - EXPECT_EQ(newLogTrackerMap.at(simple2Id), 1); - EXPECT_EQ(newLogTrackerMap.at(combination2Id), 2); - EXPECT_EQ(newLogTrackerMap.at(simple1Id), 3); - EXPECT_EQ(newLogTrackerMap.at(simple4Id), 4); - EXPECT_EQ(newLogTrackerMap.at(combination1Id), 5); + ASSERT_EQ(newAtomMatchingTrackerMap.size(), 6); + EXPECT_EQ(newAtomMatchingTrackerMap.at(combination3Id), 0); + EXPECT_EQ(newAtomMatchingTrackerMap.at(simple2Id), 1); + EXPECT_EQ(newAtomMatchingTrackerMap.at(combination2Id), 2); + EXPECT_EQ(newAtomMatchingTrackerMap.at(simple1Id), 3); + EXPECT_EQ(newAtomMatchingTrackerMap.at(simple4Id), 4); + EXPECT_EQ(newAtomMatchingTrackerMap.at(combination1Id), 5); - ASSERT_EQ(newAtomMatchers.size(), 6); + ASSERT_EQ(newAtomMatchingTrackers.size(), 6); // Make sure all atom matchers are initialized: - for (const sp<LogMatchingTracker>& tracker : newAtomMatchers) { + for (const sp<AtomMatchingTracker>& tracker : newAtomMatchingTrackers) { EXPECT_TRUE(tracker->mInitialized); } // Make sure preserved atom matchers are the same. - EXPECT_EQ(oldAtomMatchers[oldLogTrackerMap.at(simple1Id)], - newAtomMatchers[newLogTrackerMap.at(simple1Id)]); - EXPECT_EQ(oldAtomMatchers[oldLogTrackerMap.at(combination1Id)], - newAtomMatchers[newLogTrackerMap.at(combination1Id)]); + EXPECT_EQ(oldAtomMatchingTrackers[oldAtomMatchingTrackerMap.at(simple1Id)], + newAtomMatchingTrackers[newAtomMatchingTrackerMap.at(simple1Id)]); + EXPECT_EQ(oldAtomMatchingTrackers[oldAtomMatchingTrackerMap.at(combination1Id)], + newAtomMatchingTrackers[newAtomMatchingTrackerMap.at(combination1Id)]); // Make sure replaced matchers are different. - EXPECT_NE(oldAtomMatchers[oldLogTrackerMap.at(simple2Id)], - newAtomMatchers[newLogTrackerMap.at(simple2Id)]); - EXPECT_NE(oldAtomMatchers[oldLogTrackerMap.at(combination2Id)], - newAtomMatchers[newLogTrackerMap.at(combination2Id)]); + EXPECT_NE(oldAtomMatchingTrackers[oldAtomMatchingTrackerMap.at(simple2Id)], + newAtomMatchingTrackers[newAtomMatchingTrackerMap.at(simple2Id)]); + EXPECT_NE(oldAtomMatchingTrackers[oldAtomMatchingTrackerMap.at(combination2Id)], + newAtomMatchingTrackers[newAtomMatchingTrackerMap.at(combination2Id)]); // Validation, make sure the matchers have the proper ids. Could do more checks here. - EXPECT_EQ(newAtomMatchers[0]->getId(), combination3Id); - EXPECT_EQ(newAtomMatchers[1]->getId(), simple2Id); - EXPECT_EQ(newAtomMatchers[2]->getId(), combination2Id); - EXPECT_EQ(newAtomMatchers[3]->getId(), simple1Id); - EXPECT_EQ(newAtomMatchers[4]->getId(), simple4Id); - EXPECT_EQ(newAtomMatchers[5]->getId(), combination1Id); + EXPECT_EQ(newAtomMatchingTrackers[0]->getId(), combination3Id); + EXPECT_EQ(newAtomMatchingTrackers[1]->getId(), simple2Id); + EXPECT_EQ(newAtomMatchingTrackers[2]->getId(), combination2Id); + EXPECT_EQ(newAtomMatchingTrackers[3]->getId(), simple1Id); + EXPECT_EQ(newAtomMatchingTrackers[4]->getId(), simple4Id); + EXPECT_EQ(newAtomMatchingTrackers[5]->getId(), combination1Id); } } // namespace statsd diff --git a/cmds/statsd/tests/metrics/parsing_utils/metrics_manager_util_test.cpp b/cmds/statsd/tests/metrics/parsing_utils/metrics_manager_util_test.cpp index 4e97eaf6f149..d6db4c12ae4d 100644 --- a/cmds/statsd/tests/metrics/parsing_utils/metrics_manager_util_test.cpp +++ b/cmds/statsd/tests/metrics/parsing_utils/metrics_manager_util_test.cpp @@ -24,7 +24,7 @@ #include "frameworks/base/cmds/statsd/src/statsd_config.pb.h" #include "src/condition/ConditionTracker.h" -#include "src/matchers/LogMatchingTracker.h" +#include "src/matchers/AtomMatchingTracker.h" #include "src/metrics/CountMetricProducer.h" #include "src/metrics/GaugeMetricProducer.h" #include "src/metrics/MetricProducer.h" @@ -383,7 +383,7 @@ TEST(MetricsManagerTest, TestInitialConditions) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildConfigWithDifferentPredicates(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -400,7 +400,7 @@ TEST(MetricsManagerTest, TestInitialConditions) { EXPECT_TRUE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, @@ -432,7 +432,7 @@ TEST(MetricsManagerTest, TestGoodConfig) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildGoodConfig(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -449,7 +449,7 @@ TEST(MetricsManagerTest, TestGoodConfig) { EXPECT_TRUE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, @@ -469,7 +469,7 @@ TEST(MetricsManagerTest, TestDimensionMetricsWithMultiTags) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildDimensionMetricsWithMultiTags(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -486,7 +486,7 @@ TEST(MetricsManagerTest, TestDimensionMetricsWithMultiTags) { EXPECT_FALSE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, @@ -500,7 +500,7 @@ TEST(MetricsManagerTest, TestCircleLogMatcherDependency) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildCircleMatchers(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -517,7 +517,7 @@ TEST(MetricsManagerTest, TestCircleLogMatcherDependency) { EXPECT_FALSE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, @@ -531,7 +531,7 @@ TEST(MetricsManagerTest, TestMissingMatchers) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildMissingMatchers(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -547,7 +547,7 @@ TEST(MetricsManagerTest, TestMissingMatchers) { std::set<int64_t> noReportMetricIds; EXPECT_FALSE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, @@ -561,7 +561,7 @@ TEST(MetricsManagerTest, TestMissingPredicate) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildMissingPredicate(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -577,7 +577,7 @@ TEST(MetricsManagerTest, TestMissingPredicate) { std::set<int64_t> noReportMetricIds; EXPECT_FALSE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, @@ -591,7 +591,7 @@ TEST(MetricsManagerTest, TestCirclePredicateDependency) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildCirclePredicates(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -608,7 +608,7 @@ TEST(MetricsManagerTest, TestCirclePredicateDependency) { EXPECT_FALSE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, @@ -622,7 +622,7 @@ TEST(MetricsManagerTest, testAlertWithUnknownMetric) { sp<AlarmMonitor> periodicAlarmMonitor; StatsdConfig config = buildAlertWithUnknownMetric(); set<int> allTagIds; - vector<sp<LogMatchingTracker>> allAtomMatchers; + vector<sp<AtomMatchingTracker>> allAtomMatchingTrackers; unordered_map<int64_t, int> logTrackerMap; vector<sp<ConditionTracker>> allConditionTrackers; vector<sp<MetricProducer>> allMetricProducers; @@ -639,21 +639,21 @@ TEST(MetricsManagerTest, testAlertWithUnknownMetric) { EXPECT_FALSE(initStatsdConfig( kConfigKey, config, uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, - timeBaseSec, timeBaseSec, allTagIds, allAtomMatchers, logTrackerMap, + timeBaseSec, timeBaseSec, allTagIds, allAtomMatchingTrackers, logTrackerMap, allConditionTrackers, allMetricProducers, allAnomalyTrackers, allAlarmTrackers, conditionToMetricMap, trackerToMetricMap, trackerToConditionMap, activationAtomTrackerToMetricMap, deactivationAtomTrackerToMetricMap, alertTrackerMap, metricsWithActivation, noReportMetricIds)); } -TEST(MetricsManagerTest, TestCreateLogTrackerInvalidMatcher) { +TEST(MetricsManagerTest, TestCreateAtomMatchingTrackerInvalidMatcher) { sp<UidMap> uidMap = new UidMap(); AtomMatcher matcher; matcher.set_id(21); - EXPECT_EQ(createLogTracker(matcher, 0, uidMap), nullptr); + EXPECT_EQ(createAtomMatchingTracker(matcher, 0, uidMap), nullptr); } -TEST(MetricsManagerTest, TestCreateLogTrackerSimple) { +TEST(MetricsManagerTest, TestCreateAtomMatchingTrackerSimple) { int index = 1; int64_t id = 123; sp<UidMap> uidMap = new UidMap(); @@ -666,7 +666,7 @@ TEST(MetricsManagerTest, TestCreateLogTrackerSimple) { simpleAtomMatcher->mutable_field_value_matcher(0)->set_eq_int( android::view::DisplayStateEnum::DISPLAY_STATE_ON); - sp<LogMatchingTracker> tracker = createLogTracker(matcher, index, uidMap); + sp<AtomMatchingTracker> tracker = createAtomMatchingTracker(matcher, index, uidMap); EXPECT_NE(tracker, nullptr); EXPECT_TRUE(tracker->mInitialized); @@ -677,7 +677,7 @@ TEST(MetricsManagerTest, TestCreateLogTrackerSimple) { EXPECT_EQ(atomIds.count(util::SCREEN_STATE_CHANGED), 1); } -TEST(MetricsManagerTest, TestCreateLogTrackerCombination) { +TEST(MetricsManagerTest, TestCreateAtomMatchingTrackerCombination) { int index = 1; int64_t id = 123; sp<UidMap> uidMap = new UidMap(); @@ -688,7 +688,7 @@ TEST(MetricsManagerTest, TestCreateLogTrackerCombination) { combination->add_matcher(123); combination->add_matcher(223); - sp<LogMatchingTracker> tracker = createLogTracker(matcher, index, uidMap); + sp<AtomMatchingTracker> tracker = createAtomMatchingTracker(matcher, index, uidMap); EXPECT_NE(tracker, nullptr); // Combination matchers need to be initialized first. diff --git a/cmds/statsd/tests/statsd_test_util.cpp b/cmds/statsd/tests/statsd_test_util.cpp index 0be983f2a9b0..1761d5d9e1fa 100644 --- a/cmds/statsd/tests/statsd_test_util.cpp +++ b/cmds/statsd/tests/statsd_test_util.cpp @@ -16,7 +16,7 @@ #include <aidl/android/util/StatsEventParcel.h> -#include "matchers/SimpleLogMatchingTracker.h" +#include "matchers/SimpleAtomMatchingTracker.h" #include "stats_event.h" using aidl::android::util::StatsEventParcel; @@ -1008,8 +1008,8 @@ sp<EventMatcherWizard> createEventMatcherWizard( } uint64_t matcherHash = 0x12345678; int64_t matcherId = 678; - return new EventMatcherWizard({new SimpleLogMatchingTracker(matcherId, matcherIndex, - matcherHash, atomMatcher, uidMap)}); + return new EventMatcherWizard({new SimpleAtomMatchingTracker( + matcherId, matcherIndex, matcherHash, atomMatcher, uidMap)}); } void ValidateWakelockAttributionUidAndTagDimension(const DimensionsValue& value, const int atomId, |