Implement parallel processing in ReadIssues with thread-safe collections and performance logging

Co-authored-by: pascalberger <2190718+pascalberger@users.noreply.github.com>

Author: Copilot

src/Cake.Issues.Testing/FakeFailingIssueProvider.cs

@@ -0,0 +1,20 @@
+namespace Cake.Issues.Testing;
+
+using System.Collections.Generic;
+using Cake.Core.Diagnostics;
+
+/// <summary>
+/// Implementation of a <see cref="BaseIssueProvider"/> that fails during initialization for use in test cases.
+/// </summary>
+/// <param name="log">The Cake log instance.</param>
+public class FakeFailingIssueProvider(ICakeLog log) : BaseIssueProvider(log)
+{
+    /// <inheritdoc/>
+    public override string ProviderName => "Fake Failing Issue Provider";
+
+    /// <inheritdoc/>
+    public override bool Initialize(IReadIssuesSettings settings) => false;
+
+    /// <inheritdoc/>
+    protected override IEnumerable<IIssue> InternalReadIssues() => [];
+}

src/Cake.Issues.Tests/IssueReaderTests.cs

@@ -94,7 +94,7 @@ public void Should_Initialize_Issue_Provider()
             _ = fixture.ReadIssues();
 
             // Then
-            fixture.IssueProviders.ShouldAllBe(x => x.Settings == fixture.Settings);
+            fixture.IssueProviders.OfType<FakeIssueProvider>().ShouldAllBe(x => x.Settings == fixture.Settings);
         }
 
         [Fact]
@@ -142,7 +142,7 @@ public void Should_Initialize_All_Issue_Provider()
             _ = fixture.ReadIssues();
 
             // Then
-            fixture.IssueProviders.ShouldAllBe(x => x.Settings == fixture.Settings);
+            fixture.IssueProviders.OfType<FakeIssueProvider>().ShouldAllBe(x => x.Settings == fixture.Settings);
         }
 
         [Fact]
@@ -349,5 +349,91 @@ public void Should_Set_FileLink_Property()
             issue2.FileLink.ToString()
                 .ShouldBe($"{repoUrl}/blob/{branch}/{filePath2.Replace(@"\", "/")}#L{line2}");
         }
+
+        [Fact]
+        public void Should_Read_Issues_From_Multiple_Providers_Concurrently()
+        {
+            // Given
+            const int providerCount = 10;
+            const int issuesPerProvider = 100;
+            var fixture = new IssuesFixture();
+            fixture.IssueProviders.Clear();
+
+            // Create multiple providers with different issues
+            for (var i = 0; i < providerCount; i++)
+            {
+                var providerIssues = new List<IIssue>();
+                for (var j = 0; j < issuesPerProvider; j++)
+                {
+                    var issue = IssueBuilder
+                        .NewIssue($"Issue{i}-{j}", $"ProviderType{i}", $"ProviderName{i}")
+                        .InFile($@"src\Provider{i}\File{j}.cs", j + 1)
+                        .OfRule($"Rule{j}")
+                        .WithPriority(IssuePriority.Warning)
+                        .Create();
+                    providerIssues.Add(issue);
+                }
+                fixture.IssueProviders.Add(new FakeIssueProvider(fixture.Log, providerIssues));
+            }
+
+            // When
+            var stopwatch = System.Diagnostics.Stopwatch.StartNew();
+            var issues = fixture.ReadIssues().ToList();
+            stopwatch.Stop();
+
+            // Then
+            issues.Count.ShouldBe(providerCount * issuesPerProvider);
+
+            // Verify all providers contributed issues
+            for (var i = 0; i < providerCount; i++)
+            {
+                var providerIssues = issues.Where(x => x.ProviderType == $"ProviderType{i}").ToList();
+                providerIssues.Count.ShouldBe(issuesPerProvider);
+            }
+
+            // Verify all Run properties are set
+            issues.ShouldAllBe(x => x.Run == fixture.Settings.Run);
+
+            // Log timing for performance verification
+            System.Console.WriteLine($"Reading {issues.Count} issues from {providerCount} providers took {stopwatch.ElapsedMilliseconds}ms");
+        }
+
+        [Fact]
+        public void Should_Handle_Provider_Initialization_Failures_Concurrently()
+        {
+            // Given
+            var fixture = new IssuesFixture();
+            fixture.IssueProviders.Clear();
+
+            // Add mix of successful and failing providers
+            fixture.IssueProviders.Add(new FakeIssueProvider(fixture.Log, [
+                IssueBuilder.NewIssue("Success1", "ProviderType1", "ProviderName1")
+                    .InFile(@"src\File1.cs", 1)
+                    .OfRule("Rule1")
+                    .WithPriority(IssuePriority.Warning)
+                    .Create()
+            ]));
+
+            // Create a failing provider by passing null settings later
+            var failingProvider = new FakeFailingIssueProvider(fixture.Log);
+            fixture.IssueProviders.Add(failingProvider);
+            
+            fixture.IssueProviders.Add(new FakeIssueProvider(fixture.Log, [
+                IssueBuilder.NewIssue("Success2", "ProviderType2", "ProviderName2")
+                    .InFile(@"src\File2.cs", 2)
+                    .OfRule("Rule2")
+                    .WithPriority(IssuePriority.Warning)
+                    .Create()
+            ]));
+
+            // When
+            var issues = fixture.ReadIssues().ToList();
+
+            // Then
+            // Should get issues from successful providers only
+            issues.Count.ShouldBe(2);
+            issues.ShouldContain(x => x.MessageText == "Success1");
+            issues.ShouldContain(x => x.MessageText == "Success2");
+        }
     }
 }

