Allow event monitoring to ignore failing event accessors

Src/FluentAssertions/AssertionExtensions.cs

@@ -917,7 +917,31 @@ public static TaskCompletionSourceAssertions<T> Should<T>(this TaskCompletionSou
     /// <exception cref="ArgumentNullException"><paramref name="eventSource"/> is <see langword="null"/>.</exception>
     public static IMonitor<T> Monitor<T>(this T eventSource, Func<DateTime> utcNow = null)
     {
-        return new EventMonitor<T>(eventSource, utcNow ?? (() => DateTime.UtcNow));
+        var options = new EventMonitorOptions();
+
+        if (utcNow is not null)
+        {
+            options.ConfigureTimestampProvider(utcNow);
+        }
+
+        return new EventMonitor<T>(eventSource, options);
+    }
+
+    /// <summary>
+    /// Starts monitoring <paramref name="eventSource"/> for its events.
+    /// </summary>
+    /// <param name="eventSource">The object for which to monitor the events.</param>
+    /// <param name="configureOptions">
+    /// An optional delegate that can be used to configure the <see cref="EventMonitorOptions"/> used to monitor the events.
+    /// </param>
+    /// <exception cref="ArgumentNullException"><paramref name="eventSource"/> is <see langword="null"/>.</exception>
+    public static IMonitor<T> Monitor<T>(this T eventSource, Action<EventMonitorOptions> configureOptions)
+    {
+        var options = new EventMonitorOptions();
+
+        configureOptions(options);
+
+        return new EventMonitor<T>(eventSource, options);
     }
 
 #endif

Src/FluentAssertions/Events/EventMonitor.cs

@@ -18,18 +18,22 @@ internal sealed class EventMonitor<T> : IMonitor<T>
 
     private readonly ConcurrentDictionary<string, EventRecorder> recorderMap = new();
 
-    public EventMonitor(object eventSource, Func<DateTime> utcNow)
+    public EventMonitor(object eventSource, EventMonitorOptions options)
     {
         Guard.ThrowIfArgumentIsNull(eventSource, nameof(eventSource), "Cannot monitor the events of a <null> object.");
+        Guard.ThrowIfArgumentIsNull(options, nameof(options), "Event monitor needs configuration.");
+
+        this.options = options;
 
         subject = new WeakReference(eventSource);
 
-        Attach(typeof(T), utcNow);
+        Attach(typeof(T), this.options.TimestampProvider);
     }
 
     public T Subject => (T)subject.Target;
 
     private readonly ThreadSafeSequenceGenerator threadSafeSequenceGenerator = new();
+    private readonly EventMonitorOptions options;
 
     public EventMetadata[] MonitoredEvents
     {
@@ -117,12 +121,24 @@ public void Dispose()
     {
         foreach (EventRecorder recorder in recorderMap.Values)
         {
-            recorder.Dispose();
+            DisposeSafeIfRequested(recorder);
         }
 
         recorderMap.Clear();
     }
 
+    private void DisposeSafeIfRequested(EventRecorder recorder)
+    {
+        try
+        {
+            recorder.Dispose();
+        }
+        catch when (options.ShouldIgnoreEventAccessorExceptions)
+        {
+            // ignore
+        }
+    }
+
     private void AttachEventHandler(EventInfo eventInfo, Func<DateTime> utcNow)
     {
         if (!recorderMap.TryGetValue(eventInfo.Name, out _))
@@ -131,7 +147,22 @@ private void AttachEventHandler(EventInfo eventInfo, Func<DateTime> utcNow)
 
             if (recorderMap.TryAdd(eventInfo.Name, recorder))
             {
-                recorder.Attach(subject, eventInfo);
+                AttachEventHandler(eventInfo, recorder);
+            }
+        }
+    }
+
+    private void AttachEventHandler(EventInfo eventInfo, EventRecorder recorder)
+    {
+        try
+        {
+            recorder.Attach(subject, eventInfo);
+        }
+        catch when (options.ShouldIgnoreEventAccessorExceptions)
+        {
+            if (!options.RecordEventsWithBrokenAccessor)
+            {
+                recorderMap.TryRemove(eventInfo.Name, out _);
             }
         }
     }

Src/FluentAssertions/Events/EventMonitorOptions.cs

@@ -0,0 +1,51 @@
+using System;
+
+namespace FluentAssertions.Events;
+
+/// <summary>
+/// Settings for the <see cref="EventMonitor{T}"/>.
+/// </summary>
+public class EventMonitorOptions
+{
+    /// <summary>
+    /// Will ignore the events, if they throw an exception on any custom event accessor implementation. default: false.
+    /// </summary>
+    internal bool ShouldIgnoreEventAccessorExceptions { get; private set; }
+
+    /// <summary>
+    /// This will record the event, even if the event accessor add event accessor threw an exception. To ignore exceptions in the event add accessor, call <see cref="IgnoreEventAccessorExceptions"/> property to true. default: false.
+    /// </summary>
+    internal bool RecordEventsWithBrokenAccessor { get; private set; }
+
+    /// <summary>
+    /// Func used to generate the timestamp.
+    /// </summary>
+    internal Func<DateTime> TimestampProvider { get; private set; } = () => DateTime.UtcNow;
+
+    /// <summary>
+    /// When called it will ignore event accessor Exceptions.
+    /// </summary>
+    /// <param name="recordEventsWithBrokenAccessor">This will record the event, even if the event add event accessor threw an exception. default: false.</param>
+    /// <returns>The options instance for method stacking.</returns>
+    public EventMonitorOptions IgnoreEventAccessorExceptions(bool recordEventsWithBrokenAccessor = false)
+    {
+        ShouldIgnoreEventAccessorExceptions = true;
+        RecordEventsWithBrokenAccessor = recordEventsWithBrokenAccessor;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the timestamp provider. By default it is <see cref="DateTime.UtcNow"/>.
+    /// </summary>
+    /// <param name="timestampProvider">The timestamp provider.</param>
+    /// <returns>The options instance for method stacking.</returns>
+    internal EventMonitorOptions ConfigureTimestampProvider(Func<DateTime> timestampProvider)
+    {
+        if (timestampProvider != null)
+        {
+            TimestampProvider = timestampProvider;
+        }
+
+        return this;
+    }
+}

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt

@@ -37,6 +37,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1270,6 +1271,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt

@@ -37,6 +37,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1283,6 +1284,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt

@@ -37,6 +37,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1270,6 +1271,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt

@@ -37,6 +37,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1270,6 +1271,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt

@@ -37,6 +37,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1270,6 +1271,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }