Support performance

CHANGELOG.md

@@ -8,6 +8,7 @@
 * 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
 
 ## 3.0.0-alpha.5
 

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>

src/Sentry.AspNetCore/ScopeExtensions.cs

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

src/Sentry.AspNetCore/SentryMiddleware.cs

@@ -2,13 +2,15 @@
 using System.Diagnostics;
 using System.Runtime.ExceptionServices;
 using System.Threading.Tasks;
+using System.Transactions;
 using Microsoft.AspNetCore.Diagnostics;
 #if NETSTANDARD2_0
 using IHostingEnvironment = Microsoft.AspNetCore.Hosting.IHostingEnvironment;
 #else
 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 +87,7 @@ public async Task InvokeAsync(HttpContext context)
                 {
                     context.Request.EnableBuffering();
                 }
+
                 if (_options.FlushOnCompletedRequest)
                 {
                     context.Response.OnCompleted(async () =>
@@ -94,6 +97,19 @@ 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}";
+
+                var transaction = hub.CreateTransaction(transactionName, "http.server");
+
                 hub.ConfigureScope(scope =>
                 {
                     // At the point lots of stuff from the request are not yet filled
@@ -105,8 +121,10 @@ public async Task InvokeAsync(HttpContext context)
 
                     scope.OnEvaluating += (_, __) => PopulateScope(context, scope);
                 });
+
                 try
                 {
+                    transaction.StartTimestamp = DateTimeOffset.Now;
                     await _next(context).ConfigureAwait(false);
 
                     // When an exception was handled by other component (i.e: UseExceptionHandler feature).
@@ -122,6 +140,12 @@ public async Task InvokeAsync(HttpContext context)
 
                     ExceptionDispatchInfo.Capture(e).Throw();
                 }
+                finally
+                {
+                    transaction.Finish(
+                        GetSpanStatusFromCode(context.Response.StatusCode)
+                    );
+                }
 
                 void CaptureException(Exception e)
                 {
@@ -161,5 +185,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

@@ -52,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, name, operation);
+
+        /// <summary>
+        /// Returns null.
+        /// </summary>
+        public SentryTraceHeader? GetTraceHeader() => null;
+
         /// <summary>
         /// No-Op.
         /// </summary>
@@ -64,6 +75,10 @@ public void BindClient(ISentryClient client)
         /// </summary>
         public SentryId CaptureEvent(SentryEvent evt, Scope? scope = null) => SentryId.Empty;
 
+        public void CaptureTransaction(Transaction transaction)
+        {
+        }
+
         /// <summary>
         /// No-Op.
         /// </summary>

src/Sentry/Extensibility/HubAdapter.cs

@@ -71,6 +71,14 @@ public IDisposable PushScope<TState>(TState state)
         public void WithScope(Action<Scope> scopeCallback)
             => SentrySdk.WithScope(scopeCallback);
 
+        [DebuggerStepThrough]
+        public Transaction CreateTransaction(string name, string operation)
+            => SentrySdk.CreateTransaction(name, operation);
+
+        [DebuggerStepThrough]
+        public SentryTraceHeader? GetTraceHeader()
+            => SentrySdk.GetTraceHeader();
+
         /// <summary>
         /// Forwards the call to <see cref="SentrySdk"/>.
         /// </summary>
@@ -132,6 +140,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

@@ -20,5 +20,9 @@ public interface IHub :
         /// Last event id recorded in the current scope.
         /// </summary>
         SentryId LastEventId { get; }
+
+        Transaction CreateTransaction(string name, string operation);
+
+        SentryTraceHeader? GetTraceHeader();
     }
 }

src/Sentry/ISentryClient.cs

@@ -28,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,7 @@
+namespace Sentry
+{
+    public interface ISentryTraceSampler
+    {
+        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,4 +1,5 @@
 using System;
+using System.Collections.Generic;
 using System.Diagnostics;
 using System.Threading.Tasks;
 using Sentry.Extensibility;
@@ -100,6 +101,20 @@ 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, name, operation);
+            ConfigureScope(scope => scope.Transaction = trans);
+
+            return trans;
+        }
+
+        public SentryTraceHeader? GetTraceHeader()
+        {
+            var (currentScope, _) = ScopeManager.GetCurrent();
+            return currentScope.Transaction?.GetTraceHeader();
+        }
+
         public SentryId CaptureEvent(SentryEvent evt, Scope? scope = null)
         {
             try
@@ -129,6 +144,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/Polyfills.cs

@@ -3,9 +3,16 @@
 // Polyfills to bridge the missing APIs in older versions of the framework/standard.
 // In some cases, these just proxy calls to existing methods but also provide a signature that matches .netstd2.1
 
-using System.Linq;
-
 #if NET461 || NETSTANDARD2_0
+namespace System
+{
+    internal static class Extensions
+    {
+        public static string[] Split(this string str, char c, StringSplitOptions options = StringSplitOptions.None) =>
+            str.Split(new[] {c}, options);
+    }
+}
+
 namespace System.IO
 {
     using Threading;
@@ -26,6 +33,8 @@ public static Task WriteAsync(this Stream stream, byte[] buffer, CancellationTok
 
 namespace System.Collections.Generic
 {
+    using Linq;
+
     internal static class Extensions
     {
         public static void Deconstruct<TKey, TValue>(

src/Sentry/Protocol/Envelopes/Envelope.cs

@@ -106,6 +106,24 @@ public static Envelope FromUserFeedback(UserFeedback sentryUserFeedback)
             return new Envelope(header, items);
         }
 
+        /// <summary>
+        /// Creates an envelope that contains a single transaction.
+        /// </summary>
+        public static Envelope FromTransaction(Transaction transaction)
+        {
+            var header = new Dictionary<string, object?>
+            {
+                [EventIdKey] = transaction.SpanId.ToString()
+            };
+
+            var items = new[]
+            {
+                EnvelopeItem.FromTransaction(transaction)
+            };
+
+            return new Envelope(header, items);
+        }
+
         private static async Task<IReadOnlyDictionary<string, object?>> DeserializeHeaderAsync(
             Stream stream,
             CancellationToken cancellationToken = default)