Reduce the number of remote data writers

Data coming in from other nodes are logged per channel, i.e. there is
one data writer and one file per channel information being logged from
remote nodes. This takes up significant memory for the compression level
we aim for. Reduce the number of writers by consolidating all channel
data per node.

Change-Id: Id44d8ab51d0d076ae4ad6917bc22bd9e70bd3aae
Signed-off-by: James Kuszmaul <james.kuszmaul@bluerivertech.com>
diff --git a/aos/events/logging/log_namer.cc b/aos/events/logging/log_namer.cc
index bdcb454..16bd609 100644
--- a/aos/events/logging/log_namer.cc
+++ b/aos/events/logging/log_namer.cc
@@ -727,15 +727,29 @@
     nodes_.emplace_back(source_node);
   }
 
+  // If we already have a data writer for the node, then use the same writer for
+  // all channels of that node.
+  if (node_data_writers_.find(source_node) != node_data_writers_.end()) {
+    node_data_writers_.find(source_node)
+        ->second->UpdateMaxMessageSize(
+            PackMessageSize(LogType::kLogRemoteMessage, channel->max_size()));
+    return node_data_writers_.find(source_node)->second;
+  }
+
+  // If we don't have a data writer for the node, create one.
   NewDataWriter data_writer(
       this, source_node, node_,
       [this, channel](NewDataWriter *data_writer) {
         OpenWriter(channel, data_writer);
       },
       [this](NewDataWriter *data_writer) { CloseWriter(&data_writer->writer); },
+      0);
+  data_writer.UpdateMaxMessageSize(
       PackMessageSize(LogType::kLogRemoteMessage, channel->max_size()));
