feat: Profiling

CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+### Features
+
+- Initial work to support profiling in a future release. ([#2206](https://github.com/getsentry/sentry-dotnet/pull/2206))
+
 ### Fixes
 
 - Buffer payloads asynchronously when appropriate ([#2297](https://github.com/getsentry/sentry-dotnet/pull/2297))

Sentry.sln

@@ -172,6 +172,12 @@ Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sentry.AspNetCore.TestUtils
 EndProject
 Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sentry.Android.AssemblyReader", "src\Sentry.Android.AssemblyReader\Sentry.Android.AssemblyReader.csproj", "{ED5E4F7E-8267-4F3C-BD2A-779AC9BF3D7C}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sentry.Profiling", "src\Sentry.Profiling\Sentry.Profiling.csproj", "{BD6CEF44-E05E-4C22-8D2F-0558A93DD2D6}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sentry.Profiling.Tests", "test\Sentry.Profiling.Tests\Sentry.Profiling.Tests.csproj", "{2E750A7C-561D-4959-B967-042755139D84}"
+EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sentry.Samples.Console.Profiling", "samples\Sentry.Samples.Console.Profiling\Sentry.Samples.Console.Profiling.csproj", "{0F84C0BB-FDD4-43A9-B594-923EB10C8E3F}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -415,6 +421,18 @@ Global
 		{ED5E4F7E-8267-4F3C-BD2A-779AC9BF3D7C}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{ED5E4F7E-8267-4F3C-BD2A-779AC9BF3D7C}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{ED5E4F7E-8267-4F3C-BD2A-779AC9BF3D7C}.Release|Any CPU.Build.0 = Release|Any CPU
+		{BD6CEF44-E05E-4C22-8D2F-0558A93DD2D6}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{BD6CEF44-E05E-4C22-8D2F-0558A93DD2D6}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{BD6CEF44-E05E-4C22-8D2F-0558A93DD2D6}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{BD6CEF44-E05E-4C22-8D2F-0558A93DD2D6}.Release|Any CPU.Build.0 = Release|Any CPU
+		{2E750A7C-561D-4959-B967-042755139D84}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{2E750A7C-561D-4959-B967-042755139D84}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{2E750A7C-561D-4959-B967-042755139D84}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{2E750A7C-561D-4959-B967-042755139D84}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0F84C0BB-FDD4-43A9-B594-923EB10C8E3F}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0F84C0BB-FDD4-43A9-B594-923EB10C8E3F}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0F84C0BB-FDD4-43A9-B594-923EB10C8E3F}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0F84C0BB-FDD4-43A9-B594-923EB10C8E3F}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -481,6 +499,9 @@ Global
 		{5E12E053-22AF-4184-8581-3FCFD225617D} = {83263231-1A2A-4733-B759-EEFF14E8C5D5}
 		{C96CB65D-3D2D-404E-85C0-69A3FC03B48F} = {83263231-1A2A-4733-B759-EEFF14E8C5D5}
 		{ED5E4F7E-8267-4F3C-BD2A-779AC9BF3D7C} = {AF6AF4C7-8AA2-4D59-8064-2D79560904EB}
+		{BD6CEF44-E05E-4C22-8D2F-0558A93DD2D6} = {AF6AF4C7-8AA2-4D59-8064-2D79560904EB}
+		{2E750A7C-561D-4959-B967-042755139D84} = {83263231-1A2A-4733-B759-EEFF14E8C5D5}
+		{0F84C0BB-FDD4-43A9-B594-923EB10C8E3F} = {77454495-55EE-4B40-A089-71B9E8F82E89}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {0C652B1A-DF72-4EE5-A98B-194FE2C054F6}

benchmarks/Sentry.Benchmarks/StackFrameBenchmarks.cs

