Added hint support for Transaction/Event processors

src/Sentry/Extensibility/IContextualSentryEventProcessor.cs

@@ -0,0 +1,20 @@
+namespace Sentry.Extensibility;
+
+/// <summary>
+/// Process a SentryEvent during the prepare phase.
+/// </summary>
+public interface IContextualSentryEventProcessor: ISentryEventProcessor
+{
+    /// <summary>
+    /// Process the <see cref="SentryEvent"/>
+    /// </summary>
+    /// <param name="event">The event to process</param>
+    /// <param name="hint">A <see cref="Hint"/> with context that may be useful prior to sending the event</param>
+    /// <return>The processed event or <c>null</c> if the event was dropped.</return>
+    /// <remarks>
+    /// The event returned can be the same instance received or a new one.
+    /// Returning null will stop the processing pipeline so that the event will neither be processed by
+    /// additional event processors or sent to Sentry.
+    /// </remarks>
+    SentryEvent? Process(SentryEvent @event, Hint hint);
+}

src/Sentry/Extensibility/IContextualSentryTransactionProcessor.cs

@@ -0,0 +1,19 @@
+namespace Sentry.Extensibility;
+
+/// <summary>
+/// Process a <see cref="Transaction"/> during the prepare phase.
+/// </summary>
+public interface IContextualSentryTransactionProcessor: ISentryTransactionProcessor
+{
+    /// <summary>
+    /// Process the <see cref="Transaction"/>
+    /// </summary>
+    /// <param name="transaction">The Transaction to process</param>
+    /// <param name="hint">A <see cref="Hint"/> with context that may be useful prior to sending the transaction</param>
+    /// <remarks>
+    /// The transaction returned can be the same instance received or a new one.
+    /// Returning null will stop the processing pipeline.
+    /// Meaning the transaction should no longer be processed nor send.
+    /// </remarks>
+    Transaction? Process(Transaction transaction, Hint hint);
+}

src/Sentry/Extensibility/ISentryEventProcessor.cs

@@ -16,4 +16,14 @@ public interface ISentryEventProcessor
     /// Meaning the event should no longer be processed nor send.
     /// </remarks>
     SentryEvent? Process(SentryEvent @event);
-}
+}
+
+internal static class ISentryEventProcessorExtensions
+{
+    internal static SentryEvent? DoProcessEvent(this ISentryEventProcessor processor, SentryEvent @event, Hint hint)
+    {
+        return (processor is IContextualSentryEventProcessor contextualProcessor)
+            ? contextualProcessor.Process(@event, hint)
+            : processor.Process(@event);
+    }
+}

src/Sentry/Extensibility/ISentryTransactionProcessor.cs

@@ -1,4 +1,4 @@
-namespace Sentry.Extensibility;
+namespace Sentry.Extensibility;
 
 /// <summary>
 /// Process a <see cref="Transaction"/> during the prepare phase.
@@ -16,3 +16,13 @@ public interface ISentryTransactionProcessor
     /// </remarks>
     Transaction? Process(Transaction transaction);
 }
+
+internal static class ISentryTransactionProcessorExtensions
+{
+    internal static Transaction? DoProcessTransaction(this ISentryTransactionProcessor processor, Transaction transaction, Hint hint)
+    {
+        return (processor is IContextualSentryTransactionProcessor contextualProcessor)
+            ? contextualProcessor.Process(transaction, hint)
+            : processor.Process(transaction);
+    }
+}

src/Sentry/Internal/Hub.cs

@@ -427,7 +427,7 @@ public void CaptureTransaction(Transaction transaction, Hint? hint)
             {
                 foreach (var processor in scope.GetAllTransactionProcessors())
                 {
-                    processedTransaction = processor.Process(transaction);
+                    processedTransaction = processor.DoProcessTransaction(transaction, hint);
                     if (processedTransaction == null)
                     {
                         _options.ClientReportRecorder.RecordDiscardedEvent(DiscardReason.EventProcessor, DataCategory.Transaction);

src/Sentry/SentryClient.cs

@@ -258,7 +258,8 @@ private SentryId DoSendEvent(SentryEvent @event, Hint? hint, Scope? scope)
 
         foreach (var processor in scope.GetAllEventProcessors())
         {
-            processedEvent = processor.Process(processedEvent);
+            processedEvent = processor.DoProcessEvent(processedEvent, hint);
+
             if (processedEvent == null)
             {
                 _options.ClientReportRecorder.RecordDiscardedEvent(DiscardReason.EventProcessor, DataCategory.Error);

src/Sentry/SentryOptionsExtensions.cs

@@ -446,4 +446,3 @@ internal static void SetupLogging(this SentryOptions options)
         return options.TryGetDsnSpecificCacheDirectoryPath();
     }
 }
-

test/Sentry.AspNetCore.Tests/ApplicationBuilderExtensionsTests.cs

@@ -78,7 +78,6 @@ public void UseSentry_OriginalEventExceptionProcessor_StillAvailable()
 
         var sut = _fixture.GetSut();
 
-
         _ = sut.UseSentry();
 
         var missing = originalProviders.Except(_fixture.SentryAspNetCoreOptions.ExceptionProcessorsProviders);

test/Sentry.Tests/ApiApprovalTests.Run.Core3_1.verified.txt

@@ -1255,13 +1255,13 @@ namespace Sentry.Extensibility
         bool EnqueueEnvelope(Sentry.Protocol.Envelopes.Envelope envelope);
         System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout);
     }
-    public interface IContextualSentryEventProcessor
+    public interface IContextualSentryEventProcessor : Sentry.Extensibility.ISentryEventProcessor
     {
-        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint? hint);
+        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint hint);
     }
