pw_log: Add thread field to log.proto

- Updated unit tests to check for file and thread fields.

Change-Id: I644a772433a481690dba3515e87730484516a3aa
Requires: pigweed-internal:24040
Reviewed-on: https://pigweed-review.googlesource.com/c/pigweed/pigweed/+/85590
Reviewed-by: Ewout van Bekkum <ewout@google.com>
Reviewed-by: Keir Mierle <keir@google.com>
Commit-Queue: Carlos Chinchilla <cachinchilla@google.com>

6 files changed, 60 insertions, 24 deletions

diff --git a/pw_log_rpc/log_filter_test.cc b/pw_log_rpc/log_filter_test.cc
index fa412158e..be1fcdd20 100644
--- a/pw_log_rpc/log_filter_test.cc
+++ b/pw_log_rpc/log_filter_test.cc
@@ -47,6 +47,7 @@ Result<ConstByteSpan> EncodeLogEntry(std::string_view message,
   return log::EncodeTokenizedLog(metadata,
                                  std::as_bytes(std::span(message)),
                                  /*ticks_since_epoch=*/0,
+                                 /*thread_name=*/{},
                                  buffer);
 }
 
diff --git a/pw_log_rpc/log_service_test.cc b/pw_log_rpc/log_service_test.cc
index 33bb47c5b..062ebdb61 100644
--- a/pw_log_rpc/log_service_test.cc
+++ b/pw_log_rpc/log_service_test.cc
@@ -94,6 +94,7 @@ class LogServiceTest : public ::testing::Test {
         log::EncodeTokenizedLog(metadata,
                                 std::as_bytes(std::span(message)),
                                 timestamp,
+                                /*thread_name=*/{},
                                 entry_encode_buffer_);
     PW_TRY_WITH_SIZE(encoded_log_result.status());
     multisink_.HandleEntry(encoded_log_result.value());
diff --git a/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h b/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h
index 518539f4b..602e81c9d 100644
--- a/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h
+++ b/pw_log_rpc/public/pw_log_rpc/rpc_log_drain.h
@@ -64,7 +64,9 @@ class RpcLogDrain : public multisink::MultiSink::Drain {
       protobuf::SizeOfFieldUint32(log::LogEntry::Fields::LINE_LEVEL) +
       protobuf::SizeOfFieldUint32(log::LogEntry::Fields::FLAGS) +
       protobuf::SizeOfFieldInt64(log::LogEntry::Fields::TIMESTAMP) +
-      protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MODULE, 0);
+      protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MODULE, 0) +
+      protobuf::SizeOfFieldBytes(log::LogEntry::Fields::FILE, 0) +
+      protobuf::SizeOfFieldBytes(log::LogEntry::Fields::THREAD, 0);
 
   // The smallest buffer size must be able to fit a typical token size: 4 bytes.
   static constexpr size_t kMinEntryBufferSize = kMinEntrySizeWithoutPayload + 4;
diff --git a/pw_log_rpc/pw_log_rpc_private/test_utils.h b/pw_log_rpc/pw_log_rpc_private/test_utils.h
index d358d4ab8..f89f229af 100644
--- a/pw_log_rpc/pw_log_rpc_private/test_utils.h
+++ b/pw_log_rpc/pw_log_rpc_private/test_utils.h
@@ -27,6 +27,8 @@ struct TestLogEntry {
   int64_t timestamp = 0;
   uint32_t dropped = 0;
   ConstByteSpan tokenized_data = {};
+  ConstByteSpan file = {};
+  ConstByteSpan thread = {};
 };
 
 // Unpacks a `LogEntry` proto buffer to compare it with the expected data and
diff --git a/pw_log_rpc/rpc_log_drain_test.cc b/pw_log_rpc/rpc_log_drain_test.cc
index b17d2707c..2857b9919 100644
--- a/pw_log_rpc/rpc_log_drain_test.cc
+++ b/pw_log_rpc/rpc_log_drain_test.cc
@@ -203,12 +203,11 @@ class TrickleTest : public ::testing::Test {
         server_(std::span(&channel_, 1)) {}
 
   TestLogEntry BasicLog(std::string_view message) {
-    constexpr log_tokenized::Metadata kSampleMetadata =
-        log_tokenized::Metadata::Set<PW_LOG_LEVEL_INFO, 123, 0x03, __LINE__>();
     return {.metadata = kSampleMetadata,
-            .timestamp = 123,
+            .timestamp = kSampleTimestamp,
             .dropped = 0,
-            .tokenized_data = std::as_bytes(std::span(message))};
+            .tokenized_data = std::as_bytes(std::span(message)),
+            .thread = std::as_bytes(std::span(kSampleThreadName))};
   }
 
   void AttachDrain() { multisink_.AttachDrain(drains_[0]); }
