Optimisation

Signed-off-by: JCW <[email protected]>

Author: a1q123456

include/xrpl/beast/utility/Journal.h

@@ -174,8 +174,9 @@ class Journal
 
     class JsonLogContext
     {
-        rapidjson::Value attributes_;
+        rapidjson::Value messageParams_;
         rapidjson::MemoryPoolAllocator<> allocator_;
+        std::optional<std::string> journalAttributesJson_;
 
     public:
         JsonLogContext() = default;
@@ -189,28 +190,30 @@ class Journal
         rapidjson::Value&
         messageParams()
         {
-            return attributes_["Params"];
+            return messageParams_;
         }
 
-        rapidjson::Value&
-        attributes()
+        std::optional<std::string>&
+        journalAttributesJson()
         {
-            return attributes_;
+            return journalAttributesJson_;
         }
 
         void
         reset(
             std::source_location location,
             severities::Severity severity,
-            std::optional<JsonLogAttributes> const& attributes) noexcept;
+            std::optional<std::string> const& journalAttributesJson) noexcept;
     };
 
 private:
     // Severity level / threshold of a Journal message.
     using Severity = severities::Severity;
 
     std::optional<JsonLogAttributes> m_attributes;
+    std::optional<std::string> m_attributesJson;
     static std::optional<JsonLogAttributes> globalLogAttributes_;
+    static std::optional<std::string> globalLogAttributesJson_;
     static std::mutex globalLogAttributesMutex_;
     static bool m_jsonLogsEnabled;
 
@@ -227,6 +230,9 @@ class Journal
     static std::string
     formatLog(std::string&& message);
 
+    void
+    rebuildAttributeJson();
+
 public:
     //--------------------------------------------------------------------------
 
@@ -457,18 +463,8 @@ class Journal
 
     Journal(
         Journal const& other,
-        std::optional<JsonLogAttributes> attributes = std::nullopt)
-            : m_attributes(other.m_attributes)
-            , m_sink(other.m_sink)
-    {
-        if (attributes.has_value())
-        {
-            if (m_attributes)
-                m_attributes->combine(attributes->contextValues_);
-            else
-                m_attributes = std::move(attributes);
-        }
-    }
+        std::optional<JsonLogAttributes> attributes = std::nullopt);
+
     /** Create a journal that writes to the specified sink. */
     explicit Journal(
         Sink& sink,
@@ -481,6 +477,7 @@ class Journal
             m_attributes = std::move(attributes);
             m_attributes->setModuleName(name);
         }
+        rebuildAttributeJson();
     }
 
     Journal&
@@ -491,6 +488,7 @@ class Journal
 
         m_sink = other.m_sink;
         m_attributes = other.m_attributes;
+        rebuildAttributeJson();
         return *this;
     }
 
@@ -499,6 +497,7 @@ class Journal
     {
         m_sink = other.m_sink;
         m_attributes = std::move(other.m_attributes);
+        rebuildAttributeJson();
         return *this;
     }
 
@@ -586,19 +585,11 @@ class Journal
     {
         std::lock_guard lock(globalLogAttributesMutex_);
         globalLogAttributes_ = std::nullopt;
+        globalLogAttributesJson_ = std::nullopt;
     }
 
     static void
-    addGlobalAttributes(JsonLogAttributes globalLogAttributes)
-    {
-        std::lock_guard lock(globalLogAttributesMutex_);
-        if (!globalLogAttributes_)
-        {
-            globalLogAttributes_ = JsonLogAttributes{};
-        }
-        globalLogAttributes_->combine(
-            globalLogAttributes.contextValues());
-    }
+    addGlobalAttributes(JsonLogAttributes globalLogAttributes);
 };
 
 #ifndef __INTELLISENSE__

src/libxrpl/beast/utility/beast_Journal.cpp

@@ -32,6 +32,8 @@
 namespace beast {
 
 std::optional<Journal::JsonLogAttributes> Journal::globalLogAttributes_;
+std::optional<std::string> Journal::globalLogAttributesJson_;
+
 std::mutex Journal::globalLogAttributesMutex_;
 bool Journal::m_jsonLogsEnabled = false;
 thread_local Journal::JsonLogContext Journal::currentJsonLogContext_{};
@@ -169,11 +171,44 @@ Journal::JsonLogAttributes::combine(
     }
 }
 
