Fixed issue with reading the log file when deleted

Author: jschick04

src/EventLogExpert.UI.Tests/Services/DebugLogServiceTests.cs

@@ -258,6 +258,41 @@ public async Task LoadAsync_WhenLogFileDoesNotExist_ShouldReturnNoLines()
         Assert.Empty(lines);
     }
 
+    [Fact]
+    public async Task LoadAsync_WhenLogFileDeletedDuringRead_ShouldAllowDeletion()
+    {
+        // Arrange
+        var fileLocationOptions = new FileLocationOptions(_testDirectory);
+        var mockSettingsService = CreateMockSettingsService(LogLevel.Information);
+
+        var expectedLines = new[] { Constants.DebugLogLine1, Constants.DebugLogLine2, Constants.DebugLogLine3 };
+        await File.WriteAllLinesAsync(_testLogPath, expectedLines, TestContext.Current.CancellationToken);
+
+        using var debugLogService = new DebugLogService(fileLocationOptions, mockSettingsService);
+
+        // Act - Start enumeration and delete the file while the reader holds a handle
+        await using var enumerator = debugLogService.LoadAsync().GetAsyncEnumerator(TestContext.Current.CancellationToken);
+
+        // Read first line to ensure the file is open
+        Assert.True(await enumerator.MoveNextAsync());
+        Assert.Equal(Constants.DebugLogLine1, enumerator.Current);
+
+        // Delete should succeed because FileShare.Delete is set
+        var deleteException = Record.Exception(() => File.Delete(_testLogPath));
+
+        // Assert - Deletion should not throw
+        Assert.Null(deleteException);
+
+        // Continue reading remaining lines (file content is still accessible via open handle)
+        Assert.True(await enumerator.MoveNextAsync());
+        Assert.Equal(Constants.DebugLogLine2, enumerator.Current);
+
+        Assert.True(await enumerator.MoveNextAsync());
+        Assert.Equal(Constants.DebugLogLine3, enumerator.Current);
+
+        Assert.False(await enumerator.MoveNextAsync());
+    }
+
     [Fact]
     public void LoadDebugLog_WhenNoSubscribers_ShouldNotThrow()
     {

src/EventLogExpert.UI/Services/DebugLogService.cs

@@ -64,32 +64,40 @@ public void Dispose()
 
     public async IAsyncEnumerable<string> LoadAsync()
     {
-        // If the log file doesn't exist yet (fresh install, or before first write),
-        // yield no lines instead of throwing FileNotFoundException.
-        if (!File.Exists(_fileLocationOptions.LoggingPath))
-        {
-            yield break;
-        }
-
         // Read directly from the source file. Writers use File.AppendText which opens with
-        // FileShare.Read, allowing concurrent readers. We open with FileShare.ReadWrite to
-        // allow concurrent writers. This avoids the overhead of copying to a temp file and
-        // eliminates lock contention between readers and writers.
+        // FileShare.Read, allowing concurrent readers. We open with FileShare.ReadWrite | Delete
+        // to allow concurrent writers and log rotation/deletion (e.g., InitTracing deletes oversized logs).
+        // This avoids the overhead of copying to a temp file and eliminates lock contention.
         var options = new FileStreamOptions
         {
             Mode = FileMode.Open,
             Access = FileAccess.Read,
-            Share = FileShare.ReadWrite,
+            Share = FileShare.ReadWrite | FileShare.Delete,
             Options = FileOptions.Asynchronous | FileOptions.SequentialScan,
             BufferSize = 4096
         };
 
-        await using var stream = new FileStream(_fileLocationOptions.LoggingPath, options);
-        using var reader = new StreamReader(stream);
+        FileStream stream;
+
+        try
+        {
+            stream = new FileStream(_fileLocationOptions.LoggingPath, options);
+        }
+        catch (Exception ex) when (ex is FileNotFoundException or DirectoryNotFoundException)
+        {
+            // The log file doesn't exist yet (fresh install, before first write),
+            // or was deleted between check and open (e.g., InitTracing deletes oversized logs).
+            yield break;
+        }
 
-        while (await reader.ReadLineAsync() is { } line)
+        await using (stream)
         {
-            yield return line;
+            using var reader = new StreamReader(stream);
+
+            while (await reader.ReadLineAsync() is { } line)
+            {
+                yield return line;
+            }
         }
     }