@@ -222,6 +221,7 @@ class TrickleTest : public ::testing::Test {
         log::EncodeTokenizedLog(entry.metadata,
                                 entry.tokenized_data,
                                 entry.timestamp,
+                                entry.thread,
                                 log_message_encode_buffer_);
     ASSERT_EQ(encoded_log_result.status(), OkStatus());
     EXPECT_LE(encoded_log_result.value().size(), kMaxMessageSize);
@@ -236,8 +236,29 @@ class TrickleTest : public ::testing::Test {
 
   static constexpr uint32_t kDrainChannelId = 1;
   static constexpr size_t kMaxMessageSize = 60;
+
+  // Use the size of the encoded BasicLog entry to calculate buffer sizes and
+  // better control the number of entries in each sent bulk.
+  static constexpr log_tokenized::Metadata kSampleMetadata =
+      log_tokenized::Metadata::Set<PW_LOG_LEVEL_INFO, 123, 0x03, 300>();
+  static constexpr uint64_t kSampleTimestamp = 9000;
+  static constexpr std::string_view kSampleThreadName = "thread";
+  static constexpr size_t kBasicLogSizeWithoutPayload =
+      protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MESSAGE, 0) +
+      protobuf::SizeOfFieldUint32(
+          log::LogEntry::Fields::LINE_LEVEL,
+          log::PackLineLevel(kSampleMetadata.line_number(),
+                             kSampleMetadata.level())) +
+      protobuf::SizeOfFieldUint32(log::LogEntry::Fields::FLAGS,
+                                  kSampleMetadata.flags()) +
+      protobuf::SizeOfFieldInt64(log::LogEntry::Fields::TIMESTAMP,
+                                 kSampleTimestamp) +
+      protobuf::SizeOfFieldBytes(log::LogEntry::Fields::MODULE,
+                                 sizeof(kSampleMetadata.module())) +
+      protobuf::SizeOfFieldBytes(log::LogEntry::Fields::THREAD,
+                                 kSampleThreadName.size());
   static constexpr size_t kDrainEncodeBufferSize =
-      RpcLogDrain::kMinEntrySizeWithoutPayload + kMaxMessageSize;
+      kBasicLogSizeWithoutPayload + kMaxMessageSize;
   static constexpr size_t kChannelEncodeBufferSize = kDrainEncodeBufferSize * 2;
   std::array<std::byte, kMaxMessageSize> log_message_encode_buffer_;
   std::array<std::byte, kDrainEncodeBufferSize> drain_encode_buffer_;
diff --git a/pw_log_rpc/test_utils.cc b/pw_log_rpc/test_utils.cc
index df84670e5..3a06ec2b2 100644
--- a/pw_log_rpc/test_utils.cc
+++ b/pw_log_rpc/test_utils.cc
@@ -26,30 +26,35 @@
 #include "pw_protobuf/decoder.h"
 
 namespace pw::log_rpc {
+namespace {
+void VerifyOptionallyTokenizedField(protobuf::Decoder& entry_decoder,
+                                    log::LogEntry::Fields field_number,
+                                    ConstByteSpan expected_data) {
+  if (expected_data.empty()) {
+    return;
+  }
+  ConstByteSpan tokenized_data;
+  ASSERT_EQ(entry_decoder.Next(), OkStatus());
+  ASSERT_EQ(entry_decoder.FieldNumber(), static_cast<uint32_t>(field_number));
+  ASSERT_EQ(entry_decoder.ReadBytes(&tokenized_data), OkStatus());
+  std::string_view data_as_string(
+      reinterpret_cast<const char*>(tokenized_data.begin()),
+      tokenized_data.size());
+  std::string_view expected_data_as_string(
+      reinterpret_cast<const char*>(expected_data.begin()),
+      expected_data.size());
+  EXPECT_EQ(data_as_string, expected_data_as_string);
+}
+}  // namespace
 
 // Unpacks a `LogEntry` proto buffer to compare it with the expected data and
 // updates the total drop count found.
 void VerifyLogEntry(protobuf::Decoder& entry_decoder,
                     const TestLogEntry& expected_entry,
                     uint32_t& drop_count_out) {
-  ConstByteSpan tokenized_data;
-  if (!expected_entry.tokenized_data.empty()) {
-    ASSERT_EQ(entry_decoder.Next(), OkStatus());
-    ASSERT_EQ(entry_decoder.FieldNumber(),
-              static_cast<uint32_t>(log::LogEntry::Fields::MESSAGE));
-    ASSERT_TRUE(entry_decoder.ReadBytes(&tokenized_data).ok());
-    if (tokenized_data.size() != expected_entry.tokenized_data.size()) {
-      PW_LOG_ERROR(
-          "actual: '%s', expected: '%s'",
-          reinterpret_cast<const char*>(tokenized_data.begin()),
-          reinterpret_cast<const char*>(expected_entry.tokenized_data.begin()));
-    }
-    EXPECT_EQ(tokenized_data.size(), expected_entry.tokenized_data.size());
-    EXPECT_EQ(std::memcmp(tokenized_data.begin(),
-                          expected_entry.tokenized_data.begin(),
-                          expected_entry.tokenized_data.size()),
-              0);
-  }
+  VerifyOptionallyTokenizedField(entry_decoder,
+                                 log::LogEntry::Fields::MESSAGE,
+                                 expected_entry.tokenized_data);
   if (expected_entry.metadata.level()) {
     ASSERT_EQ(entry_decoder.Next(), OkStatus());
     ASSERT_EQ(entry_decoder.FieldNumber(),
@@ -98,6 +103,10 @@ void VerifyLogEntry(protobuf::Decoder& entry_decoder,
     ASSERT_EQ(module.status(), OkStatus());
     EXPECT_EQ(expected_entry.metadata.module(), module.value());
   }
+  VerifyOptionallyTokenizedField(
+      entry_decoder, log::LogEntry::Fields::FILE, expected_entry.file);
+  VerifyOptionallyTokenizedField(
+      entry_decoder, log::LogEntry::Fields::THREAD, expected_entry.thread);
 }
 
 // Compares an encoded LogEntry's fields against the expected sequence ID and