StatsdStats.cpp revision bd12527c90d55eefa657e6a71cfdd287ecdb4ab3
1/* 2 * Copyright 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 */ 16#define DEBUG false // STOPSHIP if true 17#include "Log.h" 18 19#include "StatsdStats.h" 20 21#include <android/util/ProtoOutputStream.h> 22#include "../stats_log_util.h" 23#include "statslog.h" 24#include "storage/StorageManager.h" 25 26namespace android { 27namespace os { 28namespace statsd { 29 30using android::util::FIELD_COUNT_REPEATED; 31using android::util::FIELD_TYPE_BOOL; 32using android::util::FIELD_TYPE_FLOAT; 33using android::util::FIELD_TYPE_INT32; 34using android::util::FIELD_TYPE_INT64; 35using android::util::FIELD_TYPE_MESSAGE; 36using android::util::FIELD_TYPE_STRING; 37using android::util::ProtoOutputStream; 38using std::lock_guard; 39using std::map; 40using std::shared_ptr; 41using std::string; 42using std::vector; 43 44const int FIELD_ID_BEGIN_TIME = 1; 45const int FIELD_ID_END_TIME = 2; 46const int FIELD_ID_CONFIG_STATS = 3; 47const int FIELD_ID_ATOM_STATS = 7; 48const int FIELD_ID_UIDMAP_STATS = 8; 49const int FIELD_ID_ANOMALY_ALARM_STATS = 9; 50// const int FIELD_ID_PULLED_ATOM_STATS = 10; // The proto is written in stats_log_util.cpp 51const int FIELD_ID_LOGGER_ERROR_STATS = 11; 52const int FIELD_ID_SUBSCRIBER_ALARM_STATS = 12; 53 54const int FIELD_ID_ATOM_STATS_TAG = 1; 55const int FIELD_ID_ATOM_STATS_COUNT = 2; 56 57const int FIELD_ID_ANOMALY_ALARMS_REGISTERED = 1; 58const int FIELD_ID_SUBSCRIBER_ALARMS_REGISTERED = 1; 59 60const int FIELD_ID_LOGGER_STATS_TIME = 1; 61const int FIELD_ID_LOGGER_STATS_ERROR_CODE = 2; 62 63const int FIELD_ID_CONFIG_STATS_UID = 1; 64const int FIELD_ID_CONFIG_STATS_ID = 2; 65const int FIELD_ID_CONFIG_STATS_CREATION = 3; 66const int FIELD_ID_CONFIG_STATS_RESET = 18; 67const int FIELD_ID_CONFIG_STATS_DELETION = 4; 68const int FIELD_ID_CONFIG_STATS_METRIC_COUNT = 5; 69const int FIELD_ID_CONFIG_STATS_CONDITION_COUNT = 6; 70const int FIELD_ID_CONFIG_STATS_MATCHER_COUNT = 7; 71const int FIELD_ID_CONFIG_STATS_ALERT_COUNT = 8; 72const int FIELD_ID_CONFIG_STATS_VALID = 9; 73const int FIELD_ID_CONFIG_STATS_BROADCAST = 10; 74const int FIELD_ID_CONFIG_STATS_DATA_DROP = 11; 75const int FIELD_ID_CONFIG_STATS_DUMP_REPORT = 12; 76const int FIELD_ID_CONFIG_STATS_MATCHER_STATS = 13; 77const int FIELD_ID_CONFIG_STATS_CONDITION_STATS = 14; 78const int FIELD_ID_CONFIG_STATS_METRIC_STATS = 15; 79const int FIELD_ID_CONFIG_STATS_ALERT_STATS = 16; 80const int FIELD_ID_CONFIG_STATS_METRIC_DIMENSION_IN_CONDITION_STATS = 17; 81const int FIELD_ID_CONFIG_STATS_ANNOTATION = 18; 82const int FIELD_ID_CONFIG_STATS_ANNOTATION_INT64 = 1; 83const int FIELD_ID_CONFIG_STATS_ANNOTATION_INT32 = 2; 84 85const int FIELD_ID_MATCHER_STATS_ID = 1; 86const int FIELD_ID_MATCHER_STATS_COUNT = 2; 87const int FIELD_ID_CONDITION_STATS_ID = 1; 88const int FIELD_ID_CONDITION_STATS_COUNT = 2; 89const int FIELD_ID_METRIC_STATS_ID = 1; 90const int FIELD_ID_METRIC_STATS_COUNT = 2; 91const int FIELD_ID_ALERT_STATS_ID = 1; 92const int FIELD_ID_ALERT_STATS_COUNT = 2; 93 94const int FIELD_ID_UID_MAP_CHANGES = 1; 95const int FIELD_ID_UID_MAP_BYTES_USED = 2; 96const int FIELD_ID_UID_MAP_DROPPED_CHANGES = 3; 97const int FIELD_ID_UID_MAP_DELETED_APPS = 4; 98 99const std::map<int, std::pair<size_t, size_t>> StatsdStats::kAtomDimensionKeySizeLimitMap = { 100 {android::util::CPU_TIME_PER_UID_FREQ, {6000, 10000}}, 101}; 102 103// TODO: add stats for pulled atoms. 104StatsdStats::StatsdStats() { 105 mPushedAtomStats.resize(android::util::kMaxPushedAtomId + 1); 106 mStartTimeSec = getWallClockSec(); 107} 108 109StatsdStats& StatsdStats::getInstance() { 110 static StatsdStats statsInstance; 111 return statsInstance; 112} 113 114void StatsdStats::addToIceBoxLocked(shared_ptr<ConfigStats>& stats) { 115 // The size of mIceBox grows strictly by one at a time. It won't be > kMaxIceBoxSize. 116 if (mIceBox.size() == kMaxIceBoxSize) { 117 mIceBox.pop_front(); 118 } 119 mIceBox.push_back(stats); 120} 121 122void StatsdStats::noteConfigReceived( 123 const ConfigKey& key, int metricsCount, int conditionsCount, int matchersCount, 124 int alertsCount, const std::list<std::pair<const int64_t, const int32_t>>& annotations, 125 bool isValid) { 126 lock_guard<std::mutex> lock(mLock); 127 int32_t nowTimeSec = getWallClockSec(); 128 129 // If there is an existing config for the same key, icebox the old config. 130 noteConfigRemovedInternalLocked(key); 131 132 shared_ptr<ConfigStats> configStats = std::make_shared<ConfigStats>(); 133 configStats->uid = key.GetUid(); 134 configStats->id = key.GetId(); 135 configStats->creation_time_sec = nowTimeSec; 136 configStats->metric_count = metricsCount; 137 configStats->condition_count = conditionsCount; 138 configStats->matcher_count = matchersCount; 139 configStats->alert_count = alertsCount; 140 configStats->is_valid = isValid; 141 for (auto& v : annotations) { 142 configStats->annotations.emplace_back(v); 143 } 144 145 if (isValid) { 146 mConfigStats[key] = configStats; 147 } else { 148 configStats->deletion_time_sec = nowTimeSec; 149 addToIceBoxLocked(configStats); 150 } 151} 152 153void StatsdStats::noteConfigRemovedInternalLocked(const ConfigKey& key) { 154 auto it = mConfigStats.find(key); 155 if (it != mConfigStats.end()) { 156 int32_t nowTimeSec = getWallClockSec(); 157 it->second->deletion_time_sec = nowTimeSec; 158 addToIceBoxLocked(it->second); 159 mConfigStats.erase(it); 160 } 161} 162 163void StatsdStats::noteConfigRemoved(const ConfigKey& key) { 164 lock_guard<std::mutex> lock(mLock); 165 noteConfigRemovedInternalLocked(key); 166} 167 168void StatsdStats::noteConfigResetInternalLocked(const ConfigKey& key) { 169 auto it = mConfigStats.find(key); 170 if (it != mConfigStats.end()) { 171 it->second->reset_time_sec = getWallClockSec(); 172 } 173} 174 175void StatsdStats::noteConfigReset(const ConfigKey& key) { 176 lock_guard<std::mutex> lock(mLock); 177 noteConfigResetInternalLocked(key); 178} 179 180void StatsdStats::noteBroadcastSent(const ConfigKey& key) { 181 noteBroadcastSent(key, getWallClockSec()); 182} 183 184void StatsdStats::noteBroadcastSent(const ConfigKey& key, int32_t timeSec) { 185 lock_guard<std::mutex> lock(mLock); 186 auto it = mConfigStats.find(key); 187 if (it == mConfigStats.end()) { 188 ALOGE("Config key %s not found!", key.ToString().c_str()); 189 return; 190 } 191 if (it->second->broadcast_sent_time_sec.size() == kMaxTimestampCount) { 192 it->second->broadcast_sent_time_sec.pop_front(); 193 } 194 it->second->broadcast_sent_time_sec.push_back(timeSec); 195} 196 197void StatsdStats::noteDataDropped(const ConfigKey& key) { 198 noteDataDropped(key, getWallClockSec()); 199} 200 201void StatsdStats::noteDataDropped(const ConfigKey& key, int32_t timeSec) { 202 lock_guard<std::mutex> lock(mLock); 203 auto it = mConfigStats.find(key); 204 if (it == mConfigStats.end()) { 205 ALOGE("Config key %s not found!", key.ToString().c_str()); 206 return; 207 } 208 if (it->second->data_drop_time_sec.size() == kMaxTimestampCount) { 209 it->second->data_drop_time_sec.pop_front(); 210 } 211 it->second->data_drop_time_sec.push_back(timeSec); 212} 213 214void StatsdStats::noteMetricsReportSent(const ConfigKey& key) { 215 noteMetricsReportSent(key, getWallClockSec()); 216} 217 218void StatsdStats::noteMetricsReportSent(const ConfigKey& key, int32_t timeSec) { 219 lock_guard<std::mutex> lock(mLock); 220 auto it = mConfigStats.find(key); 221 if (it == mConfigStats.end()) { 222 ALOGE("Config key %s not found!", key.ToString().c_str()); 223 return; 224 } 225 if (it->second->dump_report_time_sec.size() == kMaxTimestampCount) { 226 it->second->dump_report_time_sec.pop_front(); 227 } 228 it->second->dump_report_time_sec.push_back(timeSec); 229} 230 231void StatsdStats::noteUidMapDropped(int deltas) { 232 lock_guard<std::mutex> lock(mLock); 233 mUidMapStats.dropped_changes += mUidMapStats.dropped_changes + deltas; 234} 235 236void StatsdStats::noteUidMapAppDeletionDropped() { 237 lock_guard<std::mutex> lock(mLock); 238 mUidMapStats.deleted_apps++; 239} 240 241void StatsdStats::setUidMapChanges(int changes) { 242 lock_guard<std::mutex> lock(mLock); 243 mUidMapStats.changes = changes; 244} 245 246void StatsdStats::setCurrentUidMapMemory(int bytes) { 247 lock_guard<std::mutex> lock(mLock); 248 mUidMapStats.bytes_used = bytes; 249} 250 251void StatsdStats::noteConditionDimensionSize(const ConfigKey& key, const int64_t& id, int size) { 252 lock_guard<std::mutex> lock(mLock); 253 // if name doesn't exist before, it will create the key with count 0. 254 auto statsIt = mConfigStats.find(key); 255 if (statsIt == mConfigStats.end()) { 256 return; 257 } 258 259 auto& conditionSizeMap = statsIt->second->condition_stats; 260 if (size > conditionSizeMap[id]) { 261 conditionSizeMap[id] = size; 262 } 263} 264 265void StatsdStats::noteMetricDimensionSize(const ConfigKey& key, const int64_t& id, int size) { 266 lock_guard<std::mutex> lock(mLock); 267 // if name doesn't exist before, it will create the key with count 0. 268 auto statsIt = mConfigStats.find(key); 269 if (statsIt == mConfigStats.end()) { 270 return; 271 } 272 auto& metricsDimensionMap = statsIt->second->metric_stats; 273 if (size > metricsDimensionMap[id]) { 274 metricsDimensionMap[id] = size; 275 } 276} 277 278void StatsdStats::noteMetricDimensionInConditionSize( 279 const ConfigKey& key, const int64_t& id, int size) { 280 lock_guard<std::mutex> lock(mLock); 281 // if name doesn't exist before, it will create the key with count 0. 282 auto statsIt = mConfigStats.find(key); 283 if (statsIt == mConfigStats.end()) { 284 return; 285 } 286 auto& metricsDimensionMap = statsIt->second->metric_dimension_in_condition_stats; 287 if (size > metricsDimensionMap[id]) { 288 metricsDimensionMap[id] = size; 289 } 290} 291 292void StatsdStats::noteMatcherMatched(const ConfigKey& key, const int64_t& id) { 293 lock_guard<std::mutex> lock(mLock); 294 295 auto statsIt = mConfigStats.find(key); 296 if (statsIt == mConfigStats.end()) { 297 return; 298 } 299 statsIt->second->matcher_stats[id]++; 300} 301 302void StatsdStats::noteAnomalyDeclared(const ConfigKey& key, const int64_t& id) { 303 lock_guard<std::mutex> lock(mLock); 304 auto statsIt = mConfigStats.find(key); 305 if (statsIt == mConfigStats.end()) { 306 return; 307 } 308 statsIt->second->alert_stats[id]++; 309} 310 311void StatsdStats::noteRegisteredAnomalyAlarmChanged() { 312 lock_guard<std::mutex> lock(mLock); 313 mAnomalyAlarmRegisteredStats++; 314} 315 316void StatsdStats::noteRegisteredPeriodicAlarmChanged() { 317 lock_guard<std::mutex> lock(mLock); 318 mPeriodicAlarmRegisteredStats++; 319} 320 321void StatsdStats::updateMinPullIntervalSec(int pullAtomId, long intervalSec) { 322 lock_guard<std::mutex> lock(mLock); 323 mPulledAtomStats[pullAtomId].minPullIntervalSec = intervalSec; 324} 325 326void StatsdStats::notePull(int pullAtomId) { 327 lock_guard<std::mutex> lock(mLock); 328 mPulledAtomStats[pullAtomId].totalPull++; 329} 330 331void StatsdStats::notePullFromCache(int pullAtomId) { 332 lock_guard<std::mutex> lock(mLock); 333 mPulledAtomStats[pullAtomId].totalPullFromCache++; 334} 335 336void StatsdStats::noteAtomLogged(int atomId, int32_t timeSec) { 337 lock_guard<std::mutex> lock(mLock); 338 339 if (atomId > android::util::kMaxPushedAtomId) { 340 ALOGW("not interested in atom %d", atomId); 341 return; 342 } 343 344 mPushedAtomStats[atomId]++; 345} 346 347void StatsdStats::noteLoggerError(int error) { 348 lock_guard<std::mutex> lock(mLock); 349 // grows strictly one at a time. so it won't > kMaxLoggerErrors 350 if (mLoggerErrors.size() == kMaxLoggerErrors) { 351 mLoggerErrors.pop_front(); 352 } 353 mLoggerErrors.push_back(std::make_pair(getWallClockSec(), error)); 354} 355 356void StatsdStats::reset() { 357 lock_guard<std::mutex> lock(mLock); 358 resetInternalLocked(); 359} 360 361void StatsdStats::resetInternalLocked() { 362 // Reset the historical data, but keep the active ConfigStats 363 mStartTimeSec = getWallClockSec(); 364 mIceBox.clear(); 365 std::fill(mPushedAtomStats.begin(), mPushedAtomStats.end(), 0); 366 mAnomalyAlarmRegisteredStats = 0; 367 mPeriodicAlarmRegisteredStats = 0; 368 mLoggerErrors.clear(); 369 for (auto& config : mConfigStats) { 370 config.second->broadcast_sent_time_sec.clear(); 371 config.second->data_drop_time_sec.clear(); 372 config.second->dump_report_time_sec.clear(); 373 config.second->annotations.clear(); 374 config.second->matcher_stats.clear(); 375 config.second->condition_stats.clear(); 376 config.second->metric_stats.clear(); 377 config.second->metric_dimension_in_condition_stats.clear(); 378 config.second->alert_stats.clear(); 379 } 380} 381 382void StatsdStats::dumpStats(FILE* out) const { 383 lock_guard<std::mutex> lock(mLock); 384 time_t t = mStartTimeSec; 385 struct tm* tm = localtime(&t); 386 char timeBuffer[80]; 387 strftime(timeBuffer, sizeof(timeBuffer), "%Y-%m-%d %I:%M%p\n", tm); 388 fprintf(out, "Stats collection start second: %s\n", timeBuffer); 389 fprintf(out, "%lu Config in icebox: \n", (unsigned long)mIceBox.size()); 390 for (const auto& configStats : mIceBox) { 391 fprintf(out, 392 "Config {%d_%lld}: creation=%d, deletion=%d, reset=%d, #metric=%d, #condition=%d, " 393 "#matcher=%d, #alert=%d, valid=%d\n", 394 configStats->uid, (long long)configStats->id, configStats->creation_time_sec, 395 configStats->deletion_time_sec, configStats->reset_time_sec, 396 configStats->metric_count, 397 configStats->condition_count, configStats->matcher_count, configStats->alert_count, 398 configStats->is_valid); 399 400 for (const auto& broadcastTime : configStats->broadcast_sent_time_sec) { 401 fprintf(out, "\tbroadcast time: %d\n", broadcastTime); 402 } 403 404 for (const auto& dataDropTime : configStats->data_drop_time_sec) { 405 fprintf(out, "\tdata drop time: %d\n", dataDropTime); 406 } 407 } 408 fprintf(out, "%lu Active Configs\n", (unsigned long)mConfigStats.size()); 409 for (auto& pair : mConfigStats) { 410 auto& configStats = pair.second; 411 fprintf(out, 412 "Config {%d-%lld}: creation=%d, deletion=%d, #metric=%d, #condition=%d, " 413 "#matcher=%d, #alert=%d, valid=%d\n", 414 configStats->uid, (long long)configStats->id, configStats->creation_time_sec, 415 configStats->deletion_time_sec, configStats->metric_count, 416 configStats->condition_count, configStats->matcher_count, configStats->alert_count, 417 configStats->is_valid); 418 for (const auto& annotation : configStats->annotations) { 419 fprintf(out, "\tannotation: %lld, %d\n", (long long)annotation.first, 420 annotation.second); 421 } 422 423 for (const auto& broadcastTime : configStats->broadcast_sent_time_sec) { 424 fprintf(out, "\tbroadcast time: %d\n", broadcastTime); 425 } 426 427 for (const auto& dataDropTime : configStats->data_drop_time_sec) { 428 fprintf(out, "\tdata drop time: %d\n", dataDropTime); 429 } 430 431 for (const auto& dumpTime : configStats->dump_report_time_sec) { 432 fprintf(out, "\tdump report time: %d\n", dumpTime); 433 } 434 435 for (const auto& stats : pair.second->matcher_stats) { 436 fprintf(out, "matcher %lld matched %d times\n", (long long)stats.first, stats.second); 437 } 438 439 for (const auto& stats : pair.second->condition_stats) { 440 fprintf(out, "condition %lld max output tuple size %d\n", (long long)stats.first, 441 stats.second); 442 } 443 444 for (const auto& stats : pair.second->condition_stats) { 445 fprintf(out, "metrics %lld max output tuple size %d\n", (long long)stats.first, 446 stats.second); 447 } 448 449 for (const auto& stats : pair.second->alert_stats) { 450 fprintf(out, "alert %lld declared %d times\n", (long long)stats.first, stats.second); 451 } 452 } 453 fprintf(out, "********Disk Usage stats***********\n"); 454 StorageManager::printStats(out); 455 fprintf(out, "********Pushed Atom stats***********\n"); 456 const size_t atomCounts = mPushedAtomStats.size(); 457 for (size_t i = 2; i < atomCounts; i++) { 458 if (mPushedAtomStats[i] > 0) { 459 fprintf(out, "Atom %lu->%d\n", (unsigned long)i, mPushedAtomStats[i]); 460 } 461 } 462 463 fprintf(out, "********Pulled Atom stats***********\n"); 464 for (const auto& pair : mPulledAtomStats) { 465 fprintf(out, "Atom %d->%ld, %ld, %ld\n", (int)pair.first, (long)pair.second.totalPull, 466 (long)pair.second.totalPullFromCache, (long)pair.second.minPullIntervalSec); 467 } 468 469 if (mAnomalyAlarmRegisteredStats > 0) { 470 fprintf(out, "********AnomalyAlarmStats stats***********\n"); 471 fprintf(out, "Anomaly alarm registrations: %d\n", mAnomalyAlarmRegisteredStats); 472 } 473 474 if (mPeriodicAlarmRegisteredStats > 0) { 475 fprintf(out, "********SubscriberAlarmStats stats***********\n"); 476 fprintf(out, "Subscriber alarm registrations: %d\n", mPeriodicAlarmRegisteredStats); 477 } 478 479 fprintf(out, "UID map stats: bytes=%d, changes=%d, deleted=%d, changes lost=%d\n", 480 mUidMapStats.bytes_used, mUidMapStats.changes, mUidMapStats.deleted_apps, 481 mUidMapStats.dropped_changes); 482 483 for (const auto& error : mLoggerErrors) { 484 time_t error_time = error.first; 485 struct tm* error_tm = localtime(&error_time); 486 char buffer[80]; 487 strftime(buffer, sizeof(buffer), "%Y-%m-%d %I:%M%p\n", error_tm); 488 fprintf(out, "Logger error %d at %s\n", error.second, buffer); 489 } 490} 491 492void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* proto) { 493 uint64_t token = 494 proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_CONFIG_STATS); 495 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_UID, configStats.uid); 496 proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_ID, (long long)configStats.id); 497 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_CREATION, configStats.creation_time_sec); 498 if (configStats.reset_time_sec != 0) { 499 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_RESET, configStats.reset_time_sec); 500 } 501 if (configStats.deletion_time_sec != 0) { 502 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DELETION, 503 configStats.deletion_time_sec); 504 } 505 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_METRIC_COUNT, configStats.metric_count); 506 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_CONDITION_COUNT, 507 configStats.condition_count); 508 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_MATCHER_COUNT, configStats.matcher_count); 509 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_ALERT_COUNT, configStats.alert_count); 510 proto->write(FIELD_TYPE_BOOL | FIELD_ID_CONFIG_STATS_VALID, configStats.is_valid); 511 512 for (const auto& broadcast : configStats.broadcast_sent_time_sec) { 513 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_BROADCAST | FIELD_COUNT_REPEATED, 514 broadcast); 515 } 516 517 for (const auto& drop : configStats.data_drop_time_sec) { 518 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DATA_DROP | FIELD_COUNT_REPEATED, 519 drop); 520 } 521 522 for (const auto& dump : configStats.dump_report_time_sec) { 523 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DUMP_REPORT | FIELD_COUNT_REPEATED, 524 dump); 525 } 526 527 for (const auto& annotation : configStats.annotations) { 528 uint64_t token = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | 529 FIELD_ID_CONFIG_STATS_ANNOTATION); 530 proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_ANNOTATION_INT64, 531 (long long)annotation.first); 532 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_ANNOTATION_INT32, annotation.second); 533 proto->end(token); 534 } 535 536 for (const auto& pair : configStats.matcher_stats) { 537 uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | 538 FIELD_ID_CONFIG_STATS_MATCHER_STATS); 539 proto->write(FIELD_TYPE_INT64 | FIELD_ID_MATCHER_STATS_ID, (long long)pair.first); 540 proto->write(FIELD_TYPE_INT32 | FIELD_ID_MATCHER_STATS_COUNT, pair.second); 541 proto->end(tmpToken); 542 } 543 544 for (const auto& pair : configStats.condition_stats) { 545 uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | 546 FIELD_ID_CONFIG_STATS_CONDITION_STATS); 547 proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONDITION_STATS_ID, (long long)pair.first); 548 proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONDITION_STATS_COUNT, pair.second); 549 proto->end(tmpToken); 550 } 551 552 for (const auto& pair : configStats.metric_stats) { 553 uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | 554 FIELD_ID_CONFIG_STATS_METRIC_STATS); 555 proto->write(FIELD_TYPE_INT64 | FIELD_ID_METRIC_STATS_ID, (long long)pair.first); 556 proto->write(FIELD_TYPE_INT32 | FIELD_ID_METRIC_STATS_COUNT, pair.second); 557 proto->end(tmpToken); 558 } 559 for (const auto& pair : configStats.metric_dimension_in_condition_stats) { 560 uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | 561 FIELD_ID_CONFIG_STATS_METRIC_DIMENSION_IN_CONDITION_STATS); 562 proto->write(FIELD_TYPE_INT64 | FIELD_ID_METRIC_STATS_ID, (long long)pair.first); 563 proto->write(FIELD_TYPE_INT32 | FIELD_ID_METRIC_STATS_COUNT, pair.second); 564 proto->end(tmpToken); 565 } 566 567 for (const auto& pair : configStats.alert_stats) { 568 uint64_t tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | 569 FIELD_ID_CONFIG_STATS_ALERT_STATS); 570 proto->write(FIELD_TYPE_INT64 | FIELD_ID_ALERT_STATS_ID, (long long)pair.first); 571 proto->write(FIELD_TYPE_INT32 | FIELD_ID_ALERT_STATS_COUNT, pair.second); 572 proto->end(tmpToken); 573 } 574 575 proto->end(token); 576} 577 578void StatsdStats::dumpStats(std::vector<uint8_t>* output, bool reset) { 579 lock_guard<std::mutex> lock(mLock); 580 581 ProtoOutputStream proto; 582 proto.write(FIELD_TYPE_INT32 | FIELD_ID_BEGIN_TIME, mStartTimeSec); 583 proto.write(FIELD_TYPE_INT32 | FIELD_ID_END_TIME, (int32_t)getWallClockSec()); 584 585 for (const auto& configStats : mIceBox) { 586 addConfigStatsToProto(*configStats, &proto); 587 } 588 589 for (auto& pair : mConfigStats) { 590 addConfigStatsToProto(*(pair.second), &proto); 591 } 592 593 const size_t atomCounts = mPushedAtomStats.size(); 594 for (size_t i = 2; i < atomCounts; i++) { 595 if (mPushedAtomStats[i] > 0) { 596 uint64_t token = 597 proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ATOM_STATS | FIELD_COUNT_REPEATED); 598 proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_TAG, (int32_t)i); 599 proto.write(FIELD_TYPE_INT32 | FIELD_ID_ATOM_STATS_COUNT, mPushedAtomStats[i]); 600 proto.end(token); 601 } 602 } 603 604 for (const auto& pair : mPulledAtomStats) { 605 android::os::statsd::writePullerStatsToStream(pair, &proto); 606 } 607 608 if (mAnomalyAlarmRegisteredStats > 0) { 609 uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_ANOMALY_ALARM_STATS); 610 proto.write(FIELD_TYPE_INT32 | FIELD_ID_ANOMALY_ALARMS_REGISTERED, 611 mAnomalyAlarmRegisteredStats); 612 proto.end(token); 613 } 614 615 if (mPeriodicAlarmRegisteredStats > 0) { 616 uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_SUBSCRIBER_ALARM_STATS); 617 proto.write(FIELD_TYPE_INT32 | FIELD_ID_SUBSCRIBER_ALARMS_REGISTERED, 618 mPeriodicAlarmRegisteredStats); 619 proto.end(token); 620 } 621 622 uint64_t uidMapToken = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_UIDMAP_STATS); 623 proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_CHANGES, mUidMapStats.changes); 624 proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_BYTES_USED, mUidMapStats.bytes_used); 625 proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_DROPPED_CHANGES, mUidMapStats.dropped_changes); 626 proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_DELETED_APPS, mUidMapStats.deleted_apps); 627 proto.end(uidMapToken); 628 629 for (const auto& error : mLoggerErrors) { 630 uint64_t token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_LOGGER_ERROR_STATS | 631 FIELD_COUNT_REPEATED); 632 proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOGGER_STATS_TIME, error.first); 633 proto.write(FIELD_TYPE_INT32 | FIELD_ID_LOGGER_STATS_ERROR_CODE, error.second); 634 proto.end(token); 635 } 636 637 output->clear(); 638 size_t bufferSize = proto.size(); 639 output->resize(bufferSize); 640 641 size_t pos = 0; 642 auto it = proto.data(); 643 while (it.readBuffer() != NULL) { 644 size_t toRead = it.currentToRead(); 645 std::memcpy(&((*output)[pos]), it.readBuffer(), toRead); 646 pos += toRead; 647 it.rp()->move(toRead); 648 } 649 650 if (reset) { 651 resetInternalLocked(); 652 } 653 654 VLOG("reset=%d, returned proto size %lu", reset, (unsigned long)bufferSize); 655} 656 657} // namespace statsd 658} // namespace os 659} // namespace android 660