@@ -145,7 +145,7 @@ public void ConfigureAppFrame()
           Module ="Sentry.Extensions.Profiling"
         },
         new SentryStackFrame() {
-          Function ="SamplingTransactionProfiler.OnTransactionStart(class Sentry.ITransaction) {QuickJitted}",
+          Function ="SamplingTransactionProfiler.Start(class Sentry.ITransaction) {QuickJitted}",
           Module ="Sentry.Extensions.Profiling"
         },
         new SentryStackFrame() {

samples/Sentry.Samples.Console.Profiling/Program.cs

@@ -0,0 +1,323 @@
+using System.Reflection;
+using System.Xml.Xsl;
+using Sentry;
+using Sentry.Extensibility;
+using Sentry.Profiling;
+
+// One of the ways to set your DSN is via an attribute:
+// It could be set via AssemblyInfo.cs and patched via CI.
+// Other ways are via environment variable, configuration files and explicitly via parameter to Init
+[assembly: Dsn(Program.DefaultDsn)]
+// Tracks the release which sent the event and enables more features: https://docs.sentry.io/learn/releases/
+// Much like the DSN above, this is only one of the ways to define the release.
+// If not set here, it can also be defined via appsettings.json, environment variable 'SENTRY_RELEASE' and AssemblyVersion
+// STANDARD_CI_SOURCE_REVISION_ID -> TeamCity: %build.vcs.number%, VSTS: BUILD_SOURCEVERSION, Travis-CI: TRAVIS_COMMIT, AppVeyor: APPVEYOR_REPO_COMMIT, CircleCI: CIRCLE_SHA1
+[assembly: AssemblyInformationalVersion("e386dfd")]
+
+internal static class Program
+{
+    public const string DefaultDsn = "https://[email protected]/5428537";
+    // A different DSN for a section of the app (i.e: admin)
+    public const string AdminDsn = "https://[email protected]/259314";
+
+    private static async Task Main()
+    {
+        // When the SDK is disabled, no callback is executed:
+        await SentrySdk.ConfigureScopeAsync(async scope =>
+        {
+            // Never executed:
+            // This could be any async I/O operation, like a DB query
+            await Task.Yield();
+            scope.SetExtra("Key", "Value");
+        });
+
+        // Enable the SDK
+        using (SentrySdk.Init(o =>
+        {
+            // Send stack trace for events that were not created from an exception
+            // e.g: CaptureMessage, log.LogDebug, log.LogInformation ...
+            o.AttachStacktrace = true;
+
+            // Sentry won't consider code from namespace LibraryX.* as part of the app code and will hide it from the stacktrace by default
+            // To see the lines from non `AppCode`, select `Full`. Will include non App code like System.*, Microsoft.* and LibraryX.*
+            o.AddInAppExclude("LibraryX.");
+
+            // Before excluding all prefixed 'LibraryX.', any stack trace from a type namespaced 'LibraryX.Core' will be considered InApp.
+            o.AddInAppInclude("LibraryX.Core");
+
+            // Send personal identifiable information like the username logged on to the computer and machine name
+            o.SendDefaultPii = true;
+
+            // To enable event sampling, uncomment:
+            // o.SampleRate = 0.5f; // Randomly drop (don't send to Sentry) half of events
+
+            // Modifications to event before it goes out. Could replace the event altogether
+            o.BeforeSend = @event =>
+            {
+                // Drop an event altogether:
+                if (@event.Tags.ContainsKey("SomeTag"))
+                {
+                    return null;
+                }
+
+                return @event;
+            };
+
+            // Allows inspecting and modifying, returning a new or simply rejecting (returning null)
+            o.BeforeBreadcrumb = crumb =>
+            {
+                // Don't add breadcrumbs with message containing:
+                if (crumb.Message?.Contains("bad breadcrumb") == true)
+                {
+                    return null;
+                }
+
+                return crumb;
+            };
+
+            // Ignore exception by its type:
+            o.AddExceptionFilterForType<XsltCompileException>();
+
+            // Configure the background worker which sends events to sentry:
+            // Wait up to 5 seconds before shutdown while there are events to send.
+            o.ShutdownTimeout = TimeSpan.FromSeconds(5);
+
+            // Enable SDK logging with Debug level
+            o.Debug = true;
+            // To change the verbosity, use:
+            // o.DiagnosticLevel = SentryLevel.Info;
+            // To use a custom logger:
+            // o.DiagnosticLogger = ...
+
+            // Using a proxy:
+            o.HttpProxy = null; //new WebProxy("https://localhost:3128");
+
+            // Example customizing the HttpClientHandlers created
+            o.CreateHttpClientHandler = () => new HttpClientHandler
+            {
+                ServerCertificateCustomValidationCallback = (_, certificate, _, _) =>
+                    !certificate.Archived
+            };
+
+            // Access to the HttpClient created to serve the SentryClint
+            o.ConfigureClient = client => client.DefaultRequestHeaders.TryAddWithoutValidation("CustomHeader", new[] { "my value" });
+
+            // Control/override how to apply the State object into the scope
+            o.SentryScopeStateProcessor = new MyCustomerScopeStateProcessor();
+
+            o.TracesSampleRate = 1.0;
+
+            o.AddIntegration(new ProfilingIntegration(Path.GetTempPath()));
+        }))
+        {
+            var tx = SentrySdk.StartTransaction("app", "run");
+            // Ignored by its type due to the setting above
+            SentrySdk.CaptureException(new XsltCompileException());
+
+            SentrySdk.AddBreadcrumb(
+                "A 'bad breadcrumb' that will be rejected because of 'BeforeBreadcrumb callback above.'");
+
+            // Data added to the root scope (no PushScope called up to this point)
+            // The modifications done here will affect all events sent and will propagate to child scopes.
+            await SentrySdk.ConfigureScopeAsync(async scope =>
+            {
+                scope.AddEventProcessor(new SomeEventProcessor());
+                scope.AddExceptionProcessor(new ArgumentExceptionProcessor());
+
+                // This could be any async I/O operation, like a DB query
+                await Task.Yield();
+                scope.SetExtra("SomeExtraInfo",
+                    new
+                    {
+                        Data = "Value fetched asynchronously",
+                        ManaLevel = 199
+                    });
+            });
+
+            // Configures a scope which is only valid within the callback
+            SentrySdk.CaptureMessage("Fatal message!", s =>
+            {
+                s.Level = SentryLevel.Fatal;
+                s.TransactionName = "main";
+                s.Environment = "SpecialEnvironment";
+
+                // Add a file attachment for upload
+                s.AddAttachment(typeof(Program).Assembly.Location);
+            });
+
+            FindPrimeNumber(100000);
+            var eventId = SentrySdk.CaptureMessage("Some warning!", SentryLevel.Warning);
+
+            // Send an user feedback linked to the warning.
+            var timestamp = DateTime.Now.Ticks;
+            var user = $"user{timestamp}";
+            var email = $"user{timestamp}@user{timestamp}.com";
+
+            SentrySdk.CaptureUserFeedback(new UserFeedback(eventId, user, email, "this is a sample user feedback"));
+
+            var error = new Exception("Attempting to send this multiple times");
+
+            // Only the first capture will be sent to Sentry
+            for (var i = 0; i < 3; i++)
+            {
+                // The SDK is able to detect duplicate events:
+                // This is useful, for example, when multiple loggers log the same exception. Or exception is re-thrown and recaptured.
+                SentrySdk.CaptureException(error);
+            }
+
+            var count = 10;
+            for (var i = 0; i < count; i++)
+            {
+                const string msg = "{0} of {1} items we'll wait to flush to Sentry!";
+                SentrySdk.CaptureEvent(new SentryEvent
+                {
+                    Message = new SentryMessage
+                    {
+                        Message = msg,
+                        Formatted = string.Format(msg, i, count)
+                    },
+                    Level = SentryLevel.Debug
+                });
+
+                FindPrimeNumber(100000);
+            }
+            // Console output will show queue being flushed.
+            await SentrySdk.FlushAsync();
+
+            // -------------------------
+
+            // A custom made client, that could be registered with DI,
+            // would get disposed by the container on app shutdown
+
+            var evt = new SentryEvent
+            {
+                Message = "Starting new client"
+            };
+            evt.AddBreadcrumb("Breadcrumb directly to the event");
+            evt.User.Username = "some@user";
+            // Group all events with the following fingerprint:
+            evt.SetFingerprint("NewClientDebug");
+            evt.Level = SentryLevel.Debug;
+            SentrySdk.CaptureEvent(evt);
+
+            // Using a different DSN:
+            using (var adminClient = new SentryClient(new SentryOptions { Dsn = AdminDsn }))
+            {
+                // Make believe web framework middleware
+                var middleware = new AdminPartMiddleware(adminClient, null);
+                var request = new { Path = "/admin" }; // made up request
+                middleware.Invoke(request);
+            } // Dispose the client which flushes any queued events
+
+            SentrySdk.CaptureException(
+                new Exception("Error outside of the admin section: Goes to the default DSN"));
+
+            tx.Finish();
+        }  // On Dispose: SDK closed, events queued are flushed/sent to Sentry
+    }
+
+    private static long FindPrimeNumber(int n)
+    {
+        int count = 0;
+        long a = 2;
+        while (count < n)
+        {
+            long b = 2;
+            int prime = 1;// to check if found a prime
+            while (b * b <= a)
+            {
+                if (a % b == 0)
+                {
+                    prime = 0;
+                    break;
+                }
+                b++;
+            }
+            if (prime > 0)
+            {
+                count++;
+            }
+            a++;
+        }
+        return (--a);
+    }
+
+    private class AdminPartMiddleware
+    {
+        private readonly ISentryClient _adminClient;
+        private readonly dynamic _middleware;
+
+        public AdminPartMiddleware(ISentryClient adminClient, dynamic middleware)
+        {
+            _adminClient = adminClient;
+            _middleware = middleware;
+        }
+
+        public void Invoke(dynamic request)
+        {
+            using (SentrySdk.PushScope(new SpecialContextObject()))
+            {
+                SentrySdk.AddBreadcrumb(request.Path, "request-path");
+
+                // Change the SentryClient in case the request is to the admin part:
+                if (request.Path.StartsWith("/admin"))
+                {
+                    // Within this scope, the _adminClient will be used instead of whatever
+                    // client was defined before this point:
+                    SentrySdk.BindClient(_adminClient);
+                }
+
+                SentrySdk.CaptureException(new Exception("Error at the admin section"));
+                // Else it uses the default client
+
+                _middleware?.Invoke(request);
+            } // Scope is disposed.
+        }
+    }
+
+    private class SomeEventProcessor : ISentryEventProcessor
+    {
+        public SentryEvent Process(SentryEvent @event)
+        {
+            // Here you can modify the event as you need
+            if (@event.Level > SentryLevel.Info)
+            {
+                @event.AddBreadcrumb("Processed by " + nameof(SomeEventProcessor));
+            }
+
+            return @event;
+        }
+    }
+
+    private class ArgumentExceptionProcessor : SentryEventExceptionProcessor<ArgumentException>
+    {
+        protected override void ProcessException(ArgumentException exception, SentryEvent sentryEvent)
+        {
+            // Handle specific types of exceptions and add more data to the event
+            sentryEvent.SetTag("parameter-name", exception.ParamName);
+        }
+    }
+
+    private class MyCustomerScopeStateProcessor : ISentryScopeStateProcessor
+    {
+        private readonly ISentryScopeStateProcessor _fallback = new DefaultSentryScopeStateProcessor();
+
+        public void Apply(Scope scope, object state)
+        {
+            if (state is SpecialContextObject specialState)
+            {
+                scope.SetTag("SpecialContextObject", specialState.A + specialState.B);
+            }
+            else
+            {
+                _fallback.Apply(scope, state);
+            }
+        }
+    }
+
+    private class SpecialContextObject
+    {
+        public string A { get; } = "hello";
+        public string B { get; } = "world";
+    }
+}

samples/Sentry.Samples.Console.Profiling/Sentry.Samples.Console.Profiling.csproj

@@ -0,0 +1,12 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFrameworks>net6.0</TargetFrameworks>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\..\src\Sentry\Sentry.csproj" />
+    <ProjectReference Include="..\..\src\Sentry.Profiling\Sentry.Profiling.csproj" />
+  </ItemGroup>
+</Project>