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
 

src/Sentry.AspNetCore/SentryMiddleware.cs

@@ -104,7 +104,9 @@ public async Task InvokeAsync(HttpContext context)
                     // event creation will be sent to Sentry
 
                     scope.OnEvaluating += (_, __) => PopulateScope(context, scope);
+                    scope.Transaction.StartTimestamp = DateTimeOffset.Now;
                 });
+
                 try
                 {
                     await _next(context).ConfigureAwait(false);
@@ -122,6 +124,13 @@ public async Task InvokeAsync(HttpContext context)
 
                     ExceptionDispatchInfo.Capture(e).Throw();
                 }
+                finally
+                {
+                    hub.ConfigureScope(scope =>
+                    {
+                        scope.Transaction.Finish();
+                    });
+                }
 
                 void CaptureException(Exception e)
                 {

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.AspNetCore/SpanStatusMapper.cs

@@ -0,0 +1,23 @@
+using Sentry.Protocol;
+
+namespace Sentry.AspNetCore
+{
+    internal static class SpanStatusMapper
+    {
+        public static SpanStatus FromStatusCode(int statusCode) => statusCode switch
+        {
+            400 => SpanStatus.InvalidArgument,
+            401 => SpanStatus.Unauthenticated,
+            403 => SpanStatus.PermissionDenied,
+            404 => SpanStatus.NotFound,
+            409 => SpanStatus.AlreadyExists,
+            429 => SpanStatus.ResourceExhausted,
+            499 => SpanStatus.Cancelled,
+            500 => SpanStatus.InternalError,
+            501 => SpanStatus.Unimplemented,
+            503 => SpanStatus.Unavailable,
+            504 => SpanStatus.DeadlineExceeded,
+            _   => SpanStatus.UnknownError
+        };
+    }
+}

src/Sentry/ISentryTraceSampler.cs

@@ -0,0 +1,7 @@
+namespace Sentry
+{
+    public interface ISentryTraceSampler
+    {
+        double GetSampleRate();
+    }
+}

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/Protocol/Envelopes/Envelope.cs

@@ -106,6 +106,25 @@ 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>
+            {
+                // TODO: Is this right?
+                [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)

src/Sentry/Protocol/Envelopes/EnvelopeItem.cs

@@ -18,6 +18,7 @@ internal sealed class EnvelopeItem : ISerializable, IDisposable
         private const string TypeKey = "type";
         private const string TypeValueEvent = "event";
         private const string TypeValueUserReport = "user_report";
+        private const string TypeValueTransaction = "transaction";
         private const string LengthKey = "length";
         private const string FileNameKey = "file_name";
 
@@ -176,6 +177,19 @@ public static EnvelopeItem FromUserFeedback(UserFeedback sentryUserFeedback)
             return new EnvelopeItem(header, new JsonSerializable(sentryUserFeedback));
         }
 
+        /// <summary>
+        /// Creates an envelope item from transaction.
+        /// </summary>
+        public static EnvelopeItem FromTransaction(Transaction transaction)
+        {
+            var header = new Dictionary<string, object>(StringComparer.Ordinal)
+            {
+                [TypeKey] = TypeValueTransaction
+            };
+
+            return new EnvelopeItem(header, new JsonSerializable(transaction));
+        }
+
         private static async Task<IReadOnlyDictionary<string, object?>> DeserializeHeaderAsync(
             Stream stream,
             CancellationToken cancellationToken = default)
@@ -237,6 +251,18 @@ private static async Task<ISerializable> DeserializePayloadAsync(
                 );
             }
 
+            // Transaction
+            if (string.Equals(payloadType, TypeValueTransaction, StringComparison.OrdinalIgnoreCase))
+            {
+                var bufferLength = (int)(payloadLength ?? stream.Length);
+                var buffer = await stream.ReadByteChunkAsync(bufferLength, cancellationToken).ConfigureAwait(false);
+                using var jsonDocument = JsonDocument.Parse(buffer);
+
+                return new JsonSerializable(
+                    Transaction.FromJson(jsonDocument.RootElement.Clone())
+                );
+            }
+
             // Arbitrary payload
             var payloadStream = new PartialStream(stream, stream.Position, payloadLength);
 

src/Sentry/Protocol/IScope.cs

@@ -28,17 +28,6 @@ public interface IScope
         /// </summary>
         SentryLevel? Level { get; set; }
 
-        /// <summary>
-        /// The name of the transaction in which there was an event.
-        /// </summary>
-        /// <remarks>
-        /// A transaction should only be defined when it can be well defined.
-        /// On a Web framework, for example, a transaction is the route template
-        /// rather than the actual request path. That is so GET /user/10 and /user/20
-        /// (which have route template /user/{id}) are identified as the same transaction.
-        /// </remarks>
-        string? Transaction { get; set; }
-
         /// <summary>
         /// Gets or sets the HTTP.
         /// </summary>

src/Sentry/Protocol/ISpan.cs

@@ -0,0 +1,34 @@
+using System;
+using System.Collections.Generic;
+
+namespace Sentry.Protocol
+{
+    public interface ISpan
+    {
+        SentryId SpanId { get; }
+
+        SentryId? ParentSpanId { get; }
+
+        SentryId TraceId { get; set; }
+
+        DateTimeOffset StartTimestamp { get; set; }
+
+        DateTimeOffset EndTimestamp { get; set; }
+
+        string? Operation { get; set; }
+
+        string? Description { get; set; }
+
+        SpanStatus? Status { get; set; }
+
+        bool IsSampled { get; set; }
+
+        IReadOnlyDictionary<string, string> Tags { get; }
+
+        IReadOnlyDictionary<string, object> Data { get; }
+
+        ISpan StartChild();
+
+        void Finish();
+    }
+}

