Merge pull request #189 from getsentry/ref/extend-stacktrace-factory

ref: stacktrace factory extensibility

Author: bruno-garcia

src/Sentry/Extensibility/ISentryStackTraceFactory.cs

@@ -3,8 +3,16 @@
 
 namespace Sentry.Extensibility
 {
+    /// <summary>
+    /// Factory to <see cref="SentryStackTrace" /> from an <see cref="Exception" />.
+    /// </summary>
     public interface ISentryStackTraceFactory
     {
+        /// <summary>
+        /// Creates a <see cref="SentryStackTrace" /> from the optional <see cref="Exception" />.
+        /// </summary>
+        /// <param name="exception">The exception to create the stacktrace from.</param>
+        /// <returns>A Sentry stack trace.</returns>
         SentryStackTrace Create(Exception exception = null);
     }
 }

src/Sentry/Extensibility/SentryStackTraceFactory.cs

@@ -8,12 +8,20 @@
 
 namespace Sentry.Extensibility
 {
+    /// <summary>
+    /// Default factory to <see cref="SentryStackTrace" /> from an <see cref="Exception" />.
+    /// </summary>
     public class SentryStackTraceFactory : ISentryStackTraceFactory
     {
         private readonly SentryOptions _options;
 
         public SentryStackTraceFactory(SentryOptions options) => _options = options;
 
+        /// <summary>
+        /// Creates a <see cref="SentryStackTrace" /> from the optional <see cref="Exception" />.
+        /// </summary>
+        /// <param name="exception">The exception to create the stacktrace from.</param>
+        /// <returns>A Sentry stack trace.</returns>
         public SentryStackTrace Create(Exception exception = null)
         {
             var isCurrentStackTrace = exception == null && _options.AttachStacktrace;

src/Sentry/Internal/MainExceptionProcessor.cs

@@ -11,14 +11,14 @@ namespace Sentry.Internal
     internal class MainExceptionProcessor : ISentryEventExceptionProcessor
     {
         private readonly SentryOptions _options;
-        private readonly ISentryStackTraceFactory _sentryStackTraceFactory;
+        internal Func<ISentryStackTraceFactory> SentryStackTraceFactoryAccessor { get; }
 
-        public MainExceptionProcessor(SentryOptions options, ISentryStackTraceFactory sentryStackTraceFactory)
+        public MainExceptionProcessor(SentryOptions options, Func<ISentryStackTraceFactory> sentryStackTraceFactoryAccessor)
         {
             Debug.Assert(options != null);
-            Debug.Assert(sentryStackTraceFactory != null);
+            Debug.Assert(sentryStackTraceFactoryAccessor != null);
             _options = options;
-            _sentryStackTraceFactory = sentryStackTraceFactory;
+            SentryStackTraceFactoryAccessor = sentryStackTraceFactoryAccessor;
         }
 
         public void Process(Exception exception, SentryEvent sentryEvent)
@@ -101,7 +101,7 @@ internal IEnumerable<SentryException> CreateSentryException(Exception exception)
                 }
             }
 
-            sentryEx.Stacktrace = _sentryStackTraceFactory.Create(exception);
+            sentryEx.Stacktrace = SentryStackTraceFactoryAccessor().Create(exception);
 
             yield return sentryEx;
         }

src/Sentry/Internal/MainSentryEventProcessor.cs

@@ -32,19 +32,19 @@ private static readonly (string Name, string Version) NameAndVersion
         private static readonly string ProtocolPackageName = "nuget:" + NameAndVersion.Name;
 
         private readonly SentryOptions _options;
-        private readonly ISentryStackTraceFactory _sentryStackTraceFactory;
+        internal Func<ISentryStackTraceFactory> SentryStackTraceFactoryAccessor { get; }
 
         internal string Release => _release.Value;
         internal Runtime Runtime => _runtime.Value;
 
         public MainSentryEventProcessor(
             SentryOptions options,
-            ISentryStackTraceFactory sentryStackTraceFactory)
+            Func<ISentryStackTraceFactory> sentryStackTraceFactoryAccessor)
         {
             Debug.Assert(options != null);
-            Debug.Assert(sentryStackTraceFactory != null);
+            Debug.Assert(sentryStackTraceFactoryAccessor != null);
             _options = options;
-            _sentryStackTraceFactory = sentryStackTraceFactory;
+            SentryStackTraceFactoryAccessor = sentryStackTraceFactoryAccessor;
         }
 
         public SentryEvent Process(SentryEvent @event)