-  return &(
-      data_writers_.emplace(channel, std::move(data_writer)).first->second);
+
+  data_writers_.emplace(channel, std::move(data_writer));
+  node_data_writers_.emplace(source_node, &data_writers_.find(channel)->second);
+  return &(data_writers_.find(channel)->second);
 }
 
 NewDataWriter *MultiNodeLogNamer::MakeForwardedTimestampWriter(
@@ -782,6 +796,7 @@
 
 WriteCode MultiNodeLogNamer::Close() {
   data_writers_.clear();
+  node_data_writers_.clear();
   data_writer_.reset();
   if (ran_out_of_space_) {
     return WriteCode::kOutOfSpace;
@@ -820,9 +835,9 @@
 void MultiNodeLogNamer::OpenWriter(const Channel *channel,
                                    NewDataWriter *data_writer) {
   const std::string filename = absl::StrCat(
-      CHECK_NOTNULL(channel->source_node())->string_view(), "_data",
-      channel->name()->string_view(), "/", channel->type()->string_view(),
-      ".part", data_writer->parts_index(), ".bfbs", extension_);
+      CHECK_NOTNULL(channel->source_node())->string_view(), "_data/",
+      channel->source_node()->string_view(), "_data.part",
+      data_writer->parts_index(), ".bfbs", extension_);
   CreateBufferWriter(filename, data_writer->max_message_size(),
                      &data_writer->writer);
 }
diff --git a/aos/events/logging/log_namer.h b/aos/events/logging/log_namer.h
index 6408aea..fb69f03 100644
--- a/aos/events/logging/log_namer.h
+++ b/aos/events/logging/log_namer.h
@@ -534,6 +534,9 @@
   std::unique_ptr<NewDataWriter> data_writer_;
 
   std::map<const Channel *, NewDataWriter> data_writers_;
+
+  // Data writer per remote node.
+  std::map<const Node *, NewDataWriter *> node_data_writers_;
 };
 
 // This is specialized log namer that deals with directory centric log events.
diff --git a/aos/events/logging/multinode_logger_test.cc b/aos/events/logging/multinode_logger_test.cc
index 01f4d2f..b1f35f9 100644
--- a/aos/events/logging/multinode_logger_test.cc
+++ b/aos/events/logging/multinode_logger_test.cc
@@ -80,9 +80,9 @@
 
     EXPECT_EQ(logfile_uuids.size(), 2u);
     if (shared()) {
-      EXPECT_EQ(parts_uuids.size(), 7u);
+      EXPECT_EQ(parts_uuids.size(), 6u);
     } else {
-      EXPECT_EQ(parts_uuids.size(), 8u);
+      EXPECT_EQ(parts_uuids.size(), 7u);
     }
 
     // And confirm everything is on the correct node.
@@ -92,33 +92,30 @@
 
     EXPECT_EQ(log_header[5].message().node()->name()->string_view(), "pi2");
     EXPECT_EQ(log_header[6].message().node()->name()->string_view(), "pi2");
-
     EXPECT_EQ(log_header[7].message().node()->name()->string_view(), "pi2");
-    EXPECT_EQ(log_header[8].message().node()->name()->string_view(), "pi2");
-    EXPECT_EQ(log_header[9].message().node()->name()->string_view(), "pi2");
 
-    EXPECT_EQ(log_header[10].message().node()->name()->string_view(), "pi1");
-    EXPECT_EQ(log_header[11].message().node()->name()->string_view(), "pi1");
+    EXPECT_EQ(log_header[8].message().node()->name()->string_view(), "pi1");
+    EXPECT_EQ(log_header[9].message().node()->name()->string_view(), "pi1");
 
-    EXPECT_EQ(log_header[12].message().node()->name()->string_view(), "pi2");
-    EXPECT_EQ(log_header[13].message().node()->name()->string_view(), "pi2");
+    EXPECT_EQ(log_header[10].message().node()->name()->string_view(), "pi2");
+    EXPECT_EQ(log_header[11].message().node()->name()->string_view(), "pi2");
 
     if (shared()) {
+      EXPECT_EQ(log_header[12].message().node()->name()->string_view(), "pi2");
+      EXPECT_EQ(log_header[13].message().node()->name()->string_view(), "pi2");
       EXPECT_EQ(log_header[14].message().node()->name()->string_view(), "pi2");
-      EXPECT_EQ(log_header[15].message().node()->name()->string_view(), "pi2");
-      EXPECT_EQ(log_header[16].message().node()->name()->string_view(), "pi2");
 
-      EXPECT_EQ(log_header[17].message().node()->name()->string_view(), "pi1");
-      EXPECT_EQ(log_header[18].message().node()->name()->string_view(), "pi1");
-    } else {
-      EXPECT_EQ(log_header[14].message().node()->name()->string_view(), "pi2");
-      EXPECT_EQ(log_header[15].message().node()->name()->string_view(), "pi2");
-
+      EXPECT_EQ(log_header[15].message().node()->name()->string_view(), "pi1");
       EXPECT_EQ(log_header[16].message().node()->name()->string_view(), "pi1");
-      EXPECT_EQ(log_header[17].message().node()->name()->string_view(), "pi1");
+    } else {
+      EXPECT_EQ(log_header[12].message().node()->name()->string_view(), "pi2");
+      EXPECT_EQ(log_header[13].message().node()->name()->string_view(), "pi2");
 
-      EXPECT_EQ(log_header[18].message().node()->name()->string_view(), "pi2");
-      EXPECT_EQ(log_header[19].message().node()->name()->string_view(), "pi2");
+      EXPECT_EQ(log_header[14].message().node()->name()->string_view(), "pi1");
+      EXPECT_EQ(log_header[15].message().node()->name()->string_view(), "pi1");
+
+      EXPECT_EQ(log_header[16].message().node()->name()->string_view(), "pi2");
+      EXPECT_EQ(log_header[17].message().node()->name()->string_view(), "pi2");
     }
 
     // And the parts index matches.
@@ -128,33 +125,30 @@
 
     EXPECT_EQ(log_header[5].message().parts_index(), 0);
     EXPECT_EQ(log_header[6].message().parts_index(), 1);
+    EXPECT_EQ(log_header[7].message().parts_index(), 2);
 
-    EXPECT_EQ(log_header[7].message().parts_index(), 0);
-    EXPECT_EQ(log_header[8].message().parts_index(), 1);
-    EXPECT_EQ(log_header[9].message().parts_index(), 2);
+    EXPECT_EQ(log_header[8].message().parts_index(), 0);
+    EXPECT_EQ(log_header[9].message().parts_index(), 1);
 
     EXPECT_EQ(log_header[10].message().parts_index(), 0);
     EXPECT_EQ(log_header[11].message().parts_index(), 1);
 
-    EXPECT_EQ(log_header[12].message().parts_index(), 0);
-    EXPECT_EQ(log_header[13].message().parts_index(), 1);
-
     if (shared()) {
-      EXPECT_EQ(log_header[14].message().parts_index(), 0);
-      EXPECT_EQ(log_header[15].message().parts_index(), 1);
-      EXPECT_EQ(log_header[16].message().parts_index(), 2);
+      EXPECT_EQ(log_header[12].message().parts_index(), 0);
+      EXPECT_EQ(log_header[13].message().parts_index(), 1);
+      EXPECT_EQ(log_header[14].message().parts_index(), 2);
 
-      EXPECT_EQ(log_header[17].message().parts_index(), 0);
-      EXPECT_EQ(log_header[18].message().parts_index(), 1);
+      EXPECT_EQ(log_header[15].message().parts_index(), 0);
+      EXPECT_EQ(log_header[16].message().parts_index(), 1);
     } else {
+      EXPECT_EQ(log_header[12].message().parts_index(), 0);
+      EXPECT_EQ(log_header[13].message().parts_index(), 1);
+
       EXPECT_EQ(log_header[14].message().parts_index(), 0);
       EXPECT_EQ(log_header[15].message().parts_index(), 1);
 
       EXPECT_EQ(log_header[16].message().parts_index(), 0);
       EXPECT_EQ(log_header[17].message().parts_index(), 1);
-
-      EXPECT_EQ(log_header[18].message().parts_index(), 0);
-      EXPECT_EQ(log_header[19].message().parts_index(), 1);
     }
   }
 
