Snap for 7728678 from 4075e14a13ea28837e14768894c9fe7870488525 to mainline-ipsec-releaseandroid-mainline-12.0.0_r10

Change-Id: I5b2065838e7d390bc20f26aa21c56937c3537a90

18 files changed, 151 insertions, 118 deletions

diff --git a/apex/tests/libstatspull/Android.bp b/apex/tests/libstatspull/Android.bp
index 82dba72f..e96a6986 100644
--- a/apex/tests/libstatspull/Android.bp
+++ b/apex/tests/libstatspull/Android.bp
@@ -54,12 +54,11 @@ cc_library_shared {
     ],
     shared_libs: [
         "libbinder_ndk",
-        "statsd-aidl-ndk_platform",
+        "statsd-aidl-ndk",
     ],
     static_libs: [
         "libstatspull_private",
         "libstatssocket_private",
-        "libutils",
         "libcutils",
     ],
 }
diff --git a/lib/libstatspull/Android.bp b/lib/libstatspull/Android.bp
index 3698a575..bf00942e 100644
--- a/lib/libstatspull/Android.bp
+++ b/lib/libstatspull/Android.bp
@@ -37,7 +37,7 @@ cc_defaults {
     ],
     static_libs: [
         "libutils",
-        "statsd-aidl-ndk_platform",
+        "statsd-aidl-ndk",
     ],
     target: {
         android: {
diff --git a/statsd/Android.bp b/statsd/Android.bp
index bc711dc9..f606438c 100644
--- a/statsd/Android.bp
+++ b/statsd/Android.bp
@@ -101,7 +101,7 @@ cc_defaults {
         "libsysutils",
         "libutils",
         "server_configurable_flags",
-        "statsd-aidl-ndk_platform",
+        "statsd-aidl-ndk",
     ],
     shared_libs: [
         "libbinder_ndk",
diff --git a/statsd/src/StatsLogProcessor.cpp b/statsd/src/StatsLogProcessor.cpp
index 7571ba87..2470127e 100644
--- a/statsd/src/StatsLogProcessor.cpp
+++ b/statsd/src/StatsLogProcessor.cpp
@@ -149,12 +149,7 @@ void StatsLogProcessor::mapIsolatedUidToHostUidIfNecessaryLocked(LogEvent* event
             }
         }
     } else {
-        int uidFieldIndex = event->getUidFieldIndex();
-        if (uidFieldIndex != -1) {
-           Value& value = (*event->getMutableValues())[uidFieldIndex].mValue;
-           const int hostUid = mUidMap->getHostUidOrSelf(value.int_value);
-           value.setInt(hostUid);
-        }
+        mapIsolatedUidsToHostUidInLogEvent(mUidMap, *event);
     }
 }
 
@@ -520,13 +515,19 @@ void StatsLogProcessor::GetActiveConfigsLocked(const int uid, vector<int64_t>& o
     }
 }
 
