Support performance

CHANGELOG.md

@@ -12,6 +12,8 @@
 * Add `SentryScopeStateProcessor` #603
 * Add net5.0 TFM to libraries #606
 * Add more logging to CachingTransport #619
+* Bump Microsoft.Bcl.AsyncInterfaces to 5.0.0 #618
+* Add support for performance
 * Bump `Microsoft.Bcl.AsyncInterfaces` to 5.0.0 #618
 * `DefaultTags` moved from `SentryLoggingOptions` to `SentryOptions` (#637) @PureKrome
 * `Sentry.Serilog` can accept DefaultTags (#637) @PureKrome 

samples/Sentry.Samples.AspNetCore.Basic/Sentry.Samples.AspNetCore.Basic.csproj

@@ -1,7 +1,7 @@
 <Project Sdk="Microsoft.NET.Sdk.Web">
 
   <PropertyGroup>
-    <TargetFramework>netcoreapp2.1</TargetFramework>
+    <TargetFramework>net5.0</TargetFramework>
   </PropertyGroup>
 
   <ItemGroup>

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

@@ -139,7 +139,7 @@ await SentrySdk.ConfigureScopeAsync(async scope =>
             SentrySdk.WithScope(s =>
             {
                 s.Level = SentryLevel.Fatal;
-                s.Transaction = "main";
+                s.TransactionName = "main";
                 s.Environment = "SpecialEnvironment";
 
                 SentrySdk.CaptureMessage("Fatal message!");

src/Sentry.AspNetCore/ScopeExtensions.cs

@@ -87,7 +87,9 @@ public static void Populate(this Scope scope, HttpContext context, SentryAspNetC
                         scope.SetTag("route.area", area);
                     }
 
-                    scope.Transaction = area == null ? $"{controller}.{action}" : $"{area}.{controller}.{action}";
+                    scope.TransactionName = area == null
+                        ? $"{controller}.{action}"
+                        : $"{area}.{controller}.{action}";
                 }
             }
             catch(Exception e)

src/Sentry.AspNetCore/SentryMiddleware.cs

@@ -9,6 +9,7 @@
 using IHostingEnvironment = Microsoft.AspNetCore.Hosting.IWebHostEnvironment;
 #endif
 using Microsoft.AspNetCore.Http;
+using Microsoft.AspNetCore.Routing;
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Sentry.Extensibility;
@@ -85,6 +86,7 @@ public async Task InvokeAsync(HttpContext context)
                 {
                     context.Request.EnableBuffering();
                 }
+
                 if (_options.FlushOnCompletedRequest)
                 {
                     context.Response.OnCompleted(async () =>
@@ -94,6 +96,17 @@ public async Task InvokeAsync(HttpContext context)
                     });
                 }
 
+                var routeData = context.GetRouteData();
+                var controller = routeData.Values["controller"]?.ToString();
+                var action = routeData.Values["action"]?.ToString();
+                var area = routeData.Values["area"]?.ToString();
+
+                // TODO: What if it's not using controllers (i.e. endpoints)?
+
+                var transactionName = area == null
+                    ? $"{controller}.{action}"
+                    : $"{area}.{controller}.{action}";
+
                 hub.ConfigureScope(scope =>
                 {
                     // At the point lots of stuff from the request are not yet filled
@@ -105,6 +118,9 @@ public async Task InvokeAsync(HttpContext context)
 
                     scope.OnEvaluating += (_, __) => PopulateScope(context, scope);
                 });
+
+                var transaction = hub.CreateTransaction(transactionName, "http.server");
+
                 try
                 {
                     await _next(context).ConfigureAwait(false);
@@ -122,6 +138,12 @@ public async Task InvokeAsync(HttpContext context)
 
                     ExceptionDispatchInfo.Capture(e).Throw();
                 }
+                finally
+                {
+                    transaction.Finish(
+                        GetSpanStatusFromCode(context.Response.StatusCode)
+                    );
+                }
 
                 void CaptureException(Exception e)
                 {
@@ -161,5 +183,24 @@ internal void PopulateScope(HttpContext context, Scope scope)
                 scope.Populate(Activity.Current);
             }
         }
+
+        private static SpanStatus GetSpanStatusFromCode(int statusCode) => statusCode switch
+        {
+            < 400 => SpanStatus.Ok,
+            400 => SpanStatus.InvalidArgument,
+            401 => SpanStatus.Unauthenticated,
+            403 => SpanStatus.PermissionDenied,
+            404 => SpanStatus.NotFound,
+            409 => SpanStatus.AlreadyExists,
+            429 => SpanStatus.ResourceExhausted,
+            499 => SpanStatus.Cancelled,
+            < 500 => SpanStatus.InvalidArgument,
+            500 => SpanStatus.InternalError,
+            501 => SpanStatus.Unimplemented,
+            503 => SpanStatus.Unavailable,
+            504 => SpanStatus.DeadlineExceeded,
+            < 600 => SpanStatus.InternalError,
+            _ => SpanStatus.UnknownError
+        };
     }
 }