+Journal::Journal(
+    Journal const& other,
+    std::optional<JsonLogAttributes> attributes)
+    : m_attributes(other.m_attributes), m_sink(other.m_sink)
+{
+    if (attributes.has_value())
+    {
+        if (m_attributes)
+            m_attributes->combine(attributes->contextValues_);
+        else
+            m_attributes = std::move(attributes);
+    }
+    rebuildAttributeJson();
+}
+
+void
+Journal::addGlobalAttributes(JsonLogAttributes globalLogAttributes)
+{
+    std::lock_guard lock(globalLogAttributesMutex_);
+    if (!globalLogAttributes_)
+    {
+        globalLogAttributes_ = JsonLogAttributes{};
+    }
+    globalLogAttributes_->combine(globalLogAttributes.contextValues());
+
+    rapidjson::StringBuffer buffer;
+    rapidjson::Writer writer{buffer};
+
+    globalLogAttributes_->contextValues().Accept(writer);
+
+    globalLogAttributesJson_ = {buffer.GetString()};
+}
+
 void
 Journal::JsonLogContext::reset(
     std::source_location location,
     severities::Severity severity,
-    std::optional<JsonLogAttributes> const& attributes) noexcept
+    std::optional<std::string> const& journalAttributesJson) noexcept
 {
     struct ThreadIdStringInitializer
     {
@@ -187,67 +222,37 @@ Journal::JsonLogContext::reset(
     };
     thread_local ThreadIdStringInitializer const threadId;
 
-    attributes_.SetObject();
-    if (globalLogAttributes_.has_value())
-    {
-        attributes_.CopyFrom(globalLogAttributes_->contextValues(), allocator_);
-        if (attributes.has_value())
-        {
-            for (auto const& [key, value] :
-             attributes->contextValues().GetObject())
-            {
-                attributes_.RemoveMember(key);
-
-                rapidjson::Value jsonValue;
-                jsonValue.CopyFrom(value, allocator_);
-
-                attributes_.AddMember(
-                    rapidjson::Value{key, allocator_},
-                    rapidjson::Value{value, allocator_},
-                    allocator_);
-            }
-        }
-    }
-    else if (attributes.has_value())
-    {
-        attributes_.CopyFrom(attributes->contextValues(), allocator_);
-    }
+    journalAttributesJson_ = journalAttributesJson;
+
+    messageParams_.SetObject();
 
-    attributes_.RemoveMember("Function");
-    attributes_.AddMember(
+    messageParams_.AddMember(
         rapidjson::StringRef("Function"),
         rapidjson::Value{location.function_name(), allocator_},
         allocator_);
 
-    attributes_.RemoveMember("File");
-    attributes_.AddMember(
+    messageParams_.AddMember(
         rapidjson::StringRef("File"),
         rapidjson::Value{location.file_name(), allocator_},
         allocator_);
 
-    attributes_.RemoveMember("Line");
-    attributes_.AddMember(
+    messageParams_.AddMember(
         rapidjson::StringRef("Line"),
         location.line(),
         allocator_);
-    attributes_.RemoveMember("ThreadId");
-    attributes_.AddMember(
+
+    messageParams_.AddMember(
         rapidjson::StringRef("ThreadId"),
         rapidjson::Value{threadId.value.c_str(), allocator_},
         allocator_);
-    attributes_.RemoveMember("Params");
-    attributes_.AddMember(
-        rapidjson::StringRef("Params"),
-        rapidjson::Value{rapidjson::kObjectType},
-        allocator_);
+
     auto severityStr = to_string(severity);
-    attributes_.RemoveMember("Level");
-    attributes_.AddMember(
+    messageParams_.AddMember(
         rapidjson::StringRef("Level"),
         rapidjson::Value{severityStr.c_str(), allocator_},
         allocator_);
-    attributes_.RemoveMember("Time");
-    attributes_.AddMember(
+
+    messageParams_.AddMember(
         rapidjson::StringRef("Time"),
         std::chrono::duration_cast<std::chrono::milliseconds>(
             std::chrono::system_clock::now().time_since_epoch())
@@ -260,7 +265,7 @@ Journal::initMessageContext(
     std::source_location location,
     severities::Severity severity) const
 {
-    currentJsonLogContext_.reset(location, severity, m_attributes);
+    currentJsonLogContext_.reset(location, severity, m_attributesJson);
 }
 
 std::string
@@ -271,23 +276,59 @@ Journal::formatLog(std::string&& message)
         return message;
     }
 
-    auto& attributes = currentJsonLogContext_.attributes();
-
-    attributes.RemoveMember("Message");
-    attributes.AddMember(
-        rapidjson::StringRef("Message"),
-        rapidjson::Value{rapidjson::StringRef(message.c_str()), currentJsonLogContext_.allocator()},
-        currentJsonLogContext_.allocator()
-    );
+    auto& messageParams = currentJsonLogContext_.messageParams();
 
     rapidjson::StringBuffer buffer;
     rapidjson::Writer writer(buffer);
 
-    attributes.Accept(writer);
+    writer.StartObject();
+    if (globalLogAttributesJson_.has_value())
+    {
+        writer.Key("GlobalParams");
+        writer.RawValue(
+            globalLogAttributesJson_->c_str(),
+            globalLogAttributesJson_->length(),
+            rapidjson::kObjectType);
+    }
+
+    if (currentJsonLogContext_.journalAttributesJson().has_value())
+    {
+        writer.Key("JournalParams");
+        writer.RawValue(
+            currentJsonLogContext_.journalAttributesJson()->c_str(),
+            currentJsonLogContext_.journalAttributesJson()->length(),
+            rapidjson::kObjectType);
+    }
+
+    writer.Key("MessageParams");
+    messageParams.Accept(writer);
+
+    writer.Key("Message");
+    writer.String(message.c_str(), message.length());
+
+    writer.EndObject();
 
     return {buffer.GetString()};
 }
 
+void
+Journal::rebuildAttributeJson()
+{
+    if (m_attributes.has_value())
+    {
+        rapidjson::StringBuffer buffer;
+        rapidjson::Writer writer{buffer};
+
+        m_attributes->contextValues().Accept(writer);
+
+        m_attributesJson = {buffer.GetString()};
+    }
+    else
+    {
+        m_attributesJson = {};
+    }
+}
+
 void
 Journal::enableStructuredJournal()
 {