@@ -223,37 +217,19 @@
             std::make_tuple("/pi2/aos", "aos.message_bridge.Timestamp", 200)))
         << " : " << logfiles_[4];
 
-    // Pong data.
-    EXPECT_THAT(
-        CountChannelsData(config, logfiles_[5]),
-        UnorderedElementsAre(std::make_tuple("/test", "aos.examples.Pong", 91)))
-        << " : " << logfiles_[5];
-    EXPECT_THAT(CountChannelsData(config, logfiles_[6]),
-                UnorderedElementsAre(
-                    std::make_tuple("/test", "aos.examples.Pong", 1910)))
-        << " : " << logfiles_[6];
-
-    // No timestamps
-    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[5]),
-                UnorderedElementsAre())
-        << " : " << logfiles_[5];
-    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[6]),
-                UnorderedElementsAre())
-        << " : " << logfiles_[6];
-
     // Timing reports and pongs.
-    EXPECT_THAT(CountChannelsData(config, logfiles_[7]),
+    EXPECT_THAT(CountChannelsData(config, logfiles_[5]),
                 UnorderedElementsAre(
                     std::make_tuple("/pi2/aos", "aos.examples.Ping", 1),
                     std::make_tuple("/pi2/aos",
                                     "aos.message_bridge.ServerStatistics", 1)))
-        << " : " << logfiles_[7];
+        << " : " << logfiles_[5];
     EXPECT_THAT(
-        CountChannelsData(config, logfiles_[8]),
+        CountChannelsData(config, logfiles_[6]),
         UnorderedElementsAre(std::make_tuple("/test", "aos.examples.Pong", 1)))
-        << " : " << logfiles_[8];
+        << " : " << logfiles_[6];
     EXPECT_THAT(
-        CountChannelsData(config, logfiles_[9]),
+        CountChannelsData(config, logfiles_[7]),
         UnorderedElementsAre(
             std::make_tuple("/pi2/aos", "aos.examples.Ping", 2000),
             std::make_tuple("/pi2/aos", "aos.message_bridge.Timestamp", 200),
@@ -263,57 +239,68 @@
                             200),
             std::make_tuple("/pi2/aos", "aos.timing.Report", 60),
             std::make_tuple("/test", "aos.examples.Pong", 2000)))
