Fixed: IWrappedMessage + IDeadLetterSuppression handling

src/core/Akka.Tests/Actor/DeadLettersSpec.cs

@@ -13,6 +13,47 @@
 
 namespace Akka.Tests
 {
+
+    public class WrappedMessagesSpec
+    {
+        private sealed record WrappedClass(object Message) : IWrappedMessage;
+
+        private sealed record WrappedSuppressedClass(object Message) : IWrappedMessage, IDeadLetterSuppression;
+
+        private sealed class SuppressedMessage : IDeadLetterSuppression
+        {
+
+        }
+
+
+        [Fact]
+        public void ShouldUnwrapWrappedMessage()
+        {
+            var message = new WrappedClass("chocolate-beans");
+            var unwrapped = WrappedMessage.Unwrap(message);
+            unwrapped.ShouldBe("chocolate-beans");
+        }
+
+        public static readonly TheoryData<object, bool> SuppressedMessages = new()
+        {
+            {new SuppressedMessage(), true},
+            {new WrappedClass(new SuppressedMessage()), true},
+            {new WrappedClass(new WrappedClass(new SuppressedMessage())), true},
+            {new WrappedClass(new WrappedClass("chocolate-beans")), false},
+            {new WrappedSuppressedClass("foo"), true},
+            {new WrappedClass(new WrappedSuppressedClass("chocolate-beans")), true},
+            {new WrappedClass("chocolate-beans"), false},
+            {"chocolate-beans", false}
+        };
+
+        [Theory]
+        [MemberData(nameof(SuppressedMessages))]
+        public void ShouldDetectIfWrappedMessageIsSuppressed(object message, bool expected)
+        {
+            var isSuppressed = WrappedMessage.IsDeadLetterSuppressedAnywhere(message, out _);
+            isSuppressed.ShouldBe(expected);
+        }
+    }
 
     public class DeadLettersSpec : AkkaSpec
     {
@@ -23,6 +64,34 @@ public async Task Can_send_messages_to_dead_letters()
             Sys.DeadLetters.Tell("foobar");
             await ExpectMsgAsync<DeadLetter>(deadLetter=>deadLetter.Message.Equals("foobar"));
         }
+
+        private sealed record WrappedClass(object Message) : IWrappedMessage;
+
+        private sealed class SuppressedMessage : IDeadLetterSuppression
+        {
+
+        }
+
+        [Fact]
+        public async Task ShouldLogNormalWrappedMessages()
+        {
+            Sys.EventStream.Subscribe(TestActor, typeof(DeadLetter));
+            Sys.DeadLetters.Tell(new WrappedClass("chocolate-beans"));
+
+            // this is just to make the test deterministic
+            await ExpectMsgAsync<DeadLetter>();
+        }
+
+        [Fact]
+        public async Task ShouldNotLogWrappedMessagesWithDeadLetterSuppression()
+        {
+            Sys.EventStream.Subscribe(TestActor, typeof(AllDeadLetters));
+            Sys.DeadLetters.Tell(new WrappedClass(new SuppressedMessage()));
+
+            // this is just to make the test deterministic
+            var msg = await ExpectMsgAsync<SuppressedDeadLetter>();
+            msg.Message.ToString()!.Contains("SuppressedMessage").ShouldBeTrue();
+        }
     }
 }
 

src/core/Akka/Actor/BuiltInActors.cs

@@ -197,6 +197,27 @@ public static object Unwrap(object message)
             }
             return message;
         }
+
+        /// <summary>
+        /// Is this message marked as "suppress dead letters" anywhere in its "wrap stack"
+        /// </summary>
+        internal static bool IsDeadLetterSuppressedAnywhere(object message, out IDeadLetterSuppression? suppressed)
+        {
+            var loopMessage = message;
+            while(loopMessage is not IDeadLetterSuppression && loopMessage is IWrappedMessage wm)
+            {
+                loopMessage = wm.Message;
+            }
+
+            if (loopMessage is IDeadLetterSuppression suppression)
+            {
+                suppressed = suppression;
+                return true;
+            }
+
+            suppressed = null;
+            return false;
+        }
     }
 
     /// <summary>
@@ -226,19 +247,20 @@ public DeadLetterActorRef(IActorRefProvider provider, ActorPath path, EventStrea
         /// <exception cref="InvalidMessageException">This exception is thrown if the given <paramref name="message"/> is undefined.</exception>
         protected override void TellInternal(object message, IActorRef sender)
         {
-            if (message == null) throw new InvalidMessageException("Message is null");
-            var i = message as Identify;
-            if (i != null)
-            {
-                sender.Tell(new ActorIdentity(i.MessageId, ActorRefs.Nobody));
-                return;
-            }
-            var d = message as DeadLetter;
-            if (d != null)
+            switch (message)
             {
-                if (!SpecialHandle(d.Message, d.Sender)) { _eventStream.Publish(d); }
-                return;
+                case null:
+                    throw new InvalidMessageException("Message is null");
+                case Identify i:
+                    sender.Tell(new ActorIdentity(i.MessageId, ActorRefs.Nobody));
+                    return;
+                case DeadLetter d:
+                {
+                    if (!SpecialHandle(d.Message, d.Sender)) { _eventStream.Publish(d); }
+                    return;
+                }
             }
+
             if (!SpecialHandle(message, sender)) { _eventStream.Publish(new DeadLetter(message, sender.IsNobody() ? Provider.DeadLetters : sender, this)); }
         }
 

src/core/Akka/Actor/EmptyLocalActorRef.cs

@@ -78,13 +78,15 @@ public override void SendSystemMessage(ISystemMessage message)
         }
 
         /// <summary>
-        /// TBD
+        /// Performs filtering on special messages that need different DeadLetter treatment.
         /// </summary>
-        /// <param name="message">TBD</param>
-        /// <param name="sender">TBD</param>
-        /// <returns>TBD</returns>
-        protected virtual bool SpecialHandle(object message, IActorRef sender)
+        /// <param name="possiblyWrapped">The raw message payload.</param>
+        /// <param name="sender">The sender.</param>
+        /// <returns><c>true</c> if this method handled the message.</returns>
+        protected virtual bool SpecialHandle(object possiblyWrapped, IActorRef sender)
         {
+            var message = WrappedMessage.Unwrap(possiblyWrapped);
+
             if (message is Watch watch)
             {
                 if (watch.Watchee.Equals(this) && !watch.Watcher.Equals(this))
@@ -123,9 +125,9 @@ protected virtual bool SpecialHandle(object message, IActorRef sender)
                 return true;
             }
 
-            if (message is IDeadLetterSuppression deadLetterSuppression)
+            if (WrappedMessage.IsDeadLetterSuppressedAnywhere(possiblyWrapped, out var suppressed))
             {
-                PublishSupressedDeadLetter(deadLetterSuppression, sender);
+                PublishSupressedDeadLetter(suppressed, sender);
                 return true;
             }
 

src/core/Akka/Event/UnhandledMessage.cs

@@ -12,7 +12,7 @@ namespace Akka.Event
     /// <summary>
     /// This message is published to the EventStream whenever an Actor receives a message it doesn't understand
     /// </summary>
-    public sealed class UnhandledMessage : AllDeadLetters, IWrappedMessage
+    public sealed class UnhandledMessage : AllDeadLetters
     {
         /// <summary>
         /// Initializes a new instance of the <see cref="UnhandledMessage" /> class.