Added trace origin to distinguish Sentry traces from custom instrumented traces (#3400)

Author: jamescrosswell

Diff for: Sentry.sln.DotSettings

@@ -1,4 +1,5 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=EF/@EntryIndexedValue">EF</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=IO/@EntryIndexedValue">IO</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=OS/@EntryIndexedValue">OS</s:String>
 	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=QL/@EntryIndexedValue">QL</s:String>

Diff for: src/Sentry.AspNet/HttpContextExtensions.cs

@@ -1,4 +1,5 @@
 using Sentry.Extensibility;
+using Sentry.Protocol;
 
 namespace Sentry.AspNet;
 
@@ -9,6 +10,7 @@ namespace Sentry.AspNet;
 public static class HttpContextExtensions
 {
     private const string HttpContextTransactionItemName = "__SentryTransaction";
+    internal const string AspNetOrigin = "auto.http.aspnet";
 
     private static SentryTraceHeader? TryGetSentryTraceHeader(HttpContext context, SentryOptions? options)
     {
@@ -114,6 +116,7 @@ public static ITransactionTracer StartSentryTransaction(this HttpContext httpCon
         }
 
         var transaction = SentrySdk.StartTransaction(transactionContext, customSamplingContext, dynamicSamplingContext);
+        transaction.Contexts.Trace.Origin = AspNetOrigin;
 
         SentrySdk.ConfigureScope(scope => scope.Transaction = transaction);
         httpContext.Items[HttpContextTransactionItemName] = transaction;

Diff for: src/Sentry.AspNetCore/SentryTracingMiddleware.cs

@@ -12,6 +12,7 @@ namespace Sentry.AspNetCore;
 internal class SentryTracingMiddleware
 {
     private const string OperationName = "http.server";
+    internal const string AspNetCoreOrigin = "auto.http.aspnetcore";
 
     private readonly RequestDelegate _next;
     private readonly Func<IHub> _getHub;
@@ -78,6 +79,7 @@ public SentryTracingMiddleware(
             }
 
             var transaction = _getHub().StartTransaction(transactionContext, customSamplingContext, dynamicSamplingContext);
+            transaction.Contexts.Trace.Origin = AspNetCoreOrigin;
 
             _options.LogInfo(
                 "Started transaction with span ID '{0}' and trace ID '{1}'.",

Diff for: src/Sentry.Azure.Functions.Worker/SentryFunctionsWorkerMiddleware.cs

@@ -8,6 +8,7 @@ namespace Sentry.Azure.Functions.Worker;
 internal class SentryFunctionsWorkerMiddleware : IFunctionsWorkerMiddleware
 {
     private const string Operation = "function";
+    internal const string AzureFunctionsOrigin = "auto.function.azure";
 
     private readonly IHub _hub;
     private readonly IDiagnosticLogger? _logger;
@@ -23,6 +24,7 @@ public async Task Invoke(FunctionContext context, FunctionExecutionDelegate next
     {
         var transactionContext = await StartOrContinueTraceAsync(context);
         var transaction = _hub.StartTransaction(transactionContext);
+        transaction.Contexts.Trace.Origin = AzureFunctionsOrigin;
         Exception? unhandledException = null;
 
         try
@@ -98,7 +100,7 @@ private async Task<TransactionContext> StartOrContinueTraceAsync(FunctionContext
         // Note that, when Trimming is enabled, we can't use reflection to read route data from the HttpTrigger
         // attribute. In that case the route name will always be /api/<FUNCTION_NAME>
         // If this is ever a problem for customers, we can potentially see if there are alternate ways to get this info
-        // from route tables or something. We're not even sure if anyone will use this functionality for now though. 
+        // from route tables or something. We're not even sure if anyone will use this functionality for now though.
         if (!AotHelper.IsNativeAot && !TransactionNameCache.TryGetValue(transactionNameKey, out transactionName))
         {
             // Find the HTTP Trigger attribute via reflection

Diff for: src/Sentry.DiagnosticSource/Internal/DiagnosticSource/EFDiagnosticSourceHelper.cs

@@ -59,6 +59,7 @@ internal void AddSpan(object? diagnosticSourceValue)
         // 2. Sentry's performance errors functionality only works when all queries have the same parent span.
         var parent = Transaction.GetDbParentSpan();
         var child = parent.StartChild(Operation, GetDescription(diagnosticSourceValue));
+        child.SetOrigin(SentryEFCoreListener.EFCoreListenerOrigin);
 
         SetDbData(child, diagnosticSourceValue);
         SetSpanReference(child, diagnosticSourceValue);

Diff for: src/Sentry.DiagnosticSource/Internal/DiagnosticSource/SentryEFCoreListener.cs

@@ -13,6 +13,8 @@ internal class SentryEFCoreListener : IObserver<KeyValuePair<string, object?>>
     internal const string EFCommandExecuted = "Microsoft.EntityFrameworkCore.Database.Command.CommandExecuted";
     internal const string EFCommandFailed = "Microsoft.EntityFrameworkCore.Database.Command.CommandError";
 
+    internal const string EFCoreListenerOrigin = "auto.db.ef_core_listener";
+
     /// <summary>
     /// Used for EF Core 2.X and 3.X.
     /// <seealso href="https://docs.microsoft.com/dotnet/api/microsoft.entityframeworkcore.diagnostics.coreeventid.querymodelcompiling?view=efcore-3.1"/>

Diff for: src/Sentry.DiagnosticSource/Internal/DiagnosticSource/SentrySqlListener.cs

@@ -11,6 +11,8 @@ private enum SentrySqlSpanType
         Execution
     };
 
+    internal const string SqlListenerOrigin = "auto.db.sql_listener";
+
     internal const string SqlDataWriteConnectionOpenBeforeCommand = "System.Data.SqlClient.WriteConnectionOpenBefore";
     internal const string SqlMicrosoftWriteConnectionOpenBeforeCommand = "Microsoft.Data.SqlClient.WriteConnectionOpenBefore";
 
@@ -80,6 +82,7 @@ private void AddSpan(string operation, object? value)
 
         var parent = transaction.GetDbParentSpan();
         var span = parent.StartChild(operation);
+        span.SetOrigin(SqlListenerOrigin);
         span.SetExtra(OTelKeys.DbSystem, "sql");
         SetOperationId(span, value?.GetGuidProperty("OperationId", _options.DiagnosticLogger));
         SetConnectionId(span, value?.GetGuidProperty("ConnectionId", _options.DiagnosticLogger));

Diff for: src/Sentry.EntityFramework/SentryQueryPerformanceListener.cs

@@ -1,3 +1,5 @@
+using Sentry.Internal;
+
 namespace Sentry.EntityFramework;
 
 internal class SentryQueryPerformanceListener : IDbCommandInterceptor
@@ -7,6 +9,8 @@ internal class SentryQueryPerformanceListener : IDbCommandInterceptor
     internal const string DbNonQueryKey = "db.execute";
     internal const string DbScalarKey = "db.query.scalar";
 
+    internal static readonly string EntityFrameworkOrigin = "auto.db.entity_framework";
+
     private SentryOptions _options;
     private IHub _hub;
 
@@ -39,6 +43,7 @@ private void CreateSpan<T>(string key, string? command,
     {
         if (_hub.GetSpan()?.StartChild(key, command) is { } span)
         {
+            span.SetOrigin(EntityFrameworkOrigin);
             interceptionContext.AttachSpan(span);
         }
     }

Diff for: src/Sentry.OpenTelemetry/SentrySpanProcessor.cs

@@ -13,6 +13,7 @@ public class SentrySpanProcessor : BaseProcessor<Activity>
 {
     private readonly IHub _hub;
     internal readonly IEnumerable<IOpenTelemetryEnricher> _enrichers;
+    internal const string OpenTelemetryOrigin = "auto.otel";
 
     // ReSharper disable once MemberCanBePrivate.Global - Used by tests
     internal readonly ConcurrentDictionary<ActivitySpanId, ISpan> _map = new();
@@ -123,6 +124,7 @@ private void CreateChildSpan(Activity data, ISpan parentSpan, SpanId? parentSpan
         };
 
         var span = (SpanTracer)parentSpan.StartChild(context);
+        span.Origin = OpenTelemetryOrigin;
         span.StartTimestamp = data.StartTimeUtc;
         // Used to filter out spans that are not recorded when finishing a transaction.
         span.SetFused(data);
@@ -152,6 +154,7 @@ private void CreateRootSpan(Activity data)
         var transaction = (TransactionTracer)_hub.StartTransaction(
             transactionContext, new Dictionary<string, object?>(), dynamicSamplingContext
         );
+        transaction.Contexts.Trace.Origin = OpenTelemetryOrigin;
         transaction.StartTimestamp = data.StartTimeUtc;
         _hub.ConfigureScope(scope => scope.Transaction = transaction);
         transaction.SetFused(data);

Diff for: src/Sentry/IBaseTracer.cs

@@ -1,6 +1,6 @@
 namespace Sentry;
 
-internal interface IBaseTracer
+internal interface IBaseTracer : ITraceContextInternal
 {
     internal bool IsOtelInstrumenter { get; }
 }

Diff for: src/Sentry/ITraceContextInternal.cs

@@ -0,0 +1,19 @@
+namespace Sentry;
+
+/// <summary>
+///  Internal interface defining members to be added to the TraceContexts for the next major release
+///  (since adding members to interfaces is a breaking change).
+/// </summary>
+/// <remarks>
+/// TODO: Remove this interface in the next major version.
+/// </remarks>
+internal interface ITraceContextInternal
+{
+    /// <summary>
+    /// Specifies the origin of the trace. If no origin is set then the trace origin is assumed to be "manual".
+    /// </summary>
+    /// <remarks>
+    /// See https://develop.sentry.dev/sdk/performance/trace-origin/ for more information.
+    /// </remarks>
+    string? Origin { get; }
+}

Diff for: src/Sentry/Internal/NoOpSpan.cs

@@ -5,7 +5,7 @@ namespace Sentry.Internal;
 /// <summary>
 /// Span class to use when we can't return null but a request to create a span couldn't be completed.
 /// </summary>
-internal class NoOpSpan : ISpan
+internal class NoOpSpan : ISpan, ITraceContextInternal
 {
     public static ISpan Instance { get; } = new NoOpSpan();
 
@@ -78,4 +78,6 @@ public void SetExtra(string key, object? value)
     public void SetMeasurement(string name, Measurement measurement)
     {
     }
+
+    public string? Origin { get; set; }
 }

Diff for: src/Sentry/Internal/OriginHelper.cs

@@ -0,0 +1,37 @@
+namespace Sentry.Internal;
+
+internal static partial class OriginHelper
+{
+    internal const string Manual = "manual";
+    private const string ValidOriginPattern = @"^(auto|manual)(\.[\w]+){0,3}$";
+
+#if NET8_0_OR_GREATER
+    [GeneratedRegex(ValidOriginPattern, RegexOptions.Compiled)]
+    private static partial Regex ValidOriginRegEx();
+    private static readonly Regex ValidOrigin = ValidOriginRegEx();
+#else
+    private static readonly Regex ValidOrigin = new (ValidOriginPattern, RegexOptions.Compiled);
+#endif
+
+    public static bool IsValidOrigin(string? value) => value == null || ValidOrigin.IsMatch(value);
+
+    internal static string? TryParse(string origin) => IsValidOrigin(origin) ? origin : null;
+
+    /// <summary>
+    /// Convenience method to let us set the origin on interfaces whose concrete implementations
+    /// typically have an Origin property.
+    /// </summary>
+    /// <remarks>We can remove once we deprecate the ITraceContextInternal interface</remarks>
+    public static void SetOrigin(this ISpan span, string origin)
+    {
+        switch (span)
+        {
+            case SpanTracer spanTracer:
+                spanTracer.Origin = origin;
+                break;
+            case TransactionTracer transactionTracer:
+                transactionTracer.Contexts.Trace.Origin = origin;
+                break;
+        }
+    }
+}

Diff for: src/Sentry/Protocol/Trace.cs

@@ -7,7 +7,7 @@ namespace Sentry.Protocol;
 /// <summary>
 /// Trace context data.
 /// </summary>
-public class Trace : ITraceContext, ISentryJsonSerializable, ICloneable<Trace>, IUpdatable<Trace>
+public class Trace : ITraceContext, ITraceContextInternal, ISentryJsonSerializable, ICloneable<Trace>, IUpdatable<Trace>
 {
     /// <summary>
     /// Tells Sentry which type of context this is.
@@ -26,6 +26,21 @@ public class Trace : ITraceContext, ISentryJsonSerializable, ICloneable<Trace>,
     /// <inheritdoc />
     public string Operation { get; set; } = "";
 
+    /// <inheritdoc />
+    public string? Origin
+    {
+        get => _origin;
+        internal set
+        {
+            if (!OriginHelper.IsValidOrigin(value))
+            {
+                throw new ArgumentException("Invalid origin");
+            }
+            _origin = value;
+        }
+    }
+    private string? _origin;
+
     /// <inheritdoc />
     public string? Description { get; set; }
 
@@ -46,6 +61,7 @@ public class Trace : ITraceContext, ISentryJsonSerializable, ICloneable<Trace>,
         ParentSpanId = ParentSpanId,
         TraceId = TraceId,
         Operation = Operation,
+        Origin = Origin,
         Status = Status,
         IsSampled = IsSampled
     };
@@ -84,6 +100,7 @@ public void WriteTo(Utf8JsonWriter writer, IDiagnosticLogger? logger)
         writer.WriteSerializableIfNotNull("parent_span_id", ParentSpanId?.NullIfDefault(), logger);
         writer.WriteSerializableIfNotNull("trace_id", TraceId.NullIfDefault(), logger);
         writer.WriteStringIfNotWhiteSpace("op", Operation);
+        writer.WriteString("origin", Origin ?? Internal.OriginHelper.Manual);
         writer.WriteStringIfNotWhiteSpace("description", Description);
         writer.WriteStringIfNotWhiteSpace("status", Status?.ToString().ToSnakeCase());
 
@@ -99,6 +116,7 @@ public static Trace FromJson(JsonElement json)
         var parentSpanId = json.GetPropertyOrNull("parent_span_id")?.Pipe(SpanId.FromJson);
         var traceId = json.GetPropertyOrNull("trace_id")?.Pipe(SentryId.FromJson) ?? SentryId.Empty;
         var operation = json.GetPropertyOrNull("op")?.GetString() ?? "";
+        var origin = Internal.OriginHelper.TryParse(json.GetPropertyOrNull("origin")?.GetString() ?? "");
         var description = json.GetPropertyOrNull("description")?.GetString();
         var status = json.GetPropertyOrNull("status")?.GetString()?.Replace("_", "").ParseEnum<SpanStatus>();
         var isSampled = json.GetPropertyOrNull("sampled")?.GetBoolean();
@@ -109,6 +127,7 @@ public static Trace FromJson(JsonElement json)
             ParentSpanId = parentSpanId,
             TraceId = traceId,
             Operation = operation,
+            Origin = origin,
             Description = description,
             Status = status,
             IsSampled = isSampled

Diff for: src/Sentry/SentryGraphQLHttpMessageHandler.cs

@@ -13,6 +13,8 @@ public class SentryGraphQLHttpMessageHandler : SentryMessageHandler
     private readonly SentryOptions? _options;
     private readonly ISentryFailedRequestHandler? _failedRequestHandler;
 
+    internal const string GraphQlOrigin = "auto.graphql";
+
     /// <summary>
     /// Constructs an instance of <see cref="SentryGraphQLHttpMessageHandler"/>.
     /// </summary>
@@ -54,6 +56,7 @@ internal SentryGraphQLHttpMessageHandler(IHub? hub, SentryOptions? options,
             "http.client",
             $"{method} {url}" // e.g. "GET https://example.com"
         );
+        span?.SetOrigin(GraphQlOrigin);
         span?.SetExtra(OtelSemanticConventions.AttributeHttpRequestMethod, method);
         if (!string.IsNullOrWhiteSpace(request.RequestUri?.Host))
         {

Diff for: src/Sentry/SentryHttpMessageHandler.cs

@@ -1,4 +1,5 @@
 using Sentry.Extensibility;
+using Sentry.Internal;
 using Sentry.Internal.OpenTelemetry;
 
 namespace Sentry;
@@ -12,6 +13,8 @@ public class SentryHttpMessageHandler : SentryMessageHandler
     private readonly SentryOptions? _options;
     private readonly ISentryFailedRequestHandler? _failedRequestHandler;
 
+    internal const string HttpClientOrigin = "auto.http.client";
+
     /// <summary>
     /// Constructs an instance of <see cref="SentryHttpMessageHandler"/>.
     /// </summary>
@@ -67,6 +70,7 @@ internal SentryHttpMessageHandler(IHub? hub, SentryOptions? options, HttpMessage
             "http.client",
             $"{method} {url}" // e.g. "GET https://example.com"
             );
+        span?.SetOrigin(HttpClientOrigin);
         span?.SetExtra(OtelSemanticConventions.AttributeHttpRequestMethod, method);
         if (request.RequestUri is not null && !string.IsNullOrWhiteSpace(request.RequestUri.Host))
         {

Diff for: src/Sentry/SentrySpan.cs

@@ -10,7 +10,7 @@ namespace Sentry;
 /// <summary>
 /// Transaction span.
 /// </summary>
-public class SentrySpan : ISpanData, ISentryJsonSerializable
+public class SentrySpan : ISpanData, ISentryJsonSerializable, ITraceContextInternal
 {
     /// <inheritdoc />
     public SpanId SpanId { get; private set; }
@@ -182,4 +182,19 @@ internal void Redact()
     {
         Description = Description?.RedactUrl();
     }
+
+    /// <inheritdoc />
+    public string? Origin
+    {
+        get => _origin;
+        internal set
+        {
+            if (!OriginHelper.IsValidOrigin(value))
+            {
+                throw new ArgumentException("Invalid origin");
+            }
+            _origin = value;
+        }
+    }
+    private string? _origin;
 }

Diff for: src/Sentry/SentryTransaction.cs

@@ -10,7 +10,7 @@ namespace Sentry;
 /// <summary>
 /// Sentry performance transaction.
 /// </summary>
-public class SentryTransaction : ITransactionData, ISentryJsonSerializable
+public class SentryTransaction : ITransactionData, ISentryJsonSerializable, ITraceContextInternal
 {
     /// <summary>
     /// Transaction's event ID.
@@ -24,6 +24,13 @@ public SpanId SpanId
         private set => Contexts.Trace.SpanId = value;
     }
 
+    /// <inheritdoc />
+    public string? Origin
+    {
+        get => Contexts.Trace.Origin;
+        private set => Contexts.Trace.Origin = value;
+    }
+
     // A transaction normally does not have a parent because it represents
     // the top node in the span hierarchy.
     // However, a transaction may also be continued from a trace header