Fix serializer regressions and preserve raw data markers

- preserve literal JSON-looking strings in DataDictionary as strings
- restore raw JSON emission only for values produced from structured data
- preserve raw JSON markers through MessagePack storage roundtrips
- coerce primitive SettingsDictionary JSON values to strings like main
- keep dictionary depth-limit regression coverage

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

Author: niemyjski

src/Exceptionless/Extensions/DataDictionaryExtensions.cs

@@ -135,7 +135,10 @@ public static void AddObject(this IData data, ExtendedDataInfo info, Exceptionle
             if (String.IsNullOrEmpty(json))
                 return;
 
-            data.Data[name] = json;
+            if (dataType.IsPrimitiveType())
+                data.Data[name] = json;
+            else
+                data.Data.SetRawJson(name, json);
         }
     }
 }

src/Exceptionless/Models/Collections/DataDictionary.cs

@@ -3,13 +3,38 @@
 
 namespace Exceptionless.Models {
     public class DataDictionary : Dictionary<string, object> {
+        private readonly HashSet<string> _rawJsonKeys = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
         public DataDictionary() : base(StringComparer.OrdinalIgnoreCase) {}
 
         public DataDictionary(IEnumerable<KeyValuePair<string, object>> values) : base(StringComparer.OrdinalIgnoreCase) {
             foreach (var kvp in values)
                 Add(kvp.Key, kvp.Value);
         }
 
+        public new object this[string key] {
+            get => base[key];
+            set {
+                ClearRawJson(key);
+                base[key] = value;
+            }
+        }
+
+        public new void Add(string key, object value) {
+            ClearRawJson(key);
+            base.Add(key, value);
+        }
+
+        public new bool Remove(string key) {
+            ClearRawJson(key);
+            return base.Remove(key);
+        }
+
+        public new void Clear() {
+            _rawJsonKeys.Clear();
+            base.Clear();
+        }
+
         public object GetValueOrDefault(string key) {
             return TryGetValue(key, out object value) ? value : null;
         }
@@ -35,5 +60,21 @@ public string GetString(string name, string @default) {
 
             return String.Empty;
         }
+
+        internal bool IsRawJson(string key) {
+            return !String.IsNullOrEmpty(key) && _rawJsonKeys.Contains(key);
+        }
+
+        internal void SetRawJson(string key, string value) {
+            base[key] = value;
+
+            if (!String.IsNullOrEmpty(key))
+                _rawJsonKeys.Add(key);
+        }
+
+        private void ClearRawJson(string key) {
+            if (!String.IsNullOrEmpty(key))
+                _rawJsonKeys.Remove(key);
+        }
     }
 }

src/Exceptionless/Properties/AssemblyInfo.cs

@@ -10,5 +10,6 @@
 [assembly: Exceptionless.Linking.Preserve]
 [assembly: Guid("2d458cc4-3bb3-4852-b6a2-11d5ac8672df")]
 
+[assembly: InternalsVisibleTo("Exceptionless.MessagePack, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a9357232b9bcad78fd310297fdb41bf42816ee2ca9ccdace999889de2badb6f06df2de1d9f2c8cb17b21f5311f11d6bb328d55e0dd9fe8adc5e2dc4610028c1bdacb3355d2e239b81d0bb0ac83e615fc641f8a3ec49e4fad8e305994953d448ef7b38e8c256601e54af19c035b562e3e5e5461c2a93b8dd11936e451b05034a2")]
 [assembly: InternalsVisibleTo("Exceptionless.Tests, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a9357232b9bcad78fd310297fdb41bf42816ee2ca9ccdace999889de2badb6f06df2de1d9f2c8cb17b21f5311f11d6bb328d55e0dd9fe8adc5e2dc4610028c1bdacb3355d2e239b81d0bb0ac83e615fc641f8a3ec49e4fad8e305994953d448ef7b38e8c256601e54af19c035b562e3e5e5461c2a93b8dd11936e451b05034a2")]
 [assembly: InternalsVisibleTo("Exceptionless.TestHarness, PublicKey=0024000004800000940000000602000000240000525341310004000001000100a9357232b9bcad78fd310297fdb41bf42816ee2ca9ccdace999889de2badb6f06df2de1d9f2c8cb17b21f5311f11d6bb328d55e0dd9fe8adc5e2dc4610028c1bdacb3355d2e239b81d0bb0ac83e615fc641f8a3ec49e4fad8e305994953d448ef7b38e8c256601e54af19c035b562e3e5e5461c2a93b8dd11936e451b05034a2")]

src/Exceptionless/Serializer/DataDictionaryConverter.cs

