Add ISentryTransactionProcessor (#1862)

Author: SimonCropp

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ## Features
 
+- Add ISentryTransactionProcessor ([#1862](https://github.com/getsentry/sentry-dotnet/pull/1862))
 - Move Array option over to use List<T> ([#1866](https://github.com/getsentry/sentry-dotnet/pull/1866))
 - Added 'integrations' to SdkVersion ([#1820](https://github.com/getsentry/sentry-dotnet/pull/1820))
 - Updated Sentry Android SDK to version 6.3.0 ([#1826](https://github.com/getsentry/sentry-dotnet/pull/1826))

src/Sentry/Extensibility/ISentryTransactionProcessor.cs

@@ -0,0 +1,19 @@
+namespace Sentry.Extensibility
+{
+    /// <summary>
+    /// Process a <see cref="Transaction"/> during the prepare phase.
+    /// </summary>
+    public interface ISentryTransactionProcessor
+    {
+        /// <summary>
+        /// Process the <see cref="Transaction"/>
+        /// </summary>
+        /// <param name="transaction">The Transaction to process</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);
+    }
+}

src/Sentry/Internal/DelegateTransactionProcessor.cs

@@ -0,0 +1,20 @@
+using System;
+using Sentry.Extensibility;
+
+namespace Sentry.Internal
+{
+    internal class DelegateTransactionProcessor : ISentryTransactionProcessor
+    {
+        private readonly Func<Transaction, Transaction?> _func;
+
+        public DelegateTransactionProcessor(Func<Transaction, Transaction?> func)
+        {
+            _func = func;
+        }
+
+        public Transaction? Process(Transaction transaction)
+        {
+            return _func(transaction);
+        }
+    }
+}

src/Sentry/Internal/Hub.cs

@@ -344,13 +344,29 @@ public void CaptureTransaction(Transaction transaction)
             {
                 // Apply scope data
                 var currentScope = ScopeManager.GetCurrent();
-                currentScope.Key.Evaluate();
-                currentScope.Key.Apply(transaction);
+                var scope = currentScope.Key;
+                scope.Evaluate();
+                scope.Apply(transaction);
 
                 // Apply enricher
                 _enricher.Apply(transaction);
 
-                currentScope.Value.CaptureTransaction(transaction);
+                var processedTransaction = transaction;
+                if (transaction.IsSampled != false)
+                {
+                    foreach (var processor in scope.GetAllTransactionProcessors())
+                    {
+                        processedTransaction = processor.Process(transaction);
+                        if (processedTransaction == null)
+                        {
+                            _options.ClientReportRecorder.RecordDiscardedEvent(DiscardReason.EventProcessor, DataCategory.Transaction);
+                            _options.LogInfo("Event dropped by processor {0}", processor.GetType().Name);
+                            return;
+                        }
+                    }
+                }
+
+                currentScope.Value.CaptureTransaction(processedTransaction);
             }
             catch (Exception e)
             {

src/Sentry/Scope.cs

@@ -62,11 +62,19 @@ internal SentryId LastEventId
         private readonly Lazy<ConcurrentBag<ISentryEventProcessor>> _lazyEventProcessors =
             new(LazyThreadSafetyMode.PublicationOnly);
 
+        private readonly Lazy<ConcurrentBag<ISentryTransactionProcessor>> _lazyTransactionProcessors =
+            new(LazyThreadSafetyMode.PublicationOnly);
+
         /// <summary>
         /// A list of event processors.
         /// </summary>
         internal ConcurrentBag<ISentryEventProcessor> EventProcessors => _lazyEventProcessors.Value;
 
+        /// <summary>
+        /// A list of event processors.
+        /// </summary>
+        internal ConcurrentBag<ISentryTransactionProcessor> TransactionProcessors => _lazyTransactionProcessors.Value;
+
         /// <summary>
         /// An event that fires when the scope evaluates.
         /// </summary>
@@ -425,6 +433,11 @@ public Scope Clone()
                 clone.EventProcessors.Add(processor);
             }
 
+            foreach (var processor in TransactionProcessors)
+            {
+                clone.TransactionProcessors.Add(processor);
+            }
+
             foreach (var processor in ExceptionProcessors)
             {
                 clone.ExceptionProcessors.Add(processor);

src/Sentry/ScopeExtensions.cs

@@ -32,6 +32,23 @@ public static IEnumerable<ISentryEventProcessor> GetAllEventProcessors(this Scop
             }
         }
 
+        /// <summary>
+        /// Invokes all transaction processor providers available.
+        /// </summary>
+        /// <param name="scope">The Scope which holds the processor providers.</param>
+        public static IEnumerable<ISentryTransactionProcessor> GetAllTransactionProcessors(this Scope scope)
+        {
+            foreach (var processor in scope.Options.GetAllTransactionProcessors())
+            {
+                yield return processor;
+            }
+
+            foreach (var processor in scope.TransactionProcessors)
+            {
+                yield return processor;
+            }
+        }
+
         /// <summary>
         /// Invokes all exception processor providers available.
         /// </summary>
@@ -99,6 +116,35 @@ public static void AddEventProcessors(this Scope scope, IEnumerable<ISentryEvent
             }
         }
 
+        /// <summary>
+        /// Adds an transaction processor which is invoked when creating a <see cref="Transaction"/>.
+        /// </summary>
+        /// <param name="scope">The Scope to hold the processor.</param>
+        /// <param name="processor">The transaction processor.</param>
+        public static void AddTransactionProcessor(this Scope scope, ISentryTransactionProcessor processor)
+            => scope.TransactionProcessors.Add(processor);
+
+        /// <summary>
+        /// Adds an transaction processor which is invoked when creating a <see cref="Transaction"/>.
+        /// </summary>
+        /// <param name="scope">The Scope to hold the processor.</param>
+        /// <param name="processor">The transaction processor.</param>
+        public static void AddTransactionProcessor(this Scope scope, Func<Transaction, Transaction?> processor)
+            => scope.AddTransactionProcessor(new DelegateTransactionProcessor(processor));
+
+        /// <summary>
+        /// Adds transaction processors which are invoked when creating a <see cref="Transaction"/>.
+        /// </summary>
+        /// <param name="scope">The Scope to hold the processor.</param>
+        /// <param name="processors">The transaction processors.</param>
+        public static void AddTransactionProcessors(this Scope scope, IEnumerable<ISentryTransactionProcessor> processors)
+        {
+            foreach (var processor in processors)
+            {
+                scope.TransactionProcessors.Add(processor);
+            }
+        }
+
         /// <summary>
         /// Adds an attachment.
         /// </summary>

src/Sentry/SentryClient.cs

@@ -116,10 +116,12 @@ public void CaptureTransaction(Transaction transaction)
                                     "to properly finalize the transaction and send it to Sentry.");
             }
 
+
             // Sampling decision MUST have been made at this point
             Debug.Assert(transaction.IsSampled != null,
                 "Attempt to capture transaction without sampling decision.");
 
+
             if (transaction.IsSampled != true)
             {
                 _options.ClientReportRecorder.RecordDiscardedEvent(DiscardReason.SampleRate, DataCategory.Transaction);

src/Sentry/SentryOptions.cs

@@ -91,6 +91,11 @@ public bool IsGlobalModeEnabled
         /// </summary>
         internal List<ISentryEventExceptionProcessor>? ExceptionProcessors { get; set; }
 
+        /// <summary>
+        /// A list of transaction processors
+        /// </summary>
+        internal List<ISentryTransactionProcessor>? TransactionProcessors { get; set; }
+
         /// <summary>
         /// A list of event processors
         /// </summary>
@@ -101,6 +106,11 @@ public bool IsGlobalModeEnabled
         /// </summary>
         internal List<Func<IEnumerable<ISentryEventProcessor>>>? EventProcessorsProviders { get; set; }
 
+        /// <summary>
+        /// A list of providers of <see cref="ISentryTransactionProcessor"/>
+        /// </summary>
+        internal List<Func<IEnumerable<ISentryTransactionProcessor>>>? TransactionProcessorsProviders { get; set; }
+
         /// <summary>
         /// A list of providers of <see cref="ISentryEventExceptionProcessor"/>
         /// </summary>
@@ -684,6 +694,10 @@ public SentryOptions()
                 () => EventProcessors ?? Enumerable.Empty<ISentryEventProcessor>()
             };
 
+            TransactionProcessorsProviders = new () {
+                () => TransactionProcessors ?? Enumerable.Empty<ISentryTransactionProcessor>()
+            };
+
             ExceptionProcessorsProviders = new () {
                 () => ExceptionProcessors ?? Enumerable.Empty<ISentryEventExceptionProcessor>()
             };

src/Sentry/SentryOptionsExtensions.cs

@@ -266,6 +266,50 @@ public static void AddEventProcessorProvider(this SentryOptions options, Func<IE
             }
         }
 
+        /// <summary>
+        /// Adds an transaction processor which is invoked when creating a <see cref="Transaction"/>.
+        /// </summary>
+        /// <param name="options">The SentryOptions to hold the processor.</param>
+        /// <param name="processor">The transaction processor.</param>
+        public static void AddTransactionProcessor(this SentryOptions options, ISentryTransactionProcessor processor)
+        {
+            if (options.TransactionProcessors == null)
+            {
+                options.TransactionProcessors = new() {processor};
+            }
+            else
+            {
+                options.TransactionProcessors.Add(processor);
+            }
+        }
+
+        /// <summary>
+        /// Adds transaction processors which are invoked when creating a <see cref="Transaction"/>.
+        /// </summary>
+        /// <param name="options">The SentryOptions to hold the processor.</param>
+        /// <param name="processors">The transaction processors.</param>
+        public static void AddTransactionProcessors(this SentryOptions options, IEnumerable<ISentryTransactionProcessor> processors)
+        {
+            if (options.TransactionProcessors == null)
+            {
+                options.TransactionProcessors = processors.ToList();
+            }
+            else
+            {
+                options.TransactionProcessors.AddRange(processors);
+            }
+        }
+
+        /// <summary>
+        /// Adds an transaction processor provider which is invoked when creating a <see cref="Transaction"/>.
+        /// </summary>
+        /// <param name="options">The SentryOptions to hold the processor provider.</param>
+        /// <param name="processorProvider">The transaction processor provider.</param>
+        public static void AddTransactionProcessorProvider(this SentryOptions options, Func<IEnumerable<ISentryTransactionProcessor>> processorProvider)
+            => options.TransactionProcessorsProviders = options.TransactionProcessorsProviders != null
+                ? options.TransactionProcessorsProviders.Concat(new[] { processorProvider }).ToList()
+                : new() { processorProvider };
+
         /// <summary>
         /// Add the exception processor provider.
         /// </summary>
@@ -291,6 +335,13 @@ public static void AddExceptionProcessorProvider(this SentryOptions options,
         public static IEnumerable<ISentryEventProcessor> GetAllEventProcessors(this SentryOptions options)
             => options.EventProcessorsProviders?.SelectMany(p => p()) ?? Enumerable.Empty<ISentryEventProcessor>();
 
+        /// <summary>
+        /// Invokes all transaction processor providers available.
+        /// </summary>
+        /// <param name="options">The SentryOptions which holds the processor providers.</param>
+        public static IEnumerable<ISentryTransactionProcessor> GetAllTransactionProcessors(this SentryOptions options)
+            => options.TransactionProcessorsProviders?.SelectMany(p => p()) ?? Enumerable.Empty<ISentryTransactionProcessor>();
+
         /// <summary>
         /// Invokes all exception processor providers available.
         /// </summary>

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

@@ -1,4 +1,4 @@
-[assembly: System.CLSCompliant(true)]
+[assembly: System.CLSCompliant(true)]
 namespace Sentry
 {
     [System.Diagnostics.DebuggerDisplay("{FileName}")]
@@ -344,8 +344,12 @@ namespace Sentry
         public static void AddEventProcessors(this Sentry.Scope scope, System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryEventProcessor> processors) { }
         public static void AddExceptionProcessor(this Sentry.Scope scope, Sentry.Extensibility.ISentryEventExceptionProcessor processor) { }
         public static void AddExceptionProcessors(this Sentry.Scope scope, System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryEventExceptionProcessor> processors) { }
+        public static void AddTransactionProcessor(this Sentry.Scope scope, Sentry.Extensibility.ISentryTransactionProcessor processor) { }
+        public static void AddTransactionProcessor(this Sentry.Scope scope, System.Func<Sentry.Transaction, Sentry.Transaction?> processor) { }
+        public static void AddTransactionProcessors(this Sentry.Scope scope, System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryTransactionProcessor> processors) { }
         public static System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryEventProcessor> GetAllEventProcessors(this Sentry.Scope scope) { }
         public static System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryEventExceptionProcessor> GetAllExceptionProcessors(this Sentry.Scope scope) { }
+        public static System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryTransactionProcessor> GetAllTransactionProcessors(this Sentry.Scope scope) { }
     }
     public sealed class SdkVersion : Sentry.IJsonSerializable
     {
@@ -528,13 +532,17 @@ namespace Sentry
         public static void AddInAppExclude(this Sentry.SentryOptions options, string prefix) { }
         public static void AddInAppInclude(this Sentry.SentryOptions options, string prefix) { }
         public static void AddIntegration(this Sentry.SentryOptions options, Sentry.Integrations.ISdkIntegration integration) { }
+        public static void AddTransactionProcessor(this Sentry.SentryOptions options, Sentry.Extensibility.ISentryTransactionProcessor processor) { }
+        public static void AddTransactionProcessorProvider(this Sentry.SentryOptions options, System.Func<System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryTransactionProcessor>> processorProvider) { }
+        public static void AddTransactionProcessors(this Sentry.SentryOptions options, System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryTransactionProcessor> processors) { }
         public static void ApplyDefaultTags(this Sentry.SentryOptions options, Sentry.IHasTags hasTags) { }
         public static void DisableAppDomainProcessExitFlush(this Sentry.SentryOptions options) { }
         public static void DisableAppDomainUnhandledExceptionCapture(this Sentry.SentryOptions options) { }
         public static void DisableDuplicateEventDetection(this Sentry.SentryOptions options) { }
         public static void DisableTaskUnobservedTaskExceptionCapture(this Sentry.SentryOptions options) { }
         public static System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryEventProcessor> GetAllEventProcessors(this Sentry.SentryOptions options) { }
         public static System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryEventExceptionProcessor> GetAllExceptionProcessors(this Sentry.SentryOptions options) { }
+        public static System.Collections.Generic.IEnumerable<Sentry.Extensibility.ISentryTransactionProcessor> GetAllTransactionProcessors(this Sentry.SentryOptions options) { }
         public static void RemoveIntegration<TIntegration>(this Sentry.SentryOptions options)
             where TIntegration : Sentry.Integrations.ISdkIntegration { }
         public static Sentry.SentryOptions UseStackTraceFactory(this Sentry.SentryOptions options, Sentry.Extensibility.ISentryStackTraceFactory sentryStackTraceFactory) { }
@@ -1063,6 +1071,10 @@ namespace Sentry.Extensibility
     {
         Sentry.SentryStackTrace? Create(System.Exception? exception = null);
     }
+    public interface ISentryTransactionProcessor
+    {
+        Sentry.Transaction? Process(Sentry.Transaction transaction);
+    }
     public interface ITransport
     {
         System.Threading.Tasks.Task SendEnvelopeAsync(Sentry.Protocol.Envelopes.Envelope envelope, System.Threading.CancellationToken cancellationToken = default);