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