src/Cake.Issues.Tests/IssuesFixture.cs

@@ -7,15 +7,15 @@ public class IssuesFixture
     public IssuesFixture()
     {
         this.Log = new FakeLog { Verbosity = Verbosity.Normal };
-        this.IssueProviders = [new(this.Log)];
+        this.IssueProviders = [new FakeIssueProvider(this.Log)];
         this.Settings =
             new ReadIssuesSettings(
                 new Core.IO.DirectoryPath(@"c:\Source\Cake.Issues"));
     }
 
     public FakeLog Log { get; init; }
 
-    public IList<FakeIssueProvider> IssueProviders { get; init; }
+    public IList<IIssueProvider> IssueProviders { get; init; }
 
     public ReadIssuesSettings Settings { get; init; }
 

src/Cake.Issues/IssuesReader.cs

@@ -1,7 +1,10 @@
 namespace Cake.Issues;
 
+using System.Collections.Concurrent;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
+using System.Threading.Tasks;
 using Cake.Core.Diagnostics;
 
 /// <summary>
@@ -41,12 +44,17 @@ public IssuesReader(
     /// <returns>List of issues.</returns>
     public IEnumerable<IIssue> ReadIssues()
     {
-        // Initialize issue providers and read issues.
-        var issues = new List<IIssue>();
-        foreach (var issueProvider in this.issueProviders)
+        var stopwatch = Stopwatch.StartNew();
+
+        // Use thread-safe collection for collecting results
+        var allIssues = new ConcurrentBag<IIssue>();
+
+        // Process providers in parallel
+        _ = Parallel.ForEach(this.issueProviders, issueProvider =>
         {
             var providerName = issueProvider.GetType().Name;
             this.log.Verbose("Initialize issue provider {0}...", providerName);
+
             if (issueProvider.Initialize(this.settings))
             {
                 this.log.Verbose("Reading issues from {0}...", providerName);
@@ -57,6 +65,7 @@ public IEnumerable<IIssue> ReadIssues()
                     currentIssues.Count,
                     providerName);
 
+                // Post-process issues - this is thread-safe as each provider gets its own issues
                 currentIssues.ForEach(x =>
                 {
                     x.Run = this.settings.Run;
@@ -67,14 +76,27 @@ public IEnumerable<IIssue> ReadIssues()
                     }
                 });
 
-                issues.AddRange(currentIssues);
+                // Add to thread-safe collection
+                foreach (var issue in currentIssues)
+                {
+                    allIssues.Add(issue);
+                }
             }
             else
             {
                 this.log.Warning("Error initializing issue provider {0}.", providerName);
             }
-        }
+        });
+
+        stopwatch.Stop();
+
+        var issuesList = allIssues.ToList();
+        this.log.Verbose(
+            "Reading {0} issues from {1} providers took {2} ms",
+            issuesList.Count,
+            this.issueProviders.Count,
+            stopwatch.ElapsedMilliseconds);
 
-        return issues;
+        return issuesList;
     }
 }