Address PR comments

src/BenchmarkDotNet/Configs/ConfigExtensions.cs

@@ -111,7 +111,7 @@ public static class ConfigExtensions
         [Obsolete("This method will soon be removed, please start using .AddLogicalGroupRules() instead.")]
         [EditorBrowsable(EditorBrowsableState.Never)] public static IConfig With(this IConfig config, params BenchmarkLogicalGroupRule[] rules) => config.AddLogicalGroupRules(rules);
         [PublicAPI] public static ManualConfig AddLogicalGroupRules(this IConfig config, params BenchmarkLogicalGroupRule[] rules) => config.With(c => c.AddLogicalGroupRules(rules));
-        [PublicAPI] public static ManualConfig AddEventHandler(this IConfig config, params IEventHandler[] eventHandlers) => config.With(c => AddEventHandler(c, eventHandlers));
+        [PublicAPI] public static ManualConfig AddBenchmarkEventHandler(this IConfig config, BenchmarkEventHandlerBase eventHandler) => config.With(c => c.AddBenchmarkEventHandler(eventHandler));
 
         [PublicAPI] public static ManualConfig HideColumns(this IConfig config, params string[] columnNames) => config.With(c => c.HideColumns(columnNames));
         [PublicAPI] public static ManualConfig HideColumns(this IConfig config, params IColumn[] columns) => config.With(c => c.HideColumns(columns));

src/BenchmarkDotNet/Configs/DebugConfig.cs

@@ -62,7 +62,7 @@ public abstract class DebugConfig : IConfig
         public IEnumerable<IDiagnoser> GetDiagnosers() => Array.Empty<IDiagnoser>();
         public IEnumerable<IAnalyser> GetAnalysers() => Array.Empty<IAnalyser>();
         public IEnumerable<HardwareCounter> GetHardwareCounters() => Array.Empty<HardwareCounter>();
-        public IEnumerable<IEventHandler> GetEventHandlers() => Array.Empty<IEventHandler>();
+        public IEnumerable<BenchmarkEventHandlerBase> GetBenchmarkEventHandlers() => Array.Empty<BenchmarkEventHandlerBase>();
         public IEnumerable<IFilter> GetFilters() => Array.Empty<IFilter>();
         public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => Array.Empty<IColumnHidingRule>();
 

src/BenchmarkDotNet/Configs/DefaultConfig.cs

@@ -109,7 +109,7 @@ public string ArtifactsPath
 
         public IEnumerable<IFilter> GetFilters() => Array.Empty<IFilter>();
 
-        public IEnumerable<IEventHandler> GetEventHandlers() => Array.Empty<IEventHandler>();
+        public IEnumerable<BenchmarkEventHandlerBase> GetBenchmarkEventHandlers() => Array.Empty<BenchmarkEventHandlerBase>();
 
         public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => Array.Empty<IColumnHidingRule>();
     }

src/BenchmarkDotNet/Configs/IConfig.cs

@@ -28,7 +28,7 @@ public interface IConfig
         IEnumerable<HardwareCounter> GetHardwareCounters();
         IEnumerable<IFilter> GetFilters();
         IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules();
-        IEnumerable<IEventHandler> GetEventHandlers();
+        IEnumerable<BenchmarkEventHandlerBase> GetBenchmarkEventHandlers();
         IEnumerable<IColumnHidingRule> GetColumnHidingRules();
 
         IOrderer? Orderer { get; }

src/BenchmarkDotNet/Configs/ImmutableConfig.cs

@@ -32,7 +32,7 @@ public sealed class ImmutableConfig : IConfig
         private readonly ImmutableHashSet<HardwareCounter> hardwareCounters;
         private readonly ImmutableHashSet<IFilter> filters;
         private readonly ImmutableArray<BenchmarkLogicalGroupRule> rules;