-        << " : " << logfiles_[9];
-    // And ping timestamps.
-    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[7]),
-                UnorderedElementsAre())
         << " : " << logfiles_[7];
+    // And ping timestamps.
+    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[5]),
+                UnorderedElementsAre())
+        << " : " << logfiles_[5];
     EXPECT_THAT(
-        CountChannelsTimestamp(config, logfiles_[8]),
+        CountChannelsTimestamp(config, logfiles_[6]),
         UnorderedElementsAre(std::make_tuple("/test", "aos.examples.Ping", 1)))
-        << " : " << logfiles_[8];
+        << " : " << logfiles_[6];
     EXPECT_THAT(
-        CountChannelsTimestamp(config, logfiles_[9]),
+        CountChannelsTimestamp(config, logfiles_[7]),
         UnorderedElementsAre(
             std::make_tuple("/test", "aos.examples.Ping", 2000),
             std::make_tuple("/pi1/aos", "aos.message_bridge.Timestamp", 200)))
-        << " : " << logfiles_[9];
+        << " : " << logfiles_[7];
 
     // And then test that the remotely logged timestamp data files only have
     // timestamps in them.
+    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[8]),
+                UnorderedElementsAre())
+        << " : " << logfiles_[8];
+    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[9]),
+                UnorderedElementsAre())
+        << " : " << logfiles_[9];
     EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[10]),
                 UnorderedElementsAre())
         << " : " << logfiles_[10];
     EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[11]),
                 UnorderedElementsAre())
         << " : " << logfiles_[11];
-    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[12]),
-                UnorderedElementsAre())
-        << " : " << logfiles_[12];
-    EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[13]),
-                UnorderedElementsAre())
-        << " : " << logfiles_[13];
 
-    EXPECT_THAT(CountChannelsData(config, logfiles_[10]),
+    EXPECT_THAT(CountChannelsData(config, logfiles_[8]),
                 UnorderedElementsAre(std::make_tuple(
                     "/pi1/aos", "aos.message_bridge.Timestamp", 9)))
-        << " : " << logfiles_[10];
-    EXPECT_THAT(CountChannelsData(config, logfiles_[11]),
+        << " : " << logfiles_[8];
+    EXPECT_THAT(CountChannelsData(config, logfiles_[9]),
                 UnorderedElementsAre(std::make_tuple(
                     "/pi1/aos", "aos.message_bridge.Timestamp", 191)))
-        << " : " << logfiles_[11];
+        << " : " << logfiles_[9];
 
-    EXPECT_THAT(CountChannelsData(config, logfiles_[12]),
-                UnorderedElementsAre(std::make_tuple(
-                    "/pi2/aos", "aos.message_bridge.Timestamp", 9)))
-        << " : " << logfiles_[12];
-    EXPECT_THAT(CountChannelsData(config, logfiles_[13]),
-                UnorderedElementsAre(std::make_tuple(
-                    "/pi2/aos", "aos.message_bridge.Timestamp", 191)))
-        << " : " << logfiles_[13];
+    // Pong snd timestamp data.
+    EXPECT_THAT(
+        CountChannelsData(config, logfiles_[10]),
+        UnorderedElementsAre(
+            std::make_tuple("/pi2/aos", "aos.message_bridge.Timestamp", 9),
+            std::make_tuple("/test", "aos.examples.Pong", 91)))
+        << " : " << logfiles_[10];
+    EXPECT_THAT(
+        CountChannelsData(config, logfiles_[11]),
+        UnorderedElementsAre(
+            std::make_tuple("/pi2/aos", "aos.message_bridge.Timestamp", 191),
+            std::make_tuple("/test", "aos.examples.Pong", 1910)))
+        << " : " << logfiles_[11];
 
     // Timestamps from pi2 on pi1, and the other way.
     if (shared()) {
+      EXPECT_THAT(CountChannelsData(config, logfiles_[12]),
+                  UnorderedElementsAre())
+          << " : " << logfiles_[12];
+      EXPECT_THAT(CountChannelsData(config, logfiles_[13]),
+                  UnorderedElementsAre())
+          << " : " << logfiles_[13];
       EXPECT_THAT(CountChannelsData(config, logfiles_[14]),
                   UnorderedElementsAre())
           << " : " << logfiles_[14];
@@ -323,38 +310,38 @@
       EXPECT_THAT(CountChannelsData(config, logfiles_[16]),
                   UnorderedElementsAre())
           << " : " << logfiles_[16];
-      EXPECT_THAT(CountChannelsData(config, logfiles_[17]),
-                  UnorderedElementsAre())
-          << " : " << logfiles_[17];
-      EXPECT_THAT(CountChannelsData(config, logfiles_[18]),
-                  UnorderedElementsAre())
-          << " : " << logfiles_[18];
 
-      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[14]),
+      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[12]),
                   UnorderedElementsAre(
                       std::make_tuple("/test", "aos.examples.Ping", 1)))
-          << " : " << logfiles_[14];
+          << " : " << logfiles_[12];
       EXPECT_THAT(
-          CountChannelsTimestamp(config, logfiles_[15]),
+          CountChannelsTimestamp(config, logfiles_[13]),
           UnorderedElementsAre(
               std::make_tuple("/pi1/aos", "aos.message_bridge.Timestamp", 9),
               std::make_tuple("/test", "aos.examples.Ping", 90)))
-          << " : " << logfiles_[15];
+          << " : " << logfiles_[13];
       EXPECT_THAT(
-          CountChannelsTimestamp(config, logfiles_[16]),
+          CountChannelsTimestamp(config, logfiles_[14]),
           UnorderedElementsAre(
               std::make_tuple("/pi1/aos", "aos.message_bridge.Timestamp", 191),
               std::make_tuple("/test", "aos.examples.Ping", 1910)))
-          << " : " << logfiles_[16];
-      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[17]),
+          << " : " << logfiles_[14];
+      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[15]),
                   UnorderedElementsAre(std::make_tuple(
                       "/pi2/aos", "aos.message_bridge.Timestamp", 9)))
-          << " : " << logfiles_[17];
-      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[18]),
+          << " : " << logfiles_[15];
+      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[16]),
                   UnorderedElementsAre(std::make_tuple(
                       "/pi2/aos", "aos.message_bridge.Timestamp", 191)))
-          << " : " << logfiles_[18];
+          << " : " << logfiles_[16];
     } else {
+      EXPECT_THAT(CountChannelsData(config, logfiles_[12]),
+                  UnorderedElementsAre())
+          << " : " << logfiles_[12];
+      EXPECT_THAT(CountChannelsData(config, logfiles_[13]),
+                  UnorderedElementsAre())
+          << " : " << logfiles_[13];
       EXPECT_THAT(CountChannelsData(config, logfiles_[14]),
                   UnorderedElementsAre())
           << " : " << logfiles_[14];
@@ -367,37 +354,31 @@
       EXPECT_THAT(CountChannelsData(config, logfiles_[17]),
                   UnorderedElementsAre())
           << " : " << logfiles_[17];
-      EXPECT_THAT(CountChannelsData(config, logfiles_[18]),
-                  UnorderedElementsAre())
-          << " : " << logfiles_[18];
-      EXPECT_THAT(CountChannelsData(config, logfiles_[19]),
-                  UnorderedElementsAre())
-          << " : " << logfiles_[19];
 
-      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[14]),
+      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[12]),
                   UnorderedElementsAre(std::make_tuple(
                       "/pi1/aos", "aos.message_bridge.Timestamp", 9)))