src/Sentry.AspNetCore/SentryStartupFilter.cs

@@ -7,12 +7,11 @@ namespace Sentry.AspNetCore
     /// <inheritdoc />
     internal class SentryStartupFilter : IStartupFilter
     {
-        public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next)
-            => e =>
-            {
-                _ = e.UseSentry();
+        public Action<IApplicationBuilder> Configure(Action<IApplicationBuilder> next) => e =>
+        {
+            e.UseSentry();
 
-                next(e);
-            };
+            next(e);
+        };
     }
 }

src/Sentry/Extensibility/DisabledHub.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using Sentry.Protocol;
 
 namespace Sentry.Extensibility
 {
@@ -51,6 +52,17 @@ public void WithScope(Action<Scope> scopeCallback)
         {
         }
 
+        /// <summary>
+        /// Returns a dummy transaction.
+        /// </summary>
+        public Transaction CreateTransaction(string name, string operation) =>
+            new Transaction(this, null);
+
+        /// <summary>
+        /// Returns null.
+        /// </summary>
+        public SentryTraceHeader? GetSentryTrace() => null;
+
         /// <summary>
         /// No-Op.
         /// </summary>
@@ -63,6 +75,13 @@ public void BindClient(ISentryClient client)
         /// </summary>
         public SentryId CaptureEvent(SentryEvent evt, Scope? scope = null) => SentryId.Empty;
 
+        /// <summary>
+        /// No-Op.
+        /// </summary>
+        public void CaptureTransaction(Transaction transaction)
+        {
+        }
+
         /// <summary>
         /// No-Op.
         /// </summary>

src/Sentry/Extensibility/HubAdapter.cs

@@ -71,6 +71,20 @@ public IDisposable PushScope<TState>(TState state)
         public void WithScope(Action<Scope> scopeCallback)
             => SentrySdk.WithScope(scopeCallback);
 
+        /// <summary>
+        /// Forwards the call to <see cref="SentrySdk"/>.
+        /// </summary>
+        [DebuggerStepThrough]
+        public Transaction CreateTransaction(string name, string operation)
+            => SentrySdk.CreateTransaction(name, operation);
+
+        /// <summary>
+        /// Forwards the call to <see cref="SentrySdk"/>.
+        /// </summary>
+        [DebuggerStepThrough]
+        public SentryTraceHeader? GetSentryTrace()
+            => SentrySdk.GetTraceHeader();
+
         /// <summary>
         /// Forwards the call to <see cref="SentrySdk"/>.
         /// </summary>
@@ -132,6 +146,14 @@ public SentryId CaptureException(Exception exception)
         public SentryId CaptureEvent(SentryEvent evt, Scope? scope)
             => SentrySdk.CaptureEvent(evt, scope);
 
+        /// <summary>
+        /// Forwards the call to <see cref="SentrySdk"/>.
+        /// </summary>
+        [DebuggerStepThrough]
+        [EditorBrowsable(EditorBrowsableState.Never)]
+        public void CaptureTransaction(Transaction transaction)
+            => SentrySdk.CaptureTransaction(transaction);
+
         /// <summary>
         /// Forwards the call to <see cref="SentrySdk"/>
         /// </summary>

src/Sentry/IHub.cs

@@ -1,3 +1,5 @@
+using Sentry.Protocol;
+
 namespace Sentry
 {
     /// <summary>
@@ -18,5 +20,15 @@ public interface IHub :
         /// Last event id recorded in the current scope.
         /// </summary>
         SentryId LastEventId { get; }
+
+        /// <summary>
+        /// Creates a transaction.
+        /// </summary>
+        Transaction CreateTransaction(string name, string operation);
+
+        /// <summary>
+        /// Gets the sentry trace header.
+        /// </summary>
+        SentryTraceHeader? GetSentryTrace();
     }
 }

src/Sentry/ISentryClient.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Threading.Tasks;
+using Sentry.Protocol;
 
 namespace Sentry
 {
@@ -27,6 +28,12 @@ public interface ISentryClient
         /// <param name="userFeedback">The user feedback to send to Sentry.</param>
         void CaptureUserFeedback(UserFeedback userFeedback);
 
+        /// <summary>
+        /// Captures a transaction.
+        /// </summary>
+        /// <param name="transaction">The transaction.</param>
+        void CaptureTransaction(Transaction transaction);
+
         /// <summary>
         /// Flushes events queued up.
         /// </summary>

src/Sentry/ISentryTraceSampler.cs

@@ -0,0 +1,13 @@
+namespace Sentry
+{
+    /// <summary>
+    /// Trace sampler.
+    /// </summary>
+    public interface ISentryTraceSampler
+    {
+        /// <summary>
+        /// Gets the sample rate based on context.
+        /// </summary>
+        double GetSampleRate(TraceSamplingContext context);
+    }
+}

src/Sentry/Internal/Extensions/JsonExtensions.cs

@@ -57,6 +57,15 @@ public static void WriteDictionaryValue(
             }
         }
 