-        private readonly ImmutableHashSet<IEventHandler> eventHandlers;
+        private readonly ImmutableHashSet<BenchmarkEventHandlerBase> eventHandlers;
         private readonly ImmutableArray<IColumnHidingRule> columnHidingRules;
 
         internal ImmutableConfig(
@@ -47,7 +47,7 @@ internal ImmutableConfig(
             ImmutableArray<BenchmarkLogicalGroupRule> uniqueRules,
             ImmutableArray<IColumnHidingRule> uniqueColumnHidingRules,
             ImmutableHashSet<Job> uniqueRunnableJobs,
-            ImmutableHashSet<IEventHandler> uniqueEventHandlers,
+            ImmutableHashSet<BenchmarkEventHandlerBase> uniqueEventHandlers,
             ConfigUnionRule unionRule,
             string artifactsPath,
             CultureInfo cultureInfo,
@@ -100,15 +100,14 @@ internal ImmutableConfig(
         public IEnumerable<HardwareCounter> GetHardwareCounters() => hardwareCounters;
         public IEnumerable<IFilter> GetFilters() => filters;
         public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => rules;
-        public IEnumerable<IEventHandler> GetEventHandlers() => eventHandlers;
+        public IEnumerable<BenchmarkEventHandlerBase> GetBenchmarkEventHandlers() => eventHandlers;
         public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => columnHidingRules;
 
         public ILogger GetCompositeLogger() => new CompositeLogger(loggers);
         public IExporter GetCompositeExporter() => new CompositeExporter(exporters);
         public IValidator GetCompositeValidator() => new CompositeValidator(validators);
         public IAnalyser GetCompositeAnalyser() => new CompositeAnalyser(analysers);
         public IDiagnoser GetCompositeDiagnoser() => new CompositeDiagnoser(diagnosers);
-        public IEventHandler GetCompositeEventHandler() => new CompositeEventHandler(eventHandlers);
 
         public bool HasMemoryDiagnoser() => diagnosers.OfType<MemoryDiagnoser>().Any();
 

src/BenchmarkDotNet/Configs/ImmutableConfigBuilder.cs

@@ -53,7 +53,7 @@ public static ImmutableConfig Create(IConfig source)
             var uniqueHidingRules = source.GetColumnHidingRules().ToImmutableArray();
 
             var uniqueRunnableJobs = GetRunnableJobs(source.GetJobs()).ToImmutableHashSet();
-            var uniqueEventHandlers = source.GetEventHandlers().ToImmutableHashSet();
+            var uniqueEventHandlers = source.GetBenchmarkEventHandlers().ToImmutableHashSet();
 
             return new ImmutableConfig(
                 uniqueColumnProviders,

src/BenchmarkDotNet/Configs/ManualConfig.cs

@@ -34,7 +34,7 @@ public class ManualConfig : IConfig
         private readonly HashSet<HardwareCounter> hardwareCounters = new HashSet<HardwareCounter>();
         private readonly List<IFilter> filters = new List<IFilter>();
         private readonly List<BenchmarkLogicalGroupRule> logicalGroupRules = new List<BenchmarkLogicalGroupRule>();
-        private readonly List<IEventHandler> eventHandlers = new List<IEventHandler>();
+        private readonly List<BenchmarkEventHandlerBase> eventHandlers = new List<BenchmarkEventHandlerBase>();
         private readonly List<IColumnHidingRule> columnHidingRules = new List<IColumnHidingRule>();
 
         public IEnumerable<IColumnProvider> GetColumnProviders() => columnProviders;
@@ -47,7 +47,7 @@ public class ManualConfig : IConfig
         public IEnumerable<HardwareCounter> GetHardwareCounters() => hardwareCounters;
         public IEnumerable<IFilter> GetFilters() => filters;
         public IEnumerable<BenchmarkLogicalGroupRule> GetLogicalGroupRules() => logicalGroupRules;
-        public IEnumerable<IEventHandler> GetEventHandlers() => eventHandlers;
+        public IEnumerable<BenchmarkEventHandlerBase> GetBenchmarkEventHandlers() => eventHandlers;
         public IEnumerable<IColumnHidingRule> GetColumnHidingRules() => columnHidingRules;
 
         [PublicAPI] public ConfigOptions Options { get; set; }
@@ -224,9 +224,9 @@ public ManualConfig AddLogicalGroupRules(params BenchmarkLogicalGroupRule[] rule
             return this;
         }
 
-        public ManualConfig AddEventHandler(params IEventHandler[] eventHandlers)
+        public ManualConfig AddBenchmarkEventHandler(BenchmarkEventHandlerBase eventHandler)
         {
-            this.eventHandlers.AddRange(eventHandlers);
+            this.eventHandlers.Add(eventHandler);
             return this;
         }
 

src/BenchmarkDotNet/EventHandlers/BenchmarkEventHandlerBase.cs

@@ -0,0 +1,25 @@
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Running;
+using BenchmarkDotNet.Toolchains.Results;
+using BenchmarkDotNet.Validators;
+
+namespace BenchmarkDotNet.EventHandlers
+{
+    public abstract class BenchmarkEventHandlerBase
+    {
+        public virtual void OnStartValidationStage() { }
+        public virtual void OnValidationError(ValidationError validationError) { }
+        public virtual void OnEndValidationStage() { }
+        public virtual void OnStartBuildStage() { }
+        public virtual void OnBuildFailed(BenchmarkCase benchmarkCase, BuildResult buildResult) { }
+        public virtual void OnEndBuildStage() { }
+        public virtual void OnStartRunStage() { }
+        public virtual void OnStartRunBenchmarksInType(Type type, IReadOnlyList<BenchmarkCase> benchmarks) { }
+        public virtual void OnEndRunBenchmarksInType(Type type, Summary summary) { }
+        public virtual void OnStartRunBenchmark(BenchmarkCase benchmarkCase) { }
+        public virtual void OnEndRunBenchmark(BenchmarkCase benchmarkCase, BenchmarkReport report) { }
+        public virtual void OnEndRunStage() { }
+    }
+}

src/BenchmarkDotNet/EventHandlers/CompositeBenchmarkEventHandler.cs

@@ -0,0 +1,91 @@
+using System;
+using System.Collections.Generic;
+using BenchmarkDotNet.Reports;
+using BenchmarkDotNet.Running;
+using BenchmarkDotNet.Toolchains.Results;
+using BenchmarkDotNet.Validators;
+
+namespace BenchmarkDotNet.EventHandlers
+{
+    public class CompositeBenchmarkEventHandler : BenchmarkEventHandlerBase
+    {
+        private readonly IReadOnlyCollection<BenchmarkEventHandlerBase> eventHandlers;
+
+        public CompositeBenchmarkEventHandler(IReadOnlyCollection<BenchmarkEventHandlerBase> eventHandlers)
+        {
+            this.eventHandlers = eventHandlers;
+        }
+
+        public override void OnStartValidationStage()
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnStartValidationStage();
+        }
+
+        public override void OnValidationError(ValidationError validationError)
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnValidationError(validationError);
+        }
+
+        public override void OnEndValidationStage()
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnEndValidationStage();
+        }
+
+        public override void OnStartBuildStage()
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnStartBuildStage();
+        }
+
+        public override void OnBuildFailed(BenchmarkCase benchmarkCase, BuildResult buildResult)
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnBuildFailed(benchmarkCase, buildResult);
+        }
+
+        public override void OnEndBuildStage()
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnEndBuildStage();
+        }
+
+        public override void OnStartRunStage()
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnStartRunStage();
+        }
+
+        public override void OnEndRunStage()
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnEndRunStage();
+        }
+
+        public override void OnStartRunBenchmarksInType(Type type, IReadOnlyList<BenchmarkCase> benchmarks)
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnStartRunBenchmarksInType(type, benchmarks);
+        }
+
+        public override void OnEndRunBenchmarksInType(Type type, Summary summary)
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnEndRunBenchmarksInType(type, summary);
+        }
+
+        public override void OnEndRunBenchmark(BenchmarkCase benchmarkCase, BenchmarkReport report)
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnEndRunBenchmark(benchmarkCase, report);
+        }
+
+        public override void OnStartRunBenchmark(BenchmarkCase benchmarkCase)
+        {
+            foreach (var eventHandler in eventHandlers)
+                eventHandler.OnStartRunBenchmark(benchmarkCase);
+        }
+    }
+}