+          << " : " << logfiles_[12];
+      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[13]),
+                  UnorderedElementsAre(std::make_tuple(
+                      "/pi1/aos", "aos.message_bridge.Timestamp", 191)))
+          << " : " << logfiles_[13];
+      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[14]),
+                  UnorderedElementsAre(std::make_tuple(
+                      "/pi2/aos", "aos.message_bridge.Timestamp", 9)))
           << " : " << logfiles_[14];
       EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[15]),
                   UnorderedElementsAre(std::make_tuple(
-                      "/pi1/aos", "aos.message_bridge.Timestamp", 191)))
+                      "/pi2/aos", "aos.message_bridge.Timestamp", 191)))
           << " : " << logfiles_[15];
       EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[16]),
-                  UnorderedElementsAre(std::make_tuple(
-                      "/pi2/aos", "aos.message_bridge.Timestamp", 9)))
-          << " : " << logfiles_[16];
-      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[17]),
-                  UnorderedElementsAre(std::make_tuple(
-                      "/pi2/aos", "aos.message_bridge.Timestamp", 191)))
-          << " : " << logfiles_[17];
-      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[18]),
                   UnorderedElementsAre(
                       std::make_tuple("/test", "aos.examples.Ping", 91)))
-          << " : " << logfiles_[18];
-      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[19]),
+          << " : " << logfiles_[16];
+      EXPECT_THAT(CountChannelsTimestamp(config, logfiles_[17]),
                   UnorderedElementsAre(
                       std::make_tuple("/test", "aos.examples.Ping", 1910)))
-          << " : " << logfiles_[19];
+          << " : " << logfiles_[17];
     }
   }
 
diff --git a/aos/events/logging/multinode_logger_test_lib.cc b/aos/events/logging/multinode_logger_test_lib.cc
index 2e13814..5cbe93c 100644
--- a/aos/events/logging/multinode_logger_test_lib.cc
+++ b/aos/events/logging/multinode_logger_test_lib.cc
@@ -148,26 +148,14 @@
     result.emplace_back(
         absl::StrCat(logfile_base1, "_pi1_data.part", i, Extension()));
   }
-  result.emplace_back(logfile_base1 + "_pi2_data/test/aos.examples.Pong.part0" +
-                      Extension());
-  result.emplace_back(logfile_base1 + "_pi2_data/test/aos.examples.Pong.part1" +
-                      Extension());
   for (size_t i = 0; i < pi2_data_count; ++i) {
     result.emplace_back(
         absl::StrCat(logfile_base2, "_pi2_data.part", i, Extension()));
   }
