Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2017 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
Yangster-mac | 754e29e | 2018-05-02 12:23:17 -0700 | [diff] [blame] | 16 | #define DEBUG false // STOPSHIP if true |
Joe Onorato | 9fc9edf | 2017-10-15 20:08:52 -0700 | [diff] [blame] | 17 | #include "Log.h" |
tsaichristine | d21aacf | 2019-10-07 14:47:38 -0700 | [diff] [blame] | 18 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 19 | #include "MetricsManager.h" |
tsaichristine | d21aacf | 2019-10-07 14:47:38 -0700 | [diff] [blame] | 20 | |
tsaichristine | d21aacf | 2019-10-07 14:47:38 -0700 | [diff] [blame] | 21 | #include <private/android_filesystem_config.h> |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 22 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 23 | #include "CountMetricProducer.h" |
Muhammad Qureshi | c8e2266 | 2019-11-20 17:18:03 -0800 | [diff] [blame] | 24 | #include "atoms_info.h" |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 25 | #include "condition/CombinationConditionTracker.h" |
| 26 | #include "condition/SimpleConditionTracker.h" |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 27 | #include "guardrail/StatsdStats.h" |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 28 | #include "matchers/CombinationLogMatchingTracker.h" |
| 29 | #include "matchers/SimpleLogMatchingTracker.h" |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 30 | #include "metrics_manager_util.h" |
tsaichristine | d21aacf | 2019-10-07 14:47:38 -0700 | [diff] [blame] | 31 | #include "state/StateManager.h" |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 32 | #include "stats_log_util.h" |
tsaichristine | d21aacf | 2019-10-07 14:47:38 -0700 | [diff] [blame] | 33 | #include "stats_util.h" |
Jeffrey Huang | 74fc435 | 2020-03-06 15:18:33 -0800 | [diff] [blame] | 34 | #include "statslog_statsd.h" |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 35 | |
| 36 | using android::util::FIELD_COUNT_REPEATED; |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 37 | using android::util::FIELD_TYPE_INT32; |
| 38 | using android::util::FIELD_TYPE_INT64; |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 39 | using android::util::FIELD_TYPE_MESSAGE; |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 40 | using android::util::FIELD_TYPE_STRING; |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 41 | using android::util::ProtoOutputStream; |
| 42 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 43 | using std::set; |
| 44 | using std::string; |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 45 | using std::vector; |
| 46 | |
| 47 | namespace android { |
| 48 | namespace os { |
| 49 | namespace statsd { |
| 50 | |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 51 | const int FIELD_ID_METRICS = 1; |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 52 | const int FIELD_ID_ANNOTATIONS = 7; |
| 53 | const int FIELD_ID_ANNOTATIONS_INT64 = 1; |
| 54 | const int FIELD_ID_ANNOTATIONS_INT32 = 2; |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 55 | |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 56 | // for ActiveConfig |
| 57 | const int FIELD_ID_ACTIVE_CONFIG_ID = 1; |
| 58 | const int FIELD_ID_ACTIVE_CONFIG_UID = 2; |
| 59 | const int FIELD_ID_ACTIVE_CONFIG_METRIC = 3; |
| 60 | |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 61 | MetricsManager::MetricsManager(const ConfigKey& key, const StatsdConfig& config, |
Yangster-mac | 15f6bbc | 2018-04-08 11:52:26 -0700 | [diff] [blame] | 62 | const int64_t timeBaseNs, const int64_t currentTimeNs, |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 63 | const sp<UidMap>& uidMap, |
| 64 | const sp<StatsPullerManager>& pullerManager, |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 65 | const sp<AlarmMonitor>& anomalyAlarmMonitor, |
| 66 | const sp<AlarmMonitor>& periodicAlarmMonitor) |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 67 | : mConfigKey(key), |
| 68 | mUidMap(uidMap), |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 69 | mTtlNs(config.has_ttl_in_seconds() ? config.ttl_in_seconds() * NS_PER_SEC : -1), |
| 70 | mTtlEndNs(-1), |
David Chen | 4894490 | 2018-05-03 10:29:11 -0700 | [diff] [blame] | 71 | mLastReportTimeNs(currentTimeNs), |
Yao Chen | 9a43b4f | 2019-04-10 10:43:20 -0700 | [diff] [blame] | 72 | mLastReportWallClockNs(getWallClockNs()), |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 73 | mPullerManager(pullerManager), |
Muhammad Qureshi | f681646 | 2020-05-13 15:13:33 -0700 | [diff] [blame] | 74 | mWhitelistedAtomIds(config.whitelisted_atom_ids().begin(), |
| 75 | config.whitelisted_atom_ids().end()), |
Yao Chen | 9a43b4f | 2019-04-10 10:43:20 -0700 | [diff] [blame] | 76 | mShouldPersistHistory(config.persist_locally()) { |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 77 | // Init the ttl end timestamp. |
Yangster-mac | 15f6bbc | 2018-04-08 11:52:26 -0700 | [diff] [blame] | 78 | refreshTtl(timeBaseNs); |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 79 | |
Chenjie Yu | e221920 | 2018-06-08 10:07:51 -0700 | [diff] [blame] | 80 | mConfigValid = initStatsdConfig( |
| 81 | key, config, *uidMap, pullerManager, anomalyAlarmMonitor, periodicAlarmMonitor, |
| 82 | timeBaseNs, currentTimeNs, mTagIds, mAllAtomMatchers, mAllConditionTrackers, |
| 83 | mAllMetricProducers, mAllAnomalyTrackers, mAllPeriodicAlarmTrackers, |
Yangster-mac | 849dfdc2 | 2018-10-12 15:41:45 -0700 | [diff] [blame] | 84 | mConditionToMetricMap, mTrackerToMetricMap, mTrackerToConditionMap, |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 85 | mActivationAtomTrackerToMetricMap, mDeactivationAtomTrackerToMetricMap, |
Jeffrey Huang | 38d7026 | 2020-03-19 17:28:59 -0700 | [diff] [blame] | 86 | mAlertTrackerMap, mMetricIndexesWithActivation, mNoReportMetricIds); |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 87 | |
Yangster-mac | 1c58f04 | 2018-05-17 15:52:51 -0700 | [diff] [blame] | 88 | mHashStringsInReport = config.hash_strings_in_metric_report(); |
dwchen | 730403e | 2018-10-29 11:41:56 -0700 | [diff] [blame] | 89 | mVersionStringsInReport = config.version_strings_in_metric_report(); |
| 90 | mInstallerInReport = config.installer_in_metric_report(); |
Yangster-mac | 1c58f04 | 2018-05-17 15:52:51 -0700 | [diff] [blame] | 91 | |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 92 | // Init allowed pushed atom uids. |
Yao Chen | 147ce60 | 2017-12-22 14:35:34 -0800 | [diff] [blame] | 93 | if (config.allowed_log_source_size() == 0) { |
David Chen | 8faaa01 | 2018-02-28 15:54:36 -0800 | [diff] [blame] | 94 | mConfigValid = false; |
| 95 | ALOGE("Log source whitelist is empty! This config won't get any data. Suggest adding at " |
| 96 | "least AID_SYSTEM and AID_STATSD to the allowed_log_source field."); |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 97 | } else { |
Yao Chen | 147ce60 | 2017-12-22 14:35:34 -0800 | [diff] [blame] | 98 | for (const auto& source : config.allowed_log_source()) { |
| 99 | auto it = UidMap::sAidToUidMapping.find(source); |
| 100 | if (it != UidMap::sAidToUidMapping.end()) { |
| 101 | mAllowedUid.push_back(it->second); |
| 102 | } else { |
| 103 | mAllowedPkg.push_back(source); |
| 104 | } |
| 105 | } |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 106 | |
| 107 | if (mAllowedUid.size() + mAllowedPkg.size() > StatsdStats::kMaxLogSourceCount) { |
| 108 | ALOGE("Too many log sources. This is likely to be an error in the config."); |
| 109 | mConfigValid = false; |
| 110 | } else { |
| 111 | initLogSourceWhiteList(); |
| 112 | } |
| 113 | } |
| 114 | |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 115 | // Init default allowed pull atom uids. |
| 116 | int numPullPackages = 0; |
| 117 | for (const string& pullSource : config.default_pull_packages()) { |
| 118 | auto it = UidMap::sAidToUidMapping.find(pullSource); |
| 119 | if (it != UidMap::sAidToUidMapping.end()) { |
| 120 | numPullPackages++; |
| 121 | mDefaultPullUids.insert(it->second); |
| 122 | } else { |
| 123 | ALOGE("Default pull atom packages must be in sAidToUidMapping"); |
| 124 | mConfigValid = false; |
| 125 | } |
| 126 | } |
| 127 | // Init per-atom pull atom packages. |
| 128 | for (const PullAtomPackages& pullAtomPackages : config.pull_atom_packages()) { |
| 129 | int32_t atomId = pullAtomPackages.atom_id(); |
| 130 | for (const string& pullPackage : pullAtomPackages.packages()) { |
| 131 | numPullPackages++; |
| 132 | auto it = UidMap::sAidToUidMapping.find(pullPackage); |
| 133 | if (it != UidMap::sAidToUidMapping.end()) { |
| 134 | mPullAtomUids[atomId].insert(it->second); |
| 135 | } else { |
| 136 | mPullAtomPackages[atomId].insert(pullPackage); |
| 137 | } |
| 138 | } |
| 139 | } |
| 140 | if (numPullPackages > StatsdStats::kMaxPullAtomPackages) { |
| 141 | ALOGE("Too many sources in default_pull_packages and pull_atom_packages. This is likely to " |
| 142 | "be an error in the config"); |
| 143 | mConfigValid = false; |
| 144 | } else { |
| 145 | initPullAtomSources(); |
| 146 | } |
| 147 | mPullerManager->RegisterPullUidProvider(mConfigKey, this); |
| 148 | |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 149 | // Store the sub-configs used. |
| 150 | for (const auto& annotation : config.annotation()) { |
| 151 | mAnnotations.emplace_back(annotation.field_int64(), annotation.field_int32()); |
| 152 | } |
| 153 | |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 154 | // Guardrail. Reject the config if it's too big. |
| 155 | if (mAllMetricProducers.size() > StatsdStats::kMaxMetricCountPerConfig || |
| 156 | mAllConditionTrackers.size() > StatsdStats::kMaxConditionCountPerConfig || |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 157 | mAllAtomMatchers.size() > StatsdStats::kMaxMatcherCountPerConfig) { |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 158 | ALOGE("This config is too big! Reject!"); |
| 159 | mConfigValid = false; |
| 160 | } |
Bookatz | 1476ef2 | 2018-02-13 12:26:01 -0800 | [diff] [blame] | 161 | if (mAllAnomalyTrackers.size() > StatsdStats::kMaxAlertCountPerConfig) { |
| 162 | ALOGE("This config has too many alerts! Reject!"); |
| 163 | mConfigValid = false; |
| 164 | } |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 165 | |
| 166 | mIsAlwaysActive = (mMetricIndexesWithActivation.size() != mAllMetricProducers.size()) || |
| 167 | (mAllMetricProducers.size() == 0); |
| 168 | bool isActive = mIsAlwaysActive; |
| 169 | for (int metric : mMetricIndexesWithActivation) { |
| 170 | isActive |= mAllMetricProducers[metric]->isActive(); |
| 171 | } |
| 172 | mIsActive = isActive; |
| 173 | VLOG("mIsActive is initialized to %d", mIsActive) |
| 174 | |
Yao Chen | f09569f | 2017-12-13 17:00:51 -0800 | [diff] [blame] | 175 | // no matter whether this config is valid, log it in the stats. |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 176 | StatsdStats::getInstance().noteConfigReceived( |
| 177 | key, mAllMetricProducers.size(), mAllConditionTrackers.size(), mAllAtomMatchers.size(), |
| 178 | mAllAnomalyTrackers.size(), mAnnotations, mConfigValid); |
Chenjie Yu | c7939cb | 2019-02-04 17:25:45 -0800 | [diff] [blame] | 179 | // Check active |
| 180 | for (const auto& metric : mAllMetricProducers) { |
| 181 | if (metric->isActive()) { |
| 182 | mIsActive = true; |
| 183 | break; |
| 184 | } |
| 185 | } |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 186 | } |
| 187 | |
| 188 | MetricsManager::~MetricsManager() { |
tsaichristine | d21aacf | 2019-10-07 14:47:38 -0700 | [diff] [blame] | 189 | for (auto it : mAllMetricProducers) { |
| 190 | for (int atomId : it->getSlicedStateAtoms()) { |
| 191 | StateManager::getInstance().unregisterListener(atomId, it); |
| 192 | } |
| 193 | } |
Tej Singh | 3eb9ced | 2020-04-20 22:04:38 -0700 | [diff] [blame] | 194 | mPullerManager->UnregisterPullUidProvider(mConfigKey, this); |
tsaichristine | d21aacf | 2019-10-07 14:47:38 -0700 | [diff] [blame] | 195 | |
Bookatz | d3606c7 | 2017-10-19 10:13:49 -0700 | [diff] [blame] | 196 | VLOG("~MetricsManager()"); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 197 | } |
| 198 | |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 199 | void MetricsManager::initLogSourceWhiteList() { |
| 200 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 201 | mAllowedLogSources.clear(); |
| 202 | mAllowedLogSources.insert(mAllowedUid.begin(), mAllowedUid.end()); |
| 203 | |
| 204 | for (const auto& pkg : mAllowedPkg) { |
| 205 | auto uids = mUidMap->getAppUid(pkg); |
| 206 | mAllowedLogSources.insert(uids.begin(), uids.end()); |
| 207 | } |
| 208 | if (DEBUG) { |
| 209 | for (const auto& uid : mAllowedLogSources) { |
| 210 | VLOG("Allowed uid %d", uid); |
| 211 | } |
| 212 | } |
| 213 | } |
| 214 | |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 215 | void MetricsManager::initPullAtomSources() { |
| 216 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 217 | mCombinedPullAtomUids.clear(); |
| 218 | for (const auto& [atomId, uids] : mPullAtomUids) { |
| 219 | mCombinedPullAtomUids[atomId].insert(uids.begin(), uids.end()); |
| 220 | } |
| 221 | for (const auto& [atomId, packages] : mPullAtomPackages) { |
| 222 | for (const string& pkg : packages) { |
| 223 | set<int32_t> uids = mUidMap->getAppUid(pkg); |
| 224 | mCombinedPullAtomUids[atomId].insert(uids.begin(), uids.end()); |
| 225 | } |
| 226 | } |
| 227 | } |
| 228 | |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 229 | bool MetricsManager::isConfigValid() const { |
| 230 | return mConfigValid; |
| 231 | } |
| 232 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 233 | void MetricsManager::notifyAppUpgrade(const int64_t& eventTimeNs, const string& apk, const int uid, |
David Chen | 27785a8 | 2018-01-19 17:06:45 -0800 | [diff] [blame] | 234 | const int64_t version) { |
Tej Singh | 9ec159a | 2019-11-14 11:59:48 -0800 | [diff] [blame] | 235 | // Inform all metric producers. |
Tej Singh | e678cb7 | 2020-04-14 16:23:30 -0700 | [diff] [blame] | 236 | for (const auto& it : mAllMetricProducers) { |
| 237 | it->notifyAppUpgrade(eventTimeNs); |
Tej Singh | 9ec159a | 2019-11-14 11:59:48 -0800 | [diff] [blame] | 238 | } |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 239 | // check if we care this package |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 240 | if (std::find(mAllowedPkg.begin(), mAllowedPkg.end(), apk) != mAllowedPkg.end()) { |
| 241 | // We will re-initialize the whole list because we don't want to keep the multi mapping of |
| 242 | // UID<->pkg inside MetricsManager to reduce the memory usage. |
| 243 | initLogSourceWhiteList(); |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 244 | } |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 245 | |
| 246 | for (const auto& it : mPullAtomPackages) { |
| 247 | if (it.second.find(apk) != it.second.end()) { |
| 248 | initPullAtomSources(); |
| 249 | return; |
| 250 | } |
| 251 | } |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 252 | } |
| 253 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 254 | void MetricsManager::notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, |
David Chen | 27785a8 | 2018-01-19 17:06:45 -0800 | [diff] [blame] | 255 | const int uid) { |
Tej Singh | 9ec159a | 2019-11-14 11:59:48 -0800 | [diff] [blame] | 256 | // Inform all metric producers. |
Tej Singh | e678cb7 | 2020-04-14 16:23:30 -0700 | [diff] [blame] | 257 | for (const auto& it : mAllMetricProducers) { |
| 258 | it->notifyAppRemoved(eventTimeNs); |
Tej Singh | 9ec159a | 2019-11-14 11:59:48 -0800 | [diff] [blame] | 259 | } |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 260 | // check if we care this package |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 261 | if (std::find(mAllowedPkg.begin(), mAllowedPkg.end(), apk) != mAllowedPkg.end()) { |
| 262 | // We will re-initialize the whole list because we don't want to keep the multi mapping of |
| 263 | // UID<->pkg inside MetricsManager to reduce the memory usage. |
| 264 | initLogSourceWhiteList(); |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 265 | } |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 266 | |
| 267 | for (const auto& it : mPullAtomPackages) { |
| 268 | if (it.second.find(apk) != it.second.end()) { |
| 269 | initPullAtomSources(); |
| 270 | return; |
| 271 | } |
| 272 | } |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 273 | } |
| 274 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 275 | void MetricsManager::onUidMapReceived(const int64_t& eventTimeNs) { |
Tej Singh | 9ec159a | 2019-11-14 11:59:48 -0800 | [diff] [blame] | 276 | // Purposefully don't inform metric producers on a new snapshot |
| 277 | // because we don't need to flush partial buckets. |
| 278 | // This occurs if a new user is added/removed or statsd crashes. |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 279 | initPullAtomSources(); |
| 280 | |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 281 | if (mAllowedPkg.size() == 0) { |
| 282 | return; |
| 283 | } |
| 284 | initLogSourceWhiteList(); |
| 285 | } |
| 286 | |
Tej Singh | e678cb7 | 2020-04-14 16:23:30 -0700 | [diff] [blame] | 287 | void MetricsManager::onStatsdInitCompleted(const int64_t& eventTimeNs) { |
| 288 | // Inform all metric producers. |
| 289 | for (const auto& it : mAllMetricProducers) { |
| 290 | it->onStatsdInitCompleted(eventTimeNs); |
| 291 | } |
| 292 | } |
| 293 | |
Tej Singh | 3be093b | 2020-03-04 20:08:38 -0800 | [diff] [blame] | 294 | void MetricsManager::init() { |
| 295 | for (const auto& producer : mAllMetricProducers) { |
| 296 | producer->prepareFirstBucket(); |
| 297 | } |
| 298 | } |
| 299 | |
| 300 | vector<int32_t> MetricsManager::getPullAtomUids(int32_t atomId) { |
| 301 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 302 | vector<int32_t> uids; |
| 303 | const auto& it = mCombinedPullAtomUids.find(atomId); |
| 304 | if (it != mCombinedPullAtomUids.end()) { |
| 305 | uids.insert(uids.end(), it->second.begin(), it->second.end()); |
| 306 | } |
| 307 | uids.insert(uids.end(), mDefaultPullUids.begin(), mDefaultPullUids.end()); |
| 308 | return uids; |
| 309 | } |
| 310 | |
Yao Chen | 884c8c1 | 2018-01-26 10:36:25 -0800 | [diff] [blame] | 311 | void MetricsManager::dumpStates(FILE* out, bool verbose) { |
| 312 | fprintf(out, "ConfigKey %s, allowed source:", mConfigKey.ToString().c_str()); |
| 313 | { |
| 314 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 315 | for (const auto& source : mAllowedLogSources) { |
| 316 | fprintf(out, "%d ", source); |
| 317 | } |
| 318 | } |
| 319 | fprintf(out, "\n"); |
| 320 | for (const auto& producer : mAllMetricProducers) { |
| 321 | producer->dumpStates(out, verbose); |
| 322 | } |
| 323 | } |
| 324 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 325 | void MetricsManager::dropData(const int64_t dropTimeNs) { |
Yao Chen | 06dba5d | 2018-01-26 13:38:16 -0800 | [diff] [blame] | 326 | for (const auto& producer : mAllMetricProducers) { |
| 327 | producer->dropData(dropTimeNs); |
| 328 | } |
| 329 | } |
| 330 | |
Yangster-mac | e68f3a5 | 2018-04-04 00:01:43 -0700 | [diff] [blame] | 331 | void MetricsManager::onDumpReport(const int64_t dumpTimeStampNs, |
| 332 | const bool include_current_partial_bucket, |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 333 | const bool erase_data, |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 334 | const DumpLatency dumpLatency, |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 335 | std::set<string> *str_set, |
Yangster-mac | e68f3a5 | 2018-04-04 00:01:43 -0700 | [diff] [blame] | 336 | ProtoOutputStream* protoOutput) { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 337 | VLOG("=========================Metric Reports Start=========================="); |
| 338 | // one StatsLogReport per MetricProduer |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 339 | for (const auto& producer : mAllMetricProducers) { |
| 340 | if (mNoReportMetricIds.find(producer->getMetricId()) == mNoReportMetricIds.end()) { |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 341 | uint64_t token = protoOutput->start( |
| 342 | FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_METRICS); |
Yangster-mac | 1c58f04 | 2018-05-17 15:52:51 -0700 | [diff] [blame] | 343 | if (mHashStringsInReport) { |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 344 | producer->onDumpReport(dumpTimeStampNs, include_current_partial_bucket, erase_data, |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 345 | dumpLatency, str_set, protoOutput); |
Yangster-mac | 1c58f04 | 2018-05-17 15:52:51 -0700 | [diff] [blame] | 346 | } else { |
Bookatz | ff71cad | 2018-09-20 17:17:49 -0700 | [diff] [blame] | 347 | producer->onDumpReport(dumpTimeStampNs, include_current_partial_bucket, erase_data, |
Olivier Gaillard | 6c75ecd | 2019-02-20 09:57:33 +0000 | [diff] [blame] | 348 | dumpLatency, nullptr, protoOutput); |
Yangster-mac | 1c58f04 | 2018-05-17 15:52:51 -0700 | [diff] [blame] | 349 | } |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 350 | protoOutput->end(token); |
Yangster-mac | a802d73 | 2018-04-24 07:50:38 -0700 | [diff] [blame] | 351 | } else { |
| 352 | producer->clearPastBuckets(dumpTimeStampNs); |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 353 | } |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 354 | } |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 355 | for (const auto& annotation : mAnnotations) { |
| 356 | uint64_t token = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| 357 | FIELD_ID_ANNOTATIONS); |
| 358 | protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ANNOTATIONS_INT64, |
| 359 | (long long)annotation.first); |
| 360 | protoOutput->write(FIELD_TYPE_INT32 | FIELD_ID_ANNOTATIONS_INT32, annotation.second); |
| 361 | protoOutput->end(token); |
| 362 | } |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 363 | |
Jeffrey Huang | 289eae6 | 2020-06-10 16:28:23 -0700 | [diff] [blame] | 364 | // Do not update the timestamps when data is not cleared to avoid timestamps from being |
| 365 | // misaligned. |
| 366 | if (erase_data) { |
| 367 | mLastReportTimeNs = dumpTimeStampNs; |
| 368 | mLastReportWallClockNs = getWallClockNs(); |
| 369 | } |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 370 | VLOG("=========================Metric Reports End=========================="); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 371 | } |
| 372 | |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 373 | |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 374 | bool MetricsManager::checkLogCredentials(const LogEvent& event) { |
Muhammad Qureshi | f681646 | 2020-05-13 15:13:33 -0700 | [diff] [blame] | 375 | // TODO(b/154856835): Remove this check once we get whitelist from the config. |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 376 | if (android::util::AtomsInfo::kWhitelistedAtoms.find(event.GetTagId()) != |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 377 | android::util::AtomsInfo::kWhitelistedAtoms.end()) |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 378 | { |
| 379 | return true; |
| 380 | } |
Muhammad Qureshi | f681646 | 2020-05-13 15:13:33 -0700 | [diff] [blame] | 381 | |
| 382 | if (mWhitelistedAtomIds.find(event.GetTagId()) != mWhitelistedAtomIds.end()) { |
| 383 | return true; |
| 384 | } |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 385 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 386 | if (mAllowedLogSources.find(event.GetUid()) == mAllowedLogSources.end()) { |
| 387 | VLOG("log source %d not on the whitelist", event.GetUid()); |
| 388 | return false; |
| 389 | } |
| 390 | return true; |
| 391 | } |
| 392 | |
| 393 | bool MetricsManager::eventSanityCheck(const LogEvent& event) { |
Jeffrey Huang | 74fc435 | 2020-03-06 15:18:33 -0800 | [diff] [blame] | 394 | if (event.GetTagId() == util::APP_BREADCRUMB_REPORTED) { |
David Chen | b639d14 | 2018-02-14 17:29:54 -0800 | [diff] [blame] | 395 | // Check that app breadcrumb reported fields are valid. |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 396 | status_t err = NO_ERROR; |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 397 | |
| 398 | // Uid is 3rd from last field and must match the caller's uid, |
| 399 | // unless that caller is statsd itself (statsd is allowed to spoof uids). |
| 400 | long appHookUid = event.GetLong(event.size()-2, &err); |
Ruchir Rastogi | d4cc693 | 2020-04-20 11:51:14 -0700 | [diff] [blame] | 401 | if (err != NO_ERROR) { |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 402 | VLOG("APP_BREADCRUMB_REPORTED had error when parsing the uid"); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 403 | return false; |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 404 | } |
Ruchir Rastogi | d4cc693 | 2020-04-20 11:51:14 -0700 | [diff] [blame] | 405 | |
| 406 | // Because the uid within the LogEvent may have been mapped from |
| 407 | // isolated to host, map the loggerUid similarly before comparing. |
| 408 | int32_t loggerUid = mUidMap->getHostUidOrSelf(event.GetUid()); |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 409 | if (loggerUid != appHookUid && loggerUid != AID_STATSD) { |
| 410 | VLOG("APP_BREADCRUMB_REPORTED has invalid uid: claimed %ld but caller is %d", |
| 411 | appHookUid, loggerUid); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 412 | return false; |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 413 | } |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 414 | |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 415 | // The state must be from 0,3. This part of code must be manually updated. |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 416 | long appHookState = event.GetLong(event.size(), &err); |
Ruchir Rastogi | d4cc693 | 2020-04-20 11:51:14 -0700 | [diff] [blame] | 417 | if (err != NO_ERROR) { |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 418 | VLOG("APP_BREADCRUMB_REPORTED had error when parsing the state field"); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 419 | return false; |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 420 | } else if (appHookState < 0 || appHookState > 3) { |
| 421 | VLOG("APP_BREADCRUMB_REPORTED does not have valid state %ld", appHookState); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 422 | return false; |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 423 | } |
Jeffrey Huang | 74fc435 | 2020-03-06 15:18:33 -0800 | [diff] [blame] | 424 | } else if (event.GetTagId() == util::DAVEY_OCCURRED) { |
Tej Singh | bb8554a | 2018-01-26 11:59:14 -0800 | [diff] [blame] | 425 | // Daveys can be logged from any app since they are logged in libs/hwui/JankTracker.cpp. |
| 426 | // Check that the davey duration is reasonable. Max length check is for privacy. |
| 427 | status_t err = NO_ERROR; |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 428 | |
| 429 | // Uid is the first field provided. |
| 430 | long jankUid = event.GetLong(1, &err); |
Ruchir Rastogi | d4cc693 | 2020-04-20 11:51:14 -0700 | [diff] [blame] | 431 | if (err != NO_ERROR) { |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 432 | VLOG("Davey occurred had error when parsing the uid"); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 433 | return false; |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 434 | } |
| 435 | int32_t loggerUid = event.GetUid(); |
| 436 | if (loggerUid != jankUid && loggerUid != AID_STATSD) { |
| 437 | VLOG("DAVEY_OCCURRED has invalid uid: claimed %ld but caller is %d", jankUid, |
| 438 | loggerUid); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 439 | return false; |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 440 | } |
| 441 | |
Tej Singh | bb8554a | 2018-01-26 11:59:14 -0800 | [diff] [blame] | 442 | long duration = event.GetLong(event.size(), &err); |
Ruchir Rastogi | d4cc693 | 2020-04-20 11:51:14 -0700 | [diff] [blame] | 443 | if (err != NO_ERROR) { |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 444 | VLOG("Davey occurred had error when parsing the duration"); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 445 | return false; |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 446 | } else if (duration > 100000) { |
Tej Singh | bb8554a | 2018-01-26 11:59:14 -0800 | [diff] [blame] | 447 | VLOG("Davey duration is unreasonably long: %ld", duration); |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 448 | return false; |
Tej Singh | bb8554a | 2018-01-26 11:59:14 -0800 | [diff] [blame] | 449 | } |
Andrei Onea | da01ea5 | 2019-01-30 15:28:36 +0000 | [diff] [blame] | 450 | } |
| 451 | |
| 452 | return true; |
| 453 | } |
| 454 | |
| 455 | // Consume the stats log if it's interesting to this metric. |
| 456 | void MetricsManager::onLogEvent(const LogEvent& event) { |
| 457 | if (!mConfigValid) { |
| 458 | return; |
| 459 | } |
| 460 | |
| 461 | if (!checkLogCredentials(event)) { |
| 462 | return; |
| 463 | } |
| 464 | |
| 465 | if (!eventSanityCheck(event)) { |
| 466 | return; |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 467 | } |
| 468 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 469 | int tagId = event.GetTagId(); |
Yangster-mac | 849dfdc2 | 2018-10-12 15:41:45 -0700 | [diff] [blame] | 470 | int64_t eventTimeNs = event.GetElapsedTimestampNs(); |
| 471 | |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 472 | bool isActive = mIsAlwaysActive; |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 473 | |
| 474 | // Set of metrics that are still active after flushing. |
| 475 | unordered_set<int> activeMetricsIndices; |
| 476 | |
| 477 | // Update state of all metrics w/ activation conditions as of eventTimeNs. |
| 478 | for (int metricIndex : mMetricIndexesWithActivation) { |
| 479 | const sp<MetricProducer>& metric = mAllMetricProducers[metricIndex]; |
| 480 | metric->flushIfExpire(eventTimeNs); |
| 481 | if (metric->isActive()) { |
| 482 | // If this metric w/ activation condition is still active after |
| 483 | // flushing, remember it. |
| 484 | activeMetricsIndices.insert(metricIndex); |
| 485 | } |
Yangster-mac | 849dfdc2 | 2018-10-12 15:41:45 -0700 | [diff] [blame] | 486 | } |
| 487 | |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 488 | mIsActive = isActive || !activeMetricsIndices.empty(); |
Tej Singh | 6ede28b | 2019-01-29 17:06:54 -0800 | [diff] [blame] | 489 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 490 | if (mTagIds.find(tagId) == mTagIds.end()) { |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 491 | // Not interesting... |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 492 | return; |
| 493 | } |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 494 | |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 495 | vector<MatchingState> matcherCache(mAllAtomMatchers.size(), MatchingState::kNotComputed); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 496 | |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 497 | // Evaluate all atom matchers. |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 498 | for (auto& matcher : mAllAtomMatchers) { |
| 499 | matcher->onLogEvent(event, mAllAtomMatchers, matcherCache); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 500 | } |
| 501 | |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 502 | // Set of metrics that received an activation cancellation. |
| 503 | unordered_set<int> metricIndicesWithCanceledActivations; |
| 504 | |
| 505 | // Determine which metric activations received a cancellation and cancel them. |
| 506 | for (const auto& it : mDeactivationAtomTrackerToMetricMap) { |
| 507 | if (matcherCache[it.first] == MatchingState::kMatched) { |
| 508 | for (int metricIndex : it.second) { |
| 509 | mAllMetricProducers[metricIndex]->cancelEventActivation(it.first); |
| 510 | metricIndicesWithCanceledActivations.insert(metricIndex); |
| 511 | } |
| 512 | } |
| 513 | } |
| 514 | |
| 515 | // Determine whether any metrics are no longer active after cancelling metric activations. |
| 516 | for (const int metricIndex : metricIndicesWithCanceledActivations) { |
| 517 | const sp<MetricProducer>& metric = mAllMetricProducers[metricIndex]; |
| 518 | metric->flushIfExpire(eventTimeNs); |
| 519 | if (!metric->isActive()) { |
| 520 | activeMetricsIndices.erase(metricIndex); |
| 521 | } |
| 522 | } |
| 523 | |
| 524 | isActive |= !activeMetricsIndices.empty(); |
| 525 | |
| 526 | |
| 527 | // Determine which metric activations should be turned on and turn them on |
Yangster-mac | 849dfdc2 | 2018-10-12 15:41:45 -0700 | [diff] [blame] | 528 | for (const auto& it : mActivationAtomTrackerToMetricMap) { |
| 529 | if (matcherCache[it.first] == MatchingState::kMatched) { |
| 530 | for (int metricIndex : it.second) { |
| 531 | mAllMetricProducers[metricIndex]->activate(it.first, eventTimeNs); |
Chenjie Yu | c7939cb | 2019-02-04 17:25:45 -0800 | [diff] [blame] | 532 | isActive |= mAllMetricProducers[metricIndex]->isActive(); |
Yangster-mac | 849dfdc2 | 2018-10-12 15:41:45 -0700 | [diff] [blame] | 533 | } |
| 534 | } |
| 535 | } |
| 536 | |
Chenjie Yu | c7939cb | 2019-02-04 17:25:45 -0800 | [diff] [blame] | 537 | mIsActive = isActive; |
| 538 | |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 539 | // A bitmap to see which ConditionTracker needs to be re-evaluated. |
| 540 | vector<bool> conditionToBeEvaluated(mAllConditionTrackers.size(), false); |
| 541 | |
| 542 | for (const auto& pair : mTrackerToConditionMap) { |
| 543 | if (matcherCache[pair.first] == MatchingState::kMatched) { |
| 544 | const auto& conditionList = pair.second; |
| 545 | for (const int conditionIndex : conditionList) { |
| 546 | conditionToBeEvaluated[conditionIndex] = true; |
| 547 | } |
| 548 | } |
| 549 | } |
| 550 | |
| 551 | vector<ConditionState> conditionCache(mAllConditionTrackers.size(), |
| 552 | ConditionState::kNotEvaluated); |
| 553 | // A bitmap to track if a condition has changed value. |
| 554 | vector<bool> changedCache(mAllConditionTrackers.size(), false); |
| 555 | for (size_t i = 0; i < mAllConditionTrackers.size(); i++) { |
| 556 | if (conditionToBeEvaluated[i] == false) { |
| 557 | continue; |
| 558 | } |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 559 | sp<ConditionTracker>& condition = mAllConditionTrackers[i]; |
| 560 | condition->evaluateCondition(event, matcherCache, mAllConditionTrackers, conditionCache, |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 561 | changedCache); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 562 | } |
| 563 | |
| 564 | for (size_t i = 0; i < mAllConditionTrackers.size(); i++) { |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 565 | if (changedCache[i] == false) { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 566 | continue; |
| 567 | } |
| 568 | auto pair = mConditionToMetricMap.find(i); |
| 569 | if (pair != mConditionToMetricMap.end()) { |
| 570 | auto& metricList = pair->second; |
| 571 | for (auto metricIndex : metricList) { |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 572 | // Metric cares about non sliced condition, and it's changed. |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 573 | // Push the new condition to it directly. |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 574 | if (!mAllMetricProducers[metricIndex]->isConditionSliced()) { |
Yao Chen | 5154a37 | 2017-10-30 22:57:06 -0700 | [diff] [blame] | 575 | mAllMetricProducers[metricIndex]->onConditionChanged(conditionCache[i], |
Yangster-mac | 849dfdc2 | 2018-10-12 15:41:45 -0700 | [diff] [blame] | 576 | eventTimeNs); |
Muhammad Qureshi | 3a5ebf5 | 2019-03-28 12:38:21 -0700 | [diff] [blame] | 577 | // Metric cares about sliced conditions, and it may have changed. Send |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 578 | // notification, and the metric can query the sliced conditions that are |
| 579 | // interesting to it. |
Yangster | f2bee6f | 2017-11-29 12:01:05 -0800 | [diff] [blame] | 580 | } else { |
Yao Chen | 427d372 | 2018-03-22 15:21:52 -0700 | [diff] [blame] | 581 | mAllMetricProducers[metricIndex]->onSlicedConditionMayChange(conditionCache[i], |
Yangster-mac | 849dfdc2 | 2018-10-12 15:41:45 -0700 | [diff] [blame] | 582 | eventTimeNs); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 583 | } |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 584 | } |
| 585 | } |
| 586 | } |
| 587 | |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 588 | // For matched AtomMatchers, tell relevant metrics that a matched event has come. |
| 589 | for (size_t i = 0; i < mAllAtomMatchers.size(); i++) { |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 590 | if (matcherCache[i] == MatchingState::kMatched) { |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 591 | StatsdStats::getInstance().noteMatcherMatched(mConfigKey, |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 592 | mAllAtomMatchers[i]->getId()); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 593 | auto pair = mTrackerToMetricMap.find(i); |
| 594 | if (pair != mTrackerToMetricMap.end()) { |
| 595 | auto& metricList = pair->second; |
| 596 | for (const int metricIndex : metricList) { |
Chenjie Yu | b3dda41 | 2017-10-24 13:41:59 -0700 | [diff] [blame] | 597 | // pushed metrics are never scheduled pulls |
Chenjie Yu | a7259ab | 2017-12-10 08:31:05 -0800 | [diff] [blame] | 598 | mAllMetricProducers[metricIndex]->onMatchedLogEvent(i, event); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 599 | } |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 600 | } |
| 601 | } |
| 602 | } |
| 603 | } |
| 604 | |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 605 | void MetricsManager::onAnomalyAlarmFired( |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 606 | const int64_t& timestampNs, |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 607 | unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>>& alarmSet) { |
Yangster-mac | e2cd6d5 | 2017-11-09 20:38:30 -0800 | [diff] [blame] | 608 | for (const auto& itr : mAllAnomalyTrackers) { |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 609 | itr->informAlarmsFired(timestampNs, alarmSet); |
Yangster-mac | e2cd6d5 | 2017-11-09 20:38:30 -0800 | [diff] [blame] | 610 | } |
| 611 | } |
| 612 | |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 613 | void MetricsManager::onPeriodicAlarmFired( |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 614 | const int64_t& timestampNs, |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 615 | unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>>& alarmSet) { |
| 616 | for (const auto& itr : mAllPeriodicAlarmTrackers) { |
| 617 | itr->informAlarmsFired(timestampNs, alarmSet); |
Yangster-mac | e2cd6d5 | 2017-11-09 20:38:30 -0800 | [diff] [blame] | 618 | } |
| 619 | } |
| 620 | |
yro | 69007c8 | 2017-10-26 20:42:57 -0700 | [diff] [blame] | 621 | // Returns the total byte size of all metrics managed by a single config source. |
| 622 | size_t MetricsManager::byteSize() { |
| 623 | size_t totalSize = 0; |
Chih-Hung Hsieh | a1b644e | 2018-12-11 11:09:20 -0800 | [diff] [blame] | 624 | for (const auto& metricProducer : mAllMetricProducers) { |
yro | 69007c8 | 2017-10-26 20:42:57 -0700 | [diff] [blame] | 625 | totalSize += metricProducer->byteSize(); |
| 626 | } |
| 627 | return totalSize; |
| 628 | } |
| 629 | |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 630 | void MetricsManager::loadActiveConfig(const ActiveConfig& config, int64_t currentTimeNs) { |
| 631 | if (config.metric_size() == 0) { |
Chenjie Yu | c7939cb | 2019-02-04 17:25:45 -0800 | [diff] [blame] | 632 | ALOGW("No active metric for config %s", mConfigKey.ToString().c_str()); |
| 633 | return; |
| 634 | } |
| 635 | |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 636 | for (int i = 0; i < config.metric_size(); i++) { |
| 637 | const auto& activeMetric = config.metric(i); |
| 638 | for (int metricIndex : mMetricIndexesWithActivation) { |
| 639 | const auto& metric = mAllMetricProducers[metricIndex]; |
| 640 | if (metric->getMetricId() == activeMetric.id()) { |
| 641 | VLOG("Setting active metric: %lld", (long long)metric->getMetricId()); |
| 642 | metric->loadActiveMetric(activeMetric, currentTimeNs); |
Tej Singh | 16ca28f | 2019-06-24 11:58:23 -0700 | [diff] [blame] | 643 | if (!mIsActive && metric->isActive()) { |
| 644 | StatsdStats::getInstance().noteActiveStatusChanged(mConfigKey, |
| 645 | /*activate=*/ true); |
| 646 | } |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 647 | mIsActive |= metric->isActive(); |
Chenjie Yu | c7939cb | 2019-02-04 17:25:45 -0800 | [diff] [blame] | 648 | } |
| 649 | } |
| 650 | } |
| 651 | } |
| 652 | |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 653 | void MetricsManager::writeActiveConfigToProtoOutputStream( |
Tej Singh | f53d445 | 2019-05-09 18:17:59 -0700 | [diff] [blame] | 654 | int64_t currentTimeNs, const DumpReportReason reason, ProtoOutputStream* proto) { |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 655 | proto->write(FIELD_TYPE_INT64 | FIELD_ID_ACTIVE_CONFIG_ID, (long long)mConfigKey.GetId()); |
| 656 | proto->write(FIELD_TYPE_INT32 | FIELD_ID_ACTIVE_CONFIG_UID, mConfigKey.GetUid()); |
| 657 | for (int metricIndex : mMetricIndexesWithActivation) { |
| 658 | const auto& metric = mAllMetricProducers[metricIndex]; |
| 659 | const uint64_t metricToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| 660 | FIELD_ID_ACTIVE_CONFIG_METRIC); |
Tej Singh | f53d445 | 2019-05-09 18:17:59 -0700 | [diff] [blame] | 661 | metric->writeActiveMetricToProtoOutputStream(currentTimeNs, reason, proto); |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 662 | proto->end(metricToken); |
| 663 | } |
| 664 | } |
| 665 | |
Jeffrey Huang | b8f5403 | 2020-03-23 13:42:42 -0700 | [diff] [blame] | 666 | bool MetricsManager::writeMetadataToProto(int64_t currentWallClockTimeNs, |
| 667 | int64_t systemElapsedTimeNs, |
| 668 | metadata::StatsMetadata* statsMetadata) { |
| 669 | bool metadataWritten = false; |
| 670 | metadata::ConfigKey* configKey = statsMetadata->mutable_config_key(); |
| 671 | configKey->set_config_id(mConfigKey.GetId()); |
| 672 | configKey->set_uid(mConfigKey.GetUid()); |
| 673 | for (const auto& anomalyTracker : mAllAnomalyTrackers) { |
| 674 | metadata::AlertMetadata* alertMetadata = statsMetadata->add_alert_metadata(); |
| 675 | bool alertWritten = anomalyTracker->writeAlertMetadataToProto(currentWallClockTimeNs, |
| 676 | systemElapsedTimeNs, alertMetadata); |
| 677 | if (!alertWritten) { |
| 678 | statsMetadata->mutable_alert_metadata()->RemoveLast(); |
| 679 | } |
| 680 | metadataWritten |= alertWritten; |
| 681 | } |
| 682 | return metadataWritten; |
| 683 | } |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 684 | |
Jeffrey Huang | 475677e | 2020-03-30 19:52:07 -0700 | [diff] [blame] | 685 | void MetricsManager::loadMetadata(const metadata::StatsMetadata& metadata, |
| 686 | int64_t currentWallClockTimeNs, |
| 687 | int64_t systemElapsedTimeNs) { |
| 688 | for (const metadata::AlertMetadata& alertMetadata : metadata.alert_metadata()) { |
| 689 | int64_t alertId = alertMetadata.alert_id(); |
| 690 | auto it = mAlertTrackerMap.find(alertId); |
| 691 | if (it == mAlertTrackerMap.end()) { |
| 692 | ALOGE("No anomalyTracker found for alertId %lld", (long long) alertId); |
| 693 | continue; |
| 694 | } |
| 695 | mAllAnomalyTrackers[it->second]->loadAlertMetadata(alertMetadata, |
| 696 | currentWallClockTimeNs, |
| 697 | systemElapsedTimeNs); |
| 698 | } |
| 699 | } |
Muhammad Qureshi | 844694b | 2019-04-05 10:10:40 -0700 | [diff] [blame] | 700 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 701 | } // namespace statsd |
| 702 | } // namespace os |
| 703 | } // namespace android |