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