@@ -33,7 +33,7 @@ public override DataDictionary Read(ref Utf8JsonReader reader, Type typeToConver
                     case JsonTokenType.StartArray:
                         // Store complex values as JSON strings (legacy behavior)
                         using (var doc = JsonDocument.ParseValue(ref reader))
-                            dictionary[key] = doc.RootElement.GetRawText();
+                            dictionary.SetRawJson(key, doc.RootElement.GetRawText());
                         break;
                     case JsonTokenType.String:
                         dictionary[key] = reader.GetString();
@@ -72,7 +72,7 @@ public override void Write(Utf8JsonWriter writer, DataDictionary value, JsonSeri
                 writer.WritePropertyName(kvp.Key);
                 if (kvp.Value == null) {
                     writer.WriteNullValue();
-                } else if (kvp.Value is string str && str.Length > 0 && (str[0] == '{' || str[0] == '[')) {
+                } else if (value.IsRawJson(kvp.Key) && kvp.Value is string str && str.Length > 0 && (str[0] == '{' || str[0] == '[')) {
                     // String values that contain JSON (from roundtripping through storage)
                     // must be emitted as raw JSON objects, not escaped strings.
                     try {

src/Exceptionless/Serializer/SettingsDictionaryConverter.cs

@@ -26,7 +26,16 @@ public override SettingsDictionary Read(ref Utf8JsonReader reader, Type typeToCo
                 if (!reader.Read())
                     throw new JsonException("Unexpected end of JSON");
 
-                string value = reader.TokenType == JsonTokenType.Null ? null : reader.GetString();
+                string value;
+                if (reader.TokenType == JsonTokenType.Null) {
+                    value = null;
+                } else if (reader.TokenType == JsonTokenType.String) {
+                    value = reader.GetString();
+                } else {
+                    using (var doc = JsonDocument.ParseValue(ref reader))
+                        value = doc.RootElement.GetRawText();
+                }
+
                 dictionary[key] = value;
             }
 

src/Platforms/Exceptionless.MessagePack/DataDictionaryFormatter.cs

@@ -1,11 +1,14 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using Exceptionless.Models;
 using Exceptionless.Models.Data;
 using MessagePack;
 using MessagePack.Formatters;
 
 namespace Exceptionless.MessagePack {
     internal class DataDictionaryFormatter : IMessagePackFormatter<DataDictionary?> {
+        private const string RawJsonPrefix = "\u001Eexceptionless:raw-json:";
+
         public void Serialize(ref MessagePackWriter writer, DataDictionary? value, MessagePackSerializerOptions options) {
             if (value == null) {
                 writer.WriteNil();
@@ -58,8 +61,13 @@ public void Serialize(ref MessagePackWriter writer, DataDictionary? value, Messa
                         writer.Write((string)item.Value);
                         break;
                     default:
-                        options.Resolver.GetFormatter<object>()
-                            .Serialize(ref writer, item.Value, options);
+                        if (value.IsRawJson(item.Key) && item.Value is string rawJson) {
+                            writer.Write(RawJsonPrefix + rawJson);
+                        } else {
+                            options.Resolver.GetFormatter<object>()
+                                .Serialize(ref writer, item.Value, options);
+                        }
+
                         break;
                 }
             }
@@ -138,7 +146,10 @@ public void Serialize(ref MessagePackWriter writer, DataDictionary? value, Messa
 #endif
                     default: {
                             var value = options.Resolver.GetFormatter<object>().Deserialize(ref reader, options);
-                            dic.Add(key, value);
+                            if (value is string rawJson && rawJson.StartsWith(RawJsonPrefix, StringComparison.Ordinal))
+                                dic.SetRawJson(key, rawJson.Substring(RawJsonPrefix.Length));
+                            else
+                                dic.Add(key, value);
                             break;
                         }
                 }

test/Exceptionless.Tests/Serializer/Models/DataDictionarySerializerTests.cs

@@ -1,4 +1,5 @@
 using System;
+using System.Text.Json;
 using Exceptionless.Models;
 using Exceptionless.Tests.Serializer;
 using Xunit;
@@ -107,5 +108,22 @@ public void Deserialize_DataDictionary_JArrayValuesBecomeCompactStrings() {
             // Assert
             Assert.Equal(expected, data["items"]);
         }
+
+        [Fact]
+        public void Serialize_DataDictionary_LiteralJsonString_RemainsString() {
+            // Regression test: literal string values that happen to look like JSON
+            // must stay strings on the wire. Only values produced from complex objects
+            // should be emitted as raw JSON.
+            var data = new DataDictionary {
+                ["payload"] = """{"a":1}""",
+                ["items"] = """[1,2]"""
+            };
+
+            string json = Serialize(data);
+
+            using var doc = JsonDocument.Parse(json);
+            Assert.Equal("""{"a":1}""", doc.RootElement.GetProperty("payload").GetString());
+            Assert.Equal("[1,2]", doc.RootElement.GetProperty("items").GetString());
+        }
     }
 }

test/Exceptionless.Tests/Serializer/Models/SettingsDictionarySerializerTests.cs

@@ -100,5 +100,18 @@ public void Deserialize_SettingsDictionary_GetInt32ParsesValues() {
             Assert.Equal(25, settings.GetInt32("max_events"));
             Assert.Equal(99, settings.GetInt32("invalid", 99));
         }
+
+        [Fact]
+        public void Deserialize_SettingsDictionary_PrimitiveJsonValuesBecomeStrings() {
+            // Regression test: main coerces primitive JSON values into strings when
+            // deserializing SettingsDictionary. The STJ converter must preserve that behavior.
+            const string json = """{"max_events":25,"is_enabled":true,"threshold":3.14}""";
+
+            SettingsDictionary settings = Deserialize<SettingsDictionary>(json);
+
+            Assert.Equal("25", settings["max_events"]);
+            Assert.Equal("true", settings["is_enabled"]);
+            Assert.Equal("3.14", settings["threshold"]);
+        }
     }
 }