Reduce statsd binary size from 730KB-> 664KB
1. StatsdStats does not use the proto object in memory anymore.
2. lite_static -> lite
3. don't use sstream
Bug: 72129300
Test: statsd_test
Change-Id: I8a5adaf222d4d5034e8bf115215fb6dd5f042cac
diff --git a/cmds/statsd/src/guardrail/StatsdStats.cpp b/cmds/statsd/src/guardrail/StatsdStats.cpp
index 0881d44..22faaa1 100644
--- a/cmds/statsd/src/guardrail/StatsdStats.cpp
+++ b/cmds/statsd/src/guardrail/StatsdStats.cpp
@@ -36,6 +36,7 @@
using android::util::ProtoOutputStream;
using std::lock_guard;
using std::map;
+using std::shared_ptr;
using std::string;
using std::vector;
@@ -58,6 +59,38 @@
const int FIELD_ID_LOGGER_STATS_TIME = 1;
const int FIELD_ID_LOGGER_STATS_ERROR_CODE = 2;
+const int FIELD_ID_CONFIG_STATS_UID = 1;
+const int FIELD_ID_CONFIG_STATS_ID = 2;
+const int FIELD_ID_CONFIG_STATS_CREATION = 3;
+const int FIELD_ID_CONFIG_STATS_DELETION = 4;
+const int FIELD_ID_CONFIG_STATS_METRIC_COUNT = 5;
+const int FIELD_ID_CONFIG_STATS_CONDITION_COUNT = 6;
+const int FIELD_ID_CONFIG_STATS_MATCHER_COUNT = 7;
+const int FIELD_ID_CONFIG_STATS_ALERT_COUNT = 8;
+const int FIELD_ID_CONFIG_STATS_VALID = 9;
+const int FIELD_ID_CONFIG_STATS_BROADCAST = 10;
+const int FIELD_ID_CONFIG_STATS_DATA_DROP = 11;
+const int FIELD_ID_CONFIG_STATS_DUMP_REPORT = 12;
+const int FIELD_ID_CONFIG_STATS_MATCHER_STATS = 13;
+const int FIELD_ID_CONFIG_STATS_CONDITION_STATS = 14;
+const int FIELD_ID_CONFIG_STATS_METRIC_STATS = 15;
+const int FIELD_ID_CONFIG_STATS_ALERT_STATS = 16;
+
+const int FIELD_ID_MATCHER_STATS_ID = 1;
+const int FIELD_ID_MATCHER_STATS_COUNT = 2;
+const int FIELD_ID_CONDITION_STATS_ID = 1;
+const int FIELD_ID_CONDITION_STATS_COUNT = 2;
+const int FIELD_ID_METRIC_STATS_ID = 1;
+const int FIELD_ID_METRIC_STATS_COUNT = 2;
+const int FIELD_ID_ALERT_STATS_ID = 1;
+const int FIELD_ID_ALERT_STATS_COUNT = 2;
+
+const int FIELD_ID_UID_MAP_SNAPSHOTS = 1;
+const int FIELD_ID_UID_MAP_CHANGES = 2;
+const int FIELD_ID_UID_MAP_BYTES_USED = 3;
+const int FIELD_ID_UID_MAP_DROPPED_SNAPSHOTS = 4;
+const int FIELD_ID_UID_MAP_DROPPED_CHANGES = 5;
+
std::map<int, long> StatsdStats::kPullerCooldownMap = {
{android::util::KERNEL_WAKELOCK, 1},
{android::util::WIFI_BYTES_TRANSFER, 1},
@@ -81,7 +114,7 @@
return statsInstance;
}
-void StatsdStats::addToIceBoxLocked(const StatsdStatsReport_ConfigStats& stats) {
+void StatsdStats::addToIceBoxLocked(shared_ptr<ConfigStats>& stats) {
// The size of mIceBox grows strictly by one at a time. It won't be > kMaxIceBoxSize.
if (mIceBox.size() == kMaxIceBoxSize) {
mIceBox.pop_front();
@@ -97,20 +130,20 @@
// If there is an existing config for the same key, icebox the old config.
noteConfigRemovedInternalLocked(key);
- StatsdStatsReport_ConfigStats configStats;
- configStats.set_uid(key.GetUid());
- configStats.set_id(key.GetId());
- configStats.set_creation_time_sec(nowTimeSec);
- configStats.set_metric_count(metricsCount);
- configStats.set_condition_count(conditionsCount);
- configStats.set_matcher_count(matchersCount);
- configStats.set_alert_count(alertsCount);
- configStats.set_is_valid(isValid);
+ shared_ptr<ConfigStats> configStats = std::make_shared<ConfigStats>();
+ configStats->uid = key.GetUid();
+ configStats->id = key.GetId();
+ configStats->creation_time_sec = nowTimeSec;
+ configStats->metric_count = metricsCount;
+ configStats->condition_count = conditionsCount;
+ configStats->matcher_count = matchersCount;
+ configStats->alert_count = alertsCount;
+ configStats->is_valid = isValid;
if (isValid) {
mConfigStats[key] = configStats;
} else {
- configStats.set_deletion_time_sec(nowTimeSec);
+ configStats->deletion_time_sec = nowTimeSec;
addToIceBoxLocked(configStats);
}
}
@@ -119,14 +152,7 @@
auto it = mConfigStats.find(key);
if (it != mConfigStats.end()) {
int32_t nowTimeSec = getWallClockSec();
- it->second.set_deletion_time_sec(nowTimeSec);
- // Add condition stats, metrics stats, matcher stats, alert stats
- addSubStatsToConfigLocked(key, it->second);
- // Remove them after they are added to the config stats.
- mMatcherStats.erase(key);
- mMetricsStats.erase(key);
- mAlertStats.erase(key);
- mConditionStats.erase(key);
+ it->second->deletion_time_sec = nowTimeSec;
addToIceBoxLocked(it->second);
mConfigStats.erase(it);
}
@@ -148,12 +174,10 @@
ALOGE("Config key %s not found!", key.ToString().c_str());
return;
}
- if (it->second.broadcast_sent_time_sec_size() >= kMaxTimestampCount) {
- auto timestampList = it->second.mutable_broadcast_sent_time_sec();
- // This is O(N) operation. It shouldn't happen often, and N is only 20.
- timestampList->erase(timestampList->begin());
+ if (it->second->broadcast_sent_time_sec.size() == kMaxTimestampCount) {
+ it->second->broadcast_sent_time_sec.pop_front();
}
- it->second.add_broadcast_sent_time_sec(timeSec);
+ it->second->broadcast_sent_time_sec.push_back(timeSec);
}
void StatsdStats::noteDataDropped(const ConfigKey& key) {
@@ -167,12 +191,10 @@
ALOGE("Config key %s not found!", key.ToString().c_str());
return;
}
- if (it->second.data_drop_time_sec_size() >= kMaxTimestampCount) {
- auto timestampList = it->second.mutable_data_drop_time_sec();
- // This is O(N) operation. It shouldn't happen often, and N is only 20.
- timestampList->erase(timestampList->begin());
+ if (it->second->data_drop_time_sec.size() == kMaxTimestampCount) {
+ it->second->data_drop_time_sec.pop_front();
}
- it->second.add_data_drop_time_sec(timeSec);
+ it->second->data_drop_time_sec.push_back(timeSec);
}
void StatsdStats::noteMetricsReportSent(const ConfigKey& key) {
@@ -186,39 +208,42 @@
ALOGE("Config key %s not found!", key.ToString().c_str());
return;
}
- if (it->second.dump_report_time_sec_size() >= kMaxTimestampCount) {
- auto timestampList = it->second.mutable_dump_report_time_sec();
- // This is O(N) operation. It shouldn't happen often, and N is only 20.
- timestampList->erase(timestampList->begin());
+ if (it->second->dump_report_time_sec.size() == kMaxTimestampCount) {
+ it->second->dump_report_time_sec.pop_front();
}
- it->second.add_dump_report_time_sec(timeSec);
+ it->second->dump_report_time_sec.push_back(timeSec);
}
void StatsdStats::noteUidMapDropped(int snapshots, int deltas) {
lock_guard<std::mutex> lock(mLock);
- mUidMapStats.set_dropped_snapshots(mUidMapStats.dropped_snapshots() + snapshots);
- mUidMapStats.set_dropped_changes(mUidMapStats.dropped_changes() + deltas);
+ mUidMapStats.dropped_snapshots += mUidMapStats.dropped_snapshots + snapshots;
+ mUidMapStats.dropped_changes += mUidMapStats.dropped_changes + deltas;
}
void StatsdStats::setUidMapSnapshots(int snapshots) {
lock_guard<std::mutex> lock(mLock);
- mUidMapStats.set_snapshots(snapshots);
+ mUidMapStats.snapshots = snapshots;
}
void StatsdStats::setUidMapChanges(int changes) {
lock_guard<std::mutex> lock(mLock);
- mUidMapStats.set_changes(changes);
+ mUidMapStats.changes = changes;
}
void StatsdStats::setCurrentUidMapMemory(int bytes) {
lock_guard<std::mutex> lock(mLock);
- mUidMapStats.set_bytes_used(bytes);
+ mUidMapStats.bytes_used = bytes;
}
void StatsdStats::noteConditionDimensionSize(const ConfigKey& key, const int64_t& id, int size) {
lock_guard<std::mutex> lock(mLock);
// if name doesn't exist before, it will create the key with count 0.
- auto& conditionSizeMap = mConditionStats[key];
+ auto statsIt = mConfigStats.find(key);
+ if (statsIt == mConfigStats.end()) {
+ return;
+ }
+
+ auto& conditionSizeMap = statsIt->second->condition_stats;
if (size > conditionSizeMap[id]) {
conditionSizeMap[id] = size;
}
@@ -227,7 +252,11 @@
void StatsdStats::noteMetricDimensionSize(const ConfigKey& key, const int64_t& id, int size) {
lock_guard<std::mutex> lock(mLock);
// if name doesn't exist before, it will create the key with count 0.
- auto& metricsDimensionMap = mMetricsStats[key];
+ auto statsIt = mConfigStats.find(key);
+ if (statsIt == mConfigStats.end()) {
+ return;
+ }
+ auto& metricsDimensionMap = statsIt->second->metric_stats;
if (size > metricsDimensionMap[id]) {
metricsDimensionMap[id] = size;
}
@@ -235,14 +264,21 @@
void StatsdStats::noteMatcherMatched(const ConfigKey& key, const int64_t& id) {
lock_guard<std::mutex> lock(mLock);
- auto& matcherStats = mMatcherStats[key];
- matcherStats[id]++;
+
+ auto statsIt = mConfigStats.find(key);
+ if (statsIt == mConfigStats.end()) {
+ return;
+ }
+ statsIt->second->matcher_stats[id]++;
}
void StatsdStats::noteAnomalyDeclared(const ConfigKey& key, const int64_t& id) {
lock_guard<std::mutex> lock(mLock);
- auto& alertStats = mAlertStats[key];
- alertStats[id]++;
+ auto statsIt = mConfigStats.find(key);
+ if (statsIt == mConfigStats.end()) {
+ return;
+ }
+ statsIt->second->alert_stats[id]++;
}
void StatsdStats::noteRegisteredAnomalyAlarmChanged() {
@@ -299,69 +335,18 @@
// Reset the historical data, but keep the active ConfigStats
mStartTimeSec = getWallClockSec();
mIceBox.clear();
- mConditionStats.clear();
- mMetricsStats.clear();
std::fill(mPushedAtomStats.begin(), mPushedAtomStats.end(), 0);
- mAlertStats.clear();
mAnomalyAlarmRegisteredStats = 0;
mPeriodicAlarmRegisteredStats = 0;
- mMatcherStats.clear();
mLoggerErrors.clear();
for (auto& config : mConfigStats) {
- config.second.clear_broadcast_sent_time_sec();
- config.second.clear_data_drop_time_sec();
- config.second.clear_dump_report_time_sec();
- config.second.clear_matcher_stats();
- config.second.clear_condition_stats();
- config.second.clear_metric_stats();
- config.second.clear_alert_stats();
- }
-}
-
-void StatsdStats::addSubStatsToConfigLocked(const ConfigKey& key,
- StatsdStatsReport_ConfigStats& configStats) {
- // Add matcher stats
- if (mMatcherStats.find(key) != mMatcherStats.end()) {
- const auto& matcherStats = mMatcherStats[key];
- for (const auto& stats : matcherStats) {
- auto output = configStats.add_matcher_stats();
- output->set_id(stats.first);
- output->set_matched_times(stats.second);
- VLOG("matcher %lld matched %d times",
- (long long)stats.first, stats.second);
- }
- }
- // Add condition stats
- if (mConditionStats.find(key) != mConditionStats.end()) {
- const auto& conditionStats = mConditionStats[key];
- for (const auto& stats : conditionStats) {
- auto output = configStats.add_condition_stats();
- output->set_id(stats.first);
- output->set_max_tuple_counts(stats.second);
- VLOG("condition %lld max output tuple size %d",
- (long long)stats.first, stats.second);
- }
- }
- // Add metrics stats
- if (mMetricsStats.find(key) != mMetricsStats.end()) {
- const auto& conditionStats = mMetricsStats[key];
- for (const auto& stats : conditionStats) {
- auto output = configStats.add_metric_stats();
- output->set_id(stats.first);
- output->set_max_tuple_counts(stats.second);
- VLOG("metrics %lld max output tuple size %d",
- (long long)stats.first, stats.second);
- }
- }
- // Add anomaly detection alert stats
- if (mAlertStats.find(key) != mAlertStats.end()) {
- const auto& alertStats = mAlertStats[key];
- for (const auto& stats : alertStats) {
- auto output = configStats.add_alert_stats();
- output->set_id(stats.first);
- output->set_alerted_times(stats.second);
- VLOG("alert %lld declared %d times", (long long)stats.first, stats.second);
- }
+ config.second->broadcast_sent_time_sec.clear();
+ config.second->data_drop_time_sec.clear();
+ config.second->dump_report_time_sec.clear();
+ config.second->matcher_stats.clear();
+ config.second->condition_stats.clear();
+ config.second->metric_stats.clear();
+ config.second->alert_stats.clear();
}
}
@@ -377,78 +362,57 @@
fprintf(out,
"Config {%d_%lld}: creation=%d, deletion=%d, #metric=%d, #condition=%d, "
"#matcher=%d, #alert=%d, valid=%d\n",
- configStats.uid(), (long long)configStats.id(), configStats.creation_time_sec(),
- configStats.deletion_time_sec(), configStats.metric_count(),
- configStats.condition_count(), configStats.matcher_count(),
- configStats.alert_count(), configStats.is_valid());
+ configStats->uid, (long long)configStats->id, configStats->creation_time_sec,
+ configStats->deletion_time_sec, configStats->metric_count,
+ configStats->condition_count, configStats->matcher_count, configStats->alert_count,
+ configStats->is_valid);
- for (const auto& broadcastTime : configStats.broadcast_sent_time_sec()) {
+ for (const auto& broadcastTime : configStats->broadcast_sent_time_sec) {
fprintf(out, "\tbroadcast time: %d\n", broadcastTime);
}
- for (const auto& dataDropTime : configStats.data_drop_time_sec()) {
+ for (const auto& dataDropTime : configStats->data_drop_time_sec) {
fprintf(out, "\tdata drop time: %d\n", dataDropTime);
}
}
fprintf(out, "%lu Active Configs\n", (unsigned long)mConfigStats.size());
for (auto& pair : mConfigStats) {
- auto& key = pair.first;
auto& configStats = pair.second;
-
fprintf(out,
"Config {%d-%lld}: creation=%d, deletion=%d, #metric=%d, #condition=%d, "
"#matcher=%d, #alert=%d, valid=%d\n",
- configStats.uid(), (long long)configStats.id(), configStats.creation_time_sec(),
- configStats.deletion_time_sec(), configStats.metric_count(),
- configStats.condition_count(), configStats.matcher_count(),
- configStats.alert_count(), configStats.is_valid());
- for (const auto& broadcastTime : configStats.broadcast_sent_time_sec()) {
+ configStats->uid, (long long)configStats->id, configStats->creation_time_sec,
+ configStats->deletion_time_sec, configStats->metric_count,
+ configStats->condition_count, configStats->matcher_count, configStats->alert_count,
+ configStats->is_valid);
+ for (const auto& broadcastTime : configStats->broadcast_sent_time_sec) {
fprintf(out, "\tbroadcast time: %d\n", broadcastTime);
}
- for (const auto& dataDropTime : configStats.data_drop_time_sec()) {
+ for (const auto& dataDropTime : configStats->data_drop_time_sec) {
fprintf(out, "\tdata drop time: %d\n", dataDropTime);
}
- for (const auto& dumpTime : configStats.dump_report_time_sec()) {
+ for (const auto& dumpTime : configStats->dump_report_time_sec) {
fprintf(out, "\tdump report time: %d\n", dumpTime);
}
- // Add matcher stats
- auto matcherIt = mMatcherStats.find(key);
- if (matcherIt != mMatcherStats.end()) {
- const auto& matcherStats = matcherIt->second;
- for (const auto& stats : matcherStats) {
- fprintf(out, "matcher %lld matched %d times\n", (long long)stats.first,
- stats.second);
- }
+ for (const auto& stats : pair.second->matcher_stats) {
+ fprintf(out, "matcher %lld matched %d times\n", (long long)stats.first, stats.second);
}
- // Add condition stats
- auto conditionIt = mConditionStats.find(key);
- if (conditionIt != mConditionStats.end()) {
- const auto& conditionStats = conditionIt->second;
- for (const auto& stats : conditionStats) {
- fprintf(out, "condition %lld max output tuple size %d\n", (long long)stats.first,
- stats.second);
- }
+
+ for (const auto& stats : pair.second->condition_stats) {
+ fprintf(out, "condition %lld max output tuple size %d\n", (long long)stats.first,
+ stats.second);
}
- // Add metrics stats
- auto metricIt = mMetricsStats.find(key);
- if (metricIt != mMetricsStats.end()) {
- const auto& conditionStats = metricIt->second;
- for (const auto& stats : conditionStats) {
- fprintf(out, "metrics %lld max output tuple size %d\n", (long long)stats.first,
- stats.second);
- }
+
+ for (const auto& stats : pair.second->condition_stats) {
+ fprintf(out, "metrics %lld max output tuple size %d\n", (long long)stats.first,
+ stats.second);
}
- // Add anomaly detection alert stats
- auto alertIt = mAlertStats.find(key);
- if (alertIt != mAlertStats.end()) {
- const auto& alertStats = alertIt->second;
- for (const auto& stats : alertStats) {
- fprintf(out, "alert %lld declared %d times\n", (long long)stats.first,
- stats.second);
- }
+
+ for (const auto& stats : pair.second->alert_stats) {
+ fprintf(out, "alert %lld declared %d times\n", (long long)stats.first, stats.second);
}
}
fprintf(out, "********Pushed Atom stats***********\n");
@@ -462,7 +426,7 @@
fprintf(out, "********Pulled Atom stats***********\n");
for (const auto& pair : mPulledAtomStats) {
fprintf(out, "Atom %d->%ld, %ld, %ld\n", (int)pair.first, (long)pair.second.totalPull,
- (long)pair.second.totalPullFromCache, (long)pair.second.minPullIntervalSec);
+ (long)pair.second.totalPullFromCache, (long)pair.second.minPullIntervalSec);
}
if (mAnomalyAlarmRegisteredStats > 0) {
@@ -478,8 +442,8 @@
fprintf(out,
"UID map stats: bytes=%d, snapshots=%d, changes=%d, snapshots lost=%d, changes "
"lost=%d\n",
- mUidMapStats.bytes_used(), mUidMapStats.snapshots(), mUidMapStats.changes(),
- mUidMapStats.dropped_snapshots(), mUidMapStats.dropped_changes());
+ mUidMapStats.bytes_used, mUidMapStats.snapshots, mUidMapStats.changes,
+ mUidMapStats.dropped_snapshots, mUidMapStats.dropped_changes);
for (const auto& error : mLoggerErrors) {
time_t error_time = error.first;
@@ -490,6 +454,73 @@
}
}
+void addConfigStatsToProto(const ConfigStats& configStats, ProtoOutputStream* proto) {
+ long long token =
+ proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_CONFIG_STATS);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_UID, configStats.uid);
+ proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONFIG_STATS_ID, (long long)configStats.id);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_CREATION, configStats.creation_time_sec);
+ if (configStats.deletion_time_sec != 0) {
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DELETION,
+ configStats.deletion_time_sec);
+ }
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_METRIC_COUNT, configStats.metric_count);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_CONDITION_COUNT,
+ configStats.condition_count);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_MATCHER_COUNT, configStats.matcher_count);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_ALERT_COUNT, configStats.alert_count);
+ proto->write(FIELD_TYPE_BOOL | FIELD_ID_CONFIG_STATS_VALID, configStats.is_valid);
+
+ for (const auto& broadcast : configStats.broadcast_sent_time_sec) {
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_BROADCAST | FIELD_COUNT_REPEATED,
+ broadcast);
+ }
+
+ for (const auto& drop : configStats.data_drop_time_sec) {
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DATA_DROP | FIELD_COUNT_REPEATED,
+ drop);
+ }
+
+ for (const auto& dump : configStats.dump_report_time_sec) {
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONFIG_STATS_DUMP_REPORT | FIELD_COUNT_REPEATED,
+ dump);
+ }
+
+ for (const auto& pair : configStats.matcher_stats) {
+ long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
+ FIELD_ID_CONFIG_STATS_MATCHER_STATS);
+ proto->write(FIELD_TYPE_INT64 | FIELD_ID_MATCHER_STATS_ID, (long long)pair.first);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_MATCHER_STATS_COUNT, pair.second);
+ proto->end(tmpToken);
+ }
+
+ for (const auto& pair : configStats.condition_stats) {
+ long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
+ FIELD_ID_CONFIG_STATS_CONDITION_STATS);
+ proto->write(FIELD_TYPE_INT64 | FIELD_ID_CONDITION_STATS_ID, (long long)pair.first);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_CONDITION_STATS_COUNT, pair.second);
+ proto->end(tmpToken);
+ }
+
+ for (const auto& pair : configStats.metric_stats) {
+ long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
+ FIELD_ID_CONFIG_STATS_METRIC_STATS);
+ proto->write(FIELD_TYPE_INT64 | FIELD_ID_METRIC_STATS_ID, (long long)pair.first);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_METRIC_STATS_COUNT, pair.second);
+ proto->end(tmpToken);
+ }
+
+ for (const auto& pair : configStats.alert_stats) {
+ long long tmpToken = proto->start(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED |
+ FIELD_ID_CONFIG_STATS_ALERT_STATS);
+ proto->write(FIELD_TYPE_INT64 | FIELD_ID_ALERT_STATS_ID, (long long)pair.first);
+ proto->write(FIELD_TYPE_INT32 | FIELD_ID_ALERT_STATS_COUNT, pair.second);
+ proto->end(tmpToken);
+ }
+
+ proto->end(token);
+}
+
void StatsdStats::dumpStats(std::vector<uint8_t>* output, bool reset) {
lock_guard<std::mutex> lock(mLock);
@@ -498,28 +529,11 @@
proto.write(FIELD_TYPE_INT32 | FIELD_ID_END_TIME, (int32_t)getWallClockSec());
for (const auto& configStats : mIceBox) {
- const int numBytes = configStats.ByteSize();
- vector<char> buffer(numBytes);
- configStats.SerializeToArray(&buffer[0], numBytes);
- proto.write(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_CONFIG_STATS, &buffer[0],
- buffer.size());
+ addConfigStatsToProto(*configStats, &proto);
}
for (auto& pair : mConfigStats) {
- auto& configStats = pair.second;
- addSubStatsToConfigLocked(pair.first, configStats);
-
- const int numBytes = configStats.ByteSize();
- vector<char> buffer(numBytes);
- configStats.SerializeToArray(&buffer[0], numBytes);
- proto.write(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_CONFIG_STATS, &buffer[0],
- buffer.size());
- // reset the sub stats, the source of truth is in the individual map
- // they will be repopulated when dumpStats() is called again.
- configStats.clear_matcher_stats();
- configStats.clear_condition_stats();
- configStats.clear_metric_stats();
- configStats.clear_alert_stats();
+ addConfigStatsToProto(*(pair.second), &proto);
}
const size_t atomCounts = mPushedAtomStats.size();
@@ -551,10 +565,14 @@
proto.end(token);
}
- const int numBytes = mUidMapStats.ByteSize();
- vector<char> buffer(numBytes);
- mUidMapStats.SerializeToArray(&buffer[0], numBytes);
- proto.write(FIELD_TYPE_MESSAGE | FIELD_ID_UIDMAP_STATS, &buffer[0], buffer.size());
+ long long uidMapToken = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_UIDMAP_STATS);
+ proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_SNAPSHOTS, mUidMapStats.snapshots);
+ proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_CHANGES, mUidMapStats.changes);
+ proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_BYTES_USED, mUidMapStats.bytes_used);
+ proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_DROPPED_SNAPSHOTS,
+ mUidMapStats.dropped_snapshots);
+ proto.write(FIELD_TYPE_INT32 | FIELD_ID_UID_MAP_DROPPED_CHANGES, mUidMapStats.dropped_changes);
+ proto.end(uidMapToken);
for (const auto& error : mLoggerErrors) {
long long token = proto.start(FIELD_TYPE_MESSAGE | FIELD_ID_LOGGER_ERROR_STATS |