Fixed #125 Ensure settings are thread safe

Author: niemyjski

samples/Exceptionless.SampleConsole/Program.cs

@@ -1,7 +1,6 @@
 using System;
 using System.Diagnostics;
 using System.IO;
-using System.Reflection;
 using System.Threading;
 using System.Threading.Tasks;
 using Exceptionless.Configuration;

src/Exceptionless/Models/Collections/ObservableDictionary.cs

@@ -1,51 +1,90 @@
 using System;
 using System.Collections;
+#if !PORTABLE
+using System.Collections.Concurrent;
+#endif
 using System.Collections.Generic;
 
 namespace Exceptionless.Models.Collections {
     public class ObservableDictionary<TKey, TValue> : IDictionary<TKey, TValue> {
+#if !PORTABLE
+        private readonly ConcurrentDictionary<TKey, TValue> _dictionary;
+#else
         private readonly IDictionary<TKey, TValue> _dictionary;
+#endif
 
         public ObservableDictionary() {
+#if !PORTABLE
+            _dictionary = new ConcurrentDictionary<TKey, TValue>();
+#else
             _dictionary = new Dictionary<TKey, TValue>();
+#endif
         }
 
         public ObservableDictionary(IDictionary<TKey, TValue> dictionary) {
+#if !PORTABLE
+            _dictionary = new ConcurrentDictionary<TKey, TValue>(dictionary);
+#else
             _dictionary = new Dictionary<TKey, TValue>(dictionary);
+#endif
         }
 
         public ObservableDictionary(IEqualityComparer<TKey> comparer) {
+#if !PORTABLE
+            _dictionary = new ConcurrentDictionary<TKey, TValue>(comparer);
+#else
             _dictionary = new Dictionary<TKey, TValue>(comparer);
+#endif
         }
 
         public ObservableDictionary(IDictionary<TKey, TValue> dictionary, IEqualityComparer<TKey> comparer) {
+#if !PORTABLE
+            _dictionary = new ConcurrentDictionary<TKey, TValue>(dictionary, comparer);
+#else
             _dictionary = new Dictionary<TKey, TValue>(dictionary, comparer);
+#endif
         }
 
         public void Add(TKey key, TValue value) {
+#if !PORTABLE
+            if (_dictionary.TryAdd(key, value))
+                OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(new KeyValuePair<TKey, TValue>(key, value), ChangedAction.Add));
+#else
             _dictionary.Add(key, value);
-
             OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(new KeyValuePair<TKey, TValue>(key, value), ChangedAction.Add));
+#endif
         }
 
         public void Add(KeyValuePair<TKey, TValue> item) {
+#if !PORTABLE
+            if (_dictionary.TryAdd(item.Key, item.Value))
+                OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(item, ChangedAction.Add));
+#else
             _dictionary.Add(item);
-
             OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(item, ChangedAction.Add));
+#endif
         }
 
         public bool Remove(TKey key) {
+            TValue value = default(TValue);
+#if !PORTABLE
+            bool success = _dictionary.TryRemove(key, out value);
+#else
             bool success = _dictionary.Remove(key);
-
+#endif
             if (success)
-                OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(new KeyValuePair<TKey, TValue>(key, default(TValue)), ChangedAction.Remove));
+                OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(new KeyValuePair<TKey, TValue>(key, value), ChangedAction.Remove));
 
             return success;
         }
 
         public bool Remove(KeyValuePair<TKey, TValue> item) {
+#if !PORTABLE
+            TValue value;
+            bool success = _dictionary.TryRemove(item.Key, out value);
+#else
             bool success = _dictionary.Remove(item);
-
+#endif
             if (success)
                 OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(item, ChangedAction.Remove));
 
