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