added EnableTrace() on ConnectionSettings, great for debugging with i.e glimpse

Author: Mpdreamz

src/Nest/Domain/Connection/Connection.cs

@@ -5,6 +5,7 @@
 using System.IO;
 using System.Threading.Tasks;
 using System.Collections.Generic;
+using Nest.Domain.Connection;
 
 namespace Nest
 {
@@ -14,6 +15,7 @@ public class Connection : IConnection
 
 		private IConnectionSettings _ConnectionSettings { get; set; }
 		private Semaphore _ResourceLock;
+		private readonly bool _enableTrace;
 
 		public Connection(IConnectionSettings settings)
 		{
@@ -22,6 +24,7 @@ public Connection(IConnectionSettings settings)
 
 			this._ConnectionSettings = settings;
 			this._ResourceLock = new Semaphore(settings.MaximumAsyncConnections, settings.MaximumAsyncConnections);
+			this._enableTrace = settings.TraceEnabled;
 		}
 
 		public ConnectionStatus GetSync(string path)
@@ -162,61 +165,81 @@ private HttpWebRequest CreateWebRequest(string path, string method)
 
 		protected virtual ConnectionStatus DoSynchronousRequest(HttpWebRequest request, string data = null)
 		{
-			var timeout = this._ConnectionSettings.Timeout;
-			if (data != null)
+			using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
 			{
-				using (var r = request.GetRequestStream())
+				ConnectionStatus cs = null;
+				if (data != null)
 				{
-					byte[] buffer = Encoding.UTF8.GetBytes(data);
-					r.Write(buffer, 0, buffer.Length);
+					using (var r = request.GetRequestStream())
+					{
+						byte[] buffer = Encoding.UTF8.GetBytes(data);
+						r.Write(buffer, 0, buffer.Length);
+					}
 				}
-			}
-			try
-			{
-				using (var response = (HttpWebResponse)request.GetResponse())
-				using (var responseStream = response.GetResponseStream())
-				using (var streamReader = new StreamReader(responseStream))
+				try
+				{
+					using (var response = (HttpWebResponse)request.GetResponse())
+					using (var responseStream = response.GetResponseStream())
+					using (var streamReader = new StreamReader(responseStream))
+					{
+						string result = streamReader.ReadToEnd();
+						cs = new ConnectionStatus(result)
+						{
+							Request = data,
+							RequestUrl = request.RequestUri.ToString(),
+							RequestMethod = request.Method
+						};
+						tracer.SetResult(cs);
+						return cs;
+					}
+				}
+				catch (WebException webException)
 				{
-					string result = streamReader.ReadToEnd();
-					var cs = new ConnectionStatus(result)
+					cs = new ConnectionStatus(webException)
 					{
 						Request = data,
 						RequestUrl = request.RequestUri.ToString(),
 						RequestMethod = request.Method
 					};
+					tracer.SetResult(cs);
 					return cs;
 				}
 			}
-			catch (WebException webException)
-			{
-				return new ConnectionStatus(webException) { Request = data, RequestUrl = request.RequestUri.ToString(), RequestMethod = request.Method };
-			}		
 		}
 
 		protected virtual Task<ConnectionStatus> DoAsyncRequest(HttpWebRequest request, string data = null)
 		{
-			var timeout = this._ConnectionSettings.Timeout;
-
 			var tcs = new TaskCompletionSource<ConnectionStatus>();
+			var timeout = this._ConnectionSettings.Timeout;
 			if (!this._ResourceLock.WaitOne(timeout))
 			{
-				var m = "Could not start the operation before the timeout of " + timeout + "ms completed while waiting for the semaphore";
-				tcs.SetResult(new ConnectionStatus(new TimeoutException(m)));
-				return tcs.Task;
+				using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
+				{
+					var m = "Could not start the operation before the timeout of " + timeout +
+						"ms completed while waiting for the semaphore";
+					var cs = new ConnectionStatus(new TimeoutException(m));
+					tcs.SetResult(cs);
+					tracer.SetResult(cs);
+					return tcs.Task;
+				}
 			}
 			try
 			{
 				return Task.Factory.StartNew(() =>
 				{
-					this.Iterate(this._AsyncSteps(request, tcs, data), tcs);
-					return tcs.Task.Result;
+					using (var tracer = new ConnectionStatusTracer(this._ConnectionSettings.TraceEnabled))
+					{
+						this.Iterate(this._AsyncSteps(request, tcs, data), tcs);
+						var cs = tcs.Task.Result;
+						tracer.SetResult(cs);
+						return cs;
+					}
 				}, TaskCreationOptions.LongRunning);
 			}
 			finally
 			{
 				this._ResourceLock.Release();
 			}
-
 		}
 
 		private IEnumerable<Task> _AsyncSteps(HttpWebRequest request, TaskCompletionSource<ConnectionStatus> tcs, string data = null)
@@ -284,7 +307,7 @@ public void Iterate(IEnumerable<Task> asyncIterator, TaskCompletionSource<Connec
 					//none of the individual steps in _AsyncSteps run in parallel for 1 request
 					//as this would be impossible we can assume Aggregate Exception.InnerException
 					var exception = completedTask.Exception.InnerException;
-					
+
 					//cleanly exit from exceptions in stages if the exception is a webexception
 					if (exception is WebException)
 						tcs.SetResult(new ConnectionStatus(exception));

src/Nest/Domain/Connection/ConnectionSettings.cs

@@ -29,7 +29,7 @@ public string DefaultIndex
 
 		public int MaximumAsyncConnections { get; private set; }
 		public bool UsesPrettyResponses { get; private set; }
-
+		public bool TraceEnabled { get; private set; }
 		public Func<Type, string> DefaultTypeNameInferrer { get; private set; }
 		public FluentDictionary<Type, string> DefaultIndices { get; private set; }
 		public FluentDictionary<Type, string> DefaultTypeNames { get; private set; }
@@ -90,6 +90,15 @@ public ConnectionSettings SetProxy(Uri proxyAdress, string username, string pass
 			return this;
 		}
 
+		/// <summary>
+		/// Enable Trace signals to the IConnection that it should put debug information on the Trace.
+		/// </summary>
+		public ConnectionSettings EnableTrace(bool enabled = true)
+		{
+			this.TraceEnabled = enabled;
+			return this;
+		}
+
 		/// <summary>
 		/// Timeout in milliseconds when the .NET webrquest should abort the request, note that you can set this to a high value here,
 		/// and specify the timeout in various calls on Elasticsearch's side.

src/Nest/Domain/Connection/ConnectionStatusTracer.cs

@@ -0,0 +1,61 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+
+namespace Nest.Domain.Connection
+{
+	public class ConnectionStatusTracer : IDisposable
+	{
+		private readonly bool _enabled;
+		private Stopwatch _stopwatch;
+
+		public ConnectionStatus _result { get; set; }
+
+		public ConnectionStatusTracer(bool enabled)
+		{
+			this._enabled = enabled;
+			if (enabled)
+			{
+				this._stopwatch = Stopwatch.StartNew();
+			}
+		}
+
+		public void SetResult(ConnectionStatus status)
+		{
+			if (!_enabled)
+				return;
+			this._result = status;
+			this._stopwatch.Stop();
+		}
+
+		public void Dispose()
+		{
+			if (!_enabled || this._result == null)
+				return;
+
+			if (_result.Success)
+			{
+				Trace.TraceInformation(
+					"NEST {0} {1} ({2}):\r\n{3}"
+					, _result.RequestMethod
+					, _result.RequestUrl
+					, _stopwatch.Elapsed.ToString()
+					, _result.ToString()
+				);
+			}
+			else
+			{
+				Trace.TraceError(
+					"NEST {0} {1} ({2}):\r\n{3}"
+					, _result.RequestMethod
+					, _result.RequestUrl
+					, _stopwatch.Elapsed.ToString()
+					, _result.ToString()
+				);
+			}
+		}
+
+	}
+}

src/Nest/Domain/Connection/IConnectionSettings.cs

@@ -18,7 +18,10 @@ public interface IConnectionSettings
 		string ProxyUsername { get; }
 		string ProxyPassword { get; }
 
-		int MaximumAsyncConnections { get; }
+		int MaximumAsyncConnections { get; }
+
+		bool TraceEnabled { get; }
+
 		bool UsesPrettyResponses { get; }
 		Uri Uri { get; }
 

src/Nest/Nest.csproj

@@ -67,6 +67,7 @@
     <Reference Include="System.ServiceModel" />
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Domain\Connection\ConnectionStatusTracer.cs" />
     <Compile Include="Domain\PathAndData.cs" />
     <Compile Include="DSL\PercolatorDescriptor.cs" />
     <Compile Include="DSL\PercolateDescriptor.cs" />