@@ -104,7 +104,7 @@ public SentryEvent Process(SentryEvent @event)
 
             if (@event.Exception == null)
             {
-                var stackTrace = _sentryStackTraceFactory.Create(@event.Exception);
+                var stackTrace = SentryStackTraceFactoryAccessor().Create(@event.Exception);
                 if (stackTrace != null)
                 {
                     @event.Stacktrace = stackTrace;

src/Sentry/SentryOptions.cs

@@ -22,6 +22,9 @@ namespace Sentry
     /// </summary>
     public class SentryOptions : IScopeOptions
     {
+        private readonly Func<ISentryStackTraceFactory> _sentryStackTraceFactoryAccessor;
+        internal ISentryStackTraceFactory SentryStackTraceFactory { get; set; }
+
         internal string ClientVersion { get; } = SdkName;
 
         internal int SentryVersion { get; } = ProtocolVersion;
@@ -332,12 +335,14 @@ public SentryOptions()
                 = ImmutableList.Create<Func<IEnumerable<ISentryEventExceptionProcessor>>>(
                     () => ExceptionProcessors);
 
-            var sentryStackTraceFactory = new SentryStackTraceFactory(this);
+            SentryStackTraceFactory = new SentryStackTraceFactory(this);
+            _sentryStackTraceFactoryAccessor = () => SentryStackTraceFactory;
+
             EventProcessors
                 = ImmutableList.Create<ISentryEventProcessor>(
                     // de-dupe to be the first to run
                     new DuplicateEventDetectionEventProcessor(this),
-                    new MainSentryEventProcessor(this, sentryStackTraceFactory));
+                    new MainSentryEventProcessor(this, _sentryStackTraceFactoryAccessor));
 
 #if SYSTEM_WEB
             EventProcessors = EventProcessors.Add(
@@ -355,7 +360,7 @@ public SentryOptions()
 
             ExceptionProcessors
                 = ImmutableList.Create<ISentryEventExceptionProcessor>(
-                    new MainExceptionProcessor(this, sentryStackTraceFactory));
+                    new MainExceptionProcessor(this, _sentryStackTraceFactoryAccessor));
 
             Integrations
                 = ImmutableList.Create<ISdkIntegration>(

src/Sentry/SentryOptionsExtensions.cs

@@ -127,13 +127,12 @@ public static IEnumerable<ISentryEventExceptionProcessor> GetAllExceptionProcess
         /// <param name="sentryStackTraceFactory">The stack trace factory.</param>
         public static SentryOptions UseStackTraceFactory(this SentryOptions options, ISentryStackTraceFactory sentryStackTraceFactory)
         {
-            if (sentryStackTraceFactory == null) throw new ArgumentNullException(nameof(sentryStackTraceFactory));
-
-            options.EventProcessors = options.EventProcessors.RemoveAt(1)
-                .Insert(1, new MainSentryEventProcessor(options, sentryStackTraceFactory));
+            if (sentryStackTraceFactory == null)
+            {
+                throw new ArgumentNullException(nameof(sentryStackTraceFactory));
+            }
 
-            options.ExceptionProcessors = options.ExceptionProcessors.RemoveAt(0)
-                .Insert(0, new MainExceptionProcessor(options, sentryStackTraceFactory));
+            options.SentryStackTraceFactory = sentryStackTraceFactory;
 
             return options;
         }

test/Sentry.Tests/Internals/MainExceptionProcessorTests.cs

@@ -13,7 +13,7 @@ private class Fixture
         {
             public ISentryStackTraceFactory SentryStackTraceFactory { get; set; } = Substitute.For<ISentryStackTraceFactory>();
             public SentryOptions SentryOptions { get; set; } = new SentryOptions();
-            public MainExceptionProcessor GetSut() => new MainExceptionProcessor(SentryOptions, SentryStackTraceFactory);
+            public MainExceptionProcessor GetSut() => new MainExceptionProcessor(SentryOptions, () => SentryStackTraceFactory);
         }
 
         private readonly Fixture _fixture = new Fixture();

test/Sentry.Tests/Internals/MainSentryEventProcessorTests.cs

@@ -16,7 +16,7 @@ private class Fixture
         {
             public ISentryStackTraceFactory SentryStackTraceFactory { get; set; } = Substitute.For<ISentryStackTraceFactory>();
             public SentryOptions SentryOptions { get; set; } = new SentryOptions();
-            public MainSentryEventProcessor GetSut() => new MainSentryEventProcessor(SentryOptions, SentryStackTraceFactory);
+            public MainSentryEventProcessor GetSut() => new MainSentryEventProcessor(SentryOptions, () => SentryStackTraceFactory);
         }
 
         private readonly Fixture _fixture = new Fixture();

test/Sentry.Tests/SentryOptionsExtensionsTests.cs

@@ -189,23 +189,25 @@ public void GetAllEventProcessors_NoAdding_SecondReturned_MainSentryEventProcess
         }
 
         [Fact]
-        public void UseStackTraceFactory()
+        public void UseStackTraceFactory_ReplacesStackTraceFactory()
         {
-            var eventProcessor1 = Sut.GetAllEventProcessors().Skip(1).First();
-            var exceptionProcessor1 = Sut.GetAllExceptionProcessors().First();
+            var expected = Substitute.For<ISentryStackTraceFactory>();
+            Sut.UseStackTraceFactory(expected);
 
-            Sut.UseStackTraceFactory(Substitute.For<ISentryStackTraceFactory>());
+            Assert.Same(expected, Sut.SentryStackTraceFactory);
+        }
 
-            var eventProcessor2 = Sut.GetAllEventProcessors().Skip(1).First();
-            var exceptionProcessor2 = Sut.GetAllExceptionProcessors().First();
+        [Fact]
+        public void UseStackTraceFactory_ReplacesStackTraceFactory_InCurrentProcessors()
+        {
+            var eventProcessor = Sut.GetAllEventProcessors().OfType<MainSentryEventProcessor>().Single();
+            var exceptionProcessor = Sut.GetAllExceptionProcessors().OfType<MainExceptionProcessor>().Single();
 
-            Assert.IsType<MainSentryEventProcessor>(eventProcessor1);
-            Assert.IsType<MainExceptionProcessor>(exceptionProcessor1);
-            Assert.IsType<MainSentryEventProcessor>(eventProcessor2);
-            Assert.IsType<MainExceptionProcessor>(exceptionProcessor2);
+            var expected = Substitute.For<ISentryStackTraceFactory>();
+            Sut.UseStackTraceFactory(expected);
 
-            Assert.NotEqual(eventProcessor1, eventProcessor2);
-            Assert.NotEqual(exceptionProcessor1, exceptionProcessor2);
+            Assert.Same(expected, eventProcessor.SentryStackTraceFactoryAccessor());
+            Assert.Same(expected, exceptionProcessor.SentryStackTraceFactoryAccessor());
         }
 
         [Fact]