+        public static void WriteDictionary(
+            this Utf8JsonWriter writer,
+            string propertyName,
+            IEnumerable<KeyValuePair<string, object?>>? dic)
+        {
+            writer.WritePropertyName(propertyName);
+            writer.WriteDictionaryValue(dic);
+        }
+
         public static void WriteDictionary(
             this Utf8JsonWriter writer,
             string propertyName,

src/Sentry/Internal/Hub.cs

@@ -1,8 +1,10 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading.Tasks;
 using Sentry.Extensibility;
 using Sentry.Integrations;
+using Sentry.Protocol;
 
 namespace Sentry.Internal
 {
@@ -99,6 +101,39 @@ public void WithScope(Action<Scope> scopeCallback)
 
         public void BindClient(ISentryClient client) => ScopeManager.BindClient(client);
 
+        public Transaction CreateTransaction(string name, string operation)
+        {
+            var trans = new Transaction(this, _options)
+            {
+                Name = name,
+                Operation = operation
+            };
+
+            var nameAndVersion = MainSentryEventProcessor.NameAndVersion;
+            var protocolPackageName = MainSentryEventProcessor.ProtocolPackageName;
+
+            if (trans.Sdk.Version == null && trans.Sdk.Name == null)
+            {
+                trans.Sdk.Name = Constants.SdkName;
+                trans.Sdk.Version = nameAndVersion.Version;
+            }
+
+            if (nameAndVersion.Version != null)
+            {
+                trans.Sdk.AddPackage(protocolPackageName, nameAndVersion.Version);
+            }
+
+            ConfigureScope(scope => scope.Transaction = trans);
+
+            return trans;
+        }
+
+        public SentryTraceHeader? GetSentryTrace()
+        {
+            var (currentScope, _) = ScopeManager.GetCurrent();
+            return currentScope.Transaction?.GetTraceHeader();
+        }
+
         public SentryId CaptureEvent(SentryEvent evt, Scope? scope = null)
         {
             try
@@ -128,6 +163,18 @@ public void CaptureUserFeedback(UserFeedback userFeedback)
             }
         }
 
+        public void CaptureTransaction(Transaction transaction)
+        {
+            try
+            {
+                _ownedClient.CaptureTransaction(transaction);
+            }
+            catch (Exception e)
+            {
+                _options.DiagnosticLogger?.LogError("Failure to capture transaction: {0}", e, transaction.SpanId);
+            }
+        }
+
         public async Task FlushAsync(TimeSpan timeout)
         {
             try

src/Sentry/Internal/MainSentryEventProcessor.cs

@@ -31,10 +31,10 @@ internal class MainSentryEventProcessor : ISentryEventProcessor
                    : null;
         });
 
-        private static readonly SdkVersion NameAndVersion
+        internal static readonly SdkVersion NameAndVersion
             = typeof(ISentryClient).Assembly.GetNameAndVersion();
 
-        private static readonly string ProtocolPackageName = "nuget:" + NameAndVersion.Name;
+        internal static readonly string ProtocolPackageName = "nuget:" + NameAndVersion.Name;
 
         private readonly SentryOptions _options;
         internal Func<ISentryStackTraceFactory> SentryStackTraceFactoryAccessor { get; }
@@ -96,20 +96,17 @@ public SentryEvent Process(SentryEvent @event)
 
             @event.Platform = Protocol.Constants.Platform;
 
-            if (@event.Sdk != null)
+            // SDK Name/Version might have be already set by an outer package
+            // e.g: ASP.NET Core can set itself as the SDK
+            if (@event.Sdk.Version == null && @event.Sdk.Name == null)
             {
-                // SDK Name/Version might have be already set by an outer package
-                // e.g: ASP.NET Core can set itself as the SDK
-                if (@event.Sdk.Version == null && @event.Sdk.Name == null)
-                {
-                    @event.Sdk.Name = Constants.SdkName;
-                    @event.Sdk.Version = NameAndVersion.Version;
-                }
+                @event.Sdk.Name = Constants.SdkName;
+                @event.Sdk.Version = NameAndVersion.Version;
+            }
 
-                if (NameAndVersion.Version != null)
-                {
-                    @event.Sdk.AddPackage(ProtocolPackageName, NameAndVersion.Version);
-                }
+            if (NameAndVersion.Version != null)
+            {
+                @event.Sdk.AddPackage(ProtocolPackageName, NameAndVersion.Version);
             }
 
             // Report local user if opt-in PII, no user was already set to event and feature not opted-out: