Merge pull request #184 from pengweiqhca/EnhancedStackTrace

Custom SentryStackTraceFactory support

Author: bruno-garcia

src/Sentry.AspNetCore/ApplicationBuilderExtensions.cs

@@ -38,6 +38,12 @@ public static IApplicationBuilder UseSentry(this IApplicationBuilder app)
                     o.DiagnosticLogger = new MelDiagnosticLogger(logger, o.DiagnosticsLevel);
                 }
 
+                var stackTraceFactory = app.ApplicationServices.GetService<ISentryStackTraceFactory>();
+                if (stackTraceFactory != null)
+                {
+                    o.UseStackTraceFactory(stackTraceFactory);
+                }
+
                 if (app.ApplicationServices.GetService<IEnumerable<ISentryEventProcessor>>().Any())
                 {
                     o.AddEventProcessorProvider(app.ApplicationServices.GetServices<ISentryEventProcessor>);

src/Sentry/Internal/ISentryStackTraceFactory.cs renamed to src/Sentry/Extensibility/ISentryStackTraceFactory.cs

@@ -1,10 +1,10 @@
-using System;
+using System;
 using Sentry.Protocol;
 
-namespace Sentry.Internal
+namespace Sentry.Extensibility
 {
-    internal interface ISentryStackTraceFactory
+    public interface ISentryStackTraceFactory
     {
         SentryStackTrace Create(Exception exception = null);
     }
-}
+}

src/Sentry/Internal/SentryStackTraceFactory.cs renamed to src/Sentry/Extensibility/SentryStackTraceFactory.cs

@@ -4,12 +4,11 @@
 using System.Linq;
 using System.Reflection;
 using System.Text.RegularExpressions;
-using Sentry.Extensibility;
 using Sentry.Protocol;
 
