Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Make LogMatchingTracker, SimpleLogMatchingTracker, CombinationLogMatchingTracker, LogTracker, and AtomMatcher naming consistent"

Browse Source
This commit is contained in:
Salud Lemus
2020-08-15 02:29:57 +00:00
committed by Android (Google) Code Review
parent 567f322862 f63fa89921
commit 0ba14747cf
23 changed files with 441 additions and 414 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
cmds/statsd/Android.bp
View File

@@ -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",

4
cmds/statsd/src/condition/CombinationConditionTracker.cpp
View File

@@ -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,

14
cmds/statsd/src/condition/ConditionTracker.h
View File

@@ -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.

47
cmds/statsd/src/matchers/LogMatchingTracker.h → cmds/statsd/src/matchers/AtomMatchingTracker.h
View File

@@ -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

36
cmds/statsd/src/matchers/CombinationLogMatchingTracker.cpp → cmds/statsd/src/matchers/CombinationAtomMatchingTracker.cpp
View File

@@ -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);
}
}

24
cmds/statsd/src/matchers/CombinationLogMatchingTracker.h → cmds/statsd/src/matchers/CombinationAtomMatchingTracker.h
View File

@@ -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

6
cmds/statsd/src/matchers/EventMatcherWizard.h
View File

@@ -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

28
cmds/statsd/src/matchers/SimpleLogMatchingTracker.cpp → cmds/statsd/src/matchers/SimpleAtomMatchingTracker.cpp
View File

@@ -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;

23
cmds/statsd/src/matchers/SimpleLogMatchingTracker.h → cmds/statsd/src/matchers/SimpleAtomMatchingTracker.h
View File

@@ -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

2
cmds/statsd/src/matchers/matcher_util.cpp
View File

@@ -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"

54
cmds/statsd/src/metrics/MetricsManager.cpp
View File

@@ -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();
@@ -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;

20
cmds/statsd/src/metrics/MetricsManager.h
View File

@@ -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

77
cmds/statsd/src/metrics/parsing_utils/config_update_utils.cpp
View File

@@ -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
} // namespace android

44
cmds/statsd/src/metrics/parsing_utils/config_update_utils.h
View File

@@ -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
} // namespace android

190
cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.cpp
View File

@@ -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;
}

38
cmds/statsd/src/metrics/parsing_utils/metrics_manager_util.h
View File

@@ -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,

2
cmds/statsd/tests/MetricsManager_test.cpp
View File

@@ -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"

52
cmds/statsd/tests/StatsLogProcessor_test.cpp
View File

@@ -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);

2
cmds/statsd/tests/metrics/GaugeMetricProducer_test.cpp
View File

@@ -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"

2
cmds/statsd/tests/metrics/ValueMetricProducer_test.cpp
View File

@@ -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"

134
cmds/statsd/tests/metrics/parsing_utils/config_update_utils_test.cpp
View File

@@ -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

46
cmds/statsd/tests/metrics/parsing_utils/metrics_manager_util_test.cpp
View File

@@ -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.

6
cmds/statsd/tests/statsd_test_util.cpp
View File

@@ -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,