@@ -54,7 +93,6 @@ public bool Remove(KeyValuePair<TKey, TValue> item) {
 
         public void Clear() {
             _dictionary.Clear();
-
             OnChanged(new ChangedEventArgs<KeyValuePair<TKey, TValue>>(new KeyValuePair<TKey, TValue>(), ChangedAction.Clear));
         }
 
@@ -63,15 +101,19 @@ public bool ContainsKey(TKey key) {
         }
 
         public bool Contains(KeyValuePair<TKey, TValue> item) {
+#if !PORTABLE
+            return _dictionary.ContainsKey(item.Key);
+#else
             return _dictionary.Contains(item);
+#endif
         }
 
         public bool TryGetValue(TKey key, out TValue value) {
             return _dictionary.TryGetValue(key, out value);
         }
 
         public void CopyTo(KeyValuePair<TKey, TValue>[] array, int arrayIndex) {
-            _dictionary.CopyTo(array, arrayIndex);
+            ((IDictionary)_dictionary).CopyTo(array, arrayIndex);
         }
 
         public ICollection<TKey> Keys {
@@ -87,7 +129,7 @@ public int Count {
         }
 
         public bool IsReadOnly {
-            get { return _dictionary.IsReadOnly; }
+            get { return ((IDictionary)_dictionary).IsReadOnly; }
         }
 
         public TValue this[TKey key] {
@@ -132,4 +174,4 @@ public enum ChangedAction {
         Clear,
         Update
     }
-}
+}

src/Exceptionless/Models/Collections/SettingsDictionary.cs

@@ -1,4 +1,7 @@
 using System;
+#if !PORTABLE
+using System.Collections.Concurrent;
+#endif
 using System.Collections.Generic;
 using System.Linq;
 using Exceptionless.Extensions;
@@ -161,12 +164,22 @@ protected override void OnChanged(ChangedEventArgs<KeyValuePair<string, string>>
                         logLevelKeysToRemove.Add(key);
                 }
 
-                foreach (var logger in logLevelKeysToRemove)
+                foreach (var logger in logLevelKeysToRemove) {
+#if !PORTABLE
+                    LogLevel value;
+                    _minLogLevels.TryRemove(logger, out value);
+#else
                     _minLogLevels.Remove(logger);
-            }
+#endif
+                }
+}
 
             foreach (var eventType in _eventTypes) {
+#if !PORTABLE
+                ConcurrentDictionary<string, bool> sourceDictionary;
+#else
                 Dictionary<string, bool> sourceDictionary;
+#endif
                 if (eventType.Key == null || !_typeSourceEnabled.TryGetValue(eventType.Key, out sourceDictionary))
                     continue;
 
@@ -179,14 +192,24 @@ protected override void OnChanged(ChangedEventArgs<KeyValuePair<string, string>>
                         sourceKeysToRemove.Add(key);
                 }
 
-                foreach (var logger in sourceKeysToRemove)
+                foreach (var logger in sourceKeysToRemove) {
+#if !PORTABLE
+                    bool value;
+                    sourceDictionary.TryRemove(logger, out value);
+#else
                     sourceDictionary.Remove(logger);
+#endif
+                }
             }
 
             base.OnChanged(args);
         }
 
+#if !PORTABLE
+        private readonly ConcurrentDictionary<string, LogLevel> _minLogLevels = new ConcurrentDictionary<string, LogLevel>(StringComparer.OrdinalIgnoreCase);
+#else
         private readonly Dictionary<string, LogLevel> _minLogLevels = new Dictionary<string, LogLevel>(StringComparer.OrdinalIgnoreCase);