src/Sentry/Protocol/SentryEvent.cs

@@ -111,7 +111,15 @@ public IEnumerable<SentryThread>? SentryThreads
         /// <inheritdoc />
         public SentryLevel? Level { get; set; }
 
-        /// <inheritdoc />
+        /// <summary>
+        /// The name of the transaction in which there was an event.
+        /// </summary>
+        /// <remarks>
+        /// A transaction should only be defined when it can be well defined.
+        /// On a Web framework, for example, a transaction is the route template
+        /// rather than the actual request path. That is so GET /user/10 and /user/20
+        /// (which have route template /user/{id}) are identified as the same transaction.
+        /// </remarks>
         public string? Transaction { get; set; }
 
         private Request? _request;

src/Sentry/Protocol/SentryId.cs

@@ -39,6 +39,11 @@ namespace Sentry.Protocol
         /// <inheritdoc />
         public override int GetHashCode() => _eventId.GetHashCode();
 
+        /// <summary>
+        /// Generates a new Sentry ID.
+        /// </summary>
+        public static SentryId Create() => new SentryId(Guid.NewGuid());
+
         /// <inheritdoc />
         public void WriteTo(Utf8JsonWriter writer) => writer.WriteStringValue(ToString());
 

src/Sentry/Protocol/Span.cs

@@ -0,0 +1,116 @@
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.Json;
+using Sentry.Internal.Extensions;
+
+namespace Sentry.Protocol
+{
+    // https://develop.sentry.dev/sdk/event-payloads/span
+    public class Span : ISpan, IJsonSerializable
+    {
+        public SentryId SpanId { get; }
+        public SentryId? ParentSpanId { get; }
+        public SentryId TraceId { get; set; }
+        public DateTimeOffset StartTimestamp { get; set; }
+        public DateTimeOffset EndTimestamp { get; set; }
+        public string? Operation { get; set; }
+        public string? Description { get; set; }
+        public SpanStatus? Status { get; set; }
+        public bool IsSampled { get; set; }
+
+        private ConcurrentDictionary<string, string>? _tags;
+        public IReadOnlyDictionary<string, string> Tags => _tags ??= new ConcurrentDictionary<string, string>();
+
+        private ConcurrentDictionary<string, object>? _data;
+        public IReadOnlyDictionary<string, object> Data => _data ??= new ConcurrentDictionary<string, object>();
+
+        public Span(SentryId? spanId = null, SentryId? parentSpanId = null)
+        {
+            SpanId = spanId ?? SentryId.Create();
+            ParentSpanId = parentSpanId;
+            StartTimestamp = EndTimestamp = DateTimeOffset.Now;
+        }
+
+        public ISpan StartChild() => new Span(parentSpanId: SpanId);
+
+        public void Finish()
+        {
+            EndTimestamp = DateTimeOffset.Now;
+        }
+
+        public void WriteTo(Utf8JsonWriter writer)
+        {
+            writer.WriteStartObject();
+
+            writer.WriteString("span_id", SpanId);
+
+            if (ParentSpanId is {} parentSpanId)
+            {
+                writer.WriteString("parent_span_id", parentSpanId);
+            }
+
+            writer.WriteString("trace_id", TraceId);
+            writer.WriteString("start_timestamp", StartTimestamp);
+            writer.WriteString("timestamp", EndTimestamp);
+
+            if (!string.IsNullOrWhiteSpace(Operation))
+            {
+                writer.WriteString("op", Operation);
+            }
+
+            if (!string.IsNullOrWhiteSpace(Description))
+            {
+                writer.WriteString("description", Description);
+            }
+
+            if (Status is {} status)
+            {
+                writer.WriteString("status", status.ToString().ToLowerInvariant());
+            }
+
+            writer.WriteBoolean("sampled", IsSampled);
+
+            if (_tags is {} tags && tags.Any())
+            {
+                writer.WriteDictionary("tags", tags!);
+            }
+
+            if (_data is {} data && data.Any())
+            {
+                writer.WriteDictionary("data", data!);
+            }
+
+            writer.WriteEndObject();
+        }
+
+        public static Span FromJson(JsonElement json)
+        {
+            var spanId = json.GetPropertyOrNull("span_id")?.Pipe(SentryId.FromJson) ?? SentryId.Empty;
+            var parentSpanId = json.GetPropertyOrNull("parent_span_id")?.Pipe(SentryId.FromJson);
+            var traceId = json.GetPropertyOrNull("trace_id")?.Pipe(SentryId.FromJson) ?? SentryId.Empty;
+            var startTimestamp = json.GetPropertyOrNull("start_timestamp")?.GetDateTimeOffset() ?? default;
+            var endTimestamp = json.GetPropertyOrNull("timestamp")?.GetDateTimeOffset() ?? default;
+            var operation = json.GetPropertyOrNull("op")?.GetString();
+            var description = json.GetPropertyOrNull("description")?.GetString();
+            var status = json.GetPropertyOrNull("status")?.GetString()?.Pipe(s => s.ParseEnum<SpanStatus>());
+            var sampled = json.GetPropertyOrNull("sampled")?.GetBoolean() ?? false;
+            var tags = json.GetPropertyOrNull("tags")?.GetDictionary()?.Pipe(v => new ConcurrentDictionary<string, string>(v!));
+            var data = json.GetPropertyOrNull("data")?.GetObjectDictionary()?.Pipe(v => new ConcurrentDictionary<string, object>(v!));
+
+            return new Span(spanId, parentSpanId)
+            {
+                TraceId = traceId,
+                StartTimestamp = startTimestamp,
+                EndTimestamp = endTimestamp,
+                Operation = operation,
+                Description = description,
+                Status = status,
+                IsSampled = sampled,
+                _tags = tags,
+                _data = data
+            };
+        }
+    }
+}