Fix dictionary depth limit bypass in WriteValue

WriteValue for IDictionary entries wrote the property name before checking
whether the value could actually be serialized at the current depth. When a
complex value exceeded maxDepth, WriteValue returned without writing anything,
leaving the JSON writer in an invalid state. The error was silently swallowed
by continueOnSerializationError, causing a fallback to full serialization
(effectively ignoring the depth limit entirely).

Fix: check depth before writing the property name. Skip complex dictionary
entries that would exceed maxDepth, consistent with the object property path.

Added regression test that fails before the fix (depth limit violated) and
passes after.

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

Author: niemyjski

src/Exceptionless/Serializer/DefaultJsonSerializer.cs

@@ -95,11 +95,17 @@ private void WriteValue(Utf8JsonWriter writer, object value, Type type, string[]
                     string key = entry.Key?.ToString() ?? "";
                     if (hasExclusions && key.AnyWildcardMatches(exclusions, ignoreCase: true))
                         continue;
-                    writer.WritePropertyName(key);
-                    if (entry.Value == null)
+                    if (entry.Value == null) {
+                        writer.WritePropertyName(key);
                         writer.WriteNullValue();
-                    else
-                        WriteValue(writer, entry.Value, entry.Value.GetType(), exclusions, hasExclusions, maxDepth, currentDepth + 1);
+                    } else {
+                        Type entryType = entry.Value.GetType();
+                        // Skip complex values that would exceed max depth
+                        if (!IsPrimitiveType(entryType) && currentDepth + 1 >= maxDepth)
+                            continue;
+                        writer.WritePropertyName(key);
+                        WriteValue(writer, entry.Value, entryType, exclusions, hasExclusions, maxDepth, currentDepth + 1);
+                    }
                 }
                 writer.WriteEndObject();
                 return;

test/Exceptionless.Tests/Serializer/JsonSerializerTests.cs

@@ -624,6 +624,29 @@ public void Serialize_Event_DataDictionaryRoundTrip_PreservesObjectStructure() {
             Assert.Contains("\"o_s_name\":\"Windows\"", apiJson);
         }
 
+        [Fact]
+        public void Serialize_DictionaryWithNestedObjectAtDepthLimit_ProducesValidJson() {
+            // Regression test: When a dictionary contains a nested complex object and
+            // the depth limit is reached, WriteValue returned without writing a value
+            // after the property name was already written. The error was silently swallowed
+            // by continueOnSerializationError, falling back to full serialization (violating
+            // the depth limit). This means depth limits don't work for dictionaries.
+            var serializer = GetSerializer();
+            var dict = new Dictionary<string, object> {
+                { "simple", "hello" },
+                { "nested", new Dictionary<string, object> { { "deep", "value" } } }
+            };
+
+            // maxDepth=1: top-level dict is written, nested complex values should be truncated
+            string json = serializer.Serialize(dict, null, maxDepth: 1);
+
+            // Must produce valid JSON
+            Assert.NotNull(json);
+            Assert.Contains("\"simple\":\"hello\"", json);
+            // The nested dictionary should NOT appear at depth (depth limit should be respected)
+            Assert.DoesNotContain("\"deep\"", json);
+        }
+
         [Fact]
         public void Deserialize_Event_ShouldDeserializeReferenceIds() {
             // Arrange