feat: Add diagnostic source integration.

CHANGELOG.md

@@ -4,6 +4,7 @@
 
 ### Features
 
+- EF Core and SQLClient performance monitoring integration ([#1154](https://github.com/getsentry/sentry-dotnet/pull/1154))
 - Improved SDK diagnostic logs ([#1161](https://github.com/getsentry/sentry-dotnet/pull/1161))
 - Add Scope observer to SentryOptions ([#1153](https://github.com/getsentry/sentry-dotnet/pull/1153))
 

Sentry.sln

@@ -135,6 +135,10 @@ Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sentry.Tunnel", "src\Sentry
 EndProject
 Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sentry.Tunnel.Tests", "test\Sentry.Tunnel.Tests\Sentry.Tunnel.Tests.csproj", "{BB54EF08-2FA1-498B-827B-32D905FB0F9F}"
 EndProject
+Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Sentry.Diagnostics.DiagnosticSource", "src\Sentry.Diagnostics.DiagnosticSource\Sentry.Diagnostics.DiagnosticSource.csproj", "{0BE821AB-88D4-4EB5-B012-C964FF58087A}"
+EndProject
+Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Sentry.Diagnostics.DiagnosticSource.Tests", "test\Sentry.Diagnostics.DiagnosticSource.Tests\Sentry.Diagnostics.DiagnosticSource.Tests.csproj", "{D870B028-16ED-4551-8B0F-5529479D04C9}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|Any CPU = Debug|Any CPU
@@ -301,6 +305,14 @@ Global
 		{BB54EF08-2FA1-498B-827B-32D905FB0F9F}.Debug|Any CPU.Build.0 = Debug|Any CPU
 		{BB54EF08-2FA1-498B-827B-32D905FB0F9F}.Release|Any CPU.ActiveCfg = Release|Any CPU
 		{BB54EF08-2FA1-498B-827B-32D905FB0F9F}.Release|Any CPU.Build.0 = Release|Any CPU
+		{0BE821AB-88D4-4EB5-B012-C964FF58087A}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{0BE821AB-88D4-4EB5-B012-C964FF58087A}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{0BE821AB-88D4-4EB5-B012-C964FF58087A}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{0BE821AB-88D4-4EB5-B012-C964FF58087A}.Release|Any CPU.Build.0 = Release|Any CPU
+		{D870B028-16ED-4551-8B0F-5529479D04C9}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{D870B028-16ED-4551-8B0F-5529479D04C9}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{D870B028-16ED-4551-8B0F-5529479D04C9}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{D870B028-16ED-4551-8B0F-5529479D04C9}.Release|Any CPU.Build.0 = Release|Any CPU
 	EndGlobalSection
 	GlobalSection(SolutionProperties) = preSolution
 		HideSolutionNode = FALSE
@@ -349,6 +361,8 @@ Global
 		{066522A4-8380-4D29-8DD0-973B1EDF0B39} = {83263231-1A2A-4733-B759-EEFF14E8C5D5}
 		{D2F8BF0E-7749-4C92-A4F1-7B96A9878458} = {AF6AF4C7-8AA2-4D59-8064-2D79560904EB}
 		{BB54EF08-2FA1-498B-827B-32D905FB0F9F} = {83263231-1A2A-4733-B759-EEFF14E8C5D5}
+		{0BE821AB-88D4-4EB5-B012-C964FF58087A} = {AF6AF4C7-8AA2-4D59-8064-2D79560904EB}
+		{D870B028-16ED-4551-8B0F-5529479D04C9} = {83263231-1A2A-4733-B759-EEFF14E8C5D5}
 	EndGlobalSection
 	GlobalSection(ExtensibilityGlobals) = postSolution
 		SolutionGuid = {0C652B1A-DF72-4EE5-A98B-194FE2C054F6}

src/Sentry.AspNet/Sentry.AspNet.csproj

@@ -12,6 +12,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\Sentry\Sentry.csproj" />
+    <ProjectReference Include="..\Sentry.Diagnostics.DiagnosticSource\Sentry.Diagnostics.DiagnosticSource.csproj" />
   </ItemGroup>
 
 </Project>

src/Sentry.AspNet/SentryAspNetOptionsExtensions.cs

@@ -1,3 +1,4 @@
+using System;
 using System.Web;
 using Sentry.AspNet.Internal;
 using Sentry.Extensibility;
@@ -28,6 +29,7 @@ public static void AddAspNet(this SentryOptions options, RequestSize maxRequestB
             options.DiagnosticLogger ??= new TraceDiagnosticLogger(options.DiagnosticLevel);
             options.Release ??= SystemWebVersionLocator.Resolve(options, HttpContext.Current);
             options.AddEventProcessor(eventProcessor);
+            options.AddDiagnosticListeners();
         }
     }
 }

src/Sentry.AspNetCore/Sentry.AspNetCore.csproj

@@ -10,7 +10,10 @@
     <ProjectReference Include="..\Sentry.Extensions.Logging\Sentry.Extensions.Logging.csproj" />
   </ItemGroup>
 
+
   <ItemGroup Condition="'$(TargetFramework)' == 'netstandard2.0'">
+    <ProjectReference Include="..\Sentry.Diagnostics.DiagnosticSource\Sentry.Diagnostics.DiagnosticSource.csproj" />
+
     <PackageReference Include="Microsoft.AspNetCore.Hosting" Version="2.1.0" />
     <PackageReference Include="Microsoft.AspNetCore.Diagnostics.Abstractions" Version="2.1.0" />
     <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="2.1.0" />

src/Sentry.AspNetCore/SentryAspNetCoreOptionsSetup.cs

@@ -90,6 +90,10 @@ public override void Configure(SentryAspNetCoreOptions options)
                        category,
                        "Microsoft.AspNetCore.Server.Kestrel",
                        StringComparison.Ordinal));
+
+#if NETSTANDARD2_0
+            options.AddDiagnosticListeners();
+#endif
         }
     }
 }

