Fix issue with concurrent logging (#63)

* Fix issue with concurrent logging

* Fix namespace + code format/cleanup

src/WireMock.Net/Owin/AspNetCoreSelfHost.cs

@@ -46,6 +46,7 @@ namespace WireMock.Owin
             _host = new WebHostBuilder()
                 .Configure(appBuilder =>
                 {
+                    appBuilder.UseMiddleware<GlobalExceptionMiddleware>();
                     _options.PreWireMockMiddlewareInit?.Invoke(appBuilder);
                     appBuilder.UseMiddleware<WireMockMiddleware>(_options);
                     _options.PostWireMockMiddlewareInit?.Invoke(appBuilder);

src/WireMock.Net/Owin/GlobalExceptionMiddleware.cs

@@ -0,0 +1,49 @@
+using System;
+using System.Threading.Tasks;
+using Newtonsoft.Json;
+#if !NETSTANDARD
+using Microsoft.Owin;
+#else
+using Microsoft.AspNetCore.Http;
+#endif
+
+namespace WireMock.Owin
+{
+#if !NETSTANDARD
+    internal class GlobalExceptionMiddleware : OwinMiddleware
+#else
+    internal class GlobalExceptionMiddleware
+#endif
+    {
+#if !NETSTANDARD
+        public GlobalExceptionMiddleware(OwinMiddleware next) : base(next) { }
+#else
+        public GlobalExceptionMiddleware(RequestDelegate next)
+        {
+            Next = next;
+        }
+#endif
+
+#if NETSTANDARD
+    public RequestDelegate Next { get; private set; }
+#endif
+
+    private readonly OwinResponseMapper _responseMapper = new OwinResponseMapper();
+
+#if !NETSTANDARD
+        public override async Task Invoke(IOwinContext ctx)
+#else
+        public async Task Invoke(HttpContext ctx)
+#endif
+        {
+            try
+            {
+                await Next?.Invoke(ctx);
+            }
+            catch (Exception ex)
+            {
+                await _responseMapper.MapAsync(new ResponseMessage { StatusCode = 500, Body = JsonConvert.SerializeObject(ex) }, ctx.Response);
+            }
+        }
+    }
+}

src/WireMock.Net/Owin/OwinSelfHost.cs

@@ -61,6 +61,7 @@ namespace WireMock.Owin
 
             Action<IAppBuilder> startup = app =>
             {
+                app.Use<GlobalExceptionMiddleware>();
                 _options.PreWireMockMiddlewareInit?.Invoke(app);
                 app.Use<WireMockMiddleware>(_options);
                 _options.PostWireMockMiddlewareInit?.Invoke(app);

src/WireMock.Net/Owin/WireMockMiddleware.cs

@@ -5,6 +5,7 @@ using WireMock.Matchers.Request;
 using System.Linq;
 using WireMock.Matchers;
 using WireMock.Util;
+using Newtonsoft.Json;
 #if !NETSTANDARD
 using Microsoft.Owin;
 #else
@@ -124,7 +125,7 @@ namespace WireMock.Owin
             }
             catch (Exception ex)
             {
-                response = new ResponseMessage { StatusCode = 500, Body = ex.ToString() };
+                response = new ResponseMessage { StatusCode = 500, Body = JsonConvert.SerializeObject(ex) };
             }
             finally
             {

src/WireMock.Net/Owin/WireMockMiddlewareOptions.cs

@@ -4,6 +4,7 @@ using System.Collections.Generic;
 using System.Collections.ObjectModel;
 using WireMock.Logging;
 using WireMock.Matchers;
+using WireMock.Util;
 #if !NETSTANDARD
 using Owin;
 #else
@@ -22,7 +23,7 @@ namespace WireMock.Owin
 
         public IList<Mapping> Mappings { get; set; } = new List<Mapping>();
 
-        public ObservableCollection<LogEntry> LogEntries { get; } = new ObservableCollection<LogEntry>();
+        public ObservableCollection<LogEntry> LogEntries { get; } = new ConcurentObservableCollection<LogEntry>();
 
         public int? RequestLogExpirationDuration { get; set; }
 

src/WireMock.Net/Util/ConcurentObservableCollection.cs

@@ -0,0 +1,77 @@
+using System.Collections.Generic;
+using System.Collections.ObjectModel;
+
+namespace WireMock.Util
+{
+    /// <summary>
+    /// A special Collection that overrides methods of <see cref="ObservableCollection{T}"/> to make them thread safe
+    /// </summary>
+    /// <typeparam name="T">The type of elements in the collection.</typeparam>
+    /// <inheritdoc cref="ObservableCollection{T}" />
+    public class ConcurentObservableCollection<T> : ObservableCollection<T>
+    {
+        private readonly object _lockObject = new object();
+
+        /// <summary> 
+        /// Initializes a new instance of the <see cref="T:WireMock.Util.ConcurentObservableCollection`1" /> class. 
+        /// </summary> 
+        public ConcurentObservableCollection() { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConcurentObservableCollection{T}"/> class that contains elements copied from the specified list.
+        /// </summary>
+        /// <param name="list">The list from which the elements are copied.</param>
+        public ConcurentObservableCollection(List<T> list) : base(list) { }
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="ConcurentObservableCollection{T}"/> class that contains elements copied from the specified collection.
+        /// </summary>
+        /// <param name="collection">The collection from which the elements are copied.</param>
+        public ConcurentObservableCollection(IEnumerable<T> collection) : base(collection) { }
+
+        /// <inheritdoc cref="ObservableCollection{T}.ClearItems"/>
+        protected override void ClearItems()
+        {
+            lock (_lockObject)
+            {
+                base.ClearItems();
+            }
+        }
+
+        /// <inheritdoc cref="ObservableCollection{T}.RemoveItem"/>
+        protected override void RemoveItem(int index)
+        {
+            lock (_lockObject)
+            {
+                base.RemoveItem(index);
+            }
+        }
+
+        /// <inheritdoc cref="ObservableCollection{T}.InsertItem"/>
+        protected override void InsertItem(int index, T item)
+        {
+            lock (_lockObject)
+            {
+                base.InsertItem(index, item);
+            }
+        }
+
+        /// <inheritdoc cref="ObservableCollection{T}.SetItem"/>
+        protected override void SetItem(int index, T item)
+        {
+            lock (_lockObject)
+            {
+                base.SetItem(index, item);
+            }
+        }
+
+        /// <inheritdoc cref="ObservableCollection{T}.MoveItem"/>
+        protected override void MoveItem(int oldIndex, int newIndex)
+        {
+            lock (_lockObject)
+            {
+                base.MoveItem(oldIndex, newIndex);
+            }
+        }
+    }
+}