-  result.emplace_back(logfile_base2 +
-                      "_pi1_data/pi1/aos/aos.message_bridge.Timestamp.part0" +
-                      Extension());
-  result.emplace_back(logfile_base2 +
-                      "_pi1_data/pi1/aos/aos.message_bridge.Timestamp.part1" +
-                      Extension());
-  result.emplace_back(logfile_base1 +
-                      "_pi2_data/pi2/aos/aos.message_bridge.Timestamp.part0" +
-                      Extension());
-  result.emplace_back(logfile_base1 +
-                      "_pi2_data/pi2/aos/aos.message_bridge.Timestamp.part1" +
-                      Extension());
+  result.emplace_back(logfile_base2 + "_pi1_data/pi1_data.part0" + Extension());
+  result.emplace_back(logfile_base2 + "_pi1_data/pi1_data.part1" + Extension());
+  result.emplace_back(logfile_base1 + "_pi2_data/pi2_data.part0" + Extension());
+  result.emplace_back(logfile_base1 + "_pi2_data/pi2_data.part1" + Extension());
   if (shared()) {
     result.emplace_back(logfile_base1 +
                         "_timestamps/pi1/aos/remote_timestamps/pi2/"
@@ -232,25 +220,13 @@
   result.emplace_back(logfile_base1_ + "_pi1_data.part2" + Extension());
   result.emplace_back(logfile_base1_ + "_pi1_data.part3" + Extension());
   result.emplace_back(logfile_base1_ + "_pi1_data.part4" + Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/test/aos.examples.Pong.part0" + Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/test/aos.examples.Pong.part1" + Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/test/aos.examples.Pong.part2" + Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/test/aos.examples.Pong.part3" + Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/pi2/aos/aos.message_bridge.Timestamp.part0" +
+  result.emplace_back(logfile_base1_ + "_pi2_data/pi2_data.part0" +
                       Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/pi2/aos/aos.message_bridge.Timestamp.part1" +
+  result.emplace_back(logfile_base1_ + "_pi2_data/pi2_data.part1" +
                       Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/pi2/aos/aos.message_bridge.Timestamp.part2" +
+  result.emplace_back(logfile_base1_ + "_pi2_data/pi2_data.part2" +
                       Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/pi2/aos/aos.message_bridge.Timestamp.part3" +
+  result.emplace_back(logfile_base1_ + "_pi2_data/pi2_data.part3" +
                       Extension());
   result.emplace_back(absl::StrCat(
       logfile_base1_, "_", std::get<0>(GetParam()).sha256, Extension()));
@@ -312,9 +288,6 @@
   std::vector<std::string> result;
   result.emplace_back(logfile_base1_ + "_pi1_data.part0" + Extension());
   result.emplace_back(logfile_base1_ + "_pi1_data.part1" + Extension());
-  result.emplace_back(logfile_base1_ +
-                      "_pi2_data/pi2/aos/aos.message_bridge.Timestamp.part0" +
-                      Extension());
   result.emplace_back(absl::StrCat(
       logfile_base1_, "_", std::get<0>(GetParam()).sha256, Extension()));
   return result;
@@ -331,19 +304,19 @@
 std::vector<std::vector<std::string>> MultinodeLoggerTest::StructureLogFiles() {
   std::vector<std::vector<std::string>> result{
       std::vector<std::string>{logfiles_[2], logfiles_[3], logfiles_[4]},
-      std::vector<std::string>{logfiles_[5], logfiles_[6]},
-      std::vector<std::string>{logfiles_[7], logfiles_[8], logfiles_[9]},
-      std::vector<std::string>{logfiles_[10], logfiles_[11]},
-      std::vector<std::string>{logfiles_[12], logfiles_[13]}};
+      // std::vector<std::string>{logfiles_[5], logfiles_[6]},
+      std::vector<std::string>{logfiles_[5], logfiles_[6], logfiles_[7]},
+      std::vector<std::string>{logfiles_[8], logfiles_[9]},
+      std::vector<std::string>{logfiles_[10], logfiles_[11]}};
 
   if (shared()) {
     result.emplace_back(
-        std::vector<std::string>{logfiles_[14], logfiles_[15], logfiles_[16]});
-    result.emplace_back(std::vector<std::string>{logfiles_[17], logfiles_[18]});
+        std::vector<std::string>{logfiles_[12], logfiles_[13], logfiles_[14]});
+    result.emplace_back(std::vector<std::string>{logfiles_[15], logfiles_[16]});
   } else {
+    result.emplace_back(std::vector<std::string>{logfiles_[12], logfiles_[13]});
     result.emplace_back(std::vector<std::string>{logfiles_[14], logfiles_[15]});
     result.emplace_back(std::vector<std::string>{logfiles_[16], logfiles_[17]});
-    result.emplace_back(std::vector<std::string>{logfiles_[18], logfiles_[19]});
   }
 
   return result;
@@ -422,7 +395,7 @@
   // depends on if we have the remote timestamps split across 2 files, or just
   // across 1, depending on if we are using a split or combined timestamp
   // channel config.
-  EXPECT_EQ(missing_rt_count, shared() ? 5u : 6u);
+  EXPECT_EQ(missing_rt_count, shared() ? 4u : 5u);
 
   EXPECT_EQ(log_event_uuids.size(), 2u);
   EXPECT_EQ(parts_uuids.size(), ToLogReaderVector(sorted_parts).size());