| /* |
| * Copyright 2017, The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #define DEBUG false // STOPSHIP if true |
| #include "Log.h" |
| |
| #include "StatsdStats.h" |
| |
| #include <android/util/ProtoOutputStream.h> |
| #include "../stats_log_util.h" |
| #include "statslog_statsd.h" |
| #include "storage/StorageManager.h" |
| |
| namespace android { |
| namespace os { |
| namespace statsd { |
| |
| using android::util::FIELD_COUNT_REPEATED; |
| using android::util::FIELD_TYPE_BOOL; |
| using android::util::FIELD_TYPE_FLOAT; |
| using android::util::FIELD_TYPE_INT32; |
| using android::util::FIELD_TYPE_INT64; |
| using android::util::FIELD_TYPE_MESSAGE; |
| using android::util::FIELD_TYPE_STRING; |
| using android::util::ProtoOutputStream; |
| using std::lock_guard; |
| using std::shared_ptr; |
| using std::string; |
| using std::to_string; |
| using std::vector; |
| |
| const int FIELD_ID_BEGIN_TIME = 1; |
| const int FIELD_ID_END_TIME = 2; |
| const int FIELD_ID_CONFIG_STATS = 3; |
| const int FIELD_ID_ATOM_STATS = 7; |
| const int FIELD_ID_UIDMAP_STATS = 8; |
| const int FIELD_ID_ANOMALY_ALARM_STATS = 9; |
| const int FIELD_ID_PERIODIC_ALARM_STATS = 12; |
| const int FIELD_ID_SYSTEM_SERVER_RESTART = 15; |
| const int FIELD_ID_LOGGER_ERROR_STATS = 16; |
| const int FIELD_ID_OVERFLOW = 18; |
| const int FIELD_ID_ACTIVATION_BROADCAST_GUARDRAIL = 19; |
| |
| const int FIELD_ID_ATOM_STATS_TAG = 1; |
| const int FIELD_ID_ATOM_STATS_COUNT = 2; |
| const int FIELD_ID_ATOM_STATS_ERROR_COUNT = 3; |
| |
| const int FIELD_ID_ANOMALY_ALARMS_REGISTERED = 1; |
| const int FIELD_ID_PERIODIC_ALARMS_REGISTERED = 1; |
| |
| const int FIELD_ID_LOG_LOSS_STATS_TIME = 1; |
| const int FIELD_ID_LOG_LOSS_STATS_COUNT = 2; |
| const int FIELD_ID_LOG_LOSS_STATS_ERROR = 3; |
| const int FIELD_ID_LOG_LOSS_STATS_TAG = 4; |
| const int FIELD_ID_LOG_LOSS_STATS_UID = 5; |
| const int FIELD_ID_LOG_LOSS_STATS_PID = 6; |
| |
| const int FIELD_ID_OVERFLOW_COUNT = 1; |
| const int FIELD_ID_OVERFLOW_MAX_HISTORY = 2; |
| const int FIELD_ID_OVERFLOW_MIN_HISTORY = 3; |
| |
| const int FIELD_ID_CONFIG_STATS_UID = 1; |
| const int FIELD_ID_CONFIG_STATS_ID = 2; |
| const int FIELD_ID_CONFIG_STATS_CREATION = 3; |
| const int FIELD_ID_CONFIG_STATS_RESET = 19; |
| const int FIELD_ID_CONFIG_STATS_DELETION = 4; |
| const int FIELD_ID_CONFIG_STATS_METRIC_COUNT = 5; |
| const int FIELD_ID_CONFIG_STATS_CONDITION_COUNT = 6; |
| const int FIELD_ID_CONFIG_STATS_MATCHER_COUNT = 7; |
| const int FIELD_ID_CONFIG_STATS_ALERT_COUNT = 8; |
| const int FIELD_ID_CONFIG_STATS_VALID = 9; |
| const int FIELD_ID_CONFIG_STATS_BROADCAST = 10; |
| const int FIELD_ID_CONFIG_STATS_DATA_DROP_TIME = 11; |
| const int FIELD_ID_CONFIG_STATS_DATA_DROP_BYTES = 21; |
| const int FIELD_ID_CONFIG_STATS_DUMP_REPORT_TIME = 12; |
| const int FIELD_ID_CONFIG_STATS_DUMP_REPORT_BYTES = 20; |
| const int FIELD_ID_CONFIG_STATS_MATCHER_STATS = 13; |
| const int FIELD_ID_CONFIG_STATS_CONDITION_STATS = 14; |
| const int FIELD_ID_CONFIG_STATS_METRIC_STATS = 15; |
| const int FIELD_ID_CONFIG_STATS_ALERT_STATS = 16; |
| const int FIELD_ID_CONFIG_STATS_METRIC_DIMENSION_IN_CONDITION_STATS = 17; |
| const int FIELD_ID_CONFIG_STATS_ANNOTATION = 18; |
| const int FIELD_ID_CONFIG_STATS_ACTIVATION = 22; |
| const int FIELD_ID_CONFIG_STATS_DEACTIVATION = 23; |
| const int FIELD_ID_CONFIG_STATS_ANNOTATION_INT64 = 1; |
| const int FIELD_ID_CONFIG_STATS_ANNOTATION_INT32 = 2; |
| |
| const int FIELD_ID_MATCHER_STATS_ID = 1; |
| const int FIELD_ID_MATCHER_STATS_COUNT = 2; |
| const int FIELD_ID_CONDITION_STATS_ID = 1; |
| const int FIELD_ID_CONDITION_STATS_COUNT = 2; |
| const int FIELD_ID_METRIC_STATS_ID = 1; |
| const int FIELD_ID_METRIC_STATS_COUNT = 2; |
| const int FIELD_ID_ALERT_STATS_ID = 1; |
| const int FIELD_ID_ALERT_STATS_COUNT = 2; |
| |
| const int FIELD_ID_UID_MAP_CHANGES = 1; |
| const int FIELD_ID_UID_MAP_BYTES_USED = 2; |
| const int FIELD_ID_UID_MAP_DROPPED_CHANGES = 3; |
| const int FIELD_ID_UID_MAP_DELETED_APPS = 4; |
| |
| const int FIELD_ID_ACTIVATION_BROADCAST_GUARDRAIL_UID = 1; |
| const int FIELD_ID_ACTIVATION_BROADCAST_GUARDRAIL_TIME = 2; |
| |
| const std::map<int, std::pair<size_t, size_t>> StatsdStats::kAtomDimensionKeySizeLimitMap = { |
| {util::BINDER_CALLS, {6000, 10000}}, |
| {util::LOOPER_STATS, {1500, 2500}}, |
| {util::CPU_TIME_PER_UID_FREQ, {6000, 10000}}, |
| }; |
| |
| StatsdStats::StatsdStats() { |
| mPushedAtomStats.resize(kMaxPushedAtomId + 1); |
| mStartTimeSec = getWallClockSec(); |
| } |
| |
| StatsdStats& StatsdStats::getInstance() { |
| static StatsdStats statsInstance; |
| return statsInstance; |
| } |
| |
| void StatsdStats::addToIceBoxLocked(shared_ptr<ConfigStats>& stats) { |
| // The size of mIceBox grows strictly by one at a time. It won't be > kMaxIceBoxSize. |
| if (mIceBox.size() == kMaxIceBoxSize) { |
| mIceBox.pop_front(); |
| } |
| mIceBox.push_back(stats); |
| } |
| |
| void StatsdStats::noteConfigReceived( |
| const ConfigKey& key, int metricsCount, int conditionsCount, int matchersCount, |
| int alertsCount, const std::list<std::pair<const int64_t, const int32_t>>& annotations, |
| bool isValid) { |
| lock_guard<std::mutex> lock(mLock); |
| int32_t nowTimeSec = getWallClockSec(); |
| |
| // If there is an existing config for the same key, icebox the old config. |
| noteConfigRemovedInternalLocked(key); |
| |
| shared_ptr<ConfigStats> configStats = std::make_shared<ConfigStats>(); |
| configStats->uid = key.GetUid(); |
| configStats->id = key.GetId(); |
| configStats->creation_time_sec = nowTimeSec; |
| configStats->metric_count = metricsCount; |
| configStats->condition_count = conditionsCount; |
| configStats->matcher_count = matchersCount; |
| configStats->alert_count = alertsCount; |
| configStats->is_valid = isValid; |
| for (auto& v : annotations) { |
| configStats->annotations.emplace_back(v); |
| } |
| |
| if (isValid) { |
| mConfigStats[key] = configStats; |
| } else { |
| configStats->deletion_time_sec = nowTimeSec; |
| addToIceBoxLocked(configStats); |
| } |
| } |
| |
| void StatsdStats::noteConfigRemovedInternalLocked(const ConfigKey& key) { |
| auto it = mConfigStats.find(key); |
| if (it != mConfigStats.end()) { |
| int32_t nowTimeSec = getWallClockSec(); |
| it->second->deletion_time_sec = nowTimeSec; |
| addToIceBoxLocked(it->second); |
| mConfigStats.erase(it); |
| } |
| } |
| |
| void StatsdStats::noteConfigRemoved(const ConfigKey& key) { |
| lock_guard<std::mutex> lock(mLock); |
| noteConfigRemovedInternalLocked(key); |
| } |
| |
| void StatsdStats::noteConfigResetInternalLocked(const ConfigKey& key) { |
| auto it = mConfigStats.find(key); |
| if (it != mConfigStats.end()) { |
| it->second->reset_time_sec = getWallClockSec(); |
| } |
| } |
| |
| void StatsdStats::noteConfigReset(const ConfigKey& key) { |
| lock_guard<std::mutex> lock(mLock); |
| noteConfigResetInternalLocked(key); |
| } |
| |
| void StatsdStats::noteLogLost(int32_t wallClockTimeSec, int32_t count, int32_t lastError, |
| int32_t lastTag, int32_t uid, int32_t pid) { |
| lock_guard<std::mutex> lock(mLock); |
| if (mLogLossStats.size() == kMaxLoggerErrors) { |
| mLogLossStats.pop_front(); |
| } |
| mLogLossStats.emplace_back(wallClockTimeSec, count, lastError, lastTag, uid, pid); |
| } |
| |
| void StatsdStats::noteBroadcastSent(const ConfigKey& key) { |
| noteBroadcastSent(key, getWallClockSec()); |
| } |
| |
| void StatsdStats::noteBroadcastSent(const ConfigKey& key, int32_t timeSec) { |
| lock_guard<std::mutex> lock(mLock); |
| auto it = mConfigStats.find(key); |
| if (it == mConfigStats.end()) { |
| ALOGE("Config key %s not found!", key.ToString().c_str()); |
| return; |
| } |
| if (it->second->broadcast_sent_time_sec.size() == kMaxTimestampCount) { |
| it->second->broadcast_sent_time_sec.pop_front(); |
| } |
| it->second->broadcast_sent_time_sec.push_back(timeSec); |
| } |
| |
| void StatsdStats::noteActiveStatusChanged(const ConfigKey& key, bool activated) { |
| noteActiveStatusChanged(key, activated, getWallClockSec()); |
| } |
| |
| void StatsdStats::noteActiveStatusChanged(const ConfigKey& key, bool activated, int32_t timeSec) { |
| lock_guard<std::mutex> lock(mLock); |
| auto it = mConfigStats.find(key); |
| if (it == mConfigStats.end()) { |
| ALOGE("Config key %s not found!", key.ToString().c_str()); |
| return; |
| } |
| auto& vec = activated ? it->second->activation_time_sec |
| : it->second->deactivation_time_sec; |
| if (vec.size() == kMaxTimestampCount) { |
| vec.pop_front(); |
| } |
| vec.push_back(timeSec); |
| } |
| |
| void StatsdStats::noteActivationBroadcastGuardrailHit(const int uid) { |
| noteActivationBroadcastGuardrailHit(uid, getWallClockSec()); |
| } |
| |
| void StatsdStats::noteActivationBroadcastGuardrailHit(const int uid, const int32_t timeSec) { |
| lock_guard<std::mutex> lock(mLock); |
| auto& guardrailTimes = mActivationBroadcastGuardrailStats[uid]; |
| if (guardrailTimes.size() == kMaxTimestampCount) { |
| guardrailTimes.pop_front(); |
| } |
| guardrailTimes.push_back(timeSec); |
| } |
| |
| void StatsdStats::noteDataDropped(const ConfigKey& key, const size_t totalBytes) { |
| noteDataDropped(key, totalBytes, getWallClockSec()); |
| } |
| |
| void StatsdStats::noteEventQueueOverflow(int64_t oldestEventTimestampNs) { |
| lock_guard<std::mutex> lock(mLock); |
| |
| mOverflowCount++; |
| |
| int64_t history = getElapsedRealtimeNs() - oldestEventTimestampNs; |
| |
| if (history > mMaxQueueHistoryNs) { |
| mMaxQueueHistoryNs = history; |
| } |
| |
| if (history < mMinQueueHistoryNs) { |
| mMinQueueHistoryNs = history; |
| } |
| } |
| |
| void StatsdStats::noteDataDropped(const ConfigKey& key, const size_t totalBytes, int32_t timeSec) { |
| lock_guard<std::mutex> lock(mLock); |
| auto it = mConfigStats.find(key); |
| if (it == mConfigStats.end()) { |
| ALOGE("Config key %s not found!", key.ToString().c_str()); |
| return; |
| } |
| if (it->second->data_drop_time_sec.size() == kMaxTimestampCount) { |
| it->second->data_drop_time_sec.pop_front(); |
| it->second->data_drop_bytes.pop_front(); |
| } |
| it->second->data_drop_time_sec.push_back(timeSec); |
| it->second->data_drop_bytes.push_back(totalBytes); |
| } |
| |
| void StatsdStats::noteMetricsReportSent(const ConfigKey& key, const size_t num_bytes) { |
| noteMetricsReportSent(key, num_bytes, getWallClockSec()); |
| } |
| |
| void StatsdStats::noteMetricsReportSent(const ConfigKey& key, const size_t num_bytes, |
| int32_t timeSec) { |
| lock_guard<std::mutex> lock(mLock); |
| auto it = mConfigStats.find(key); |
| if (it == mConfigStats.end()) { |
| ALOGE("Config key %s not found!", key.ToString().c_str()); |
| return; |
| } |
| if (it->second->dump_report_stats.size() == kMaxTimestampCount) { |
| it->second->dump_report_stats.pop_front(); |
| } |
| it->second->dump_report_stats.push_back(std::make_pair(timeSec, num_bytes)); |
| } |
| |
| void StatsdStats::noteUidMapDropped(int deltas) { |
| lock_guard<std::mutex> lock(mLock); |
| mUidMapStats.dropped_changes += mUidMapStats.dropped_changes + deltas; |
| } |
| |
| void StatsdStats::noteUidMapAppDeletionDropped() { |
| lock_guard<std::mutex> lock(mLock); |
| mUidMapStats.deleted_apps++; |
| } |
| |
| void StatsdStats::setUidMapChanges(int changes) { |
| lock_guard<std::mutex> lock(mLock); |
| mUidMapStats.changes = changes; |
| } |
| |
| void StatsdStats::setCurrentUidMapMemory(int bytes) { |
| lock_guard<std::mutex> lock(mLock); |
| mUidMapStats.bytes_used = bytes; |
| } |
| |
| void StatsdStats::noteConditionDimensionSize(const ConfigKey& key, const int64_t& id, int size) { |
| lock_guard<std::mutex> lock(mLock); |
| // if name doesn't exist before, it will create the key with count 0. |
| auto statsIt = mConfigStats.find(key); |
| if (statsIt == mConfigStats.end()) { |
| return; |
| } |
| |
| auto& conditionSizeMap = statsIt->second->condition_stats; |
| if (size > conditionSizeMap[id]) { |
| conditionSizeMap[id] = size; |
| } |
| } |
| |
| void StatsdStats::noteMetricDimensionSize(const ConfigKey& key, const int64_t& id, int size) { |
| lock_guard<std::mutex> lock(mLock); |
| // if name doesn't exist before, it will create the key with count 0. |
| auto statsIt = mConfigStats.find(key); |
| if (statsIt == mConfigStats.end()) { |
| return; |
| } |
| auto& metricsDimensionMap = statsIt->second->metric_stats; |
| if (size > metricsDimensionMap[id]) { |
| metricsDimensionMap[id] = size; |
| } |
| } |
| |
| void StatsdStats::noteMetricDimensionInConditionSize( |
| const ConfigKey& key, const int64_t& id, int size) { |
| lock_guard<std::mutex> lock(mLock); |
| // if name doesn't exist before, it will create the key with count 0. |
| auto statsIt = mConfigStats.find(key); |
| if (statsIt == mConfigStats.end()) { |
| return; |
| } |
| auto& metricsDimensionMap = statsIt->second->metric_dimension_in_condition_stats; |
| if (size > metricsDimensionMap[id]) { |
| metricsDimensionMap[id] = size; |
| } |
| } |
| |
| void StatsdStats::noteMatcherMatched(const ConfigKey& key, const int64_t& id) { |
| lock_guard<std::mutex> lock(mLock); |
| |
| auto statsIt = mConfigStats.find(key); |
| if (statsIt == mConfigStats.end()) { |
| return; |
| } |
| statsIt->second->matcher_stats[id]++; |
| } |
| |
| void StatsdStats::noteAnomalyDeclared(const ConfigKey& key, const int64_t& id) { |
| lock_guard<std::mutex> lock(mLock); |
| auto statsIt = mConfigStats.find(key); |
| if (statsIt == mConfigStats.end()) { |
| return; |
| } |
| statsIt->second->alert_stats[id]++; |
| } |
| |
| void StatsdStats::noteRegisteredAnomalyAlarmChanged() { |
| lock_guard<std::mutex> lock(mLock); |
| mAnomalyAlarmRegisteredStats++; |
| } |
| |
| void StatsdStats::noteRegisteredPeriodicAlarmChanged() { |
| lock_guard<std::mutex> lock(mLock); |
| mPeriodicAlarmRegisteredStats++; |
| } |
| |
| void StatsdStats::updateMinPullIntervalSec(int pullAtomId, long intervalSec) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[pullAtomId].minPullIntervalSec = |
| std::min(mPulledAtomStats[pullAtomId].minPullIntervalSec, intervalSec); |
| } |
| |
| void StatsdStats::notePull(int pullAtomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[pullAtomId].totalPull++; |
| } |
| |
| void StatsdStats::notePullFromCache(int pullAtomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[pullAtomId].totalPullFromCache++; |
| } |
| |
| void StatsdStats::notePullTime(int pullAtomId, int64_t pullTimeNs) { |
| lock_guard<std::mutex> lock(mLock); |
| auto& pullStats = mPulledAtomStats[pullAtomId]; |
| pullStats.maxPullTimeNs = std::max(pullStats.maxPullTimeNs, pullTimeNs); |
| pullStats.avgPullTimeNs = (pullStats.avgPullTimeNs * pullStats.numPullTime + pullTimeNs) / |
| (pullStats.numPullTime + 1); |
| pullStats.numPullTime += 1; |
| } |
| |
| void StatsdStats::notePullDelay(int pullAtomId, int64_t pullDelayNs) { |
| lock_guard<std::mutex> lock(mLock); |
| auto& pullStats = mPulledAtomStats[pullAtomId]; |
| pullStats.maxPullDelayNs = std::max(pullStats.maxPullDelayNs, pullDelayNs); |
| pullStats.avgPullDelayNs = |
| (pullStats.avgPullDelayNs * pullStats.numPullDelay + pullDelayNs) / |
| (pullStats.numPullDelay + 1); |
| pullStats.numPullDelay += 1; |
| } |
| |
| void StatsdStats::notePullDataError(int pullAtomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[pullAtomId].dataError++; |
| } |
| |
| void StatsdStats::notePullTimeout(int pullAtomId, |
| int64_t pullUptimeMillis, |
| int64_t pullElapsedMillis) { |
| lock_guard<std::mutex> lock(mLock); |
| PulledAtomStats& pulledAtomStats = mPulledAtomStats[pullAtomId]; |
| pulledAtomStats.pullTimeout++; |
| |
| if (pulledAtomStats.pullTimeoutMetadata.size() == kMaxTimestampCount) { |
| pulledAtomStats.pullTimeoutMetadata.pop_front(); |
| } |
| |
| pulledAtomStats.pullTimeoutMetadata.emplace_back(pullUptimeMillis, pullElapsedMillis); |
| } |
| |
| void StatsdStats::notePullExceedMaxDelay(int pullAtomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[pullAtomId].pullExceedMaxDelay++; |
| } |
| |
| void StatsdStats::noteAtomLogged(int atomId, int32_t timeSec) { |
| lock_guard<std::mutex> lock(mLock); |
| |
| if (atomId >= 0 && atomId <= kMaxPushedAtomId) { |
| mPushedAtomStats[atomId]++; |
| } else { |
| if (atomId < 0) { |
| android_errorWriteLog(0x534e4554, "187957589"); |
| } |
| if (mNonPlatformPushedAtomStats.size() < kMaxNonPlatformPushedAtoms) { |
| mNonPlatformPushedAtomStats[atomId]++; |
| } |
| } |
| } |
| |
| void StatsdStats::noteSystemServerRestart(int32_t timeSec) { |
| lock_guard<std::mutex> lock(mLock); |
| |
| if (mSystemServerRestartSec.size() == kMaxSystemServerRestarts) { |
| mSystemServerRestartSec.pop_front(); |
| } |
| mSystemServerRestartSec.push_back(timeSec); |
| } |
| |
| void StatsdStats::notePullFailed(int atomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[atomId].pullFailed++; |
| } |
| |
| void StatsdStats::notePullUidProviderNotFound(int atomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[atomId].pullUidProviderNotFound++; |
| } |
| |
| void StatsdStats::notePullerNotFound(int atomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[atomId].pullerNotFound++; |
| } |
| |
| void StatsdStats::notePullBinderCallFailed(int atomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[atomId].binderCallFailCount++; |
| } |
| |
| void StatsdStats::noteEmptyData(int atomId) { |
| lock_guard<std::mutex> lock(mLock); |
| mPulledAtomStats[atomId].emptyData++; |
| } |
| |
| void StatsdStats::notePullerCallbackRegistrationChanged(int atomId, bool registered) { |
| lock_guard<std::mutex> lock(mLock); |
| if (registered) { |
| mPulledAtomStats[atomId].registeredCount++; |
| } else { |
| mPulledAtomStats[atomId].unregisteredCount++; |
| } |
| } |
| |
| void StatsdStats::noteHardDimensionLimitReached(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).hardDimensionLimitReached++; |
| } |
| |
| void StatsdStats::noteLateLogEventSkipped(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).lateLogEventSkipped++; |
| } |
| |
| void StatsdStats::noteSkippedForwardBuckets(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).skippedForwardBuckets++; |
| } |
| |
| void StatsdStats::noteBadValueType(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).badValueType++; |
| } |
| |
| void StatsdStats::noteBucketDropped(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).bucketDropped++; |
| } |
| |
| void StatsdStats::noteBucketUnknownCondition(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).bucketUnknownCondition++; |
| } |
| |
| void StatsdStats::noteConditionChangeInNextBucket(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).conditionChangeInNextBucket++; |
| } |
| |
| void StatsdStats::noteInvalidatedBucket(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).invalidatedBucket++; |
| } |
| |
| void StatsdStats::noteBucketCount(int64_t metricId) { |
| lock_guard<std::mutex> lock(mLock); |
| getAtomMetricStats(metricId).bucketCount++; |
| } |
| |
| void StatsdStats::noteBucketBoundaryDelayNs(int64_t metricId, int64_t timeDelayNs) { |
| lock_guard<std::mutex> lock(mLock); |
| AtomMetricStats& pullStats = getAtomMetricStats(metricId); |
| pullStats.maxBucketBoundaryDelayNs = |
| std::max(pullStats.maxBucketBoundaryDelayNs, timeDelayNs); |
| pullStats.minBucketBoundaryDelayNs = |
| std::min(pullStats.minBucketBoundaryDelayNs, timeDelayNs); |
| } |
| |
| void StatsdStats::noteAtomError(int atomTag, bool pull) { |
| lock_guard<std::mutex> lock(mLock); |
| if (pull) { |
| mPulledAtomStats[atomTag].atomErrorCount++; |
| return; |
| } |
| |
| bool present = (mPushedAtomErrorStats.find(atomTag) != mPushedAtomErrorStats.end()); |
| bool full = (mPushedAtomErrorStats.size() >= (size_t)kMaxPushedAtomErrorStatsSize); |
| if (!full || present) { |
| mPushedAtomErrorStats[atomTag]++; |
| } |
| } |
| |
| StatsdStats::AtomMetricStats& StatsdStats::getAtomMetricStats(int64_t metricId) { |
| auto atomMetricStatsIter = mAtomMetricStats.find(metricId); |
| if (atomMetricStatsIter != mAtomMetricStats.end()) { |
| return atomMetricStatsIter->second; |
| } |
| auto emplaceResult = mAtomMetricStats.emplace(metricId, AtomMetricStats()); |
| return emplaceResult.first->second; |
| } |
| |
| void StatsdStats::reset() { |
| lock_guard<std::mutex> lock(mLock); |
| resetInternalLocked(); |
| } |
| |
| void StatsdStats::resetInternalLocked() { |
| // Reset the historical data, but keep the active ConfigStats |
| mStartTimeSec = getWallClockSec(); |
| mIceBox.clear(); |
| std::fill(mPushedAtomStats.begin(), mPushedAtomStats.end(), 0); |
| mNonPlatformPushedAtomStats.clear(); |
| mAnomalyAlarmRegisteredStats = 0; |
| mPeriodicAlarmRegisteredStats = 0; |
| mSystemServerRestartSec.clear(); |
| mLogLossStats.clear(); |
| mOverflowCount = 0; |
| mMinQueueHistoryNs = kInt64Max; |
| mMaxQueueHistoryNs = 0; |
| for (auto& config : mConfigStats) { |
| config.second->broadcast_sent_time_sec.clear(); |
| config.second->activation_time_sec.clear(); |
| config.second->deactivation_time_sec.clear(); |
| config.second->data_drop_time_sec.clear(); |
| config.second->data_drop_bytes.clear(); |
| config.second->dump_report_stats.clear(); |
| config.second->annotations.clear(); |
| config.second->matcher_stats.clear(); |
| config.second->condition_stats.clear(); |
| config.second->metric_stats.clear(); |
| config.second->metric_dimension_in_condition_stats.clear(); |
| config.second->alert_stats.clear(); |
| } |
| for (auto& pullStats : mPulledAtomStats) { |
| pullStats.second.totalPull = 0; |
| pullStats.second.totalPullFromCache = 0; |
| pullStats.second.minPullIntervalSec = LONG_MAX; |
| pullStats.second.avgPullTimeNs = 0; |
| pullStats.second.maxPullTimeNs = 0; |
| pullStats.second.numPullTime = 0; |
| pullStats.second.avgPullDelayNs = 0; |
| pullStats.second.maxPullDelayNs = 0; |
| pullStats.second.numPullDelay = 0; |
| pullStats.second.dataError = 0; |
| pullStats.second.pullTimeout = 0; |
| pullStats.second.pullExceedMaxDelay = 0; |
| pullStats.second.pullFailed = 0; |
| pullStats.second.pullUidProviderNotFound = 0; |
| pullStats.second.pullerNotFound = 0; |
| pullStats.second.registeredCount = 0; |
| pullStats.second.unregisteredCount = 0; |
| pullStats.second.atomErrorCount = 0; |
| pullStats.second.binderCallFailCount = 0; |
| pullStats.second.pullTimeoutMetadata.clear(); |
| } |
| mAtomMetricStats.clear(); |
| mActivationBroadcastGuardrailStats.clear(); |
| mPushedAtomErrorStats.clear(); |
| } |
| |
| string buildTimeString(int64_t timeSec) { |
| time_t t = timeSec; |
| struct tm* tm = localtime(&t); |
| char timeBuffer[80]; |
| strftime(timeBuffer, sizeof(timeBuffer), "%Y-%m-%d %I:%M%p", tm); |
| return string(timeBuffer); |
| } |
| |
| int StatsdStats::getPushedAtomErrors(int atomId) const { |
| const auto& it = mPushedAtomErrorStats.find(atomId); |
| if (it != mPushedAtomErrorStats.end()) { |
| return it->second; |
| } else { |
| return 0; |
| } |
| } |
| |
| void StatsdStats::dumpStats(int out) const { |
| lock_guard<std::mutex> lock(mLock); |
| time_t t = mStartTimeSec; |
| struct tm* tm = localtime(&t); |
| char timeBuffer[80]; |
| strftime(timeBuffer, sizeof(timeBuffer), "%Y-%m-%d %I:%M%p\n", tm); |
| dprintf(out, "Stats collection start second: %s\n", timeBuffer); |
| dprintf(out, "%lu Config in icebox: \n", (unsigned long)mIceBox.size()); |
| for (const auto& configStats : mIceBox) { |
| dprintf(out, |
| "Config {%d_%lld}: creation=%d, deletion=%d, reset=%d, #metric=%d, #condition=%d, " |
| "#matcher=%d, #alert=%d, valid=%d\n", |
| configStats->uid, (long long)configStats->id, configStats->creation_time_sec, |
| configStats->deletion_time_sec, configStats->reset_time_sec, |
| configStats->metric_count, configStats->condition_count, configStats->matcher_count, |
| configStats->alert_count, configStats->is_valid); |
| |
| for (const auto& broadcastTime : configStats->broadcast_sent_time_sec) { |
| dprintf(out, "\tbroadcast time: %d\n", broadcastTime); |
| } |
| |
| for (const int& activationTime : configStats->activation_time_sec) { |
| dprintf(out, "\tactivation time: %d\n", activationTime); |
| } |
| |
| for (const int& deactivationTime : configStats->deactivation_time_sec) { |
| dprintf(out, "\tdeactivation time: %d\n", deactivationTime); |
| } |
| |
| auto dropTimePtr = configStats->data_drop_time_sec.begin(); |
| auto dropBytesPtr = configStats->data_drop_bytes.begin(); |
| for (int i = 0; i < (int)configStats->data_drop_time_sec.size(); |
| i++, dropTimePtr++, dropBytesPtr++) { |
| dprintf(out, "\tdata drop time: %d with size %lld", *dropTimePtr, |
| (long long)*dropBytesPtr); |
| } |
| } |
| dprintf(out, "%lu Active Configs\n", (unsigned long)mConfigStats.size()); |
| for (auto& pair : mConfigStats) { |
| auto& configStats = pair.second; |
| dprintf(out, |
| "Config {%d-%lld}: creation=%d, deletion=%d, #metric=%d, #condition=%d, " |
| "#matcher=%d, #alert=%d, valid=%d\n", |
| configStats->uid, (long long)configStats->id, configStats->creation_time_sec, |
| configStats->deletion_time_sec, configStats->metric_count, |
| configStats->condition_count, configStats->matcher_count, configStats->alert_count, |
| configStats->is_valid); |
| for (const auto& annotation : configStats->annotations) { |
| dprintf(out, "\tannotation: %lld, %d\n", (long long)annotation.first, |
| annotation.second); |
| } |
| |
| for (const auto& broadcastTime : configStats->broadcast_sent_time_sec) { |
| dprintf(out, "\tbroadcast time: %s(%lld)\n", buildTimeString(broadcastTime).c_str(), |
| (long long)broadcastTime); |
| } |
| |
| for (const int& activationTime : configStats->activation_time_sec) { |
| dprintf(out, "\tactivation time: %d\n", activationTime); |
| } |
| |
| for (const int& deactivationTime : configStats->deactivation_time_sec) { |
| dprintf(out, "\tdeactivation time: %d\n", deactivationTime); |
| } |
| |
| auto dropTimePtr = configStats->data_drop_time_sec.begin(); |
| auto dropBytesPtr = configStats->data_drop_bytes.begin(); |
| for (int i = 0; i < (int)configStats->data_drop_time_sec.size(); |
| i++, dropTimePtr++, dropBytesPtr++) { |
| dprintf(out, "\tdata drop time: %s(%lld) with %lld bytes\n", |
| buildTimeString(*dropTimePtr).c_str(), (long long)*dropTimePtr, |
| (long long)*dropBytesPtr); |
| } |
| |
| for (const auto& dump : configStats->dump_report_stats) { |
| dprintf(out, "\tdump report time: %s(%lld) bytes: %lld\n", |
| buildTimeString(dump.first).c_str(), (long long)dump.first, |
| (long long)dump.second); |
| } |
| |
| for (const auto& stats : pair.second->matcher_stats) { |
| dprintf(out, "matcher %lld matched %d times\n", (long long)stats.first, stats.second); |
| } |
| |
| for (const auto& stats : pair.second->condition_stats) { |
| dprintf(out, "condition %lld max output tuple size %d\n", (long long)stats.first, |
| stats.second); |
| } |
| |
| for (const auto& stats : pair.second->condition_stats) { |
| dprintf(out, "metrics %lld max output tuple size %d\n", (long long)stats.first, |
| stats.second); |
| } |
| |
| for (const auto& stats : pair.second->alert_stats) { |
| dprintf(out, "alert %lld declared %d times\n", (long long)stats.first, stats.second); |
| } |
| } |
| dprintf(out, "********Disk Usage stats***********\n"); |
| StorageManager::printStats(out); |
| dprintf(out, "********Pushed Atom stats***********\n"); |
| const size_t atomCounts = mPushedAtomStats.size(); |
| for (size_t i = 2; i < atomCounts; i++) { |
| if (mPushedAtomStats[i] > 0) { |
| dprintf(out, "Atom %zu->(total count)%d, (error count)%d\n", i, mPushedAtomStats[i], |
| getPushedAtomErrors((int)i)); |
| } |
| } |
| for (const auto& pair : mNonPlatformPushedAtomStats) { |
| dprintf(out, "Atom %d->(total count)%d, (error count)%d\n", pair.first, pair.second, |
| getPushedAtomErrors(pair.first)); |
| } |
| |
| dprintf(out, "********Pulled Atom stats***********\n"); |
| for (const auto& pair : mPulledAtomStats) { |
| dprintf(out, |
| "Atom %d->(total pull)%ld, (pull from cache)%ld, " |
| "(pull failed)%ld, (min pull interval)%ld \n" |
| " (average pull time nanos)%lld, (max pull time nanos)%lld, (average pull delay " |
| "nanos)%lld, " |
| " (max pull delay nanos)%lld, (data error)%ld\n" |
| " (pull timeout)%ld, (pull exceed max delay)%ld" |
| " (no uid provider count)%ld, (no puller found count)%ld\n" |
| " (registered count) %ld, (unregistered count) %ld" |
| " (atom error count) %d\n", |
| (int)pair.first, (long)pair.second.totalPull, (long)pair.second.totalPullFromCache, |
| (long)pair.second.pullFailed, (long)pair.second.minPullIntervalSec, |
| (long long)pair.second.avgPullTimeNs, (long long)pair.second.maxPullTimeNs, |
| (long long)pair.second.avgPullDelayNs, (long long)pair.second.maxPullDelayNs, |
| pair.second.dataError, pair.second.pullTimeout, pair.second.pullExceedMaxDelay, |
| pair.second.pullUidProviderNotFound, pair.second.pullerNotFound, |
| pair.second.registeredCount, pair.second.unregisteredCount, |
| pair.second.atomErrorCount); |
| if (pair.second.pullTimeoutMetadata.size() > 0) { |
| string uptimeMillis = "(pull timeout system uptime millis) "; |
| string pullTimeoutMillis = "(pull timeout elapsed time millis) "; |
| for (const auto& stats : pair.second.pullTimeoutMetadata) { |
| uptimeMillis.append(to_string(stats.pullTimeoutUptimeMillis)).append(",");; |
| pullTimeoutMillis.append(to_string(stats.pullTimeoutElapsedMillis)).append(","); |
| } |
| uptimeMillis.pop_back(); |
| uptimeMillis.push_back('\n'); |
| pullTimeoutMillis.pop_back(); |
| pullTimeoutMillis.push_back('\n'); |
| dprintf(out, "%s", uptimeMillis.c_str()); |
| dprintf(out, "%s", pullTimeoutMillis.c_str()); |
| } |
| } |
| |
| if (mAnomalyAlarmRegisteredStats > 0) { |
| dprintf(out, "********AnomalyAlarmStats stats***********\n"); |
| dprintf(out, "Anomaly alarm registrations: %d\n", mAnomalyAlarmRegisteredStats); |
| } |
| |
| if (mPeriodicAlarmRegisteredStats > 0) { |
| dprintf(out, "********SubscriberAlarmStats stats***********\n"); |
| dprintf(out, "Subscriber alarm registrations: %d\n", mPeriodicAlarmRegisteredStats); |
| } |
| |
| dprintf(out, "UID map stats: bytes=%d, changes=%d, deleted=%d, changes lost=%d\n", |
| mUidMapStats.bytes_used, mUidMapStats.changes, mUidMapStats.deleted_apps, |
| mUidMapStats.dropped_changes); |
| |
| for (const auto& restart : mSystemServerRestartSec) { |
| dprintf(out, "System server restarts at %s(%lld)\n", buildTimeString(restart).c_str(), |
| (long long)restart); |
| } |
| |
| for (const auto& loss : mLogLossStats) { |
| dprintf(out, |
| "Log loss: %lld (wall clock sec) - %d (count), %d (last error), %d (last tag), %d " |
| "(uid), %d (pid)\n", |
| (long long)loss.mWallClockSec, loss.mCount, loss.mLastError, loss.mLastTag, |
| loss.mUid, loss.mPid); |
| } |
| |
| dprintf(out, "Event queue overflow: %d; MaxHistoryNs: %lld; MinHistoryNs: %lld\n", |
| mOverflowCount, (long long)mMaxQueueHistoryNs, (long long)mMinQueueHistoryNs); |
| |
| if (mActivationBroadcastGuardrailStats.size() > 0) { |
| dprintf(out, "********mActivationBroadcastGuardrail stats***********\n"); |
| for (const auto& pair: mActivationBroadcastGuardrailStats) { |
| dprintf(out, "Uid %d: Times: ", pair.first); |
| for (const auto& guardrailHitTime : pair.second) { |
| dprintf(out, "%d ", guardrailHitTime); |
| } |
| } |
| dprintf(out, "\n"); |
| } |
| } |
| |
| void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* proto) { |
| uint64_t token = |
| proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_CONFIG_STATS); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_UID, configStats.uid); |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_ID, (long long)configStats.id); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_CREATION, configStats.creation_time_sec); |
| if (configStats.reset_time_sec != 0) { |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_RESET, configStats.reset_time_sec); |
| } |
| if (configStats.deletion_time_sec != 0) { |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DELETION, |
| configStats.deletion_time_sec); |
| } |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_METRIC_COUNT, configStats.metric_count); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_CONDITION_COUNT, |
| configStats.condition_count); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_MATCHER_COUNT, configStats.matcher_count); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_ALERT_COUNT, configStats.alert_count); |
| proto->write(FIELD_TYPE_BOOL | FIELD_ID_CONFIG_STATS_VALID, configStats.is_valid); |
| |
| for (const auto& broadcast : configStats.broadcast_sent_time_sec) { |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_BROADCAST | FIELD_COUNT_REPEATED, |
| broadcast); |
| } |
| |
| for (const auto& activation : configStats.activation_time_sec) { |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_ACTIVATION | FIELD_COUNT_REPEATED, |
| activation); |
| } |
| |
| for (const auto& deactivation : configStats.deactivation_time_sec) { |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DEACTIVATION | FIELD_COUNT_REPEATED, |
| deactivation); |
| } |
| |
| for (const auto& drop_time : configStats.data_drop_time_sec) { |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DATA_DROP_TIME | FIELD_COUNT_REPEATED, |
| drop_time); |
| } |
| |
| for (const auto& drop_bytes : configStats.data_drop_bytes) { |
| proto->write( |
| FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_DATA_DROP_BYTES | FIELD_COUNT_REPEATED, |
| (long long)drop_bytes); |
| } |
| |
| for (const auto& dump : configStats.dump_report_stats) { |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DUMP_REPORT_TIME | |
| FIELD_COUNT_REPEATED, |
| dump.first); |
| } |
| |
| for (const auto& dump : configStats.dump_report_stats) { |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_DUMP_REPORT_BYTES | |
| FIELD_COUNT_REPEATED, |
| (long long)dump.second); |
| } |
| |
| for (const auto& annotation : configStats.annotations) { |
| uint64_t token = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| FIELD_ID_CONFIG_STATS_ANNOTATION); |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_ANNOTATION_INT64, |
| (long long)annotation.first); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_ANNOTATION_INT32, annotation.second); |
| proto->end(token); |
| } |
| |
| for (const auto& pair : configStats.matcher_stats) { |
| uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| FIELD_ID_CONFIG_STATS_MATCHER_STATS); |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_MATCHER_STATS_ID, (long long)pair.first); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_MATCHER_STATS_COUNT, pair.second); |
| proto->end(tmpToken); |
| } |
| |
| for (const auto& pair : configStats.condition_stats) { |
| uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| FIELD_ID_CONFIG_STATS_CONDITION_STATS); |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONDITION_STATS_ID, (long long)pair.first); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONDITION_STATS_COUNT, pair.second); |
| proto->end(tmpToken); |
| } |
| |
| for (const auto& pair : configStats.metric_stats) { |
| uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| FIELD_ID_CONFIG_STATS_METRIC_STATS); |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_METRIC_STATS_ID, (long long)pair.first); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_METRIC_STATS_COUNT, pair.second); |
| proto->end(tmpToken); |
| } |
| for (const auto& pair : configStats.metric_dimension_in_condition_stats) { |
| uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| FIELD_ID_CONFIG_STATS_METRIC_DIMENSION_IN_CONDITION_STATS); |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_METRIC_STATS_ID, (long long)pair.first); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_METRIC_STATS_COUNT, pair.second); |
| proto->end(tmpToken); |
| } |
| |
| for (const auto& pair : configStats.alert_stats) { |
| uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | |
| FIELD_ID_CONFIG_STATS_ALERT_STATS); |
| proto->write(FIELD_TYPE_INT64 | FIELD_ID_ALERT_STATS_ID, (long long)pair.first); |
| proto->write(FIELD_TYPE_INT32 | FIELD_ID_ALERT_STATS_COUNT, pair.second); |
| proto->end(tmpToken); |
| } |
| |
| proto->end(token); |
| } |
| |
| void StatsdStats::dumpStats(std::vector<uint8_t>* output, bool reset) { |
| lock_guard<std::mutex> lock(mLock); |
| |
| ProtoOutputStream proto; |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_BEGIN_TIME, mStartTimeSec); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_END_TIME, (int32_t)getWallClockSec()); |
| |
| for (const auto& configStats : mIceBox) { |
| addConfigStatsToProto(*configStats, &proto); |
| } |
| |
| for (auto& pair : mConfigStats) { |
| addConfigStatsToProto(*(pair.second), &proto); |
| } |
| |
| const size_t atomCounts = mPushedAtomStats.size(); |
| for (size_t i = 2; i < atomCounts; i++) { |
| if (mPushedAtomStats[i] > 0) { |
| uint64_t token = |
| proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ATOM_STATS | FIELD_COUNT_REPEATED); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_TAG, (int32_t)i); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_COUNT, mPushedAtomStats[i]); |
| int errors = getPushedAtomErrors(i); |
| if (errors > 0) { |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_ERROR_COUNT, errors); |
| } |
| proto.end(token); |
| } |
| } |
| |
| for (const auto& pair : mNonPlatformPushedAtomStats) { |
| uint64_t token = |
| proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ATOM_STATS | FIELD_COUNT_REPEATED); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_TAG, pair.first); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_COUNT, pair.second); |
| int errors = getPushedAtomErrors(pair.first); |
| if (errors > 0) { |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_ERROR_COUNT, errors); |
| } |
| proto.end(token); |
| } |
| |
| for (const auto& pair : mPulledAtomStats) { |
| android::os::statsd::writePullerStatsToStream(pair, &proto); |
| } |
| |
| for (const auto& pair : mAtomMetricStats) { |
| android::os::statsd::writeAtomMetricStatsToStream(pair, &proto); |
| } |
| |
| if (mAnomalyAlarmRegisteredStats > 0) { |
| uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ANOMALY_ALARM_STATS); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ANOMALY_ALARMS_REGISTERED, |
| mAnomalyAlarmRegisteredStats); |
| proto.end(token); |
| } |
| |
| if (mPeriodicAlarmRegisteredStats > 0) { |
| uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_PERIODIC_ALARM_STATS); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_PERIODIC_ALARMS_REGISTERED, |
| mPeriodicAlarmRegisteredStats); |
| proto.end(token); |
| } |
| |
| uint64_t uidMapToken = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_UIDMAP_STATS); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_CHANGES, mUidMapStats.changes); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_BYTES_USED, mUidMapStats.bytes_used); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_DROPPED_CHANGES, mUidMapStats.dropped_changes); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_DELETED_APPS, mUidMapStats.deleted_apps); |
| proto.end(uidMapToken); |
| |
| for (const auto& error : mLogLossStats) { |
| uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_LOGGER_ERROR_STATS | |
| FIELD_COUNT_REPEATED); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOG_LOSS_STATS_TIME, error.mWallClockSec); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOG_LOSS_STATS_COUNT, error.mCount); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOG_LOSS_STATS_ERROR, error.mLastError); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOG_LOSS_STATS_TAG, error.mLastTag); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOG_LOSS_STATS_UID, error.mUid); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOG_LOSS_STATS_PID, error.mPid); |
| proto.end(token); |
| } |
| |
| if (mOverflowCount > 0) { |
| uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_OVERFLOW); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_OVERFLOW_COUNT, (int32_t)mOverflowCount); |
| proto.write(FIELD_TYPE_INT64 | FIELD_ID_OVERFLOW_MAX_HISTORY, |
| (long long)mMaxQueueHistoryNs); |
| proto.write(FIELD_TYPE_INT64 | FIELD_ID_OVERFLOW_MIN_HISTORY, |
| (long long)mMinQueueHistoryNs); |
| proto.end(token); |
| } |
| |
| for (const auto& restart : mSystemServerRestartSec) { |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_SYSTEM_SERVER_RESTART | FIELD_COUNT_REPEATED, |
| restart); |
| } |
| |
| for (const auto& pair: mActivationBroadcastGuardrailStats) { |
| uint64_t token = proto.start(FIELD_TYPE_MESSAGE | |
| FIELD_ID_ACTIVATION_BROADCAST_GUARDRAIL | |
| FIELD_COUNT_REPEATED); |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ACTIVATION_BROADCAST_GUARDRAIL_UID, |
| (int32_t) pair.first); |
| for (const auto& guardrailHitTime : pair.second) { |
| proto.write(FIELD_TYPE_INT32 | FIELD_ID_ACTIVATION_BROADCAST_GUARDRAIL_TIME | |
| FIELD_COUNT_REPEATED, |
| guardrailHitTime); |
| } |
| proto.end(token); |
| } |
| |
| output->clear(); |
| size_t bufferSize = proto.size(); |
| output->resize(bufferSize); |
| |
| size_t pos = 0; |
| sp<android::util::ProtoReader> reader = proto.data(); |
| while (reader->readBuffer() != NULL) { |
| size_t toRead = reader->currentToRead(); |
| std::memcpy(&((*output)[pos]), reader->readBuffer(), toRead); |
| pos += toRead; |
| reader->move(toRead); |
| } |
| |
| if (reset) { |
| resetInternalLocked(); |
| } |
| |
| VLOG("reset=%d, returned proto size %lu", reset, (unsigned long)bufferSize); |
| } |
| |
| } // namespace statsd |
| } // namespace os |
| } // namespace android |
