Fix issues

a1q123456 · a1q123456 · commit 9643828cace9 · 2025-09-02T20:04:14.000+01:00
Signed-off-by: JCW &lt;a1q123456@users.noreply.github.com&gt;
diff --git a/include/xrpl/beast/utility/Journal.h b/include/xrpl/beast/utility/Journal.h
@@ -23,6 +23,7 @@
 #include <xrpl/beast/utility/instrumentation.h>
 
 #include <charconv>
+#include <shared_mutex>
 #include <source_location>
 #include <sstream>
 #include <string>
@@ -84,140 +85,140 @@ namespace detail {
 class SimpleJsonWriter
 {
 public:
-    explicit SimpleJsonWriter(std::string& stream) : stream_(stream)
+    explicit SimpleJsonWriter(std::string& buffer) : buffer_(buffer)
     {
     }
 
     void
     startObject() const
     {
-        stream_.push_back('{');
+        buffer_.push_back('{');
     }
     void
     endObject() const
     {
         using namespace std::string_view_literals;
-        stream_.pop_back();
-        stream_.append("},"sv);
+        buffer_.pop_back();
+        buffer_.append("},"sv);
     }
     void
     writeKey(std::string_view key) const
     {
         writeString(key);
-        stream_.back() = ':';
+        buffer_.back() = ':';
     }
     void
     startArray() const
     {
-        stream_.push_back('[');
+        buffer_.push_back('[');
     }
     void
     endArray() const
     {
         using namespace std::string_view_literals;
-        stream_.pop_back();
-        stream_.append("],"sv);
+        buffer_.pop_back();
+        buffer_.append("],"sv);
     }
     void
     writeString(std::string_view str) const
     {
         using namespace std::string_view_literals;
-        stream_.push_back('"');
-        escape(str, stream_);
-        stream_.append("\","sv);
+        buffer_.push_back('"');
+        escape(str, buffer_);
+        buffer_.append("\","sv);
     }
     std::string_view
     writeInt(std::int8_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeInt(std::int16_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeInt(std::int32_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeInt(std::int64_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeUInt(std::size_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeUInt(std::uint8_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeUInt(std::uint16_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeUInt(std::uint32_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeUInt(std::uint64_t val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeDouble(double val) const
     {
-        return pushNumber(val, stream_);
+        return pushNumber(val, buffer_);
     }
     std::string_view
     writeBool(bool val) const
     {
         using namespace std::string_view_literals;
         auto str = val ? "true,"sv : "false,"sv;
-        stream_.append(str);
+        buffer_.append(str);
         return str;
     }
     void
     writeNull() const
     {
         using namespace std::string_view_literals;
-        stream_.append("null,"sv);
+        buffer_.append("null,"sv);
     }
     void
     writeRaw(std::string_view str) const
     {
-        stream_.append(str);
+        buffer_.append(str);
     }
 
     [[nodiscard]] std::string_view
     finish()
     {
-        return std::string_view{stream_.c_str(), stream_.size() - 1};
+        return std::string_view{buffer_.c_str(), buffer_.size() - 1};
     }
 
 private:
     template <typename T>
     static std::string_view
-    pushNumber(T val, std::string& stream)
+    pushNumber(T val, std::string& str)
     {
         thread_local char buffer[128];
         auto result = std::to_chars(std::begin(buffer), std::end(buffer), val);
         auto ptr = result.ptr;
         *ptr = ',';
         auto len = ptr - std::begin(buffer);
-        stream.append(buffer, len + 1);
+        str.append(buffer, len + 1);
         return {buffer, static_cast<size_t>(len)};
     }
 
     static void
-    escape(std::string_view str, std::string& os)
+    escape(std::string_view str, std::string& buffer)
     {
         static constexpr char HEX[] = "0123456789ABCDEF";
 
@@ -240,36 +241,36 @@ class SimpleJsonWriter
 
             // Flush the preceding safe run in one go.
             if (chunk != p)
-                os.append(chunk, p - chunk);
+                buffer.append(chunk, p - chunk);
 
             switch (c)
             {
                 case '"':
-                    os.append("\\\"", 2);
+                    buffer.append("\\\"", 2);
                     break;
                 case '\\':
-                    os.append("\\\\", 2);
+                    buffer.append("\\\\", 2);
                     break;
                 case '\b':
-                    os.append("\\b", 2);
+                    buffer.append("\\b", 2);
                     break;
                 case '\f':
-                    os.append("\\f", 2);
+                    buffer.append("\\f", 2);
                     break;
                 case '\n':
-                    os.append("\\n", 2);
+                    buffer.append("\\n", 2);
                     break;
                 case '\r':
-                    os.append("\\r", 2);
+                    buffer.append("\\r", 2);
                     break;
                 case '\t':
-                    os.append("\\t", 2);
+                    buffer.append("\\t", 2);
                     break;
                 default: {
                     // Other C0 controls -> \u00XX (JSON compliant)
                     char buf[6]{
                         '\\', 'u', '0', '0', HEX[(c >> 4) & 0xF], HEX[c & 0xF]};
-                    os.append(buf, 6);
+                    buffer.append(buf, 6);
                     break;
                 }
             }
@@ -280,10 +281,10 @@ class SimpleJsonWriter
 
         // Flush trailing safe run
         if (chunk != p)
-            os.append(chunk, p - chunk);
+            buffer.append(chunk, p - chunk);
     }
 
-    std::string& stream_;
+    std::string& buffer_;
 };
 
 }  // namespace detail
@@ -369,7 +370,7 @@ class Journal
     std::string m_name;
     std::string m_attributesJson;
     static std::string globalLogAttributesJson_;
-    static std::mutex globalLogAttributesMutex_;
+    static std::shared_mutex globalLogAttributesMutex_;
     static bool m_jsonLogsEnabled;
 
     static thread_local JsonLogContext currentJsonLogContext_;
@@ -624,14 +625,14 @@ class Journal
     Journal(Journal const& other, TAttributesFactory&& attributesFactory)
         : m_name(other.m_name), m_sink(other.m_sink)
     {
-        std::string stream{other.m_attributesJson};
-        detail::SimpleJsonWriter writer{stream};
+        std::string buffer{other.m_attributesJson};
+        detail::SimpleJsonWriter writer{buffer};
         if (other.m_attributesJson.empty())
         {
             writer.startObject();
         }
         attributesFactory(writer);
-        m_attributesJson = std::move(stream);
+        m_attributesJson = std::move(buffer);
     }
 
     /** Create a journal that writes to the specified sink. */
@@ -648,11 +649,11 @@ class Journal
         TAttributesFactory&& attributesFactory)
         : m_name(name), m_sink(&sink)
     {
-        std::string stream;
-        detail::SimpleJsonWriter writer{stream};
+        std::string buffer;
+        detail::SimpleJsonWriter writer{buffer};
         writer.startObject();
         attributesFactory(writer);
-        m_attributesJson = std::move(stream);
+        m_attributesJson = std::move(buffer);
     }
 
     Journal&
@@ -758,25 +759,25 @@ class Journal
     static void
     resetGlobalAttributes()
     {
-        std::lock_guard lock(globalLogAttributesMutex_);
+        std::unique_lock lock(globalLogAttributesMutex_);
         globalLogAttributesJson_.clear();
     }
 
     template <typename TAttributesFactory>
     static void
     addGlobalAttributes(TAttributesFactory&& factory)
     {
-        std::lock_guard lock(globalLogAttributesMutex_);
+        std::unique_lock lock(globalLogAttributesMutex_);
 
         auto isEmpty = globalLogAttributesJson_.empty();
-        std::string stream{std::move(globalLogAttributesJson_)};
-        detail::SimpleJsonWriter writer{stream};
+        std::string buffer{std::move(globalLogAttributesJson_)};
+        detail::SimpleJsonWriter writer{buffer};
         if (isEmpty)
         {
             writer.startObject();
         }
         factory(writer);
-        globalLogAttributesJson_ = std::move(stream);
+        globalLogAttributesJson_ = std::move(buffer);
     }
 };
 
diff --git a/src/libxrpl/beast/utility/beast_Journal.cpp b/src/libxrpl/beast/utility/beast_Journal.cpp
@@ -22,13 +22,14 @@
 #include <ios>
 #include <ostream>
 #include <ranges>
+#include <shared_mutex>
 #include <string>
 #include <thread>
 
 namespace beast {
 
 std::string Journal::globalLogAttributesJson_;
-std::mutex Journal::globalLogAttributesMutex_;
+std::shared_mutex Journal::globalLogAttributesMutex_;
 bool Journal::m_jsonLogsEnabled = false;
 thread_local Journal::JsonLogContext Journal::currentJsonLogContext_{};
 
@@ -150,13 +151,16 @@ Journal::JsonLogContext::reset(
         writer().endObject();
     }
 
-    if (!globalLogAttributesJson_.empty())
     {
-        writer().writeKey("GlobalParams");
-        writer().writeRaw(std::string_view{
-            std::begin(globalLogAttributesJson_),
-            std::end(globalLogAttributesJson_)});
-        writer().endObject();
+        std::shared_lock lock(globalLogAttributesMutex_);
+        if (!globalLogAttributesJson_.empty())
+        {
+            writer().writeKey("GlobalParams");
+            writer().writeRaw(std::string_view{
+                std::begin(globalLogAttributesJson_),
+                std::end(globalLogAttributesJson_)});
+            writer().endObject();
+        }
     }
 
     writer().writeKey("MessageParams");
diff --git a/src/tests/libxrpl/basics/log.cpp b/src/tests/libxrpl/basics/log.cpp
@@ -231,32 +231,32 @@ TEST_CASE("Global attributes inheritable")
 TEST_CASE("Test JsonWriter")
 {
     {
-        std::string stream;
-        beast::detail::SimpleJsonWriter writer{stream};
+        std::string buffer;
+        beast::detail::SimpleJsonWriter writer{buffer};
 
         writer.writeString("\n");
         CHECK(writer.finish() == "\"\\n\"");
     }
 
     {
-        std::string stream;
-        beast::detail::SimpleJsonWriter writer{stream};
+        std::string buffer;
+        beast::detail::SimpleJsonWriter writer{buffer};
 
         writer.writeString("\t");
         CHECK(writer.finish() == "\"\\t\"");
     }
 
     {
-        std::string stream;
-        beast::detail::SimpleJsonWriter writer{stream};
+        std::string buffer;
+        beast::detail::SimpleJsonWriter writer{buffer};
 
         writer.writeString(std::string_view{"\0", 1});
         CHECK(writer.finish() == "\"\\u0000\"");
     }
 
     {
-        std::string stream;
-        beast::detail::SimpleJsonWriter writer{stream};
+        std::string buffer;
+        beast::detail::SimpleJsonWriter writer{buffer};
 
         writer.writeString("\"\\");
         CHECK(writer.finish() == "\"\\\"\\\\\"");

Original file line number	Diff line number	Diff line change
`@@ -23,6 +23,7 @@`
`23`	`23`	`#include <xrpl/beast/utility/instrumentation.h>`
`24`	`24`
`25`	`25`	`#include <charconv>`
	`26`	`+#include <shared_mutex>`
`26`	`27`	`#include <source_location>`
`27`	`28`	`#include <sstream>`
`28`	`29`	`#include <string>`
`@@ -84,140 +85,140 @@ namespace detail {`
`84`	`85`	`class SimpleJsonWriter`
`85`	`86`	`{`
`86`	`87`	`public:`
`87`		`- explicit SimpleJsonWriter(std::string& stream) : stream_(stream)`
	`88`	`+ explicit SimpleJsonWriter(std::string& buffer) : buffer_(buffer)`
`88`	`89`	`{`
`89`	`90`	`}`
`90`	`91`
`91`	`92`	`void`
`92`	`93`	`startObject() const`
`93`	`94`	`{`
`94`		`- stream_.push_back('{');`
	`95`	`+ buffer_.push_back('{');`
`95`	`96`	`}`
`96`	`97`	`void`
`97`	`98`	`endObject() const`
`98`	`99`	`{`
`99`	`100`	`using namespace std::string_view_literals;`
`100`		`- stream_.pop_back();`
`101`		`- stream_.append("},"sv);`
	`101`	`+ buffer_.pop_back();`
	`102`	`+ buffer_.append("},"sv);`
`102`	`103`	`}`
`103`	`104`	`void`
`104`	`105`	`writeKey(std::string_view key) const`
`105`	`106`	`{`
`106`	`107`	`writeString(key);`
`107`		`- stream_.back() = ':';`
	`108`	`+ buffer_.back() = ':';`
`108`	`109`	`}`
`109`	`110`	`void`
`110`	`111`	`startArray() const`
`111`	`112`	`{`
`112`		`- stream_.push_back('[');`
	`113`	`+ buffer_.push_back('[');`
`113`	`114`	`}`
`114`	`115`	`void`
`115`	`116`	`endArray() const`
`116`	`117`	`{`
`117`	`118`	`using namespace std::string_view_literals;`
`118`		`- stream_.pop_back();`
`119`		`- stream_.append("],"sv);`
	`119`	`+ buffer_.pop_back();`
	`120`	`+ buffer_.append("],"sv);`
`120`	`121`	`}`
`121`	`122`	`void`
`122`	`123`	`writeString(std::string_view str) const`
`123`	`124`	`{`
`124`	`125`	`using namespace std::string_view_literals;`
`125`		`- stream_.push_back('"');`
`126`		`- escape(str, stream_);`
`127`		`- stream_.append("\","sv);`
	`126`	`+ buffer_.push_back('"');`
	`127`	`+ escape(str, buffer_);`
	`128`	`+ buffer_.append("\","sv);`
`128`	`129`	`}`
`129`	`130`	`std::string_view`
`130`	`131`	`writeInt(std::int8_t val) const`
`131`	`132`	`{`
`132`		`- return pushNumber(val, stream_);`
	`133`	`+ return pushNumber(val, buffer_);`
`133`	`134`	`}`
`134`	`135`	`std::string_view`
`135`	`136`	`writeInt(std::int16_t val) const`
`136`	`137`	`{`
`137`		`- return pushNumber(val, stream_);`
	`138`	`+ return pushNumber(val, buffer_);`
`138`	`139`	`}`
`139`	`140`	`std::string_view`
`140`	`141`	`writeInt(std::int32_t val) const`
`141`	`142`	`{`
`142`		`- return pushNumber(val, stream_);`
	`143`	`+ return pushNumber(val, buffer_);`
`143`	`144`	`}`
`144`	`145`	`std::string_view`
`145`	`146`	`writeInt(std::int64_t val) const`
`146`	`147`	`{`
`147`		`- return pushNumber(val, stream_);`
	`148`	`+ return pushNumber(val, buffer_);`
`148`	`149`	`}`
`149`	`150`	`std::string_view`
`150`	`151`	`writeUInt(std::size_t val) const`
`151`	`152`	`{`
`152`		`- return pushNumber(val, stream_);`
	`153`	`+ return pushNumber(val, buffer_);`
`153`	`154`	`}`
`154`	`155`	`std::string_view`
`155`	`156`	`writeUInt(std::uint8_t val) const`
`156`	`157`	`{`
`157`		`- return pushNumber(val, stream_);`
	`158`	`+ return pushNumber(val, buffer_);`
`158`	`159`	`}`
`159`	`160`	`std::string_view`
`160`	`161`	`writeUInt(std::uint16_t val) const`
`161`	`162`	`{`
`162`		`- return pushNumber(val, stream_);`
	`163`	`+ return pushNumber(val, buffer_);`
`163`	`164`	`}`
`164`	`165`	`std::string_view`
`165`	`166`	`writeUInt(std::uint32_t val) const`
`166`	`167`	`{`
`167`		`- return pushNumber(val, stream_);`
	`168`	`+ return pushNumber(val, buffer_);`
`168`	`169`	`}`
`169`	`170`	`std::string_view`
`170`	`171`	`writeUInt(std::uint64_t val) const`
`171`	`172`	`{`
`172`		`- return pushNumber(val, stream_);`
	`173`	`+ return pushNumber(val, buffer_);`
`173`	`174`	`}`
`174`	`175`	`std::string_view`
`175`	`176`	`writeDouble(double val) const`
`176`	`177`	`{`
`177`		`- return pushNumber(val, stream_);`
	`178`	`+ return pushNumber(val, buffer_);`
`178`	`179`	`}`
`179`	`180`	`std::string_view`
`180`	`181`	`writeBool(bool val) const`
`181`	`182`	`{`
`182`	`183`	`using namespace std::string_view_literals;`
`183`	`184`	`auto str = val ? "true,"sv : "false,"sv;`
`184`		`- stream_.append(str);`
	`185`	`+ buffer_.append(str);`
`185`	`186`	`return str;`
`186`	`187`	`}`
`187`	`188`	`void`
`188`	`189`	`writeNull() const`
`189`	`190`	`{`
`190`	`191`	`using namespace std::string_view_literals;`
`191`		`- stream_.append("null,"sv);`
	`192`	`+ buffer_.append("null,"sv);`
`192`	`193`	`}`
`193`	`194`	`void`
`194`	`195`	`writeRaw(std::string_view str) const`
`195`	`196`	`{`
`196`		`- stream_.append(str);`
	`197`	`+ buffer_.append(str);`
`197`	`198`	`}`
`198`	`199`
`199`	`200`	`[[nodiscard]] std::string_view`
`200`	`201`	`finish()`
`201`	`202`	`{`
`202`		`- return std::string_view{stream_.c_str(), stream_.size() - 1};`
	`203`	`+ return std::string_view{buffer_.c_str(), buffer_.size() - 1};`
`203`	`204`	`}`
`204`	`205`
`205`	`206`	`private:`
`206`	`207`	`template <typename T>`
`207`	`208`	`static std::string_view`
`208`		`- pushNumber(T val, std::string& stream)`
	`209`	`+ pushNumber(T val, std::string& str)`
`209`	`210`	`{`
`210`	`211`	`thread_local char buffer[128];`
`211`	`212`	`auto result = std::to_chars(std::begin(buffer), std::end(buffer), val);`
`212`	`213`	`auto ptr = result.ptr;`
`213`	`214`	`*ptr = ',';`
`214`	`215`	`auto len = ptr - std::begin(buffer);`
`215`		`- stream.append(buffer, len + 1);`
	`216`	`+ str.append(buffer, len + 1);`
`216`	`217`	`return {buffer, static_cast<size_t>(len)};`
`217`	`218`	`}`
`218`	`219`
`219`	`220`	`static void`
`220`		`- escape(std::string_view str, std::string& os)`
	`221`	`+ escape(std::string_view str, std::string& buffer)`
`221`	`222`	`{`
`222`	`223`	`static constexpr char HEX[] = "0123456789ABCDEF";`
`223`	`224`
`@@ -240,36 +241,36 @@ class SimpleJsonWriter`
`240`	`241`
`241`	`242`	`// Flush the preceding safe run in one go.`
`242`	`243`	`if (chunk != p)`
`243`		`- os.append(chunk, p - chunk);`
	`244`	`+ buffer.append(chunk, p - chunk);`
`244`	`245`
`245`	`246`	`switch (c)`
`246`	`247`	`{`
`247`	`248`	`case '"':`
`248`		`- os.append("\\\"", 2);`
	`249`	`+ buffer.append("\\\"", 2);`
`249`	`250`	`break;`
`250`	`251`	`case '\\':`
`251`		`- os.append("\\\\", 2);`
	`252`	`+ buffer.append("\\\\", 2);`
`252`	`253`	`break;`
`253`	`254`	`case '\b':`
`254`		`- os.append("\\b", 2);`
	`255`	`+ buffer.append("\\b", 2);`
`255`	`256`	`break;`
`256`	`257`	`case '\f':`
`257`		`- os.append("\\f", 2);`
	`258`	`+ buffer.append("\\f", 2);`
`258`	`259`	`break;`
`259`	`260`	`case '\n':`
`260`		`- os.append("\\n", 2);`
	`261`	`+ buffer.append("\\n", 2);`
`261`	`262`	`break;`
`262`	`263`	`case '\r':`
`263`		`- os.append("\\r", 2);`
	`264`	`+ buffer.append("\\r", 2);`
`264`	`265`	`break;`
`265`	`266`	`case '\t':`
`266`		`- os.append("\\t", 2);`
	`267`	`+ buffer.append("\\t", 2);`
`267`	`268`	`break;`
`268`	`269`	`default: {`
`269`	`270`	`// Other C0 controls -> \u00XX (JSON compliant)`
`270`	`271`	`char buf[6]{`
`271`	`272`	`'\\', 'u', '0', '0', HEX[(c >> 4) & 0xF], HEX[c & 0xF]};`
`272`		`- os.append(buf, 6);`
	`273`	`+ buffer.append(buf, 6);`
`273`	`274`	`break;`
`274`	`275`	`}`
`275`	`276`	`}`
`@@ -280,10 +281,10 @@ class SimpleJsonWriter`
`280`	`281`
`281`	`282`	`// Flush trailing safe run`
`282`	`283`	`if (chunk != p)`
`283`		`- os.append(chunk, p - chunk);`
	`284`	`+ buffer.append(chunk, p - chunk);`
`284`	`285`	`}`
`285`	`286`
`286`		`- std::string& stream_;`
	`287`	`+ std::string& buffer_;`
`287`	`288`	`};`
`288`	`289`
`289`	`290`	`} // namespace detail`
`@@ -369,7 +370,7 @@ class Journal`
`369`	`370`	`std::string m_name;`
`370`	`371`	`std::string m_attributesJson;`
`371`	`372`	`static std::string globalLogAttributesJson_;`
`372`		`- static std::mutex globalLogAttributesMutex_;`
	`373`	`+ static std::shared_mutex globalLogAttributesMutex_;`
`373`	`374`	`static bool m_jsonLogsEnabled;`
`374`	`375`
`375`	`376`	`static thread_local JsonLogContext currentJsonLogContext_;`
`@@ -624,14 +625,14 @@ class Journal`
`624`	`625`	`Journal(Journal const& other, TAttributesFactory&& attributesFactory)`
`625`	`626`	`: m_name(other.m_name), m_sink(other.m_sink)`
`626`	`627`	`{`
`627`		`- std::string stream{other.m_attributesJson};`
`628`		`- detail::SimpleJsonWriter writer{stream};`
	`628`	`+ std::string buffer{other.m_attributesJson};`
	`629`	`+ detail::SimpleJsonWriter writer{buffer};`
`629`	`630`	`if (other.m_attributesJson.empty())`
`630`	`631`	`{`
`631`	`632`	`writer.startObject();`
`632`	`633`	`}`
`633`	`634`	`attributesFactory(writer);`
`634`		`- m_attributesJson = std::move(stream);`
	`635`	`+ m_attributesJson = std::move(buffer);`
`635`	`636`	`}`
`636`	`637`
`637`	`638`	`/** Create a journal that writes to the specified sink. */`
`@@ -648,11 +649,11 @@ class Journal`
`648`	`649`	`TAttributesFactory&& attributesFactory)`
`649`	`650`	`: m_name(name), m_sink(&sink)`
`650`	`651`	`{`
`651`		`- std::string stream;`
`652`		`- detail::SimpleJsonWriter writer{stream};`
	`652`	`+ std::string buffer;`
	`653`	`+ detail::SimpleJsonWriter writer{buffer};`
`653`	`654`	`writer.startObject();`
`654`	`655`	`attributesFactory(writer);`
`655`		`- m_attributesJson = std::move(stream);`
	`656`	`+ m_attributesJson = std::move(buffer);`
`656`	`657`	`}`
`657`	`658`
`658`	`659`	`Journal&`
`@@ -758,25 +759,25 @@ class Journal`
`758`	`759`	`static void`
`759`	`760`	`resetGlobalAttributes()`
`760`	`761`	`{`
`761`		`- std::lock_guard lock(globalLogAttributesMutex_);`
	`762`	`+ std::unique_lock lock(globalLogAttributesMutex_);`
`762`	`763`	`globalLogAttributesJson_.clear();`
`763`	`764`	`}`
`764`	`765`
`765`	`766`	`template <typename TAttributesFactory>`
`766`	`767`	`static void`
`767`	`768`	`addGlobalAttributes(TAttributesFactory&& factory)`
`768`	`769`	`{`
`769`		`- std::lock_guard lock(globalLogAttributesMutex_);`
	`770`	`+ std::unique_lock lock(globalLogAttributesMutex_);`
`770`	`771`
`771`	`772`	`auto isEmpty = globalLogAttributesJson_.empty();`
`772`		`- std::string stream{std::move(globalLogAttributesJson_)};`
`773`		`- detail::SimpleJsonWriter writer{stream};`
	`773`	`+ std::string buffer{std::move(globalLogAttributesJson_)};`
	`774`	`+ detail::SimpleJsonWriter writer{buffer};`
`774`	`775`	`if (isEmpty)`
`775`	`776`	`{`
`776`	`777`	`writer.startObject();`
`777`	`778`	`}`
`778`	`779`	`factory(writer);`
`779`		`- globalLogAttributesJson_ = std::move(stream);`
	`780`	`+ globalLogAttributesJson_ = std::move(buffer);`
`780`	`781`	`}`
`781`	`782`	`};`
`782`	`783`
Original file line number	Diff line number	Diff line change
`@@ -231,32 +231,32 @@ TEST_CASE("Global attributes inheritable")`
`231`	`231`	`TEST_CASE("Test JsonWriter")`
`232`	`232`	`{`
`233`	`233`	`{`
`234`		`- std::string stream;`
`235`		`- beast::detail::SimpleJsonWriter writer{stream};`
	`234`	`+ std::string buffer;`
	`235`	`+ beast::detail::SimpleJsonWriter writer{buffer};`
`236`	`236`
`237`	`237`	`writer.writeString("\n");`
`238`	`238`	`CHECK(writer.finish() == "\"\\n\"");`
`239`	`239`	`}`
`240`	`240`
`241`	`241`	`{`
`242`		`- std::string stream;`
`243`		`- beast::detail::SimpleJsonWriter writer{stream};`
	`242`	`+ std::string buffer;`
	`243`	`+ beast::detail::SimpleJsonWriter writer{buffer};`
`244`	`244`
`245`	`245`	`writer.writeString("\t");`
`246`	`246`	`CHECK(writer.finish() == "\"\\t\"");`
`247`	`247`	`}`
`248`	`248`
`249`	`249`	`{`
`250`		`- std::string stream;`
`251`		`- beast::detail::SimpleJsonWriter writer{stream};`
	`250`	`+ std::string buffer;`
	`251`	`+ beast::detail::SimpleJsonWriter writer{buffer};`
`252`	`252`
`253`	`253`	`writer.writeString(std::string_view{"\0", 1});`
`254`	`254`	`CHECK(writer.finish() == "\"\\u0000\"");`
`255`	`255`	`}`
`256`	`256`
`257`	`257`	`{`
`258`		`- std::string stream;`
`259`		`- beast::detail::SimpleJsonWriter writer{stream};`
	`258`	`+ std::string buffer;`
	`259`	`+ beast::detail::SimpleJsonWriter writer{buffer};`
`260`	`260`
`261`	`261`	`writer.writeString("\"\\");`
`262`	`262`	`CHECK(writer.finish() == "\"\\\"\\\\\"");`