+#endif
         public LogLevel GetMinLogLevel(string loggerName) {
             if (String.IsNullOrEmpty(loggerName))
                 loggerName = "*";
@@ -197,44 +220,77 @@ public LogLevel GetMinLogLevel(string loggerName) {
 
             var setting = GetTypeAndSourceSetting("log", loggerName, "Trace");
             if (setting == null) {
+#if !PORTABLE
+                _minLogLevels.AddOrUpdate(loggerName, LogLevel.Trace, (logName, level) => LogLevel.Trace);
+#else
                 _minLogLevels[loggerName] = LogLevel.Trace;
+#endif
                 return LogLevel.Trace;
             }
 
             minLogLevel = LogLevel.FromString(setting);
+#if !PORTABLE
+            _minLogLevels.AddOrUpdate(loggerName, minLogLevel, (logName, level) => minLogLevel);
+#else
             _minLogLevels[loggerName] = minLogLevel;
+#endif
             return minLogLevel;
         }
 
+#if !PORTABLE
+        private readonly ConcurrentDictionary<string, ConcurrentDictionary<string, bool>> _typeSourceEnabled = new ConcurrentDictionary<string, ConcurrentDictionary<string, bool>>(StringComparer.OrdinalIgnoreCase);
+#else
         private readonly Dictionary<string, Dictionary<string, bool>> _typeSourceEnabled = new Dictionary<string, Dictionary<string, bool>>(StringComparer.OrdinalIgnoreCase);
+#endif
         public bool GetTypeAndSourceEnabled(string type, string source) {
             if (type == null)
                 return true;
 
+#if !PORTABLE
+            ConcurrentDictionary<string, bool> sourceDictionary;
+#else
             Dictionary<string, bool> sourceDictionary;
-            bool sourceEnabled;
+#endif
             if (source != null && _typeSourceEnabled.TryGetValue(type, out sourceDictionary)) {
+                bool sourceEnabled;
                 if (sourceDictionary.TryGetValue(source, out sourceEnabled))
                     return sourceEnabled;
             }
 
             return GetTypeAndSourceSetting(type, source, "true").ToBoolean(true);
         }
 
+#if !PORTABLE
+        private readonly ConcurrentDictionary<string, string> _eventTypes = new ConcurrentDictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+#else
         private readonly Dictionary<string, string> _eventTypes = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
+#endif
         private string GetTypeAndSourceSetting(string type, string source, string defaultValue) {
             if (type == null)
                 return defaultValue;
 
+#if !PORTABLE
+            ConcurrentDictionary<string, bool> sourceDictionary;
+#else
             Dictionary<string, bool> sourceDictionary;
+#endif
             string sourcePrefix;
             if (!_typeSourceEnabled.TryGetValue(type, out sourceDictionary)) {
+#if !PORTABLE
+                sourceDictionary = new ConcurrentDictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
+                _typeSourceEnabled.TryAdd(type, sourceDictionary);
+#else
                 sourceDictionary = new Dictionary<string, bool>(StringComparer.OrdinalIgnoreCase);
                 _typeSourceEnabled.Add(type, sourceDictionary);
-
+#endif
                 sourcePrefix = "@@" + type + ":";
-                if (!_eventTypes.ContainsKey(type))
+                if (!_eventTypes.ContainsKey(type)) {
+#if !PORTABLE
+                    _eventTypes.TryAdd(type, sourcePrefix);
+#else
                     _eventTypes.Add(type, sourcePrefix);
+#endif
+                }
             } else {
                 sourcePrefix = _eventTypes[type];
             }

tests/Exceptionless.Tests/Configuration/ConfigurationTests.cs

@@ -2,6 +2,8 @@
 using System.Collections.Generic;
 using System.IO;
 using System.Reflection;
+using System.Threading;
+using System.Threading.Tasks;
 using Exceptionless.Configuration;
 using Exceptionless.Dependency;
 using Exceptionless.Models;
@@ -10,11 +12,17 @@
 using Exceptionless.Tests.Utility;
 using Moq;
 using Xunit;
+using Xunit.Abstractions;
 
 [assembly: Exceptionless("LhhP1C9gijpSKCslHHCvwdSIz298twx271n1l6xw", ServerUrl = "http://localhost:45000")]
 [assembly: ExceptionlessSetting("testing", "configuration")]
 namespace Exceptionless.Tests.Configuration {
     public class ConfigurationTests {
+        private readonly TestOutputWriter _writer;
+        public ConfigurationTests(ITestOutputHelper output) {
+            _writer = new TestOutputWriter(output);
+        }
+
         [Fact]
         public void CanConfigureApiKeyFromClientConstructor() {
             var client = new ExceptionlessClient("LhhP1C9gijpSKCslHHCvwdSIz298twx271n1l6xw");
@@ -98,5 +106,40 @@ public void CanUpdateSettingsFromServer() {
             Assert.Equal("2", client.Configuration.Settings["LocalSettingToOverride"]);
             Assert.Equal(2, client.Configuration.Settings.Count);
         }
+
+        [Fact]
+        public void CanGetSettingsMultithreaded() {
+            var settings = new SettingsDictionary();
+            var result = Parallel.For(0, 20, index => {
+                for (int i = 0; i < 10; i++) {
+                    string key = $"setting-{i}";
+                    if (!settings.ContainsKey(key))
+                        settings.Add(key, (index * i).ToString());
+                    else
+                        settings[key] = (index * i).ToString();
+                }
+            });
+
+            while (!result.IsCompleted)
+                Thread.Sleep(1);
+        }
+
+        [Fact]
+        public void CanGetLogSettingsMultithreaded() {
+            var settings = new SettingsDictionary();
+            settings.Add("@@log:*", "Info");
+            settings.Add("@@log:Source1", "Trace");
+            settings.Add("@@log:Source2", "Debug");
+            settings.Add("@@log:Source3", "Info");
+            settings.Add("@@log:Source4", "Info");
+
+            var result = Parallel.For(0, 100, index => {
+                var level = settings.GetMinLogLevel("Source1");
+                _writer.WriteLine("Source1 log level: {0}", level);
+            });
+
+            while (!result.IsCompleted)
+                Thread.Sleep(1);
+        }
     }
 }