-namespace Sentry.Internal
+namespace Sentry.Extensibility
 {
-    internal class SentryStackTraceFactory : ISentryStackTraceFactory
+    public class SentryStackTraceFactory : ISentryStackTraceFactory
     {
         private readonly SentryOptions _options;
 
@@ -27,13 +26,12 @@ public SentryStackTrace Create(Exception exception = null)
 
             _options.DiagnosticLogger?.LogDebug("Creating SentryStackTrace. isCurrentStackTrace: {0}.", isCurrentStackTrace);
 
-            var stackTrace = isCurrentStackTrace
-                ? new StackTrace(true)
-                : new StackTrace(exception, true);
-
-            return Create(stackTrace, isCurrentStackTrace);
+            return Create(CreateStackTrace(exception), isCurrentStackTrace);
         }
 
+        protected virtual StackTrace CreateStackTrace(Exception exception) =>
+            exception == null ? new StackTrace(true) : new StackTrace(exception, true);
+
         internal SentryStackTrace Create(StackTrace stackTrace, bool isCurrentStackTrace)
         {
             var frames = CreateFrames(stackTrace, isCurrentStackTrace)
@@ -77,19 +75,23 @@ internal IEnumerable<SentryStackFrame> CreateFrames(StackTrace stackTrace, bool
 
                 firstFrames = false;
 
-                var frame = CreateFrame(stackFrame);
+                var frame = CreateFrame(stackFrame, isCurrentStackTrace);
                 if (frame != null)
                 {
                     yield return frame;
                 }
             }
         }
 
-        internal SentryStackFrame CreateFrame(StackFrame stackFrame)
+        internal SentryStackFrame CreateFrame(StackFrame stackFrame) => InternalCreateFrame(stackFrame, true);
+
+        protected virtual SentryStackFrame CreateFrame(StackFrame stackFrame, bool isCurrentStackTrace) => InternalCreateFrame(stackFrame, true);
+
+        protected SentryStackFrame InternalCreateFrame(StackFrame stackFrame, bool demangle)
         {
             const string unknownRequiredField = "(unknown)";
             var frame = new SentryStackFrame();
-            if (stackFrame.GetMethod() is MethodBase method)
+            if (GetMethod(stackFrame) is MethodBase method)
             {
                 // TODO: SentryStackFrame.TryParse and skip frame instead of these unknown values:
                 frame.Module = method.DeclaringType?.FullName ?? unknownRequiredField;
@@ -120,13 +122,17 @@ internal SentryStackFrame CreateFrame(StackFrame stackFrame)
                 frame.ColumnNumber = colNo;
             }
 
-            // TODO: Consider Ben.Demystifier
-            DemangleAsyncFunctionName(frame);
-            DemangleAnonymousFunction(frame);
+            if (demangle)
+            {
+                DemangleAsyncFunctionName(frame);
+                DemangleAnonymousFunction(frame);
+            }
 
             return frame;
         }
 
+        protected virtual MethodBase GetMethod(StackFrame stackFrame) => stackFrame.GetMethod();
+
         private bool IsSystemModuleName(string moduleName)
         {
             if (string.IsNullOrEmpty(moduleName))

src/Sentry/SentryOptionsExtensions.cs

@@ -120,6 +120,24 @@ public static IEnumerable<ISentryEventProcessor> GetAllEventProcessors(this Sent
         public static IEnumerable<ISentryEventExceptionProcessor> GetAllExceptionProcessors(this SentryOptions options)
             => options.ExceptionProcessorsProviders.SelectMany(p => p());
 
+        /// <summary>
+        /// Use custom <see cref="ISentryStackTraceFactory" />
+        /// </summary>
+        /// <param name="options">The SentryOptions to hold the processor provider.</param>
+        /// <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));
+
+            options.ExceptionProcessors = options.ExceptionProcessors.RemoveAt(0)
+                .Insert(0, new MainExceptionProcessor(options, sentryStackTraceFactory));
+
+            return options;
+        }
+
         internal static void SetupLogging(this SentryOptions options)
         {
             if (options.Debug)

test/Sentry.Tests/Internals/MainExceptionProcessorTests.cs

@@ -1,13 +1,14 @@
 using System;
 using System.Linq;
 using NSubstitute;
+using Sentry.Extensibility;
 using Sentry.Internal;
 using Xunit;
 
 namespace Sentry.Tests.Internals
 {
     public class MainExceptionProcessorTests
-    {   
+    {
         private class Fixture
         {
             public ISentryStackTraceFactory SentryStackTraceFactory { get; set; } = Substitute.For<ISentryStackTraceFactory>();

test/Sentry.Tests/Internals/SentryStackTraceFactoryTests.cs

@@ -2,7 +2,7 @@
 using System.Diagnostics;
 using System.Linq;
 using Sentry;
-using Sentry.Internal;
+using Sentry.Extensibility;
 using Sentry.Protocol;
 using Xunit;
 

test/Sentry.Tests/SentryOptionsExtensionsTests.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Linq;
 using NSubstitute;
 using Sentry.Extensibility;
@@ -187,6 +188,32 @@ public void GetAllEventProcessors_NoAdding_SecondReturned_MainSentryEventProcess
             Assert.IsType<MainSentryEventProcessor>(Sut.GetAllEventProcessors().Skip(1).First());
         }
 
+        [Fact]
+        public void UseStackTraceFactory()
+        {
+            var eventProcessor1 = Sut.GetAllEventProcessors().Skip(1).First();
+            var exceptionProcessor1 = Sut.GetAllExceptionProcessors().First();
+
+            Sut.UseStackTraceFactory(Substitute.For<ISentryStackTraceFactory>());
+
+            var eventProcessor2 = Sut.GetAllEventProcessors().Skip(1).First();
+            var exceptionProcessor2 = Sut.GetAllExceptionProcessors().First();
+
+            Assert.IsType<MainSentryEventProcessor>(eventProcessor1);
+            Assert.IsType<MainExceptionProcessor>(exceptionProcessor1);
+            Assert.IsType<MainSentryEventProcessor>(eventProcessor2);
+            Assert.IsType<MainExceptionProcessor>(exceptionProcessor2);
+
+            Assert.NotEqual(eventProcessor1, eventProcessor2);
+            Assert.NotEqual(exceptionProcessor1, exceptionProcessor2);
+        }
+
+        [Fact]
+        public void UseStackTraceFactory_NotNull()
+        {
+            Assert.Throws<ArgumentNullException>(() => Sut.UseStackTraceFactory(null));
+        }
+
         [Fact]
         public void GetAllEventProcessors_AddingMore_FirstReturned_DuplicateDetectionProcessor()
         {