Remove LockFile in favor of using a system Mutex for locking. Hopefully improve flakey test.

Author: ejsmith

src/Exceptionless/Logging/FileExceptionlessLog.cs

@@ -3,11 +3,12 @@
 using System.IO;
 using System.Text;
 using System.Threading;
-using Exceptionless.Storage;
 using Exceptionless.Utility;
 
 namespace Exceptionless.Logging {
     public class FileExceptionlessLog : IExceptionlessLog, IDisposable {
+        private static Mutex _flushLock = new Mutex(false, nameof(FileExceptionlessLog));
+
         private Timer _flushTimer;
         private readonly bool _append;
         private bool _firstWrite = true;
@@ -126,34 +127,40 @@ public void Flush() {
             if (_isFlushing || _buffer.IsEmpty)
                 return;
 
+            bool hasFlushLock = false;
             try {
                 _isFlushing = true;
 
                 Run.WithRetries(() => {
-                    using (var logFileLock = LockFile.Acquire(FilePath + ".lock", TimeSpan.FromMilliseconds(500))) {
-                        bool append = _append || !_firstWrite;
-                        _firstWrite = false;
-
-                        try {
-                            using (var writer = GetWriter(append)) {
-                                LogEntry entry;
-                                while (_buffer.TryDequeue(out entry)) {
-                                    if (entry != null && entry.LogLevel >= MinimumLogLevel)
-                                        writer.Value.WriteLine($"{FormatLongDate(entry.Timestamp)} {entry.LogLevel.ToString().PadRight(5)} {entry.Message}");
-                                }
-                            }
-                        } catch (Exception ex) {
-                            System.Diagnostics.Trace.TraceError("Unable flush the logs. " + ex.Message);
+                    if (!_flushLock.WaitOne(TimeSpan.FromSeconds(5)))
+                        return;
+
+                    hasFlushLock = true;
+
+                    bool append = _append || !_firstWrite;
+                    _firstWrite = false;
+
+                    try {
+                        using (var writer = GetWriter(append)) {
                             LogEntry entry;
                             while (_buffer.TryDequeue(out entry)) {
-                                System.Diagnostics.Trace.WriteLine(entry);
+                                if (entry != null && entry.LogLevel >= MinimumLogLevel)
+                                    writer.Value.WriteLine($"{FormatLongDate(entry.Timestamp)} {entry.LogLevel.ToString().PadRight(5)} {entry.Message}");
                             }
                         }
+                    } catch (Exception ex) {
+                        System.Diagnostics.Trace.TraceError("Unable flush the logs. " + ex.Message);
+                        LogEntry entry;
+                        while (_buffer.TryDequeue(out entry)) {
+                            System.Diagnostics.Trace.WriteLine(entry);
+                        }
                     }
                 });
             } catch (Exception ex) {
                 System.Diagnostics.Trace.WriteLine("Exceptionless: Error flushing log contents to disk: {0}", ex.Message);
             } finally {
+                if (hasFlushLock)
+                    _flushLock.ReleaseMutex();
                 _isFlushing = false;
             }
         }
@@ -212,11 +219,12 @@ internal void CheckFileSize() {
             string lastLines = String.Empty;
             try {
                 Run.WithRetries(() => {
-                    using (var logFileLock = LockFile.Acquire(FilePath + ".lock", TimeSpan.FromMilliseconds(500))) {
-                        try {
-                            lastLines = GetLastLinesFromFile(FilePath);
-                        } catch {}
-                    }
+                    if (!_flushLock.WaitOne(TimeSpan.FromSeconds(5)))
+                        return;
+
+                    lastLines = GetLastLinesFromFile(FilePath);
+
+                    _flushLock.ReleaseMutex();
                 });
             } catch (Exception ex) {
                 System.Diagnostics.Trace.WriteLine("Exceptionless: Error getting last X lines from the log file: {0}", ex.Message);
@@ -230,10 +238,13 @@ internal void CheckFileSize() {
             // overwrite the log file and initialize it with the last X lines it had
             try {
                 Run.WithRetries(() => {
-                    using (var logFileLock = LockFile.Acquire(FilePath + ".lock", TimeSpan.FromMilliseconds(500))) {
-                        using (var writer = GetWriter(true))
-                            writer.Value.Write(lastLines);
-                    }
+                    if (!_flushLock.WaitOne(TimeSpan.FromSeconds(5)))
+                        return;
+
+                    using (var writer = GetWriter(true))
+                        writer.Value.Write(lastLines);
+
+                    _flushLock.ReleaseMutex();
                 });
             } catch (Exception ex) {
                 System.Diagnostics.Trace.WriteLine("Exceptionless: Error rewriting the log file after trimming it: {0}", ex.Message);

src/Exceptionless/Storage/LockFile.cs

@@ -17,6 +17,8 @@
 using Xunit;
 using Xunit.Abstractions;
 using LogLevel = Exceptionless.Logging.LogLevel;
+using Exceptionless.Json;
+using Exceptionless.Extensions;
 
 namespace Exceptionless.Tests.Plugins {
     public class PluginTests {
@@ -834,23 +836,35 @@ public void VerifyDeduplicationMultithreaded() {
             var client = CreateClient();
             // TODO: We need to look into why the ErrorPlugin causes data to sometimes calculate invalid hashcodes
             var errorPlugin = new SimpleErrorPlugin();
+            var simpleError = GetException().ToSimpleErrorModel(client);
 
             var contexts = new ConcurrentBag<EventPluginContext>();
-            using (var duplicateCheckerPlugin = new DuplicateCheckerPlugin(TimeSpan.FromSeconds(1))) {
+            using (var duplicateCheckerPlugin = new DuplicateCheckerPlugin(TimeSpan.FromSeconds(60))) {
+                int hashCode = 0;
                 var result = Parallel.For(0, 10, index => {
-                    var builder = GetException().ToExceptionless();
+                    var builder = client.CreateEvent();
+                    builder.SetType(Event.KnownTypes.Error);
+                    builder.Target.Data[Event.KnownDataKeys.SimpleError] = simpleError;
+
                     var context = new EventPluginContext(client, builder.Target, builder.PluginContextData);
                     contexts.Add(context);
 
-                    errorPlugin.Run(context);
                     duplicateCheckerPlugin.Run(context);
+
+                    if (hashCode == 0)
+                        hashCode = builder.Target.GetHashCode();
+                    else if (hashCode != builder.Target.GetHashCode())
+                        throw new ApplicationException();
                 });
 
                 while (!result.IsCompleted) {
                     Thread.Yield();
                 }
             }
 
+            var nonCancelled = contexts.Where(c => !c.Cancel).Select(c => (Context: c, Event: c.Event.GetHashCode(), Json: JsonConvert.SerializeObject(c.Event))).ToList();
+            var all = contexts.Select(c => (Context: c, Event: c.Event.GetHashCode())).ToList();
+
             Assert.Equal(1, contexts.Count(c => !c.Cancel));
             Assert.Equal(9, contexts.Count(c => c.Cancel));
             Assert.Equal(9, contexts.Sum(c => c.Event.Count.GetValueOrDefault()));