realm · jedelbo · Sep 22, 2023 · Sep 20, 2023 · Sep 22, 2023
diff --git a/src/realm/mixed.cpp b/src/realm/mixed.cpp
@@ -756,6 +756,57 @@ StringData Mixed::get_index_data(std::array<char, 16>& buffer) const noexcept
     return {};
 }
 
+std::string Mixed::to_string(size_t max_size) const noexcept
+{
+    std::ostringstream ostr;
+    if (is_type(type_String)) {
+        std::string ret = "\"";
+        if (string_val.size() <= max_size) {
+            ret += std::string(string_val);
+        }
+        else {
+            ret += std::string(StringData(string_val.data(), max_size)) + " ...";
+        }
+        ret += "\"";
+        return ret;
+    }
+    else if (is_type(type_Binary)) {
+        static constexpr int size_one_hex_out = 3;
+        static char hex_chars[] = "0123456789ABCDEF";
+        auto out_hex = [&ostr](char c) {
+            ostr << hex_chars[c >> 4];
+            ostr << hex_chars[c & 0xF];
+            ostr << ' ';
+        };
+
+        auto sz = binary_val.size();
+        bool capped = false;
+        size_t out_size = 0;
+
+        ostr << '"';
+        for (size_t n = 0; n < sz; n++) {
+            out_size += size_one_hex_out;
+            if (out_size > max_size) {
+                capped = true;
+                break;
+            }
+            out_hex(binary_val[n]);
+        }
+        if (capped) {
+            ostr << "...";
+        }
+        ostr << '"';
+    }
+    else if (is_type(type_Timestamp)) {
+        char buffer[32];
+        return date_val.to_string(buffer);
+    }
+    else {
+        ostr << *this;
+    }
+    return ostr.str();
+}
+
 void Mixed::use_buffer(std::string& buf) noexcept
 {
     if (is_null()) {

diff --git a/src/realm/mixed.hpp b/src/realm/mixed.hpp
@@ -263,7 +263,11 @@ class Mixed {
     Mixed operator/(const Mixed&) const noexcept;
 
     size_t hash() const;
+    // Used when inserting values into index
     StringData get_index_data(std::array<char, 16>&) const noexcept;
+    // Used when logging values
+    std::string to_string(size_t max_size) const noexcept;
+    // Used when you need a backup buffer for string or binary value
     void use_buffer(std::string& buf) noexcept;
 
     void to_json(std::ostream& out, JSONOutputMode output_mode) const noexcept;

diff --git a/src/realm/replication.cpp b/src/realm/replication.cpp
@@ -232,7 +232,8 @@ void Replication::set(const Table* t, ColKey col_key, ObjKey key, Mixed value, _
                 }
             }
             else {
-                logger->log(util::Logger::Level::trace, "   Set '%1' to %2", t->get_column_name(col_key), value);
+                logger->log(util::Logger::Level::trace, "   Set '%1' to %2", t->get_column_name(col_key),
+                            value.to_string(util::Logger::max_width_of_value));
             }
         }
     }
@@ -297,7 +298,8 @@ void Replication::log_collection_operation(const char* operation, const Collecti
         }
     }
     else {
-        logger->log(util::Logger::Level::trace, "   %1 %2 in %3%4", operation, value, path, position);
+        logger->log(util::Logger::Level::trace, "   %1 %2 in %3%4", operation,
+                    value.to_string(util::Logger::max_width_of_value), path, position);
     }
 }
 void Replication::list_insert(const CollectionBase& list, size_t list_ndx, Mixed value, size_t)

diff --git a/src/realm/util/logger.hpp b/src/realm/util/logger.hpp
@@ -79,6 +79,8 @@ class Logger {
     // this is enforced in logging.cpp.
     enum class Level { all = 0, trace = 1, debug = 2, detail = 3, info = 4, warn = 5, error = 6, fatal = 7, off = 8 };
 
+    static constexpr size_t max_width_of_value = 80;
+
     template <class... Params>
     void log(Level, const char* message, Params&&...);
 

diff --git a/test/test_table.cpp b/test/test_table.cpp
@@ -5377,14 +5377,28 @@ TEST(Table_LoggingMutations)
         auto t = wt->add_table_with_primary_key("foo", type_Int, "id");
         col = t->add_column(type_Mixed, "any");
         col_int = t->add_column(type_Int, "int");
+
         auto dict =
             t->create_object_with_primary_key(1).set_collection(col, CollectionType::Dictionary).get_dictionary(col);
         dict.insert("hello", "world");
+
         auto list =
             t->create_object_with_primary_key(2).set_collection(col, CollectionType::List).get_list<Mixed>(col);
         list.add(47.50);
+
         auto set = t->create_object_with_primary_key(3).set_collection(col, CollectionType::Set).get_set<Mixed>(col);
         set.insert(false);
+
+        std::vector<char> str_data(90);
+        std::iota(str_data.begin(), str_data.end(), ' ');
+        t->create_object_with_primary_key(5).set_any(col, StringData(str_data.data(), str_data.size()));
+
+        std::vector<char> bin_data(50);
+        std::iota(bin_data.begin(), bin_data.end(), 0);
+        t->create_object_with_primary_key(6).set_any(col, BinaryData(bin_data.data(), bin_data.size()));
+
+        t->create_object_with_primary_key(7).set_any(col, Timestamp(1695207215, 0));
+
         wt->commit();
     }
     {
@@ -5397,6 +5411,9 @@ TEST(Table_LoggingMutations)
 
     auto str = buffer.str();
     // std::cout << str << std::endl;
+    CHECK(str.find("abcdefghijklmno ...") != std::string::npos);
+    CHECK(str.find("14 15 16 17 18 19 ...") != std::string::npos);
+    CHECK(str.find("2023-09-20 10:53:35") != std::string::npos);
     CHECK(str.find("Query::get_description() failed:") != std::string::npos);
     CHECK(str.find("Set 'any' to dictionary") != std::string::npos);
     CHECK(str.find("Set 'any' to list") != std::string::npos);