src/Sentry.Diagnostics.DiagnosticSource/Internals/DiagnosticSource/SentryDiagnosticListenerIntegration.cs

@@ -0,0 +1,24 @@
+using System;
+using System.Diagnostics;
+using Sentry.Internal;
+
+namespace Sentry.Internals.DiagnosticSource
+{
+    internal class SentryDiagnosticListenerIntegration : IInternalSdkIntegration
+    {
+        private SentryDiagnosticSubscriber? _subscriber;
+        private IDisposable? _diagnosticListener { get; set; }
+
+        public void Register(IHub hub, SentryOptions options)
+        {
+            _subscriber = new SentryDiagnosticSubscriber(hub, options);
+            _diagnosticListener = DiagnosticListener.AllListeners.Subscribe(_subscriber);
+        }
+
+        public void Unregister(IHub hub)
+        {
+            _diagnosticListener?.Dispose();
+            _subscriber?.Dispose();
+        }
+    }
+}

src/Sentry.Diagnostics.DiagnosticSource/Internals/DiagnosticSource/SentryDiagnosticSubscriber.cs

@@ -0,0 +1,60 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using Sentry.Extensibility;
+
+namespace Sentry.Internals.DiagnosticSource
+{
+    /// <summary>
+    /// Class that subscribes to specific listeners from DiagnosticListener.
+    /// </summary>
+    internal class SentryDiagnosticSubscriber : IObserver<DiagnosticListener>, IDisposable
+    {
+        private SentryEFCoreListener? _efInterceptor { get; set; }
+        private SentrySqlListener? _sqlListener { get; set; }
+        private List<IDisposable> _disposableListeners = new();
+        private IHub _hub { get; }
+        private SentryOptions _options { get; }
+
+        public SentryDiagnosticSubscriber(IHub hub, SentryOptions options)
+        {
+            _hub = hub;
+            _options = options;
+        }
+
+        public void OnCompleted() { }
+
+        public void OnError(Exception error) { }
+
+        public void OnNext(DiagnosticListener listener)
+        {
+            if (listener.Name == "Microsoft.EntityFrameworkCore")
+            {
+                _efInterceptor = new(_hub, _options);
+                _disposableListeners.Add(listener.Subscribe(_efInterceptor));
+                _options.DiagnosticLogger?.Log(SentryLevel.Debug, "Registered integration with EF Core.");
+            }
+            else if (listener.Name == "SqlClientDiagnosticListener")
+            {
+                _sqlListener = new(_hub, _options);
+                _disposableListeners.Add(listener.Subscribe(_sqlListener));
+                _options.DiagnosticLogger?.LogDebug("Registered integration with SQL Client.");
+
+                // Duplicated data.
+                _efInterceptor?.DisableConnectionSpan();
+                _efInterceptor?.DisableQuerySpan();
+            }
+        }
+
+        /// <summary>
+        /// Dispose all registered integrations.
+        /// </summary>
+        public void Dispose()
+        {
+            foreach (var item in _disposableListeners)
+            {
+                item.Dispose();
+            }
+        }
+    }
+}

src/Sentry.Diagnostics.DiagnosticSource/Internals/DiagnosticSource/SentryEFCoreListener.cs