-    public interface IContextualSentryTransactionProcessor
+    public interface IContextualSentryTransactionProcessor : Sentry.Extensibility.ISentryTransactionProcessor
     {
-        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint? hint);
+        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint hint);
     }
     public interface IDiagnosticLogger
     {

test/Sentry.Tests/ApiApprovalTests.Run.DotNet6_0.verified.txt

@@ -1256,13 +1256,13 @@ namespace Sentry.Extensibility
         bool EnqueueEnvelope(Sentry.Protocol.Envelopes.Envelope envelope);
         System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout);
     }
-    public interface IContextualSentryEventProcessor
+    public interface IContextualSentryEventProcessor : Sentry.Extensibility.ISentryEventProcessor
     {
-        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint? hint);
+        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint hint);
     }
-    public interface IContextualSentryTransactionProcessor
+    public interface IContextualSentryTransactionProcessor : Sentry.Extensibility.ISentryTransactionProcessor
     {
-        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint? hint);
+        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint hint);
     }
     public interface IDiagnosticLogger
     {

test/Sentry.Tests/ApiApprovalTests.Run.DotNet7_0.verified.txt

@@ -1256,13 +1256,13 @@ namespace Sentry.Extensibility
         bool EnqueueEnvelope(Sentry.Protocol.Envelopes.Envelope envelope);
         System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout);
     }
-    public interface IContextualSentryEventProcessor
+    public interface IContextualSentryEventProcessor : Sentry.Extensibility.ISentryEventProcessor
     {
-        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint? hint);
+        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint hint);
     }
-    public interface IContextualSentryTransactionProcessor
+    public interface IContextualSentryTransactionProcessor : Sentry.Extensibility.ISentryTransactionProcessor
     {
-        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint? hint);
+        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint hint);
     }
     public interface IDiagnosticLogger
     {

test/Sentry.Tests/ApiApprovalTests.Run.Net4_8.verified.txt

@@ -1254,13 +1254,13 @@ namespace Sentry.Extensibility
         bool EnqueueEnvelope(Sentry.Protocol.Envelopes.Envelope envelope);
         System.Threading.Tasks.Task FlushAsync(System.TimeSpan timeout);
     }
-    public interface IContextualSentryEventProcessor
+    public interface IContextualSentryEventProcessor : Sentry.Extensibility.ISentryEventProcessor
     {
-        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint? hint);
+        Sentry.SentryEvent? Process(Sentry.SentryEvent @event, Sentry.Hint hint);
     }
-    public interface IContextualSentryTransactionProcessor
+    public interface IContextualSentryTransactionProcessor : Sentry.Extensibility.ISentryTransactionProcessor
     {
-        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint? hint);
+        Sentry.Transaction? Process(Sentry.Transaction transaction, Sentry.Hint hint);
     }
     public interface IDiagnosticLogger
     {

test/Sentry.Tests/HubTests.cs

@@ -1130,7 +1130,7 @@ public void CaptureTransaction_HubEnabled(bool enabled)
     }
 
     [Fact]
-    public void CaptureTransaction_Provides_Hint_To_Client()
+    public void CaptureTransaction_Client_Gets_Hint()
     {
         // Arrange        
         var hub = _fixture.GetSut();
@@ -1144,7 +1144,7 @@ public void CaptureTransaction_Provides_Hint_To_Client()
     }
 
     [Fact]
