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