-void StatsLogProcessor::OnConfigUpdated(const int64_t timestampNs, const ConfigKey& key,
-                                        const StatsdConfig& config, bool modularUpdate) {
+void StatsLogProcessor::OnConfigUpdated(const int64_t timestampNs, const int64_t wallClockNs,
+                                        const ConfigKey& key, const StatsdConfig& config,
+                                        bool modularUpdate) {
     std::lock_guard<std::mutex> lock(mMetricsMutex);
-    WriteDataToDiskLocked(key, timestampNs, CONFIG_UPDATED, NO_TIME_CONSTRAINTS);
+    WriteDataToDiskLocked(key, timestampNs, wallClockNs, CONFIG_UPDATED, NO_TIME_CONSTRAINTS);
     OnConfigUpdatedLocked(timestampNs, key, config, modularUpdate);
 }
 
+void StatsLogProcessor::OnConfigUpdated(const int64_t timestampNs, const ConfigKey& key,
+                                        const StatsdConfig& config, bool modularUpdate) {
+    OnConfigUpdated(timestampNs, getWallClockNs(), key, config, modularUpdate);
+}
+
 void StatsLogProcessor::OnConfigUpdatedLocked(const int64_t timestampNs, const ConfigKey& key,
                                               const StatsdConfig& config, bool modularUpdate) {
     VLOG("Updated configuration for key %s", key.ToString().c_str());
@@ -589,11 +590,10 @@ void StatsLogProcessor::dumpStates(int out, bool verbose) {
  * onDumpReport dumps serialized ConfigMetricsReportList into proto.
  */
 void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTimeStampNs,
+                                     const int64_t wallClockNs,
                                      const bool include_current_partial_bucket,
-                                     const bool erase_data,
-                                     const DumpReportReason dumpReportReason,
-                                     const DumpLatency dumpLatency,
-                                     ProtoOutputStream* proto) {
+                                     const bool erase_data, const DumpReportReason dumpReportReason,
+                                     const DumpLatency dumpLatency, ProtoOutputStream* proto) {
     std::lock_guard<std::mutex> lock(mMetricsMutex);
 
     // Start of ConfigKey.
@@ -621,9 +621,10 @@ void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTim
         mLastBroadcastTimes.erase(key);
 
         vector<uint8_t> buffer;
-        onConfigMetricsReportLocked(key, dumpTimeStampNs, include_current_partial_bucket,
-                                    erase_data, dumpReportReason, dumpLatency,
-                                    false /* is this data going to be saved on disk */, &buffer);
+        onConfigMetricsReportLocked(key, dumpTimeStampNs, wallClockNs,
+                                    include_current_partial_bucket, erase_data, dumpReportReason,
+                                    dumpLatency, false /* is this data going to be saved on disk */,
+                                    &buffer);
         proto->write(FIELD_TYPE_MESSAGE | FIELD_COUNT_REPEATED | FIELD_ID_REPORTS,
                      reinterpret_cast<char*>(buffer.data()), buffer.size());
     } else {
@@ -635,13 +636,12 @@ void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTim
  * onDumpReport dumps serialized ConfigMetricsReportList into outData.
  */
 void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTimeStampNs,
+                                     const int64_t wallClockNs,
                                      const bool include_current_partial_bucket,
-                                     const bool erase_data,
-                                     const DumpReportReason dumpReportReason,
-                                     const DumpLatency dumpLatency,
-                                     vector<uint8_t>* outData) {
+                                     const bool erase_data, const DumpReportReason dumpReportReason,
+                                     const DumpLatency dumpLatency, vector<uint8_t>* outData) {
     ProtoOutputStream proto;
-    onDumpReport(key, dumpTimeStampNs, include_current_partial_bucket, erase_data,
+    onDumpReport(key, dumpTimeStampNs, wallClockNs, include_current_partial_bucket, erase_data,
                  dumpReportReason, dumpLatency, &proto);
 
     if (outData != nullptr) {
@@ -653,10 +653,22 @@ void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTim
 }
 
 /*
+ * For test use only. Excludes wallclockNs.
+ * onDumpReport dumps serialized ConfigMetricsReportList into outData.
+ */
+void StatsLogProcessor::onDumpReport(const ConfigKey& key, const int64_t dumpTimeStampNs,
+                                     const bool include_current_partial_bucket,
+                                     const bool erase_data, const DumpReportReason dumpReportReason,
+                                     const DumpLatency dumpLatency, vector<uint8_t>* outData) {
+    onDumpReport(key, dumpTimeStampNs, getWallClockNs(), include_current_partial_bucket, erase_data,
+                 dumpReportReason, dumpLatency, outData);
+}
+
+/*
  * onConfigMetricsReportLocked dumps serialized ConfigMetricsReport into outData.
  */
 void StatsLogProcessor::onConfigMetricsReportLocked(
-        const ConfigKey& key, const int64_t dumpTimeStampNs,
+        const ConfigKey& key, const int64_t dumpTimeStampNs, const int64_t wallClockNs,
         const bool include_current_partial_bucket, const bool erase_data,
         const DumpReportReason dumpReportReason, const DumpLatency dumpLatency,
         const bool dataSavedOnDisk, vector<uint8_t>* buffer) {
@@ -674,8 +686,8 @@ void StatsLogProcessor::onConfigMetricsReportLocked(
     ProtoOutputStream tempProto;
     // First, fill in ConfigMetricsReport using current data on memory, which
     // starts from filling in StatsLogReport's.
-    it->second->onDumpReport(dumpTimeStampNs, include_current_partial_bucket, erase_data,
-                             dumpLatency, &str_set, &tempProto);
+    it->second->onDumpReport(dumpTimeStampNs, wallClockNs, include_current_partial_bucket,
+                             erase_data, dumpLatency, &str_set, &tempProto);
 
     // Fill in UidMap if there is at least one metric to report.
     // This skips the uid map if it's an empty config.
@@ -695,7 +707,7 @@ void StatsLogProcessor::onConfigMetricsReportLocked(
     tempProto.write(FIELD_TYPE_INT64 | FIELD_ID_LAST_REPORT_WALL_CLOCK_NANOS,
                     (long long)lastReportWallClockNs);
     tempProto.write(FIELD_TYPE_INT64 | FIELD_ID_CURRENT_REPORT_WALL_CLOCK_NANOS,
-                    (long long)getWallClockNs());
+                    (long long)wallClockNs);
     // Dump report reason
     tempProto.write(FIELD_TYPE_INT32 | FIELD_ID_DUMP_REPORT_REASON, dumpReportReason);
 
@@ -740,7 +752,8 @@ void StatsLogProcessor::resetIfConfigTtlExpiredLocked(const int64_t eventTimeNs)
         }
     }
     if (configKeysTtlExpired.size() > 0) {
-        WriteDataToDiskLocked(CONFIG_RESET, NO_TIME_CONSTRAINTS, getElapsedRealtimeNs());
+        WriteDataToDiskLocked(CONFIG_RESET, NO_TIME_CONSTRAINTS, getElapsedRealtimeNs(),
+                              getWallClockNs());
         resetConfigsLocked(eventTimeNs, configKeysTtlExpired);
     }
 }
@@ -749,7 +762,7 @@ void StatsLogProcessor::OnConfigRemoved(const ConfigKey& key) {
     std::lock_guard<std::mutex> lock(mMetricsMutex);
     auto it = mMetricsManagers.find(key);
     if (it != mMetricsManagers.end()) {
-        WriteDataToDiskLocked(key, getElapsedRealtimeNs(), CONFIG_REMOVED,
+        WriteDataToDiskLocked(key, getElapsedRealtimeNs(), getWallClockNs(), CONFIG_REMOVED,
                               NO_TIME_CONSTRAINTS);
         mMetricsManagers.erase(it);
         mUidMap->OnConfigRemoved(key);
@@ -821,8 +834,8 @@ void StatsLogProcessor::flushIfNecessaryLocked(const ConfigKey& key,
     }
 }
 
-void StatsLogProcessor::WriteDataToDiskLocked(const ConfigKey& key,
-                                              const int64_t timestampNs,
+void StatsLogProcessor::WriteDataToDiskLocked(const ConfigKey& key, const int64_t timestampNs,
+                                              const int64_t wallClockNs,
                                               const DumpReportReason dumpReportReason,
                                               const DumpLatency dumpLatency) {
     if (mMetricsManagers.find(key) == mMetricsManagers.end() ||
@@ -830,9 +843,9 @@ void StatsLogProcessor::WriteDataToDiskLocked(const ConfigKey& key,
         return;
     }
     vector<uint8_t> buffer;
-    onConfigMetricsReportLocked(key, timestampNs, true /* include_current_partial_bucket*/,
-                                true /* erase_data */, dumpReportReason, dumpLatency, true,
-                                &buffer);
+    onConfigMetricsReportLocked(key, timestampNs, wallClockNs,
+                                true /* include_current_partial_bucket*/, true /* erase_data */,
+                                dumpReportReason, dumpLatency, true, &buffer);
     string file_name =
             StorageManager::getDataFileName((long)getWallClockSec(), key.GetUid(), key.GetId());
     StorageManager::writeFile(file_name.c_str(), buffer.data(), buffer.size());
@@ -1041,7 +1054,8 @@ void StatsLogProcessor::SetConfigsActiveStateLocked(const ActiveConfigList& acti
 
 void StatsLogProcessor::WriteDataToDiskLocked(const DumpReportReason dumpReportReason,
                                               const DumpLatency dumpLatency,
-                                              const int64_t elapsedRealtimeNs) {
+                                              const int64_t elapsedRealtimeNs,
+                                              const int64_t wallClockNs) {
     // Do not write to disk if we already have in the last few seconds.
     // This is to avoid overwriting files that would have the same name if we
     //   write twice in the same second.
@@ -1053,15 +1067,17 @@ void StatsLogProcessor::WriteDataToDiskLocked(const DumpReportReason dumpReportR
     }
     mLastWriteTimeNs = elapsedRealtimeNs;
     for (auto& pair : mMetricsManagers) {
-        WriteDataToDiskLocked(pair.first, elapsedRealtimeNs, dumpReportReason, dumpLatency);
+        WriteDataToDiskLocked(pair.first, elapsedRealtimeNs, wallClockNs, dumpReportReason,
+                              dumpLatency);
     }
 }
 
 void StatsLogProcessor::WriteDataToDisk(const DumpReportReason dumpReportReason,
                                         const DumpLatency dumpLatency,
-                                        const int64_t elapsedRealtimeNs) {
+                                        const int64_t elapsedRealtimeNs,
+                                        const int64_t wallClockNs) {
     std::lock_guard<std::mutex> lock(mMetricsMutex);
-    WriteDataToDiskLocked(dumpReportReason, dumpLatency, elapsedRealtimeNs);
+    WriteDataToDiskLocked(dumpReportReason, dumpLatency, elapsedRealtimeNs, wallClockNs);
 }
 
 void StatsLogProcessor::informPullAlarmFired(const int64_t timestampNs) {
diff --git a/statsd/src/StatsLogProcessor.h b/statsd/src/StatsLogProcessor.h
index 2cb9131c..761748c6 100644
--- a/statsd/src/StatsLogProcessor.h
+++ b/statsd/src/StatsLogProcessor.h
@@ -47,6 +47,9 @@ public:
 
     void OnLogEvent(LogEvent* event);
 
+    void OnConfigUpdated(const int64_t timestampNs, const int64_t wallClockNs, const ConfigKey& key,
+                         const StatsdConfig& config, bool modularUpdate = true);
+    // For testing only.
     void OnConfigUpdated(const int64_t timestampNs, const ConfigKey& key,
                          const StatsdConfig& config, bool modularUpdate = true);
     void OnConfigRemoved(const ConfigKey& key);
@@ -55,16 +58,19 @@ public:
 
     void GetActiveConfigs(const int uid, vector<int64_t>& outActiveConfigs);
 
-    void onDumpReport(const ConfigKey& key, const int64_t dumpTimeNs,
+    void onDumpReport(const ConfigKey& key, const int64_t dumpTimeNs, const int64_t wallClockNs,
                       const bool include_current_partial_bucket, const bool erase_data,
-                      const DumpReportReason dumpReportReason,
-                      const DumpLatency dumpLatency,
+                      const DumpReportReason dumpReportReason, const DumpLatency dumpLatency,
                       vector<uint8_t>* outData);
-    void onDumpReport(const ConfigKey& key, const int64_t dumpTimeNs,
+    void onDumpReport(const ConfigKey& key, const int64_t dumpTimeNs, const int64_t wallClockNs,
                       const bool include_current_partial_bucket, const bool erase_data,
-                      const DumpReportReason dumpReportReason,
-                      const DumpLatency dumpLatency,
+                      const DumpReportReason dumpReportReason, const DumpLatency dumpLatency,
                       ProtoOutputStream* proto);
+    // For testing only.
+    void onDumpReport(const ConfigKey& key, const int64_t dumpTimeNs,
+                      const bool include_current_partial_bucket, const bool erase_data,
+                      const DumpReportReason dumpReportReason, const DumpLatency dumpLatency,
+                      vector<uint8_t>* outData);
 
     /* Tells MetricsManager that the alarms in alarmSet have fired. Modifies periodic alarmSet. */
     void onPeriodicAlarmFired(
@@ -73,7 +79,7 @@ public:
 
     /* Flushes data to disk. Data on memory will be gone after written to disk. */
     void WriteDataToDisk(const DumpReportReason dumpReportReason, const DumpLatency dumpLatency,
-                         const int64_t elapsedRealtimeNs);
+                         const int64_t elapsedRealtimeNs, const int64_t wallClockNs);
 
     /* Persist configs containing metrics with active activations to disk. */
     void SaveActiveConfigsToDisk(int64_t currentTimeNs);
@@ -207,14 +213,15 @@ private:
                                     metadata::StatsMetadataList* metadataList);
 
     void WriteDataToDiskLocked(const DumpReportReason dumpReportReason,
-                               const DumpLatency dumpLatency, const int64_t elapsedRealtimeNs);
+                               const DumpLatency dumpLatency, const int64_t elapsedRealtimeNs,
+                               const int64_t wallClockNs);
 
     void WriteDataToDiskLocked(const ConfigKey& key, const int64_t timestampNs,
-                               const DumpReportReason dumpReportReason,
+                               const int64_t wallClockNs, const DumpReportReason dumpReportReason,
                                const DumpLatency dumpLatency);
 
     void onConfigMetricsReportLocked(
-            const ConfigKey& key, const int64_t dumpTimeStampNs,
+            const ConfigKey& key, const int64_t dumpTimeStampNs, const int64_t wallClockNs,
             const bool include_current_partial_bucket, const bool erase_data,
             const DumpReportReason dumpReportReason, const DumpLatency dumpLatency,
             /*if dataSavedToDisk is true, it indicates the caller will write the data to disk
diff --git a/statsd/src/StatsService.cpp b/statsd/src/StatsService.cpp
index 3ecb8532..51e29477 100644
--- a/statsd/src/StatsService.cpp
+++ b/statsd/src/StatsService.cpp
@@ -266,11 +266,9 @@ void StatsService::dumpIncidentSection(int out) {
         // Don't include the current bucket to avoid skipping buckets.
         // If we need to include the current bucket later, consider changing to NO_TIME_CONSTRAINTS
         // or other alternatives to avoid skipping buckets for pulled metrics.
-        mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(),
-                                 false /* includeCurrentBucket */, false /* erase_data */,
-                                 ADB_DUMP,
-                                 FAST,
-                                 &proto);
+        mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(), getWallClockNs(),
+                                 false /* includeCurrentBucket */, false /* erase_data */, ADB_DUMP,
+                                 FAST, &proto);
         proto.end(reportsListToken);
         proto.flush(out);
         proto.clear();
@@ -681,9 +679,8 @@ status_t StatsService::cmd_dump_report(int out, const Vector<String8>& args) {
         if (good) {
             vector<uint8_t> data;
             mProcessor->onDumpReport(ConfigKey(uid, StrToInt64(name)), getElapsedRealtimeNs(),
-                                     includeCurrentBucket, eraseData, ADB_DUMP,
-                                     NO_TIME_CONSTRAINTS,
-                                     &data);
+                                     getWallClockNs(), includeCurrentBucket, eraseData, ADB_DUMP,
+                                     NO_TIME_CONSTRAINTS, &data);
             if (proto) {
                 for (size_t i = 0; i < data.size(); i ++) {
                     dprintf(out, "%c", data[i]);
@@ -747,7 +744,8 @@ status_t StatsService::cmd_print_uid_map(int out, const Vector<String8>& args) {
 
 status_t StatsService::cmd_write_data_to_disk(int out) {
     dprintf(out, "Writing data to disk\n");
-    mProcessor->WriteDataToDisk(ADB_DUMP, NO_TIME_CONSTRAINTS, getElapsedRealtimeNs());
+    mProcessor->WriteDataToDisk(ADB_DUMP, NO_TIME_CONSTRAINTS, getElapsedRealtimeNs(),
+                                getWallClockNs());
     return NO_ERROR;
 }
 
@@ -1017,9 +1015,10 @@ Status StatsService::informDeviceShutdown() {
     ENFORCE_UID(AID_SYSTEM);
     VLOG("StatsService::informDeviceShutdown");
     int64_t elapsedRealtimeNs = getElapsedRealtimeNs();
-    mProcessor->WriteDataToDisk(DEVICE_SHUTDOWN, FAST, elapsedRealtimeNs);
+    int64_t wallClockNs = getWallClockNs();
+    mProcessor->WriteDataToDisk(DEVICE_SHUTDOWN, FAST, elapsedRealtimeNs, wallClockNs);
     mProcessor->SaveActiveConfigsToDisk(elapsedRealtimeNs);
-    mProcessor->SaveMetadataToDisk(getWallClockNs(), elapsedRealtimeNs);
+    mProcessor->SaveMetadataToDisk(wallClockNs, elapsedRealtimeNs);
     return Status::ok();
 }
 
@@ -1069,9 +1068,11 @@ void StatsService::Terminate() {
     ALOGI("StatsService::Terminating");
     if (mProcessor != nullptr) {
         int64_t elapsedRealtimeNs = getElapsedRealtimeNs();
-        mProcessor->WriteDataToDisk(TERMINATION_SIGNAL_RECEIVED, FAST, elapsedRealtimeNs);
+        int64_t wallClockNs = getWallClockNs();
+        mProcessor->WriteDataToDisk(TERMINATION_SIGNAL_RECEIVED, FAST, elapsedRealtimeNs,
+                                    wallClockNs);
         mProcessor->SaveActiveConfigsToDisk(elapsedRealtimeNs);
-        mProcessor->SaveMetadataToDisk(getWallClockNs(), elapsedRealtimeNs);
+        mProcessor->SaveMetadataToDisk(wallClockNs, elapsedRealtimeNs);
     }
 }
 
@@ -1090,8 +1091,9 @@ Status StatsService::getData(int64_t key, const int32_t callingUid, vector<uint8
     ConfigKey configKey(callingUid, key);
     // The dump latency does not matter here since we do not include the current bucket, we do not
     // need to pull any new data anyhow.
-    mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(), false /* include_current_bucket*/,
-                             true /* erase_data */, GET_DATA_CALLED, FAST, output);
+    mProcessor->onDumpReport(configKey, getElapsedRealtimeNs(), getWallClockNs(),
+                             false /* include_current_bucket*/, true /* erase_data */,
+                             GET_DATA_CALLED, FAST, output);
     return Status::ok();
 }
 
@@ -1292,13 +1294,13 @@ void StatsService::statsCompanionServiceDiedImpl() {
     if (mProcessor != nullptr) {
         ALOGW("Reset statsd upon system server restarts.");
         int64_t systemServerRestartNs = getElapsedRealtimeNs();
+        int64_t wallClockNs = getWallClockNs();
         ProtoOutputStream activeConfigsProto;
         mProcessor->WriteActiveConfigsToProtoOutputStream(systemServerRestartNs,
                 STATSCOMPANION_DIED, &activeConfigsProto);
         metadata::StatsMetadataList metadataList;
-        mProcessor->WriteMetadataToProto(getWallClockNs(),
-                systemServerRestartNs, &metadataList);
-        mProcessor->WriteDataToDisk(STATSCOMPANION_DIED, FAST, systemServerRestartNs);
+        mProcessor->WriteMetadataToProto(wallClockNs, systemServerRestartNs, &metadataList);
+        mProcessor->WriteDataToDisk(STATSCOMPANION_DIED, FAST, systemServerRestartNs, wallClockNs);
         mProcessor->resetConfigs();
 
         std::string serializedActiveConfigs;
@@ -1308,7 +1310,7 @@ void StatsService::statsCompanionServiceDiedImpl() {
                 mProcessor->SetConfigsActiveState(activeConfigs, systemServerRestartNs);
             }
         }
-        mProcessor->SetMetadataState(metadataList, getWallClockNs(), systemServerRestartNs);
+        mProcessor->SetMetadataState(metadataList, wallClockNs, systemServerRestartNs);
     }
     mAnomalyAlarmMonitor->setStatsCompanionService(nullptr);
     mPeriodicAlarmMonitor->setStatsCompanionService(nullptr);
diff --git a/statsd/src/external/puller_util.cpp b/statsd/src/external/puller_util.cpp
index aa99d008..3076ce36 100644
--- a/statsd/src/external/puller_util.cpp
+++ b/statsd/src/external/puller_util.cpp
@@ -18,6 +18,7 @@
 #include "Log.h"
 
 #include "puller_util.h"
+#include "stats_log_util.h"
 
 namespace android {
 namespace os {
@@ -52,9 +53,9 @@ void mapAndMergeIsolatedUidsToHostUid(vector<shared_ptr<LogEvent>>& data, const
     // tagId have them or none of them do.
     std::pair<int, int> attrIndexRange;
     const bool hasAttributionChain = data[0]->hasAttributionChain(&attrIndexRange);
-    bool hasUidField = (data[0]->getUidFieldIndex() != -1);
+    const uint8_t numUidFields = data[0]->getNumUidFields();
 
-    if (!hasAttributionChain && !hasUidField) {
+    if (!hasAttributionChain && numUidFields == 0) {
         VLOG("No uid or attribution chain to merge, atom %d", tagId);
         return;
     }
@@ -75,14 +76,7 @@ void mapAndMergeIsolatedUidsToHostUid(vector<shared_ptr<LogEvent>>& data, const
                 }
             }
         } else {
-            int uidFieldIndex = event->getUidFieldIndex();
-            if (uidFieldIndex != -1) {
-                Value& value = (*event->getMutableValues())[uidFieldIndex].mValue;
-                const int hostUid = uidMap->getHostUidOrSelf(value.int_value);
-                value.setInt(hostUid);
-            } else {
-                ALOGE("Malformed log, uid not found. %s", event->ToString().c_str());
-            }
+            mapIsolatedUidsToHostUidInLogEvent(uidMap, *event);
         }
     }
 
diff --git a/statsd/src/logd/LogEvent.cpp b/statsd/src/logd/LogEvent.cpp
index 4f031724..c4f15ad6 100644
--- a/statsd/src/logd/LogEvent.cpp
+++ b/statsd/src/logd/LogEvent.cpp
@@ -247,7 +247,9 @@ void LogEvent::parseIsUidAnnotation(uint8_t annotationType) {
     }
 
     bool isUid = readNextValue<uint8_t>();
-    if (isUid) mUidFieldIndex = static_cast<int8_t>(mValues.size() - 1);
+    if (isUid) {
+        mNumUidFields++;
+    }
     mValues[mValues.size() - 1].mAnnotations.setUidField(isUid);
 }
 
diff --git a/statsd/src/logd/LogEvent.h b/statsd/src/logd/LogEvent.h
index a5f24603..20d28482 100644
--- a/statsd/src/logd/LogEvent.h
+++ b/statsd/src/logd/LogEvent.h
@@ -149,18 +149,8 @@ public:
         return mTruncateTimestamp;
     }
 
-    // Returns the index of the uid field within the FieldValues vector if the
-    // uid exists. If there is no uid field, returns -1.
-    //
-    // If the index within the atom definition is desired, do the following:
-    //    int vectorIndex = LogEvent.getUidFieldIndex();
-    //    if (vectorIndex != -1) {
-    //        FieldValue& v = LogEvent.getValues()[vectorIndex];
-    //        int atomIndex = v.mField.getPosAtDepth(0);
-    //    }
-    // Note that atomIndex is 1-indexed.
-    inline int getUidFieldIndex() {
-        return static_cast<int>(mUidFieldIndex);
+    inline uint8_t getNumUidFields() const {
+        return mNumUidFields;
     }
 
     // Returns whether this LogEvent has an AttributionChain.
@@ -316,9 +306,7 @@ private:
     bool mTruncateTimestamp = false;
     int mResetState = -1;
 
-    // Indexes within the FieldValue vector can be stored in 7 bits because
-    // that's the assumption enforced by the encoding used in FieldValue.
-    int8_t mUidFieldIndex = -1;
+    uint8_t mNumUidFields = 0;
     int8_t mAttributionChainStartIndex = -1;
     int8_t mAttributionChainEndIndex = -1;
     int8_t mExclusiveStateFieldIndex = -1;
diff --git a/statsd/src/metrics/MetricsManager.cpp b/statsd/src/metrics/MetricsManager.cpp
index 3dba8409..130c661e 100644
--- a/statsd/src/metrics/MetricsManager.cpp
+++ b/statsd/src/metrics/MetricsManager.cpp
@@ -404,11 +404,9 @@ void MetricsManager::dropData(const int64_t dropTimeNs) {
     }
 }
 
-void MetricsManager::onDumpReport(const int64_t dumpTimeStampNs,
-                                  const bool include_current_partial_bucket,
-                                  const bool erase_data,
-                                  const DumpLatency dumpLatency,
-                                  std::set<string> *str_set,
+void MetricsManager::onDumpReport(const int64_t dumpTimeStampNs, const int64_t wallClockNs,
+                                  const bool include_current_partial_bucket, const bool erase_data,
+                                  const DumpLatency dumpLatency, std::set<string>* str_set,
                                   ProtoOutputStream* protoOutput) {
     VLOG("=========================Metric Reports Start==========================");
     // one StatsLogReport per MetricProduer
@@ -441,12 +439,11 @@ void MetricsManager::onDumpReport(const int64_t dumpTimeStampNs,
     // misaligned.
     if (erase_data) {
         mLastReportTimeNs = dumpTimeStampNs;
-        mLastReportWallClockNs = getWallClockNs();
+        mLastReportWallClockNs = wallClockNs;
     }
     VLOG("=========================Metric Reports End==========================");
 }
 
-
 bool MetricsManager::checkLogCredentials(const LogEvent& event) {
     if (mWhitelistedAtomIds.find(event.GetTagId()) != mWhitelistedAtomIds.end()) {
         return true;
diff --git a/statsd/src/metrics/MetricsManager.h b/statsd/src/metrics/MetricsManager.h
index 27bdc940..66f559ab 100644
--- a/statsd/src/metrics/MetricsManager.h
+++ b/statsd/src/metrics/MetricsManager.h
@@ -129,11 +129,9 @@ public:
 
     virtual void dropData(const int64_t dropTimeNs);
 
-    virtual void onDumpReport(const int64_t dumpTimeNs,
-                              const bool include_current_partial_bucket,
-                              const bool erase_data,
-                              const DumpLatency dumpLatency,
-                              std::set<string> *str_set,
+    virtual void onDumpReport(const int64_t dumpTimeNs, const int64_t wallClockNs,
+                              const bool include_current_partial_bucket, const bool erase_data,
+                              const DumpLatency dumpLatency, std::set<string>* str_set,
                               android::util::ProtoOutputStream* protoOutput);
 
     // Computes the total byte size of all metrics managed by a single config source.
diff --git a/statsd/src/stats_log_util.cpp b/statsd/src/stats_log_util.cpp
index 1f5dd01c..b743df54 100644
--- a/statsd/src/stats_log_util.cpp
+++ b/statsd/src/stats_log_util.cpp
@@ -567,7 +567,9 @@ int64_t getSystemUptimeMillis() {
 }
 
 int64_t getWallClockNs() {
-    return time(nullptr) * NS_PER_SEC;
+    struct timespec ts;
+    clock_gettime(CLOCK_REALTIME, &ts);
+    return ts.tv_sec * NS_PER_SEC + ts.tv_nsec;
 }
 
 int64_t getWallClockSec() {
@@ -611,6 +613,19 @@ bool checkPermissionForIds(const char* permission, pid_t pid, uid_t uid) {
     return success;
 }
 
+void mapIsolatedUidsToHostUidInLogEvent(const sp<UidMap> uidMap, LogEvent& event) {
+    uint8_t remainingUidCount = event.getNumUidFields();
+    vector<FieldValue>* fieldValues = event.getMutableValues();
+    auto it = fieldValues->begin();
+    while(it != fieldValues->end() && remainingUidCount > 0) {
+        if (isUidField(*it)) {
+            it->mValue.setInt(uidMap->getHostUidOrSelf(it->mValue.int_value));
+            remainingUidCount--;
+        }
+        ++it;
+    }
+}
+
 }  // namespace statsd
 }  // namespace os
 }  // namespace android
diff --git a/statsd/src/stats_log_util.h b/statsd/src/stats_log_util.h
index 8034e88f..d6c181c5 100644
--- a/statsd/src/stats_log_util.h
+++ b/statsd/src/stats_log_util.h
@@ -23,6 +23,7 @@
 #include "src/statsd_config.pb.h"
 #include "guardrail/StatsdStats.h"
 #include "logd/LogEvent.h"
+#include "packages/UidMap.h"
 
 using android::util::ProtoOutputStream;
 
@@ -116,6 +117,8 @@ inline bool isPulledAtom(int atomId) {
     return atomId >= StatsdStats::kPullAtomStartTag && atomId < StatsdStats::kVendorAtomStartTag;
 }
 
+void mapIsolatedUidsToHostUidInLogEvent(const sp<UidMap> uidMap, LogEvent& event);
+
 }  // namespace statsd
 }  // namespace os
 }  // namespace android
diff --git a/statsd/tests/LogEvent_test.cpp b/statsd/tests/LogEvent_test.cpp
index 13c23d22..4b4c6bc9 100644
--- a/statsd/tests/LogEvent_test.cpp
+++ b/statsd/tests/LogEvent_test.cpp
@@ -289,9 +289,11 @@ TEST(LogEventTest, TestAnnotationIdIsUid) {
     LogEvent event(/*uid=*/0, /*pid=*/0);
     createIntWithBoolAnnotationLogEvent(&event, ANNOTATION_ID_IS_UID, true);
 
+    ASSERT_EQ(event.getNumUidFields(), 1);
+
     const vector<FieldValue>& values = event.getValues();
     ASSERT_EQ(values.size(), 1);
-    EXPECT_EQ(event.getUidFieldIndex(), 0);
+    EXPECT_TRUE(isUidField(values.at(0)));
 }
 
 TEST(LogEventTest, TestAnnotationIdStateNested) {
@@ -418,7 +420,7 @@ TEST(LogEventTest, TestUidAnnotationAfterTooManyFields) {
 
     LogEvent logEvent(/*uid=*/1000, /*pid=*/1001);
     EXPECT_FALSE(logEvent.parseBuffer(buf, size));
-    EXPECT_EQ(-1, logEvent.getUidFieldIndex());
+    EXPECT_EQ(0, logEvent.getNumUidFields());
 
     AStatsEvent_release(event);
 }
diff --git a/statsd/tests/e2e/ConfigUpdate_e2e_test.cpp b/statsd/tests/e2e/ConfigUpdate_e2e_test.cpp
index e18ecf83..e5ca9e72 100644
--- a/statsd/tests/e2e/ConfigUpdate_e2e_test.cpp
+++ b/statsd/tests/e2e/ConfigUpdate_e2e_test.cpp
@@ -2002,7 +2002,7 @@ TEST_F(ConfigUpdateE2eTest, TestMetricActivation) {
 
     // Fake a reboot. Code is from StatsService::informDeviceShutdown.
     int64_t shutDownTimeNs = bucketStartTimeNs + 50 * NS_PER_SEC;
-    processor->WriteDataToDisk(DEVICE_SHUTDOWN, FAST, shutDownTimeNs);
+    processor->WriteDataToDisk(DEVICE_SHUTDOWN, FAST, shutDownTimeNs, getWallClockNs());
     processor->SaveActiveConfigsToDisk(shutDownTimeNs);
     processor->SaveMetadataToDisk(getWallClockNs(), shutDownTimeNs);
 
diff --git a/statsd/tools/localtools/src/com/android/statsd/shelltools/testdrive/TestDrive.java b/statsd/tools/localtools/src/com/android/statsd/shelltools/testdrive/TestDrive.java
index b109a084..1fe788e5 100644
--- a/statsd/tools/localtools/src/com/android/statsd/shelltools/testdrive/TestDrive.java
+++ b/statsd/tools/localtools/src/com/android/statsd/shelltools/testdrive/TestDrive.java
@@ -73,6 +73,7 @@ public class TestDrive {
             "com.google.android.providers.media.module",
             "com.android.imsserviceentitlement",
             "com.google.android.cellbroadcastreceiver",
+            "com.google.android.apps.nexuslauncher",
             "AID_KEYSTORE",
     };
     private static final String[] DEFAULT_PULL_SOURCES = {
@@ -362,6 +363,9 @@ public class TestDrive {
                     .addPullAtomPackages(PullAtomPackages.newBuilder()
                             .setAtomId(Atom.GENERAL_EXTERNAL_STORAGE_ACCESS_STATS_FIELD_NUMBER)
                             .addPackages("com.google.android.providers.media.module"))
+                    .addPullAtomPackages(PullAtomPackages.newBuilder()
+                            .setAtomId(Atom.LAUNCHER_LAYOUT_SNAPSHOT_FIELD_NUMBER)
+                            .addPackages("com.google.android.apps.nexuslauncher"))
                     .setHashStringsInMetricReport(false);
         }
     }
diff --git a/tests/src/android/cts/statsd/atom/AtomTestCase.java b/tests/src/android/cts/statsd/atom/AtomTestCase.java
index 066d5bd8..a4c43e07 100644
--- a/tests/src/android/cts/statsd/atom/AtomTestCase.java
+++ b/tests/src/android/cts/statsd/atom/AtomTestCase.java
@@ -341,7 +341,7 @@ public class AtomTestCase extends BaseTestCase {
             if (metricData.hasAtom()) {
               data.add(metricData);
             } else {
-              data.addAll(backfillAggregatedAtomsinEventMetric(metricData));
+              data.addAll(backfillAggregatedAtomsInEventMetric(metricData));
             }
           }
         }
@@ -1235,10 +1235,10 @@ public class AtomTestCase extends BaseTestCase {
                 .that(timestampNs % fiveMinutesInNs).isEqualTo(0);
     }
 
-    private List<EventMetricData>
-    backfillAggregatedAtomsinEventMetric(EventMetricData metricData) {
+    protected List<EventMetricData> backfillAggregatedAtomsInEventMetric(
+            EventMetricData metricData) {
       if (!metricData.hasAggregatedAtomInfo()) {
-        return Collections.emptyList();
+        return Collections.singletonList(metricData);
       }
       List<EventMetricData> data = new ArrayList<>();
       StatsLog.AggregatedAtomInfo atomInfo = metricData.getAggregatedAtomInfo();
diff --git a/tests/src/android/cts/statsd/metric/MetricActivationTests.java b/tests/src/android/cts/statsd/metric/MetricActivationTests.java
index 339970ac..25fa0318 100644
--- a/tests/src/android/cts/statsd/metric/MetricActivationTests.java
+++ b/tests/src/android/cts/statsd/metric/MetricActivationTests.java
@@ -31,9 +31,11 @@ import com.android.os.AtomsProto.AppBreadcrumbReported;
 import com.android.os.AtomsProto.Atom;
 import com.android.os.StatsLog.ConfigMetricsReport;
 import com.android.os.StatsLog.ConfigMetricsReportList;
+import com.android.os.StatsLog.EventMetricData;
 import com.android.os.StatsLog.StatsLogReport;
 import com.android.tradefed.log.LogUtil;
 
+import java.util.ArrayList;
 import java.util.List;
 
 /**
@@ -557,9 +559,13 @@ public class MetricActivationTests extends DeviceAtomTestCase {
         assertThat(metricReport.hasEventMetrics()).isEqualTo(dataCount > 0);
 
         StatsLogReport.EventMetricDataWrapper eventData = metricReport.getEventMetrics();
-        assertThat(eventData.getDataCount()).isEqualTo(dataCount);
-        for (int i = 0; i < eventData.getDataCount(); i++) {
-            AppBreadcrumbReported atom = eventData.getData(i).getAtom().getAppBreadcrumbReported();
+        List<EventMetricData> eventMetricDataList = new ArrayList<>();
+        for (EventMetricData eventMetricData : eventData.getDataList()) {
+            eventMetricDataList.addAll(backfillAggregatedAtomsInEventMetric(eventMetricData));
+        }
+        assertThat(eventMetricDataList).hasSize(dataCount);
+        for (EventMetricData eventMetricData : eventMetricDataList) {
+            AppBreadcrumbReported atom = eventMetricData.getAtom().getAppBreadcrumbReported();
             assertThat(atom.getLabel()).isEqualTo(metricMatcherLabel);
         }
     }