fix #2052 simplejson barfs on thrown exceptions

Author: Mpdreamz

src/Elasticsearch.Net/Exceptions/ElasticsearchClientException.cs

@@ -42,7 +42,7 @@ public string DebugInformation
 				var failureReason = FailureReason.GetStringValue();
 				if (this.FailureReason == PipelineFailure.Unexpected && (this.AuditTrail.HasAny()))
 				{
-					failureReason = this.AuditTrail.Last().Event.GetStringValue();
+					failureReason = "Unrecoverable/Unexpected " + this.AuditTrail.Last().Event.GetStringValue();
 				}
 
 				sb.AppendLine($"# FailureReason: {failureReason} while attempting {Request.Method.GetStringValue()} {Request.Uri}");

src/Elasticsearch.Net/Serialization/ElasticsearchDefaultSerializer.cs

@@ -30,7 +30,7 @@ public T Deserialize<T>(Stream stream)
 		{
 			if (stream == null)
 				return default(T);
-			
+
 			using (var ms = new MemoryStream())
 			using (stream)
 			{
@@ -45,7 +45,7 @@ public T Deserialize<T>(Stream stream)
 
 		public void Serialize(object data, Stream writableStream, SerializationFormatting formatting = SerializationFormatting.Indented)
 		{
-			var serialized = SimpleJson.SerializeObject(data);
+			var serialized = SimpleJson.SerializeObject(data, ElasticsearchDefaultSerializer.Strategy);
 			if (formatting == SerializationFormatting.None)
 				serialized = RemoveNewLinesAndTabs(serialized);
 			using (var ms = new MemoryStream(serialized.Utf8Bytes()))
@@ -63,4 +63,4 @@ private static string RemoveNewLinesAndTabs(string input)
 				.ToArray());
 		}
 	}
-}
+}

src/Elasticsearch.Net/Serialization/ElasticsearchNetJsonStrategy.cs

@@ -1,12 +1,83 @@
 using System;
 using System.Collections.Generic;
+using System.Globalization;
+using System.Reflection;
+using System.Runtime.Serialization;
 
 namespace Elasticsearch.Net
 {
 	internal class ElasticsearchNetJsonStrategy : PocoJsonSerializerStrategy
 	{
 		public static readonly ElasticsearchNetJsonStrategy Instance = new ElasticsearchNetJsonStrategy();
 
+
+		public override bool TrySerializeNonPrimitiveObject(object input, out object output)
+		{
+			if (input is Exception)
+			{
+				var e = input as Exception;
+				var o = new JsonObject();
+
+				var si = new SerializationInfo(e.GetType(), new FormatterConverter());
+				var sc = new StreamingContext();
+				e.GetObjectData(si, sc);
+
+				var helpUrl = si.GetString("HelpURL");
+				var stackTrace = si.GetString("StackTraceString");
+				var remoteStackTrace = si.GetString("RemoteStackTraceString");
+				var remoteStackIndex = si.GetInt32("RemoteStackIndex");
+				var exceptionMethod = si.GetString("ExceptionMethod");
+				var hresult = si.GetInt32("HResult");
+				var source = si.GetString("Source");
+				var className = si.GetString("ClassName");
+
+				//TODO Loop over ISerializable data
+
+				o.Add("ClassName", className);
+				o.Add("Message", e.Message);
+				o.Add("Source", source);
+				o.Add("StackTraceString", stackTrace);
+				o.Add("RemoteStackTraceString", remoteStackTrace);
+				o.Add("RemoteStackIndex", remoteStackIndex);
+				o.Add("HResult", hresult);
+				o.Add("HelpURL", helpUrl);
+				this.WriteStructuredExceptionMethod(o, exceptionMethod);
+
+				output = o;
+				return true;
+
+			}
+			return base.TrySerializeNonPrimitiveObject(input, out output);
+		}
+
+		private void WriteStructuredExceptionMethod(JsonObject o, string exceptionMethodString)
+		{
+			if (string.IsNullOrWhiteSpace(exceptionMethodString)) return;
+
+			var args = exceptionMethodString.Split('\0', '\n');
+
+			if (args.Length != 5) return;
+
+			var memberType = Int32.Parse(args[0], CultureInfo.InvariantCulture);
+			var name = args[1];
+			var assemblyName = args[2];
+			var className = args[3];
+			var signature = args[4];
+			var an = new AssemblyName(assemblyName);
+			var exceptionMethod = new JsonObject();
+
+			exceptionMethod.Add("Name", name);
+			exceptionMethod.Add("AssemblyName", an.Name);
+			exceptionMethod.Add("AssemblyVersion", an.Version.ToString());
+			exceptionMethod.Add("AssemblyCulture", an.CultureName);
+			exceptionMethod.Add("ClassName", className);
+			exceptionMethod.Add("Signature", signature);
+			exceptionMethod.Add("MemberType", memberType);
+			o.Add("ExceptionMethod", exceptionMethod);
+
+		}
+
+
 		public override object DeserializeObject(object value, Type type)
 		{
 			if (type == typeof(DynamicResponse))
@@ -37,4 +108,4 @@ public override object DeserializeObject(object value, Type type)
 			return base.DeserializeObject(value, type);
 		}
 	}
-}
+}