@@ -0,0 +1,157 @@
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using Sentry.Extensibility;
+
+namespace Sentry.Internals.DiagnosticSource
+{
+    /// <summary>
+    /// Class that consumes Entity Framework Core events.
+    /// </summary>
+    internal class SentryEFCoreListener : IObserver<KeyValuePair<string, object?>>
+    {
+        private enum SentryEFSpanType
+        {
+            Connection,
+            QueryExecution,
+            QueryCompiler
+        }
+
+        internal const string EFConnectionOpening = "Microsoft.EntityFrameworkCore.Database.Connection.ConnectionOpening";
+        internal const string EFConnectionClosed = "Microsoft.EntityFrameworkCore.Database.Connection.ConnectionClosed";
+        internal const string EFCommandExecuting = "Microsoft.EntityFrameworkCore.Database.Command.CommandExecuting";
+        internal const string EFCommandExecuted = "Microsoft.EntityFrameworkCore.Database.Command.CommandExecuted";
+        internal const string EFCommandFailed = "Microsoft.EntityFrameworkCore.Database.Command.CommandError";
+
+        /// <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"></seealso>
+        /// </summary>
+        internal const string EFQueryStartCompiling = "Microsoft.EntityFrameworkCore.Query.QueryCompilationStarting";
+        /// <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"></seealso>
+        /// </summary>
+        internal const string EFQueryCompiling = "Microsoft.EntityFrameworkCore.Query.QueryModelCompiling";
+        internal const string EFQueryCompiled = "Microsoft.EntityFrameworkCore.Query.QueryExecutionPlanned";
+
+        private IHub _hub { get; }
+        private SentryOptions _options { get; }
+
+        private AsyncLocal<WeakReference<ISpan>> _spansCompilerLocal = new();
+        private AsyncLocal<WeakReference<ISpan>> _spansQueryLocal = new();
+        private AsyncLocal<WeakReference<ISpan>> _spansConnectionLocal = new();
+
+        private bool _logConnectionEnabled = true;
+        private bool _logQueryEnabled = true;
+
+        public SentryEFCoreListener(IHub hub, SentryOptions options)
+        {
+            _hub = hub;
+            _options = options;
+        }
+
+        internal void DisableConnectionSpan() => _logConnectionEnabled = false;
+
+        internal bool DisableQuerySpan() => _logQueryEnabled = false;
+
+        private ISpan? AddSpan(SentryEFSpanType type, string operation, string? description)
+        {
+            if (_hub.GetSpan()?.StartChild(operation, description) is { } span &&
+                GetSpanBucket(type) is { } asyncLocalSpan)
+            {
+                asyncLocalSpan.Value = new WeakReference<ISpan>(span);
+                return span;
+            }
+            return null;
+        }
+
+        private ISpan? TakeSpan(SentryEFSpanType type)
+        {
+            if (GetSpanBucket(type)?.Value is { } reference && reference.TryGetTarget(out var span))
+            {
+                return span;
+            }
+            _options.DiagnosticLogger?.LogWarning("Trying to close a span that was already garbage collected. {0}", type);
+            return null;
+        }
+
+        private AsyncLocal<WeakReference<ISpan>>? GetSpanBucket(SentryEFSpanType type)
+            => type switch
+            {
+                SentryEFSpanType.QueryCompiler => _spansCompilerLocal,
+                SentryEFSpanType.QueryExecution => _spansQueryLocal,
+                SentryEFSpanType.Connection => _spansConnectionLocal,
+                _ => null
+            };
+
+        public void OnCompleted() { }
+
+        public void OnError(Exception error) { }
+
+        public void OnNext(KeyValuePair<string, object?> value)
+        {
+            try
+            {
+                //Query compiler Span
+                if (value.Key == EFQueryStartCompiling || value.Key == EFQueryCompiling)
+                {
+                    AddSpan(SentryEFSpanType.QueryCompiler, "db.query_compiler", FilterNewLineValue(value.Value));
+                }
+                else if (value.Key == EFQueryCompiled)
+                {
+                    TakeSpan(SentryEFSpanType.QueryCompiler)?.Finish(SpanStatus.Ok);
+                }
+
+                //Connection Span
+                //A transaction may or may not show a connection with it.
+                if (_logConnectionEnabled && value.Key == EFConnectionOpening)
+                {
+                    AddSpan(SentryEFSpanType.Connection, "db.connection", null);
+                }
+                else if (_logConnectionEnabled && value.Key == EFConnectionClosed)
+                {
+                    TakeSpan(SentryEFSpanType.Connection)?.Finish(SpanStatus.Ok);
+                }
+
+                //Query Execution Span
+                else if (_logQueryEnabled)
+                {
+                    if (value.Key == EFCommandExecuting)
+                    {
+                        AddSpan(SentryEFSpanType.QueryExecution, "db.query", FilterNewLineValue(value.Value));
+                    }
+                    else if (value.Key == EFCommandFailed)
+                    {
+                        TakeSpan(SentryEFSpanType.QueryExecution)?.Finish(SpanStatus.InternalError);
+                    }
+                    else if (value.Key == EFCommandExecuted)
+                    {
+                        TakeSpan(SentryEFSpanType.QueryExecution)?.Finish(SpanStatus.Ok);
+                    }
+                }
+            }
+            catch (Exception ex)
+            {
+                _options.DiagnosticLogger?.LogError("Failed to intercept EF Core event.", ex);
+            }
+        }
+
+        /// <summary>
+        /// Get the Query with error message and remove the uneeded values.
+        /// </summary>
+        /// <example>
+        /// Compiling query model:
+        /// EF intialize...\r\nEF Query...
+        /// becomes:
+        /// EF Query...
+        /// </example>
+        /// <param name="value">the query to be parsed value</param>
+        /// <returns>the filtered query</returns>
+        internal static string? FilterNewLineValue(object? value)
+        {
+            var str = value?.ToString();
+            return str?.Substring(str.IndexOf('\n') + 1);
+        }
+    }
+}