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" |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 18 | #include "MetricsManager.h" |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 19 | #include "statslog.h" |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 20 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 21 | #include "CountMetricProducer.h" |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 22 | #include "condition/CombinationConditionTracker.h" |
| 23 | #include "condition/SimpleConditionTracker.h" |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 24 | #include "guardrail/StatsdStats.h" |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 25 | #include "matchers/CombinationLogMatchingTracker.h" |
| 26 | #include "matchers/SimpleLogMatchingTracker.h" |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 27 | #include "metrics_manager_util.h" |
| 28 | #include "stats_util.h" |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 29 | #include "stats_log_util.h" |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 30 | |
Yao Chen | 93fe3a3 | 2017-11-02 13:52:59 -0700 | [diff] [blame] | 31 | #include <log/logprint.h> |
Bookatz | 6f19790 | 2018-02-05 12:30:14 -0800 | [diff] [blame] | 32 | #include <private/android_filesystem_config.h> |
David Chen | 1604957 | 2018-02-01 18:27:51 -0800 | [diff] [blame] | 33 | #include <utils/SystemClock.h> |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 34 | |
| 35 | using android::util::FIELD_COUNT_REPEATED; |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 36 | using android::util::FIELD_TYPE_INT32; |
| 37 | using android::util::FIELD_TYPE_INT64; |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 38 | using android::util::FIELD_TYPE_MESSAGE; |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 39 | using android::util::FIELD_TYPE_STRING; |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 40 | using android::util::ProtoOutputStream; |
| 41 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 42 | using std::make_unique; |
| 43 | using std::set; |
| 44 | using std::string; |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 45 | using std::unordered_map; |
| 46 | using std::vector; |
| 47 | |
| 48 | namespace android { |
| 49 | namespace os { |
| 50 | namespace statsd { |
| 51 | |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 52 | const int FIELD_ID_METRICS = 1; |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 53 | const int FIELD_ID_ANNOTATIONS = 7; |
| 54 | const int FIELD_ID_ANNOTATIONS_INT64 = 1; |
| 55 | const int FIELD_ID_ANNOTATIONS_INT32 = 2; |
Yao Chen | 288c600 | 2017-12-12 13:43:18 -0800 | [diff] [blame] | 56 | |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 57 | MetricsManager::MetricsManager(const ConfigKey& key, const StatsdConfig& config, |
Yangster-mac | 15f6bbc | 2018-04-08 11:52:26 -0700 | [diff] [blame] | 58 | const int64_t timeBaseNs, const int64_t currentTimeNs, |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 59 | const sp<UidMap> &uidMap, |
| 60 | const sp<AlarmMonitor>& anomalyAlarmMonitor, |
| 61 | const sp<AlarmMonitor>& periodicAlarmMonitor) |
Yangster-mac | 3fa5d7f | 2018-03-10 21:50:27 -0800 | [diff] [blame] | 62 | : mConfigKey(key), mUidMap(uidMap), |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 63 | mTtlNs(config.has_ttl_in_seconds() ? config.ttl_in_seconds() * NS_PER_SEC : -1), |
| 64 | mTtlEndNs(-1), |
David Chen | 4894490 | 2018-05-03 10:29:11 -0700 | [diff] [blame] | 65 | mLastReportTimeNs(currentTimeNs), |
Yangster-mac | 3fa5d7f | 2018-03-10 21:50:27 -0800 | [diff] [blame] | 66 | mLastReportWallClockNs(getWallClockNs()) { |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 67 | // Init the ttl end timestamp. |
Yangster-mac | 15f6bbc | 2018-04-08 11:52:26 -0700 | [diff] [blame] | 68 | refreshTtl(timeBaseNs); |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 69 | |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 70 | mConfigValid = |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 71 | initStatsdConfig(key, config, *uidMap, anomalyAlarmMonitor, periodicAlarmMonitor, |
Yangster-mac | 15f6bbc | 2018-04-08 11:52:26 -0700 | [diff] [blame] | 72 | timeBaseNs, currentTimeNs, mTagIds, mAllAtomMatchers, |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 73 | mAllConditionTrackers, mAllMetricProducers, mAllAnomalyTrackers, |
| 74 | mAllPeriodicAlarmTrackers, mConditionToMetricMap, mTrackerToMetricMap, |
| 75 | mTrackerToConditionMap, mNoReportMetricIds); |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 76 | |
Yao Chen | 147ce60 | 2017-12-22 14:35:34 -0800 | [diff] [blame] | 77 | if (config.allowed_log_source_size() == 0) { |
David Chen | 8faaa01 | 2018-02-28 15:54:36 -0800 | [diff] [blame] | 78 | mConfigValid = false; |
| 79 | ALOGE("Log source whitelist is empty! This config won't get any data. Suggest adding at " |
| 80 | "least AID_SYSTEM and AID_STATSD to the allowed_log_source field."); |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 81 | } else { |
Yao Chen | 147ce60 | 2017-12-22 14:35:34 -0800 | [diff] [blame] | 82 | for (const auto& source : config.allowed_log_source()) { |
| 83 | auto it = UidMap::sAidToUidMapping.find(source); |
| 84 | if (it != UidMap::sAidToUidMapping.end()) { |
| 85 | mAllowedUid.push_back(it->second); |
| 86 | } else { |
| 87 | mAllowedPkg.push_back(source); |
| 88 | } |
| 89 | } |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 90 | |
| 91 | if (mAllowedUid.size() + mAllowedPkg.size() > StatsdStats::kMaxLogSourceCount) { |
| 92 | ALOGE("Too many log sources. This is likely to be an error in the config."); |
| 93 | mConfigValid = false; |
| 94 | } else { |
| 95 | initLogSourceWhiteList(); |
| 96 | } |
| 97 | } |
| 98 | |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 99 | // Store the sub-configs used. |
| 100 | for (const auto& annotation : config.annotation()) { |
| 101 | mAnnotations.emplace_back(annotation.field_int64(), annotation.field_int32()); |
| 102 | } |
| 103 | |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 104 | // Guardrail. Reject the config if it's too big. |
| 105 | if (mAllMetricProducers.size() > StatsdStats::kMaxMetricCountPerConfig || |
| 106 | mAllConditionTrackers.size() > StatsdStats::kMaxConditionCountPerConfig || |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 107 | mAllAtomMatchers.size() > StatsdStats::kMaxMatcherCountPerConfig) { |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 108 | ALOGE("This config is too big! Reject!"); |
| 109 | mConfigValid = false; |
| 110 | } |
Bookatz | 1476ef2 | 2018-02-13 12:26:01 -0800 | [diff] [blame] | 111 | if (mAllAnomalyTrackers.size() > StatsdStats::kMaxAlertCountPerConfig) { |
| 112 | ALOGE("This config has too many alerts! Reject!"); |
| 113 | mConfigValid = false; |
| 114 | } |
Yao Chen | f09569f | 2017-12-13 17:00:51 -0800 | [diff] [blame] | 115 | // no matter whether this config is valid, log it in the stats. |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 116 | StatsdStats::getInstance().noteConfigReceived( |
| 117 | key, mAllMetricProducers.size(), mAllConditionTrackers.size(), mAllAtomMatchers.size(), |
| 118 | mAllAnomalyTrackers.size(), mAnnotations, mConfigValid); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 119 | } |
| 120 | |
| 121 | MetricsManager::~MetricsManager() { |
Bookatz | d3606c7 | 2017-10-19 10:13:49 -0700 | [diff] [blame] | 122 | VLOG("~MetricsManager()"); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 123 | } |
| 124 | |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 125 | void MetricsManager::initLogSourceWhiteList() { |
| 126 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 127 | mAllowedLogSources.clear(); |
| 128 | mAllowedLogSources.insert(mAllowedUid.begin(), mAllowedUid.end()); |
| 129 | |
| 130 | for (const auto& pkg : mAllowedPkg) { |
| 131 | auto uids = mUidMap->getAppUid(pkg); |
| 132 | mAllowedLogSources.insert(uids.begin(), uids.end()); |
| 133 | } |
| 134 | if (DEBUG) { |
| 135 | for (const auto& uid : mAllowedLogSources) { |
| 136 | VLOG("Allowed uid %d", uid); |
| 137 | } |
| 138 | } |
| 139 | } |
| 140 | |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 141 | bool MetricsManager::isConfigValid() const { |
| 142 | return mConfigValid; |
| 143 | } |
| 144 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 145 | 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] | 146 | const int64_t version) { |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 147 | // check if we care this package |
| 148 | if (std::find(mAllowedPkg.begin(), mAllowedPkg.end(), apk) == mAllowedPkg.end()) { |
| 149 | return; |
| 150 | } |
| 151 | // We will re-initialize the whole list because we don't want to keep the multi mapping of |
| 152 | // UID<->pkg inside MetricsManager to reduce the memory usage. |
| 153 | initLogSourceWhiteList(); |
| 154 | } |
| 155 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 156 | void MetricsManager::notifyAppRemoved(const int64_t& eventTimeNs, const string& apk, |
David Chen | 27785a8 | 2018-01-19 17:06:45 -0800 | [diff] [blame] | 157 | const int uid) { |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 158 | // check if we care this package |
| 159 | if (std::find(mAllowedPkg.begin(), mAllowedPkg.end(), apk) == mAllowedPkg.end()) { |
| 160 | return; |
| 161 | } |
| 162 | // We will re-initialize the whole list because we don't want to keep the multi mapping of |
| 163 | // UID<->pkg inside MetricsManager to reduce the memory usage. |
| 164 | initLogSourceWhiteList(); |
| 165 | } |
| 166 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 167 | void MetricsManager::onUidMapReceived(const int64_t& eventTimeNs) { |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 168 | if (mAllowedPkg.size() == 0) { |
| 169 | return; |
| 170 | } |
| 171 | initLogSourceWhiteList(); |
| 172 | } |
| 173 | |
Yao Chen | 884c8c1 | 2018-01-26 10:36:25 -0800 | [diff] [blame] | 174 | void MetricsManager::dumpStates(FILE* out, bool verbose) { |
| 175 | fprintf(out, "ConfigKey %s, allowed source:", mConfigKey.ToString().c_str()); |
| 176 | { |
| 177 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 178 | for (const auto& source : mAllowedLogSources) { |
| 179 | fprintf(out, "%d ", source); |
| 180 | } |
| 181 | } |
| 182 | fprintf(out, "\n"); |
| 183 | for (const auto& producer : mAllMetricProducers) { |
| 184 | producer->dumpStates(out, verbose); |
| 185 | } |
| 186 | } |
| 187 | |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 188 | void MetricsManager::dropData(const int64_t dropTimeNs) { |
Yao Chen | 06dba5d | 2018-01-26 13:38:16 -0800 | [diff] [blame] | 189 | for (const auto& producer : mAllMetricProducers) { |
| 190 | producer->dropData(dropTimeNs); |
| 191 | } |
| 192 | } |
| 193 | |
Yangster-mac | e68f3a5 | 2018-04-04 00:01:43 -0700 | [diff] [blame] | 194 | void MetricsManager::onDumpReport(const int64_t dumpTimeStampNs, |
| 195 | const bool include_current_partial_bucket, |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 196 | std::set<string> *str_set, |
Yangster-mac | e68f3a5 | 2018-04-04 00:01:43 -0700 | [diff] [blame] | 197 | ProtoOutputStream* protoOutput) { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 198 | VLOG("=========================Metric Reports Start=========================="); |
| 199 | // one StatsLogReport per MetricProduer |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 200 | for (const auto& producer : mAllMetricProducers) { |
| 201 | if (mNoReportMetricIds.find(producer->getMetricId()) == mNoReportMetricIds.end()) { |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 202 | uint64_t token = protoOutput->start( |
| 203 | FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_METRICS); |
| 204 | producer->onDumpReport(dumpTimeStampNs, include_current_partial_bucket, str_set, |
| 205 | protoOutput); |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 206 | protoOutput->end(token); |
Yangster-mac | a802d73 | 2018-04-24 07:50:38 -0700 | [diff] [blame] | 207 | } else { |
| 208 | producer->clearPastBuckets(dumpTimeStampNs); |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 209 | } |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 210 | } |
David Chen | faa1af5 | 2018-03-30 15:14:04 -0700 | [diff] [blame] | 211 | for (const auto& annotation : mAnnotations) { |
| 212 | uint64_t token = protoOutput->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| 213 | FIELD_ID_ANNOTATIONS); |
| 214 | protoOutput->write(FIELD_TYPE_INT64 | FIELD_ID_ANNOTATIONS_INT64, |
| 215 | (long long)annotation.first); |
| 216 | protoOutput->write(FIELD_TYPE_INT32 | FIELD_ID_ANNOTATIONS_INT32, annotation.second); |
| 217 | protoOutput->end(token); |
| 218 | } |
Yangster-mac | 9def8e3 | 2018-04-17 13:55:51 -0700 | [diff] [blame] | 219 | |
Yangster-mac | 330af58 | 2018-02-08 15:24:38 -0800 | [diff] [blame] | 220 | mLastReportTimeNs = dumpTimeStampNs; |
Yangster-mac | 3fa5d7f | 2018-03-10 21:50:27 -0800 | [diff] [blame] | 221 | mLastReportWallClockNs = getWallClockNs(); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 222 | VLOG("=========================Metric Reports End=========================="); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 223 | } |
| 224 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 225 | // Consume the stats log if it's interesting to this metric. |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 226 | void MetricsManager::onLogEvent(const LogEvent& event) { |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 227 | if (!mConfigValid) { |
| 228 | return; |
| 229 | } |
| 230 | |
David Chen | b639d14 | 2018-02-14 17:29:54 -0800 | [diff] [blame] | 231 | if (event.GetTagId() == android::util::APP_BREADCRUMB_REPORTED) { |
| 232 | // Check that app breadcrumb reported fields are valid. |
| 233 | // TODO: Find a way to make these checks easier to maintain. |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 234 | status_t err = NO_ERROR; |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 235 | |
| 236 | // Uid is 3rd from last field and must match the caller's uid, |
| 237 | // unless that caller is statsd itself (statsd is allowed to spoof uids). |
| 238 | long appHookUid = event.GetLong(event.size()-2, &err); |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 239 | if (err != NO_ERROR ) { |
| 240 | VLOG("APP_BREADCRUMB_REPORTED had error when parsing the uid"); |
| 241 | return; |
| 242 | } |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 243 | int32_t loggerUid = event.GetUid(); |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 244 | if (loggerUid != appHookUid && loggerUid != AID_STATSD) { |
| 245 | VLOG("APP_BREADCRUMB_REPORTED has invalid uid: claimed %ld but caller is %d", |
| 246 | appHookUid, loggerUid); |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 247 | return; |
| 248 | } |
Bookatz | b223c4e | 2018-02-01 15:35:04 -0800 | [diff] [blame] | 249 | |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 250 | // 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] | 251 | long appHookState = event.GetLong(event.size(), &err); |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 252 | if (err != NO_ERROR ) { |
| 253 | VLOG("APP_BREADCRUMB_REPORTED had error when parsing the state field"); |
| 254 | return; |
| 255 | } else if (appHookState < 0 || appHookState > 3) { |
| 256 | VLOG("APP_BREADCRUMB_REPORTED does not have valid state %ld", appHookState); |
David Chen | daa9f3a | 2017-12-28 16:52:22 -0800 | [diff] [blame] | 257 | return; |
| 258 | } |
Tej Singh | bb8554a | 2018-01-26 11:59:14 -0800 | [diff] [blame] | 259 | } else if (event.GetTagId() == android::util::DAVEY_OCCURRED) { |
| 260 | // Daveys can be logged from any app since they are logged in libs/hwui/JankTracker.cpp. |
| 261 | // Check that the davey duration is reasonable. Max length check is for privacy. |
| 262 | status_t err = NO_ERROR; |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 263 | |
| 264 | // Uid is the first field provided. |
| 265 | long jankUid = event.GetLong(1, &err); |
| 266 | if (err != NO_ERROR ) { |
| 267 | VLOG("Davey occurred had error when parsing the uid"); |
| 268 | return; |
| 269 | } |
| 270 | int32_t loggerUid = event.GetUid(); |
| 271 | if (loggerUid != jankUid && loggerUid != AID_STATSD) { |
| 272 | VLOG("DAVEY_OCCURRED has invalid uid: claimed %ld but caller is %d", jankUid, |
| 273 | loggerUid); |
| 274 | return; |
| 275 | } |
| 276 | |
Tej Singh | bb8554a | 2018-01-26 11:59:14 -0800 | [diff] [blame] | 277 | long duration = event.GetLong(event.size(), &err); |
David Chen | 77ef671 | 2018-02-23 18:23:42 -0800 | [diff] [blame] | 278 | if (err != NO_ERROR ) { |
| 279 | VLOG("Davey occurred had error when parsing the duration"); |
| 280 | return; |
| 281 | } else if (duration > 100000) { |
Tej Singh | bb8554a | 2018-01-26 11:59:14 -0800 | [diff] [blame] | 282 | VLOG("Davey duration is unreasonably long: %ld", duration); |
| 283 | return; |
| 284 | } |
| 285 | } else { |
| 286 | std::lock_guard<std::mutex> lock(mAllowedLogSourcesMutex); |
| 287 | if (mAllowedLogSources.find(event.GetUid()) == mAllowedLogSources.end()) { |
| 288 | VLOG("log source %d not on the whitelist", event.GetUid()); |
| 289 | return; |
| 290 | } |
Yao Chen | d10f7b1 | 2017-12-18 12:53:50 -0800 | [diff] [blame] | 291 | } |
| 292 | |
Joe Onorato | c4dfae5 | 2017-10-17 23:38:21 -0700 | [diff] [blame] | 293 | int tagId = event.GetTagId(); |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 294 | int64_t eventTime = event.GetElapsedTimestampNs(); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 295 | if (mTagIds.find(tagId) == mTagIds.end()) { |
| 296 | // not interesting... |
| 297 | return; |
| 298 | } |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 299 | |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 300 | vector<MatchingState> matcherCache(mAllAtomMatchers.size(), MatchingState::kNotComputed); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 301 | |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 302 | for (auto& matcher : mAllAtomMatchers) { |
| 303 | matcher->onLogEvent(event, mAllAtomMatchers, matcherCache); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 304 | } |
| 305 | |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 306 | // A bitmap to see which ConditionTracker needs to be re-evaluated. |
| 307 | vector<bool> conditionToBeEvaluated(mAllConditionTrackers.size(), false); |
| 308 | |
| 309 | for (const auto& pair : mTrackerToConditionMap) { |
| 310 | if (matcherCache[pair.first] == MatchingState::kMatched) { |
| 311 | const auto& conditionList = pair.second; |
| 312 | for (const int conditionIndex : conditionList) { |
| 313 | conditionToBeEvaluated[conditionIndex] = true; |
| 314 | } |
| 315 | } |
| 316 | } |
| 317 | |
| 318 | vector<ConditionState> conditionCache(mAllConditionTrackers.size(), |
| 319 | ConditionState::kNotEvaluated); |
| 320 | // A bitmap to track if a condition has changed value. |
| 321 | vector<bool> changedCache(mAllConditionTrackers.size(), false); |
| 322 | for (size_t i = 0; i < mAllConditionTrackers.size(); i++) { |
| 323 | if (conditionToBeEvaluated[i] == false) { |
| 324 | continue; |
| 325 | } |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 326 | sp<ConditionTracker>& condition = mAllConditionTrackers[i]; |
| 327 | condition->evaluateCondition(event, matcherCache, mAllConditionTrackers, conditionCache, |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 328 | changedCache); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 329 | } |
| 330 | |
| 331 | for (size_t i = 0; i < mAllConditionTrackers.size(); i++) { |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 332 | if (changedCache[i] == false) { |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 333 | continue; |
| 334 | } |
| 335 | auto pair = mConditionToMetricMap.find(i); |
| 336 | if (pair != mConditionToMetricMap.end()) { |
| 337 | auto& metricList = pair->second; |
| 338 | for (auto metricIndex : metricList) { |
| 339 | // metric cares about non sliced condition, and it's changed. |
| 340 | // Push the new condition to it directly. |
Yao Chen | 967b205 | 2017-11-07 16:36:43 -0800 | [diff] [blame] | 341 | if (!mAllMetricProducers[metricIndex]->isConditionSliced()) { |
Yao Chen | 5154a37 | 2017-10-30 22:57:06 -0700 | [diff] [blame] | 342 | mAllMetricProducers[metricIndex]->onConditionChanged(conditionCache[i], |
| 343 | eventTime); |
Yao Chen | 729093d | 2017-10-16 10:33:26 -0700 | [diff] [blame] | 344 | // metric cares about sliced conditions, and it may have changed. Send |
| 345 | // notification, and the metric can query the sliced conditions that are |
| 346 | // interesting to it. |
Yangster | f2bee6f | 2017-11-29 12:01:05 -0800 | [diff] [blame] | 347 | } else { |
Yao Chen | 427d372 | 2018-03-22 15:21:52 -0700 | [diff] [blame] | 348 | mAllMetricProducers[metricIndex]->onSlicedConditionMayChange(conditionCache[i], |
| 349 | eventTime); |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 350 | } |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 351 | } |
| 352 | } |
| 353 | } |
| 354 | |
Stefan Lafon | b8c9aa8 | 2017-12-03 14:27:25 -0800 | [diff] [blame] | 355 | // For matched AtomMatchers, tell relevant metrics that a matched event has come. |
| 356 | for (size_t i = 0; i < mAllAtomMatchers.size(); i++) { |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 357 | if (matcherCache[i] == MatchingState::kMatched) { |
Yao Chen | b356151 | 2017-11-21 18:07:17 -0800 | [diff] [blame] | 358 | StatsdStats::getInstance().noteMatcherMatched(mConfigKey, |
Yangster-mac | 94e197c | 2018-01-02 16:03:03 -0800 | [diff] [blame] | 359 | mAllAtomMatchers[i]->getId()); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 360 | auto pair = mTrackerToMetricMap.find(i); |
| 361 | if (pair != mTrackerToMetricMap.end()) { |
| 362 | auto& metricList = pair->second; |
| 363 | for (const int metricIndex : metricList) { |
Chenjie Yu | b3dda41 | 2017-10-24 13:41:59 -0700 | [diff] [blame] | 364 | // pushed metrics are never scheduled pulls |
Chenjie Yu | a7259ab | 2017-12-10 08:31:05 -0800 | [diff] [blame] | 365 | mAllMetricProducers[metricIndex]->onMatchedLogEvent(i, event); |
Yao Chen | caf339d | 2017-10-06 16:01:10 -0700 | [diff] [blame] | 366 | } |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 367 | } |
| 368 | } |
| 369 | } |
| 370 | } |
| 371 | |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 372 | void MetricsManager::onAnomalyAlarmFired( |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 373 | const int64_t& timestampNs, |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 374 | unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>>& alarmSet) { |
Yangster-mac | e2cd6d5 | 2017-11-09 20:38:30 -0800 | [diff] [blame] | 375 | for (const auto& itr : mAllAnomalyTrackers) { |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 376 | itr->informAlarmsFired(timestampNs, alarmSet); |
Yangster-mac | e2cd6d5 | 2017-11-09 20:38:30 -0800 | [diff] [blame] | 377 | } |
| 378 | } |
| 379 | |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 380 | void MetricsManager::onPeriodicAlarmFired( |
Yangster-mac | b142cc8 | 2018-03-30 15:22:08 -0700 | [diff] [blame] | 381 | const int64_t& timestampNs, |
Yangster-mac | 932ecec | 2018-02-01 10:23:52 -0800 | [diff] [blame] | 382 | unordered_set<sp<const InternalAlarm>, SpHash<InternalAlarm>>& alarmSet) { |
| 383 | for (const auto& itr : mAllPeriodicAlarmTrackers) { |
| 384 | itr->informAlarmsFired(timestampNs, alarmSet); |
Yangster-mac | e2cd6d5 | 2017-11-09 20:38:30 -0800 | [diff] [blame] | 385 | } |
| 386 | } |
| 387 | |
yro | 69007c8 | 2017-10-26 20:42:57 -0700 | [diff] [blame] | 388 | // Returns the total byte size of all metrics managed by a single config source. |
| 389 | size_t MetricsManager::byteSize() { |
| 390 | size_t totalSize = 0; |
| 391 | for (auto metricProducer : mAllMetricProducers) { |
| 392 | totalSize += metricProducer->byteSize(); |
| 393 | } |
| 394 | return totalSize; |
| 395 | } |
| 396 | |
Yao Chen | 44cf27c | 2017-09-14 22:32:50 -0700 | [diff] [blame] | 397 | } // namespace statsd |
| 398 | } // namespace os |
| 399 | } // namespace android |