src/Tests/Reproduce/GithubIssue2052.cs

@@ -1,5 +1,9 @@
 using System;
 using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Runtime.Serialization;
+using System.Text;
 using Elasticsearch.Net;
 using FluentAssertions;
 using Tests.Framework;
@@ -9,30 +13,77 @@ namespace Tests.Reproduce
 	public class GithubIssue2052
 	{
 
-		[U] public void BadSimpleJsonDeserialization()
+		[U]
+		public void BadSimpleJsonDeserialization()
 		{
 
 			var ex = this.GimmeACaughtException();
 
-			var document = new Dictionary<string,object>{
-			    { "message", "My message"},
-			    { "exception", ex }
+			var document = new Dictionary<string, object>{
+				{ "message", "My message"},
+				{ "exception", ex }
 			};
 
 			var pool = new StaticConnectionPool(new List<Uri> { new Uri("http://localhost:9200") });
 			var memoryConnection = new InMemoryConnection();
-			var connectionSettings = new ConnectionConfiguration(pool, memoryConnection);
+			var connectionSettings = new ConnectionConfiguration(pool, memoryConnection)
+				.DisableDirectStreaming();
 			var client = new ElasticLowLevelClient(connectionSettings);
 
-			List<object> payload = new List<object>{
-			    new { index = new { _index = "myIndex", _type = "myDocumentType" } },
-			    document
+
+			var header = new { index = new { _index = "myIndex", _type = "myDocumentType" } };
+			var payload = new List<object>{
+				header,
+				document
+			};
+			var response = client.Bulk<byte[]>(payload);
+
+
+			var request = Encoding.UTF8.GetString(response.RequestBodyInBytes);
+			var a = new AssemblyName(this.GetType().Assembly.FullName);
+
+			var si = new SerializationInfo(ex.GetType(), new FormatterConverter());
+			var sc = new StreamingContext();
+			ex.GetObjectData(si, sc);
+			PostData<object> postData = new List<object>
+			{
+				header,
+				new
+				{
+					message = "My message",
+					exception = new
+					{
+						ClassName = "System.Exception",
+						Message = "Some exception",
+						Source = "Tests",
+						StackTraceString = ex.StackTrace,
+						RemoteStackTraceString = si.GetString("RemoteStackTraceString"),
+						RemoteStackIndex = 0,
+						HResult = si.GetInt32("HResult"),
+						HelpURL = si.GetString("HelpURL"),
+						ExceptionMethod = new
+						{
+							Name = nameof(GimmeACaughtException),
+							AssemblyName = a.Name,
+							AssemblyVersion = a.Version.ToString(),
+							AssemblyCulture = a.CultureName,
+							ClassName = this.GetType().FullName,
+							Signature = $"System.Exception {nameof(GimmeACaughtException)}()",
+							MemberType = 8
+						}
+					},
+				}
 			};
-			Action act = () => client.Bulk<byte[]>(payload);
-			var e = act.ShouldThrow<UnexpectedElasticsearchClientException>();
 
-			//throw new Exception(e.Subject.First().DebugInformation);
 
+
+
+			using (var ms = new MemoryStream())
+			{
+				postData.Write(ms, client.Settings);
+				var expectedString = Encoding.UTF8.GetString(ms.ToArray());
+				request.Should().Be(expectedString);
+			}
 		}
 
 		private Exception GimmeACaughtException()
@@ -41,7 +92,7 @@ private Exception GimmeACaughtException()
 			{
 				throw new Exception("Some exception");
 			}
-			catch(Exception e)
+			catch (Exception e)
 			{
 				return e;
 			}