-    public void CaptureTransaction_Hint_Gets_Attachments()
+    public void CaptureTransaction_Client_Gets_ScopeAttachments()
     {
         // Arrange        
         var hub = _fixture.GetSut();
@@ -1171,6 +1171,45 @@ public void CaptureTransaction_Hint_Gets_Attachments()
         hint.Attachments.Should().Contain(attachments);
     }
 
+    [Fact]
+    public void CaptureTransaction_EventProcessor_Gets_Hint()
+    {
+        // Arrange
+        var processor = Substitute.For<IContextualSentryTransactionProcessor>();
+        processor.Process(Arg.Any<Transaction>(), Arg.Any<Hint>()).Returns(new Transaction("name", "operation"));
+        _fixture.Options.AddTransactionProcessor(processor);
+
+        // Act
+        var hub = _fixture.GetSut();
+        var transaction = hub.StartTransaction("test", "test");
+        transaction.Finish();
+
+        // Assert
+        processor.Received(1).Process(Arg.Any<Transaction>(), Arg.Any<Hint>());
+    }
+
+    [Fact]
+    public void CaptureTransaction_EventProcessor_Gets_ScopeAttachments()
+    {
+        // Arrange
+        var processor = Substitute.For<IContextualSentryTransactionProcessor>();
+        Hint hint = null;
+        processor.Process(Arg.Any<Transaction>(), Arg.Do<Hint>(h => hint = h)).Returns(new Transaction("name", "operation"));
+        _fixture.Options.AddTransactionProcessor(processor);
+
+        List<Attachment> attachments = new List<Attachment> { AttachmentHelper.FakeAttachment("foo.txt") };
+        var hub = _fixture.GetSut();
+        hub.ConfigureScope(s => s.AddAttachment(attachments[0]));
+
+        // Act
+        var transaction = hub.StartTransaction("test", "test");
+        transaction.Finish();
+
+        // Assert
+        hint.Should().NotBeNull();
+        hint.Attachments.Should().Contain(attachments);
+    }
+
 #if ANDROID && CI_BUILD
     // TODO: Test is flaky in CI
     [SkippableTheory(typeof(NSubstitute.Exceptions.ReceivedCallsException))]

test/Sentry.Tests/SentryClientTests.cs

@@ -1,3 +1,4 @@
+using FluentAssertions.Execution;
 using Sentry.Internal.Http;
 using BackgroundWorker = Sentry.Internal.BackgroundWorker;
 
@@ -320,7 +321,7 @@ public void CaptureEvent_BeforeSend_GetsHint()
     }
 
     [Fact]
-    public void CaptureEvent_Add_ScopeAttachments_To_Hint()
+    public void CaptureEvent_BeforeSend_Gets_ScopeAttachments()
     {
         // Arrange
         Hint hint = null;
@@ -343,7 +344,44 @@ public void CaptureEvent_Add_ScopeAttachments_To_Hint()
     }
 
     [Fact]
-    public void CaptureEvent_BeforeEvent_ModifyEvent()
+    public void CaptureEvent_EventProcessor_Gets_Hint()
+    {
+        // Arrange
+        var processor = Substitute.For<IContextualSentryEventProcessor>();
+        processor.Process(Arg.Any<SentryEvent>(), Arg.Any<Hint>()).Returns(new SentryEvent());
+        _fixture.SentryOptions.AddEventProcessor(processor);
+
+        // Act
+        var sut = _fixture.GetSut();
+        _ = sut.CaptureEvent(new SentryEvent());
+
+        // Assert
+        processor.Received(1).Process(Arg.Any<SentryEvent>(), Arg.Any<Hint>());
+    }
+
+    [Fact]
+    public void CaptureEvent_EventProcessor_Gets_ScopeAttachments()
+    {
+        // Arrange
+        var processor = Substitute.For<IContextualSentryEventProcessor>();
+        Hint hint = null;
+        processor.Process(Arg.Any<SentryEvent>(), Arg.Do<Hint>(h => hint = h)).Returns(new SentryEvent());
+        _fixture.SentryOptions.AddEventProcessor(processor);
+
+        Scope scope = new Scope(_fixture.SentryOptions);
+        scope.AddAttachment(AttachmentHelper.FakeAttachment("foo.txt"));
+
+        // Act
+        var sut = _fixture.GetSut();
+        _ = sut.CaptureEvent(new SentryEvent(), scope);
+
+        // Assert
+        hint.Should().NotBeNull();
+        hint.Attachments.Should().Contain(scope.Attachments);
+    }
+
+    [Fact]
+    public void CaptureEvent_BeforeSend_ModifyEvent()
     {
         SentryEvent received = null;
         _fixture.SentryOptions.SetBeforeSend((e, _) => received = e);