feat: Add EventFilter support for semantic logging templates

Enables EventFilter to match against semantic logging templates in unit tests, resolving the core issue from GitHub #7932 where EventFilter.Info("BetId:{BetId}") would fail to match log messages using named property syntax.

Changes:
- Modified EventFilterBase.InternalDoMatch to check LogMessage.Format template before falling back to formatted output
- Allows matching against both template patterns ("{UserId}") and formatted values ("12345")
- Added comprehensive tests for EventFilter with semantic templates (exact match, contains, starts with)
- Removed FormatException catching for positional templates to maintain backward compatibility with DefaultLogMessageFormatter

All 66 logger tests pass, including 4 new EventFilter semantic logging tests and existing backward compatibility tests.

Author: Aaronontheweb

src/core/Akka.TestKit/EventFilter/Internal/EventFilterBase.cs

@@ -87,8 +87,26 @@ protected virtual void OnEventMatched(LogEvent logEvent)
     /// <returns>TBD</returns>
     protected bool InternalDoMatch(string src, object? msg)
     {
+        // Check source matcher first (fast path)
+        if (!_sourceMatcher.IsMatch(src))
+            return false;
+
+        // For semantic logging support, try matching against both the formatted message
+        // and the unformatted template pattern
+        if (msg is LogMessage logMessage)
+        {
+            // Try matching against the template pattern first (e.g., "User {UserId} logged in")
+            if (_messageMatcher.IsMatch(logMessage.Format))
+                return true;
+
+            // Fall back to matching the formatted message (e.g., "User 12345 logged in")
+            var formattedMsg = logMessage.ToString() ?? "null";
+            return _messageMatcher.IsMatch(formattedMsg);
+        }
+
+        // Non-semantic logging or legacy messages
         var msgstr = msg == null ? "null" : msg.ToString() ?? "null";
-        return _sourceMatcher.IsMatch(src) && _messageMatcher.IsMatch(msgstr);
+        return _messageMatcher.IsMatch(msgstr);
     }
 
     /// <summary>

src/core/Akka.Tests/Loggers/SemanticLoggingSpecs.cs

@@ -8,6 +8,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using Akka.Configuration;
 using Akka.Event;
 using Akka.TestKit;
 using FluentAssertions;
@@ -17,6 +18,14 @@ namespace Akka.Tests.Loggers
 {
     public class SemanticLoggingSpecs : AkkaSpec
     {
+        public SemanticLoggingSpecs() : base(ConfigurationFactory.ParseString(@"
+            akka {
+                loglevel = INFO
+                stdout-loglevel = INFO
+            }
+        "))
+        {
+        }
         [Fact(DisplayName = "MessageTemplateParser should parse positional templates correctly")]
         public void MessageTemplateParser_should_parse_positional_templates()
         {
@@ -331,5 +340,45 @@ public void End_to_end_semantic_logging_should_work()
             // Message formatting
             logMessage.ToString().Should().Be("User 123 performed action Login");
         }
+
+        [Fact(DisplayName = "EventFilter should match semantic logging templates with named properties")]
+        public void EventFilter_should_match_semantic_templates()
+        {
+            // This test demonstrates the issue from GitHub #7932
+            // EventFilter should match against the template pattern, not just the formatted output
+
+            EventFilter.Info("OnCreateBet BetId:{BetId} created").ExpectOne(() =>
+            {
+                Log.Info("OnCreateBet BetId:{BetId} created", 12345);
+            });
+        }
+
+        [Fact(DisplayName = "EventFilter should match semantic logging templates with contains")]
+        public void EventFilter_should_match_semantic_templates_with_contains()
+        {
+            EventFilter.Info(contains: "BetId:{BetId}").ExpectOne(() =>
+            {
+                Log.Info("OnCreateBet BetId:{BetId} created", 12345);
+            });
+        }
+
+        [Fact(DisplayName = "EventFilter should match semantic logging templates with partial pattern")]
+        public void EventFilter_should_match_semantic_partial_pattern()
+        {
+            EventFilter.Info(start: "User {UserId}").ExpectOne(() =>
+            {
+                Log.Info("User {UserId} logged in from {IpAddress}", 123, "192.168.1.1");
+            });
+        }
+
+        [Fact(DisplayName = "EventFilter should still match formatted output when template doesn't match")]
+        public void EventFilter_should_fallback_to_formatted_output()
+        {
+            // Should also be able to match against the actual formatted values
+            EventFilter.Info(contains: "12345").ExpectOne(() =>
+            {
+                Log.Info("OnCreateBet BetId:{BetId} created", 12345);
+            });
+        }
     }
 }

src/core/Akka/Event/SemanticLogMessageFormatter.cs

@@ -77,14 +77,9 @@ public string Format(string format, IEnumerable<object> args)
                     for (int i = 0; i < readOnlyList.Count; i++)
                         argArray[i] = readOnlyList[i];
 
-                    try
-                    {
-                        return string.Format(format, argArray);
-                    }
-                    catch (FormatException)
-                    {
-                        return $"{format} [{string.Join(", ", argArray)}]";
-                    }
+                    // For positional templates, use string.Format directly without catching FormatException
+                    // to maintain backward compatibility with DefaultLogMessageFormatter behavior
+                    return string.Format(format, argArray);
                 }
                 else
                 {
@@ -110,16 +105,9 @@ public string Format(string format, IEnumerable<object> args)
 
             if (isPositional2)
             {
-                // Use standard string.Format for positional templates
-                try
-                {
-                    return string.Format(format, argArray);
-                }
-                catch (FormatException)
-                {
-                    // If formatting fails, return the format string with args appended
-                    return $"{format} [{string.Join(", ", argArray)}]";
-                }
+                // For positional templates, use string.Format directly without catching FormatException
+                // to maintain backward compatibility with DefaultLogMessageFormatter behavior
+                return string.Format(format, argArray);
             }
             else
             {