Wrap DetachedBufferWriter in an object for logging
We have 2 use cases for more careful control of the
DetachedBufferWriter. We are seeing headers written twice, and need to
start tracking boot UUID per node per log file. Both would benifit from
an object which can control and track how the log files are being
written.
This should be purely a refactor. Follow-up commits will change how
headers are written and track UUIDs.
Change-Id: Ib5c1ed8f6cdda5e9ac4ec2cd4034d7cc61d61478
Signed-off-by: Austin Schuh <austin.schuh@bluerivertech.com>
diff --git a/aos/events/logging/log_namer.cc b/aos/events/logging/log_namer.cc
index 6cf91db..166e505 100644
--- a/aos/events/logging/log_namer.cc
+++ b/aos/events/logging/log_namer.cc
@@ -30,24 +30,23 @@
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header,
const Node *node) {
CHECK_EQ(node, this->node());
- UpdateHeader(header, uuid_, part_number_);
- data_writer_->QueueSpan(header->span());
+ UpdateHeader(header, data_writer_.uuid(), data_writer_.part_number);
+ data_writer_.writer->QueueSpan(header->span());
}
-DetachedBufferWriter *LocalLogNamer::MakeWriter(const Channel *channel) {
+NewDataWriter *LocalLogNamer::MakeWriter(const Channel *channel) {
CHECK(configuration::ChannelIsSendableOnNode(channel, node()))
<< ": " << configuration::CleanedChannelToString(channel);
- return data_writer_.get();
+ return &data_writer_;
}
void LocalLogNamer::Rotate(
const Node *node,
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header) {
CHECK(node == this->node());
- ++part_number_;
- *data_writer_ = std::move(*OpenDataWriter());
- UpdateHeader(header, uuid_, part_number_);
- data_writer_->QueueSpan(header->span());
+ data_writer_.Rotate();
+ UpdateHeader(header, data_writer_.uuid(), data_writer_.part_number);
+ data_writer_.writer->QueueSpan(header->span());
}
void LocalLogNamer::WriteConfiguration(
@@ -67,18 +66,17 @@
LOG(FATAL) << "Can't reboot a single node.";
}
-DetachedBufferWriter *LocalLogNamer::MakeTimestampWriter(
- const Channel *channel) {
+NewDataWriter *LocalLogNamer::MakeTimestampWriter(const Channel *channel) {
CHECK(configuration::ChannelIsReadableOnNode(channel, node_))
<< ": Message is not delivered to this node.";
CHECK(node_ != nullptr) << ": Can't log timestamps in a single node world";
CHECK(configuration::ConnectionDeliveryTimeIsLoggedOnNode(channel, node_,
node_))
<< ": Delivery times aren't logged for this channel on this node.";
- return data_writer_.get();
+ return &data_writer_;
}
-DetachedBufferWriter *LocalLogNamer::MakeForwardedTimestampWriter(
+NewDataWriter *LocalLogNamer::MakeForwardedTimestampWriter(
const Channel * /*channel*/, const Node * /*node*/) {
LOG(FATAL) << "Can't log forwarded timestamps in a singe log file.";
return nullptr;
@@ -103,16 +101,16 @@
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header,
const Node *node) {
if (node == this->node()) {
- if (!data_writer_.writer) {
+ if (!data_writer_) {
OpenDataWriter();
}
- UpdateHeader(header, data_writer_.uuid, data_writer_.part_number);
- data_writer_.writer->QueueSpan(header->span());
+ UpdateHeader(header, data_writer_->uuid(), data_writer_->part_number);
+ data_writer_->writer->QueueSpan(header->span());
} else {
- for (std::pair<const Channel *const, DataWriter> &data_writer :
+ for (std::pair<const Channel *const, NewDataWriter> &data_writer :
data_writers_) {
if (node == data_writer.second.node) {
- UpdateHeader(header, data_writer.second.uuid,
+ UpdateHeader(header, data_writer.second.uuid(),
data_writer.second.part_number);
data_writer.second.writer->QueueSpan(header->span());
}
@@ -137,25 +135,27 @@
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header,
bool reboot) {
if (node == this->node()) {
- if (data_writer_.writer) {
+ if (data_writer_) {
if (reboot) {
- data_writer_.uuid = UUID::Random();
+ data_writer_->Reboot();
+ } else {
+ data_writer_->Rotate();
}
- ++data_writer_.part_number;
+ // TODO(austin): Move this logic down once we have a better ownership
+ // model for the header.
+ UpdateHeader(header, data_writer_->uuid(), data_writer_->part_number);
+ data_writer_->writer->QueueSpan(header->span());
}
- OpenDataWriter();
- UpdateHeader(header, data_writer_.uuid, data_writer_.part_number);
- data_writer_.writer->QueueSpan(header->span());
} else {
- for (std::pair<const Channel *const, DataWriter> &data_writer :
+ for (std::pair<const Channel *const, NewDataWriter> &data_writer :
data_writers_) {
if (node == data_writer.second.node) {
if (reboot) {
- data_writer.second.uuid = UUID::Random();
+ data_writer.second.Reboot();
+ } else {
+ data_writer.second.Rotate();
}
- ++data_writer.second.part_number;
- data_writer.second.rotate(data_writer.first, &data_writer.second);
- UpdateHeader(header, data_writer.second.uuid,
+ UpdateHeader(header, data_writer.second.uuid(),
data_writer.second.part_number);
data_writer.second.writer->QueueSpan(header->span());
}
@@ -185,7 +185,7 @@
CloseWriter(&writer);
}
-DetachedBufferWriter *MultiNodeLogNamer::MakeWriter(const Channel *channel) {
+NewDataWriter *MultiNodeLogNamer::MakeWriter(const Channel *channel) {
// See if we can read the data on this node at all.
const bool is_readable =
configuration::ChannelIsReadableOnNode(channel, this->node());
@@ -204,10 +204,10 @@
// Now, sort out if this is data generated on this node, or not. It is
// generated if it is sendable on this node.
if (configuration::ChannelIsSendableOnNode(channel, this->node())) {
- if (!data_writer_.writer) {
+ if (!data_writer_) {
OpenDataWriter();
}
- return data_writer_.writer.get();
+ return data_writer_.get();
}
// Ok, we have data that is being forwarded to us that we are supposed to
@@ -223,18 +223,20 @@
nodes_.emplace_back(source_node);
}
- DataWriter data_writer;
+ NewDataWriter data_writer(
+ [this, channel](NewDataWriter *data_writer) {
+ OpenWriter(channel, data_writer);
+ },
+ [this](NewDataWriter *data_writer) {
+ CloseWriter(&data_writer->writer);
+ });
data_writer.node = source_node;
- data_writer.rotate = [this](const Channel *channel, DataWriter *data_writer) {
- OpenWriter(channel, data_writer);
- };
- data_writer.rotate(channel, &data_writer);
- return data_writers_.insert(std::make_pair(channel, std::move(data_writer)))
- .first->second.writer.get();
+ return &(
+ data_writers_.emplace(channel, std::move(data_writer)).first->second);
}
-DetachedBufferWriter *MultiNodeLogNamer::MakeForwardedTimestampWriter(
+NewDataWriter *MultiNodeLogNamer::MakeForwardedTimestampWriter(
const Channel *channel, const Node *node) {
// See if we can read the data on this node at all.
const bool is_readable =
@@ -247,19 +249,20 @@
nodes_.emplace_back(node);
}
- DataWriter data_writer;
+ NewDataWriter data_writer(
+ [this, channel](NewDataWriter *data_writer) {
+ OpenForwardedTimestampWriter(channel, data_writer);
+ },
+ [this](NewDataWriter *data_writer) {
+ CloseWriter(&data_writer->writer);
+ });
data_writer.node = node;
- data_writer.rotate = [this](const Channel *channel, DataWriter *data_writer) {
- OpenForwardedTimestampWriter(channel, data_writer);
- };
- data_writer.rotate(channel, &data_writer);
- return data_writers_.insert(std::make_pair(channel, std::move(data_writer)))
- .first->second.writer.get();
+ return &(
+ data_writers_.emplace(channel, std::move(data_writer)).first->second);
}
-DetachedBufferWriter *MultiNodeLogNamer::MakeTimestampWriter(
- const Channel *channel) {
+NewDataWriter *MultiNodeLogNamer::MakeTimestampWriter(const Channel *channel) {
bool log_delivery_times = false;
if (this->node() != nullptr) {
log_delivery_times = configuration::ConnectionDeliveryTimeIsLoggedOnNode(
@@ -269,30 +272,25 @@
return nullptr;
}
- if (!data_writer_.writer) {
+ if (!data_writer_) {
OpenDataWriter();
}
- return data_writer_.writer.get();
+ return data_writer_.get();
}
void MultiNodeLogNamer::Close() {
- for (std::pair<const Channel *const, DataWriter> &data_writer :
- data_writers_) {
- CloseWriter(&data_writer.second.writer);
- data_writer.second.writer.reset();
- }
- CloseWriter(&data_writer_.writer);
- data_writer_.writer.reset();
+ data_writers_.clear();
+ data_writer_.reset();
}
void MultiNodeLogNamer::ResetStatistics() {
- for (std::pair<const Channel *const, DataWriter> &data_writer :
+ for (std::pair<const Channel *const, NewDataWriter> &data_writer :
data_writers_) {
if (!data_writer.second.writer) continue;
data_writer.second.writer->ResetStatistics();
}
- if (data_writer_.writer) {
- data_writer_.writer->ResetStatistics();
+ if (data_writer_) {
+ data_writer_->writer->ResetStatistics();
}
max_write_time_ = std::chrono::nanoseconds::zero();
max_write_time_bytes_ = -1;
@@ -303,8 +301,8 @@
total_write_bytes_ = 0;
}
-void MultiNodeLogNamer::OpenForwardedTimestampWriter(const Channel *channel,
- DataWriter *data_writer) {
+void MultiNodeLogNamer::OpenForwardedTimestampWriter(
+ const Channel *channel, NewDataWriter *data_writer) {
std::string filename =
absl::StrCat("timestamps", channel->name()->string_view(), "/",
channel->type()->string_view(), ".part",
@@ -313,7 +311,7 @@
}
void MultiNodeLogNamer::OpenWriter(const Channel *channel,
- DataWriter *data_writer) {
+ 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(),
@@ -322,13 +320,21 @@
}
void MultiNodeLogNamer::OpenDataWriter() {
- std::string name;
- if (node() != nullptr) {
- name = absl::StrCat(name, node()->name()->string_view(), "_");
+ if (!data_writer_) {
+ data_writer_ = std::make_unique<NewDataWriter>(
+ [this](NewDataWriter *writer) {
+ std::string name;
+ if (node() != nullptr) {
+ name = absl::StrCat(name, node()->name()->string_view(), "_");
+ }
+ absl::StrAppend(&name, "data.part", writer->part_number, ".bfbs",
+ extension_);
+ CreateBufferWriter(name, &writer->writer);
+ },
+ [this](NewDataWriter *data_writer) {
+ CloseWriter(&data_writer->writer);
+ });
}
- absl::StrAppend(&name, "data.part", data_writer_.part_number, ".bfbs",
- extension_);
- CreateBufferWriter(name, &data_writer_.writer);
}
void MultiNodeLogNamer::CreateBufferWriter(
diff --git a/aos/events/logging/log_namer.h b/aos/events/logging/log_namer.h
index 3b2c83c..f192dd3 100644
--- a/aos/events/logging/log_namer.h
+++ b/aos/events/logging/log_namer.h
@@ -15,6 +15,77 @@
namespace aos {
namespace logger {
+// TODO(austin): Track if headers are written here much more carefully.
+//
+// TODO(austin): Rename this back to DataWriter once all other callers are of
+// the old DataWriter.
+class NewDataWriter {
+ public:
+ // Constructs a NewDataWriter.
+ // reopen is called whenever a file needs to be reopened.
+ // close is called to close that file and extract any statistics.
+ NewDataWriter(std::function<void(NewDataWriter *)> reopen,
+ std::function<void(NewDataWriter *)> close)
+ : reopen_(std::move(reopen)), close_(std::move(close)) {
+ reopen_(this);
+ }
+
+ NewDataWriter(NewDataWriter &&other) = default;
+ aos::logger::NewDataWriter &operator=(NewDataWriter &&other) = default;
+ NewDataWriter(const NewDataWriter &) = delete;
+ void operator=(const NewDataWriter &) = delete;
+
+ ~NewDataWriter() {
+ if (writer) {
+ Close();
+ }
+ }
+
+ void Rotate() {
+ ++part_number;
+ reopen_(this);
+ }
+
+ // TODO(austin): Store common header in LogNamer.
+ //
+ // TODO(austin): Copy header and add all UUIDs and such when available
+ // whenever data is written.
+ //
+ // TODO(austin): Automatically write the header and update on boot UUID
+ // change.
+ //
+ // TODO(austin): Add known timestamps for each node every time we cycle a log
+ // for sorting.
+
+ void QueueSizedFlatbuffer(flatbuffers::FlatBufferBuilder *fbb,
+ aos::monotonic_clock::time_point now) {
+ writer->QueueSizedFlatbuffer(fbb, now);
+ }
+
+ std::string_view filename() const { return writer->filename(); }
+
+ void Reboot() {
+ uuid_ = UUID::Random();
+ Rotate();
+ }
+
+ void Close() {
+ CHECK(writer);
+ close_(this);
+ writer.reset();
+ }
+
+ std::unique_ptr<DetachedBufferWriter> writer = nullptr;
+ const Node *node = nullptr;
+ size_t part_number = 0;
+ const UUID &uuid() const { return uuid_; }
+
+ private:
+ UUID uuid_ = UUID::Random();
+ std::function<void(NewDataWriter *)> reopen_;
+ std::function<void(NewDataWriter *)> close_;
+};
+
// Interface describing how to name, track, and add headers to log file parts.
class LogNamer {
public:
@@ -47,14 +118,14 @@
//
// The returned pointer will stay valid across rotations, but the object it
// points to will be assigned to.
- virtual DetachedBufferWriter *MakeWriter(const Channel *channel) = 0;
+ virtual NewDataWriter *MakeWriter(const Channel *channel) = 0;
// Returns a writer for writing timestamps from messages on this channel (on
// the primary node).
//
// The returned pointer will stay valid across rotations, but the object it
// points to will be assigned to.
- virtual DetachedBufferWriter *MakeTimestampWriter(const Channel *channel) = 0;
+ virtual NewDataWriter *MakeTimestampWriter(const Channel *channel) = 0;
// Returns a writer for writing timestamps delivered over the special
// /aos/remote_timestamps/* channels. node is the node that the timestamps
@@ -62,7 +133,7 @@
//
// The returned pointer will stay valid across rotations, but the object it
// points to will be assigned to.
- virtual DetachedBufferWriter *MakeForwardedTimestampWriter(
+ virtual NewDataWriter *MakeForwardedTimestampWriter(
const Channel *channel, const Node *node) = 0;
// Rotates all log files for the provided node. The provided header will be
@@ -106,8 +177,20 @@
LocalLogNamer(std::string_view base_name, const Node *node)
: LogNamer(node),
base_name_(base_name),
- uuid_(UUID::Random()),
- data_writer_(OpenDataWriter()) {}
+ data_writer_(
+ [this](NewDataWriter *writer) {
+ writer->writer = std::make_unique<DetachedBufferWriter>(
+ absl::StrCat(base_name_, ".part", writer->part_number,
+ ".bfbs"),
+ std::make_unique<aos::logger::DummyEncoder>());
+ },
+ [](NewDataWriter * /*writer*/) {}) {}
+
+ LocalLogNamer(const LocalLogNamer &) = delete;
+ LocalLogNamer(LocalLogNamer &&) = delete;
+ LocalLogNamer &operator=(const LocalLogNamer &) = delete;
+ LocalLogNamer &operator=(LocalLogNamer &&) = delete;
+
~LocalLogNamer() override = default;
std::string_view base_name() const final { return base_name_; }
@@ -120,7 +203,7 @@
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header,
const Node *node) override;
- DetachedBufferWriter *MakeWriter(const Channel *channel) override;
+ NewDataWriter *MakeWriter(const Channel *channel) override;
void Rotate(const Node *node,
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header)
@@ -130,9 +213,9 @@
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header)
override;
- DetachedBufferWriter *MakeTimestampWriter(const Channel *channel) override;
+ NewDataWriter *MakeTimestampWriter(const Channel *channel) override;
- DetachedBufferWriter *MakeForwardedTimestampWriter(
+ NewDataWriter *MakeForwardedTimestampWriter(
const Channel * /*channel*/, const Node * /*node*/) override;
void WriteConfiguration(
@@ -140,17 +223,9 @@
std::string_view config_sha256) override;
private:
- // Creates a new data writer with the new part number.
- std::unique_ptr<DetachedBufferWriter> OpenDataWriter() {
- return std::make_unique<DetachedBufferWriter>(
- absl::StrCat(base_name_, ".part", part_number_, ".bfbs"),
- std::make_unique<aos::logger::DummyEncoder>());
- }
-
std::string base_name_;
- const UUID uuid_;
- size_t part_number_ = 0;
- std::unique_ptr<DetachedBufferWriter> data_writer_;
+
+ NewDataWriter data_writer_;
};
// Log namer which uses a config and a base name to name a bunch of files.
@@ -214,12 +289,12 @@
aos::SizePrefixedFlatbufferDetachedBuffer<LogFileHeader> *header,
std::string_view config_sha256) override;
- DetachedBufferWriter *MakeWriter(const Channel *channel) override;
+ NewDataWriter *MakeWriter(const Channel *channel) override;
- DetachedBufferWriter *MakeForwardedTimestampWriter(const Channel *channel,
+ NewDataWriter *MakeForwardedTimestampWriter(const Channel *channel,
const Node *node) override;
- DetachedBufferWriter *MakeTimestampWriter(const Channel *channel) override;
+ NewDataWriter *MakeTimestampWriter(const Channel *channel) override;
// Indicates that at least one file ran out of space. Once this happens, we
// stop trying to open new files, to avoid writing any files with holes from
@@ -230,7 +305,7 @@
// this method.
bool ran_out_of_space() const {
return accumulate_data_writers<bool>(
- ran_out_of_space_, [](bool x, const DataWriter &data_writer) {
+ ran_out_of_space_, [](bool x, const NewDataWriter &data_writer) {
return x ||
(data_writer.writer && data_writer.writer->ran_out_of_space());
});
@@ -242,7 +317,7 @@
// Returns 0 if no files are open.
size_t maximum_total_bytes() const {
return accumulate_data_writers<size_t>(
- 0, [](size_t x, const DataWriter &data_writer) {
+ 0, [](size_t x, const NewDataWriter &data_writer) {
return std::max(x, data_writer.writer->total_bytes());
});
}
@@ -258,7 +333,7 @@
std::chrono::nanoseconds max_write_time() const {
return accumulate_data_writers(
max_write_time_,
- [](std::chrono::nanoseconds x, const DataWriter &data_writer) {
+ [](std::chrono::nanoseconds x, const NewDataWriter &data_writer) {
return std::max(x, data_writer.writer->max_write_time());
});
}
@@ -266,7 +341,7 @@
return std::get<0>(accumulate_data_writers(
std::make_tuple(max_write_time_bytes_, max_write_time_),
[](std::tuple<int, std::chrono::nanoseconds> x,
- const DataWriter &data_writer) {
+ const NewDataWriter &data_writer) {
if (data_writer.writer->max_write_time() > std::get<1>(x)) {
return std::make_tuple(data_writer.writer->max_write_time_bytes(),
data_writer.writer->max_write_time());
@@ -278,7 +353,7 @@
return std::get<0>(accumulate_data_writers(
std::make_tuple(max_write_time_messages_, max_write_time_),
[](std::tuple<int, std::chrono::nanoseconds> x,
- const DataWriter &data_writer) {
+ const NewDataWriter &data_writer) {
if (data_writer.writer->max_write_time() > std::get<1>(x)) {
return std::make_tuple(
data_writer.writer->max_write_time_messages(),
@@ -290,25 +365,25 @@
std::chrono::nanoseconds total_write_time() const {
return accumulate_data_writers(
total_write_time_,
- [](std::chrono::nanoseconds x, const DataWriter &data_writer) {
+ [](std::chrono::nanoseconds x, const NewDataWriter &data_writer) {
return x + data_writer.writer->total_write_time();
});
}
int total_write_count() const {
return accumulate_data_writers(
- total_write_count_, [](int x, const DataWriter &data_writer) {
+ total_write_count_, [](int x, const NewDataWriter &data_writer) {
return x + data_writer.writer->total_write_count();
});
}
int total_write_messages() const {
return accumulate_data_writers(
- total_write_messages_, [](int x, const DataWriter &data_writer) {
+ total_write_messages_, [](int x, const NewDataWriter &data_writer) {
return x + data_writer.writer->total_write_messages();
});
}
int total_write_bytes() const {
return accumulate_data_writers(
- total_write_bytes_, [](int x, const DataWriter &data_writer) {
+ total_write_bytes_, [](int x, const NewDataWriter &data_writer) {
return x + data_writer.writer->total_write_bytes();
});
}
@@ -316,16 +391,6 @@
void ResetStatistics();
private:
- // Files to write remote data to. We want one per channel. Maps the channel
- // to the writer, Node, and part number.
- struct DataWriter {
- std::unique_ptr<DetachedBufferWriter> writer = nullptr;
- const Node *node;
- size_t part_number = 0;
- UUID uuid = UUID::Random();
- std::function<void(const Channel *, DataWriter *)> rotate;
- };
-
// Implements Rotate and Reboot, controlled by the 'reboot' flag. The only
// difference between the two is if DataWriter::uuid is reset or not.
void DoRotate(
@@ -335,10 +400,10 @@
// Opens up a writer for timestamps forwarded back.
void OpenForwardedTimestampWriter(const Channel *channel,
- DataWriter *data_writer);
+ NewDataWriter *data_writer);
// Opens up a writer for remote data.
- void OpenWriter(const Channel *channel, DataWriter *data_writer);
+ void OpenWriter(const Channel *channel, NewDataWriter *data_writer);
// Opens the main data writer file for this node responsible for data_writer_.
void OpenDataWriter();
@@ -353,13 +418,13 @@
// A version of std::accumulate which operates over all of our DataWriters.
template <typename T, typename BinaryOperation>
T accumulate_data_writers(T t, BinaryOperation op) const {
- for (const std::pair<const Channel *const, DataWriter> &data_writer :
+ for (const std::pair<const Channel *const, NewDataWriter> &data_writer :
data_writers_) {
if (!data_writer.second.writer) continue;
t = op(std::move(t), data_writer.second);
}
- if (data_writer_.writer) {
- t = op(std::move(t), data_writer_);
+ if (data_writer_) {
+ t = op(std::move(t), *data_writer_);
}
return t;
}
@@ -386,9 +451,9 @@
int total_write_bytes_ = 0;
// File to write both delivery timestamps and local data to.
- DataWriter data_writer_;
+ std::unique_ptr<NewDataWriter> data_writer_;
- std::map<const Channel *, DataWriter> data_writers_;
+ std::map<const Channel *, NewDataWriter> data_writers_;
};
} // namespace logger
diff --git a/aos/events/logging/log_writer.h b/aos/events/logging/log_writer.h
index 8131a31..3d975a3 100644
--- a/aos/events/logging/log_writer.h
+++ b/aos/events/logging/log_writer.h
@@ -184,11 +184,11 @@
// logic determining whether each writer should be initialized, we just
// stash the answer in separate member variables.
bool wants_writer = false;
- DetachedBufferWriter *writer = nullptr;
+ NewDataWriter *writer = nullptr;
bool wants_timestamp_writer = false;
- DetachedBufferWriter *timestamp_writer = nullptr;
+ NewDataWriter *timestamp_writer = nullptr;
bool wants_contents_writer = false;
- DetachedBufferWriter *contents_writer = nullptr;
+ NewDataWriter *contents_writer = nullptr;
// Node which this data is from, or -1 if it is unknown.
int data_node_index = -1;
diff --git a/aos/events/logging/logger_test.cc b/aos/events/logging/logger_test.cc
index 67d4897..7c89b15 100644
--- a/aos/events/logging/logger_test.cc
+++ b/aos/events/logging/logger_test.cc
@@ -34,7 +34,7 @@
using aos::testing::MessageCounter;
constexpr std::string_view kSingleConfigSha256(
- "bc8c9c2e31589eae6f0e36d766f6a437643e861d9568b7483106841cf7504dea");
+ "bbe1b563139273b23a5405eebc2f2740cefcda5f96681acd0a84b8ff9ab93ea4");
std::vector<std::vector<std::string>> ToLogReaderVector(
const std::vector<LogFile> &log_files) {