Use relaxed JSON escaping for log bodies

The body formatter and batch serializer build Utf8JsonWriters with no
options, so they use the default HTML-safe JavaScriptEncoder, which
unicode-escapes every quote, ', <, >, & and all non-ASCII characters.
Because Serilog quotes string property values by default, this makes most
stored Loki lines unreadable (a regression from v8.x, which formatted
bodies with Serilog's JsonValueFormatter and standard escaping).

Construct the writers with JsonWriterOptions(Encoder =
JavaScriptEncoder.UnsafeRelaxedJsonEscaping). Output stays valid JSON and
UTF-8, so consumers (including the json parser) are unaffected. Add a unit
test covering markup and non-ASCII characters.

Author: olsh

src/Serilog.Sinks.Grafana.Loki/LokiJsonTextFormatter.fs

@@ -12,6 +12,7 @@ namespace Serilog.Sinks.Grafana.Loki
 
 open System
 open System.Buffers
+open System.Text.Encodings.Web
 open System.Text.Json
 open Serilog.Events
 open Serilog.Formatting
@@ -30,6 +31,12 @@ type LokiJsonTextFormatter(exceptionFormatter: ILokiExceptionFormatter, enrichTr
     static let pTraceId = JsonEncodedText.Encode "TraceId"
     static let pSpanId = JsonEncodedText.Encode "SpanId"
 
+    // Relaxed escaping keeps the body readable: only JSON-mandatory escapes, non-ASCII verbatim.
+    // The default Utf8JsonWriter encoder is HTML-safe and would \uXXXX-escape every '"', '<', '>',
+    // '&', '\'' and all non-ASCII. Output stays valid JSON, so consumers are unaffected.
+    static let relaxedWriterOptions =
+        JsonWriterOptions(Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping)
+
     // Names that collide with top-level JSON keys; prefixed with '_' when seen as properties.
     static let reserved =
         Collections.Generic.HashSet<string>(
@@ -173,7 +180,9 @@ type LokiJsonTextFormatter(exceptionFormatter: ILokiExceptionFormatter, enrichTr
         use buffer = new PooledByteBufferWriter(256)
         // Throwaway writer + scratch for the message render. The internal sink path passes reused
         // instances instead; the public path stays allocation-light but fully thread-safe.
-        use jsonWriter = new Utf8JsonWriter(buffer :> IBufferWriter<byte>)
+        use jsonWriter =
+            new Utf8JsonWriter(buffer :> IBufferWriter<byte>, relaxedWriterOptions)
+
         use messageBuffer = new PooledByteBufferWriter(128)
         use messageWriter = new Utf8TextWriter(messageBuffer)
         self.FormatToBuffer(logEvent, jsonWriter, messageWriter)

src/Serilog.Sinks.Grafana.Loki/Serialization.fs

@@ -16,12 +16,22 @@ open System
 open System.Buffers
 open System.Buffers.Text
 open System.Collections.Generic
+open System.Text.Encodings.Web
 open System.Text.Json
 open Microsoft.FSharp.NativeInterop
 open Serilog.Events
 open Serilog.Formatting
 open Serilog.Sinks.Grafana.Loki.Infrastructure
 
+/// Relaxed JSON escaping for the bytes the sink emits. The default Utf8JsonWriter encoder is
+/// HTML-safe and renders every '"', '<', '>', '&', '\'' and all non-ASCII as \uXXXX, which makes
+/// the stored log line unreadable; the relaxed encoder escapes only what JSON mandates and emits
+/// non-ASCII verbatim. Output stays valid JSON (and valid UTF-8), so consumers are unaffected.
+[<AutoOpen>]
+module private JsonWriterDefaults =
+    let relaxedWriterOptions =
+        JsonWriterOptions(Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping)
+
 /// Reusable per-sink serialization scratch: the buffers and writers reused across every batch
 /// (cleared/reset between uses), bundled so the serializer takes one value instead of several
 /// same-typed positional args (easy to mis-order), and disposed as a unit by the sink.
@@ -30,7 +40,10 @@ type internal SerializationBuffers() =
     let main = new PooledByteBufferWriter(4096)
     let body = new PooledByteBufferWriter(256)
     let message = new PooledByteBufferWriter(256)
-    let bodyWriter = new Utf8JsonWriter(body :> IBufferWriter<byte>)
+
+    let bodyWriter =
+        new Utf8JsonWriter(body :> IBufferWriter<byte>, relaxedWriterOptions)
+
     let messageWriter = new Utf8TextWriter(message)
 
     /// Envelope buffer holding the full push payload; read by LokiPushContent after serialize.
@@ -87,7 +100,8 @@ module internal Serialization =
             | :? LokiJsonTextFormatter as fmt when fmt.GetType() = typeof<LokiJsonTextFormatter> -> fmt
             | _ -> Unchecked.defaultof<LokiJsonTextFormatter>
 
-        use jsonWriter = new Utf8JsonWriter(buffers.Main :> IBufferWriter<byte>)
+        use jsonWriter =
+            new Utf8JsonWriter(buffers.Main :> IBufferWriter<byte>, relaxedWriterOptions)
 
         // Reused stack scratch for the per-event Unix-nanosecond timestamp. Hoisted out of
         // the event loop so the localloc happens once per batch, not once per event. An

tests/Serilog.Sinks.Grafana.Loki.UnitTests/WireFormatTests.fs

@@ -252,6 +252,19 @@ let ``body: contains Message and MessageTemplate`` () : Task =
         test <@ hasMsg && hasTpl @>
     }
 
+[<Fact>]
+let ``body: quotes, markup and non-ASCII are not unicode-escaped`` () : Task =
+    task {
+        let handler, sink = makeSink id
+        use _ = sink
+        do! flush sink [ mkInfo [ "Note", box "a>b <c> & \"q\" Привет" ] ]
+        let raw = handler.LastBodyText
+        // Relaxed escaping emits '<' '>' '&' and non-ASCII verbatim; the default HTML-safe encoder
+        // would render them as \uXXXX, so these literal substrings could not appear in the payload.
+        test <@ raw.Contains("a>b <c> &") @>
+        test <@ raw.Contains("Привет") @>
+    }
+
 [<Fact>]
 let ``body: reserved property "Message" sanitized to "_Message"`` () : Task =
     task {