Fix message truncating logic to respect UTF8 encoding.

Summary: .

Differential Revision: D82681904

Author: shoumikhin

runtime/platform/log.cpp

@@ -59,6 +59,37 @@ static_assert(
     kLevelToPal[size_t(LogLevel::Fatal)] == et_pal_log_level_t::kFatal,
     "");
 
+/**
+ * Returns the length of the longest valid UTF-8 prefix in a byte buffer.
+ */
+static inline size_t get_valid_utf8_prefix_length(const char* bytes, size_t length) {
+  if (!bytes || length == 0) {
+    return 0;
+  }
+  const auto* data = reinterpret_cast<const unsigned char*>(bytes);
+  auto index = size_t{0};
+  auto last_valid_length = size_t{0};
+  while (index < length) {
+    const auto lead_byte = data[index];
+    const size_t sequence_length =
+        (lead_byte < 0x80) ? 1 :
+        ((lead_byte & 0xE0) == 0xC0) ? 2 :
+        ((lead_byte & 0xF0) == 0xE0) ? 3 :
+        ((lead_byte & 0xF8) == 0xF0) ? 4 : 0;
+    if (!sequence_length || index + sequence_length > length) {
+      return last_valid_length;
+    }
+    for (size_t continuation_index = 1; continuation_index < sequence_length; ++continuation_index) {
+      if ((data[index + continuation_index] & 0xC0) != 0x80) {
+        return last_valid_length;
+      }
+    }
+    index += sequence_length;
+    last_valid_length = index;
+  }
+  return last_valid_length;
+}
+
 /**
  * Log a string message.
  *
@@ -84,20 +115,23 @@ void vlogf(
 
   // Maximum length of a log message.
   static constexpr size_t kMaxLogMessageLength = 256;
-  char buf[kMaxLogMessageLength];
-  size_t len = vsnprintf(buf, kMaxLogMessageLength, format, args);
-  if (len >= kMaxLogMessageLength - 1) {
-    buf[kMaxLogMessageLength - 2] = '$';
-    len = kMaxLogMessageLength - 1;
-  }
-  buf[kMaxLogMessageLength - 1] = 0;
+  char buffer[kMaxLogMessageLength];
+
+  const auto write_count = vsnprintf(buffer, kMaxLogMessageLength, format, args);
+  const size_t used_length = (write_count < 0)
+      ? 0
+      : (write_count >= static_cast<int>(kMaxLogMessageLength)
+            ? kMaxLogMessageLength - 1
+            : static_cast<size_t>(write_count));
+  const auto valid_length = get_valid_utf8_prefix_length(buffer, used_length);
+  buffer[valid_length] = '\0';
 
-  et_pal_log_level_t pal_level = (level < LogLevel::NumLevels)
+  const auto pal_level = (level < LogLevel::NumLevels)
       ? kLevelToPal[size_t(level)]
       : et_pal_log_level_t::kUnknown;
 
   pal_emit_log_message(
-      timestamp, pal_level, filename, function, line, buf, len);
+      timestamp, pal_level, filename, function, line, buffer, valid_length);
 
 #endif // ET_LOG_ENABLED
 }

runtime/platform/test/logging_test.cpp

@@ -9,16 +9,44 @@
 #include <gtest/gtest.h>
 
 #include <executorch/runtime/platform/log.h>
+#include <executorch/runtime/platform/platform.h>
 #include <executorch/runtime/platform/runtime.h>
 
 using namespace executorch::runtime;
 
+// A global variable to capture the output from our mock logger.
+static std::string captured_log_message;
+
+/**
+ * @brief A mock implementation of the PAL logging function.
+ *
+ * This function will be linked into the test instead of the default platform
+ * logger. It captures the formatted message into a global string so that
+ * tests can assert its content.
+ */
+extern "C" void et_pal_emit_log_message(
+    et_timestamp_t /*timestamp*/,
+    et_pal_log_level_t /*level*/,
+    const char* /*filename*/,
+    const char* /*function*/,
+    size_t /*line*/,
+    const char* message,
+    size_t /*length*/) {
+  captured_log_message = message;
+}
+
 class LoggingTest : public ::testing::Test {
  public:
   static void SetUpTestSuite() {
     // Initialize runtime.
     runtime_init();
   }
+
+ protected:
+  // Clear the captured message before each test.
+  void SetUp() override {
+    captured_log_message.clear();
+  }
 };
 
 TEST_F(LoggingTest, LogLevels) {
@@ -31,3 +59,27 @@ TEST_F(LoggingTest, LogLevels) {
 TEST_F(LoggingTest, LogFormatting) {
   ET_LOG(Info, "Sample log with integer: %u", 100);
 }
+
+TEST_F(LoggingTest, Utf8Truncation) {
+  {
+    // Create a prefix that ends right before the buffer limit.
+    // 253 'A's + the first 2 bytes of "€" will fill the 255-byte content area.
+    std::string prefix(253, 'A');
+    std::string multi_byte_char = "€"; // 3 bytes: 0xE2 0x82 0xAC
+    std::string suffix = "_SHOULD_BE_CUT";
+
+    ET_LOG(Info, "%s%s%s", prefix.c_str(), multi_byte_char.c_str(), suffix.c_str());
+
+    EXPECT_EQ(captured_log_message, prefix);
+  }
+  {
+    // 252 'B's + the first 3 bytes of "👍" will fill the 255-byte content area.
+    std::string prefix(252, 'B');
+    std::string multi_byte_char = "👍"; // 4 bytes: 0xF0 0x9F 0x91 0x8D
+    std::string suffix = "_SHOULD_BE_CUT";
+
+    ET_LOG(Info, "%s%s%s", prefix.c_str(), multi_byte_char.c_str(), suffix.c_str());
+
+    EXPECT_EQ(captured_log_message, prefix);
+  }
+}