Allow custom filtering logic for FakeLogger (#5848)

* Adds new nullable predicate property CustomFilter to FakeLogCollectorOptions.

* FakeLogCollector uses the new CustomFilter property when not null to filter out records if they have satisfied the previous filtering options but not the defined predicate.

Author: Demo30

src/Libraries/Microsoft.Extensions.Diagnostics.Testing/Logging/FakeLogCollector.cs

@@ -129,6 +129,13 @@ internal void AddRecord(FakeLogRecord record)
             return;
         }
 
+        var customFilter = _options.CustomFilter;
+        if (customFilter is not null && !customFilter(record))
+        {
+            // record was filtered out by a custom filter
+            return;
+        }
+
         lock (_records)
         {
             _records.Add(record);

src/Libraries/Microsoft.Extensions.Diagnostics.Testing/Logging/FakeLogCollectorOptions.cs

@@ -3,7 +3,8 @@
 
 using System;
 using System.Collections.Generic;
-using Microsoft.Extensions.Logging;
+using System.Diagnostics.CodeAnalysis;
+using Microsoft.Shared.DiagnosticIds;
 
 #pragma warning disable CA2227 // Collection properties should be read only
 
@@ -34,6 +35,17 @@ public class FakeLogCollectorOptions
     /// </remarks>
     public ISet<LogLevel> FilteredLevels { get; set; } = new HashSet<LogLevel>();
 
+    /// <summary>
+    /// Gets or sets custom filter for which records are collected.
+    /// </summary>
+    /// <value>The default is <see langword="null" />.</value>
+    /// <remarks>
+    /// Defaults to <see langword="null" /> which doesn't apply any additional filter to the records.
+    /// If not empty, only records for which the filter function returns <see langword="true" /> will be collected by the fake logger.
+    /// </remarks>
+    [Experimental(DiagnosticIds.Experiments.Telemetry)]
+    public Func<FakeLogRecord, bool>? CustomFilter { get; set; }
+
     /// <summary>
     /// Gets or sets a value indicating whether to collect records that are logged when the associated log level is currently disabled.
     /// </summary>

test/Libraries/Microsoft.Extensions.Diagnostics.Testing.Tests/Logging/FakeLoggerTests.cs

@@ -6,8 +6,6 @@
 using System.Globalization;
 using System.Linq;
 using System.Threading;
-using Microsoft.Extensions.Logging;
-using Microsoft.Extensions.Logging.Testing;
 using Microsoft.Extensions.Time.Testing;
 using Xunit;
 
@@ -283,4 +281,61 @@ public void Scopes()
         Assert.Equal(42, (int)logger.LatestRecord.Scopes[0]!);
         Assert.Equal("Hello World", (string)logger.LatestRecord.Scopes[1]!);
     }
+
+    [Theory]
+    [InlineData(false, 2)]
+    [InlineData(true, 1)]
+    public void FilterByCustomFilter(bool useErrorLevelFilter, int expectedRecordCount)
+    {
+        const string NotIgnoredMessage1 = "Not ignored message 1";
+        const string NotIgnoredMessage2 = "Not ignored message 2";
+        const string IgnoredMessage = "Ignored message";
+
+        // Given
+        var options = new FakeLogCollectorOptions
+        {
+            CustomFilter = r => r.Message != IgnoredMessage,
+            FilteredLevels = useErrorLevelFilter ? [LogLevel.Error] : new HashSet<LogLevel>(),
+        };
+
+        var collector = FakeLogCollector.Create(options);
+        var logger = new FakeLogger(collector);
+
+        // When
+        logger.LogInformation(NotIgnoredMessage1);
+        logger.LogInformation(IgnoredMessage);
+        logger.LogError(IgnoredMessage);
+        logger.LogError(NotIgnoredMessage2);
+        logger.LogCritical(IgnoredMessage);
+
+        var records = logger.Collector.GetSnapshot();
+
+        // Then
+        Assert.Equal(expectedRecordCount, records.Count);
+        Assert.Equal(expectedRecordCount, logger.Collector.Count);
+
+        IList<(string message, LogLevel level, string prefix)> expectationsInOrder = useErrorLevelFilter
+            ? [(NotIgnoredMessage2, LogLevel.Error, "error] ")]
+            : [(NotIgnoredMessage1, LogLevel.Information, "info] "), (NotIgnoredMessage2, LogLevel.Error, "error] ")];
+
+        for (var i = 0; i < expectedRecordCount; i++)
+        {
+            var (expectedMessage, expectedLevel, expectedPrefix) = expectationsInOrder[i];
+            var record = records[i];
+
+            Assert.Equal(expectedMessage, record.Message);
+            Assert.Equal(expectedLevel, record.Level);
+            Assert.Null(record.Exception);
+            Assert.Null(record.Category);
+            Assert.True(record.LevelEnabled);
+            Assert.Empty(record.Scopes);
+            Assert.Equal(0, record.Id.Id);
+            Assert.EndsWith($"{expectedPrefix}{expectedMessage}", record.ToString());
+
+            if (i == expectedRecordCount - 1)
+            {
+                Assert.Equivalent(record, logger.LatestRecord);
+            }
+        }
+    }
 }