Ensure we don't serialize excluded dictionary/dynamic keys

Author: niemyjski

src/Exceptionless/Newtonsoft.Json/JsonWriter.cs

@@ -464,6 +464,14 @@ public virtual void WriteEndConstructor()
         {
             InternalWriteEnd(JsonContainerType.Constructor);
         }
+        
+        /// <summary>
+        /// CUSTOM: Return two if the property an be written.
+        /// </summary>
+        public virtual bool ShouldWriteProperty(string name) 
+        {
+            return true;
+        }
 
         /// <summary>
         /// Writes the property name of a name/value pair of a JSON object.

src/Exceptionless/Newtonsoft.Json/Serialization/JsonSerializerInternalWriter.cs

@@ -501,7 +501,11 @@ private void SerializeObject(JsonWriter writer, object value, JsonObjectContract
                     propertyName = (contract.ExtensionDataNameResolver != null)
                         ? contract.ExtensionDataNameResolver(propertyName)
                         : propertyName;
-
+                    
+                    // CUSTOM: check to see if property name can be written.
+                    if (!writer.ShouldWriteProperty(propertyName))
+                        continue;
+                    
                     if (ShouldWriteReference(e.Value, null, valueContract, contract, member))
                     {
                         writer.WritePropertyName(propertyName);
@@ -1074,6 +1078,10 @@ private void SerializeDictionary(JsonWriter writer, IDictionary values, JsonDict
                         ? contract.DictionaryKeyResolver(propertyName)
                         : propertyName;
 
+                    // CUSTOM: check to see if property name can be written.
+                    if (!writer.ShouldWriteProperty(propertyName))
+                        continue;
+                    
                     try
                     {
                         object value = entry.Value;

src/Exceptionless/Serializer/DefaultJsonSerializer.cs

@@ -8,6 +8,7 @@
 using Exceptionless.Extensions;
 using Exceptionless.Json;
 using Exceptionless.Json.Converters;
+using Exceptionless.Json.Linq;
 using Exceptionless.Json.Serialization;
 
 namespace Exceptionless.Serializer {
@@ -42,14 +43,15 @@ public virtual string Serialize(object model, string[] exclusions = null, int ma
             if (model == null)
                 return null;
 
-            JsonSerializer serializer = JsonSerializer.Create(_serializerSettings);
+            var serializer = JsonSerializer.Create(_serializerSettings);
             if (maxDepth < 1)
                 maxDepth = Int32.MaxValue;
 
+            var excludedPropertyNames = new HashSet<string>(exclusions ?? new string[0], StringComparer.OrdinalIgnoreCase);            
             using (var sw = new StringWriter()) {
-                using (var jw = new JsonTextWriterWithDepth(sw)) {
+                using (var jw = new JsonTextWriterWithExclusions(sw, excludedPropertyNames)) {
                     jw.Formatting = Formatting.None;
-                    Func<JsonProperty, object, bool> include = (property, value) => ShouldSerialize(jw, property, value, maxDepth, exclusions);
+                    Func<JsonProperty, object, bool> include = (property, value) => ShouldSerialize(jw, property, value, maxDepth, excludedPropertyNames);
                     var resolver = new ExceptionlessContractResolver(include);
                     serializer.ContractResolver = resolver;
                     if (continueOnSerializationError)
@@ -69,7 +71,7 @@ public virtual object Deserialize(string json, Type type) {
             return JsonConvert.DeserializeObject(json, type, _serializerSettings);
         }
 
-        private bool ShouldSerialize(JsonTextWriterWithDepth jw, JsonProperty property, object obj, int maxDepth, IList<string> excludedPropertyNames) {
+        private bool ShouldSerialize(JsonTextWriterWithDepth jw, JsonProperty property, object obj, int maxDepth, ISet<string> excludedPropertyNames) {
             try {
                 if (excludedPropertyNames != null && (property.UnderlyingName.AnyWildcardMatches(excludedPropertyNames, true) || property.PropertyName.AnyWildcardMatches(excludedPropertyNames, true)))
                     return false;

src/Exceptionless/Serializer/JsonTextWriterWithExclusions.cs

@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using Exceptionless.Extensions;
+
+namespace Exceptionless.Serializer
+{
+    internal class JsonTextWriterWithExclusions : JsonTextWriterWithDepth {
+        private readonly ISet<string> _excludedPropertyNames;
+        
+        public JsonTextWriterWithExclusions(TextWriter textWriter, ISet<string> excludedPropertyNames) : base(textWriter) {
+            _excludedPropertyNames = excludedPropertyNames;
+        }
+        
+        public override bool ShouldWriteProperty(string name) {
+            return !name.AnyWildcardMatches(_excludedPropertyNames, true);
+        }
+    }
+}

test/Exceptionless.Tests/Configuration/DataExclusionTests.cs

@@ -68,8 +68,7 @@ public void CanHandleObject() {
             var ev = new Event();
             ev.SetProperty(nameof(order), order, excludedPropertyNames: new [] { nameof(order.CardLast4) });
             Assert.Single(ev.Data);
-
-            Assert.Equal("{\"id\":\"1234\"}", ev.Data.GetString(nameof(order)));
+            Assert.Equal("{\"id\":\"1234\",\"data\":{}}", ev.Data.GetString(nameof(order)));
         }
 
         [InlineData("Credit*", true)]