feat(logs): Logs for Sentry.Extensions.Logging and integrations for Sentry.AspNetCore and Sentry.Maui

CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+### Features
+
+- Add experimental support for [Sentry Structured Logging](https://docs.sentry.io/product/explore/logs/) API ([#4158](https://github.com/getsentry/sentry-dotnet/pull/4158), [#4310](https://github.com/getsentry/sentry-dotnet/pull/4310))
+  - Add experimental integrations for `Sentry.Extensions.Logging`, `Sentry.AspNetCore` and `Sentry.Maui` ([#4193](https://github.com/getsentry/sentry-dotnet/pull/4193))
+
 ### Fixes
 
 - Native AOT: don't load SentryNative on unsupported platforms ([#4347](https://github.com/getsentry/sentry-dotnet/pull/4347))
@@ -20,7 +25,6 @@
 
 ### Features
 
-- Add experimental support for [Sentry Structured Logging](https://docs.sentry.io/product/explore/logs/) via `SentrySdk.Experimental.Logger` ([#4158](https://github.com/getsentry/sentry-dotnet/pull/4158))
 - Added StartSpan and GetTransaction methods to the SentrySdk ([#4303](https://github.com/getsentry/sentry-dotnet/pull/4303))
 
 ### Fixes

benchmarks/Sentry.Benchmarks/BenchmarkDotNet.Artifacts/results/Sentry.Benchmarks.Extensions.Logging.SentryStructuredLoggerBenchmarks-report-github.md

@@ -0,0 +1,13 @@
+```
+
+BenchmarkDotNet v0.13.12, macOS 15.5 (24F74) [Darwin 24.5.0]
+Apple M3 Pro, 1 CPU, 12 logical and 12 physical cores
+.NET SDK 9.0.301
+  [Host]     : .NET 8.0.14 (8.0.1425.11118), Arm64 RyuJIT AdvSIMD
+  DefaultJob : .NET 8.0.14 (8.0.1425.11118), Arm64 RyuJIT AdvSIMD
+
+
+```
+| Method | Mean     | Error   | StdDev  | Gen0   | Allocated |
+|------- |---------:|--------:|--------:|-------:|----------:|
+| Log    | 288.4 ns | 1.28 ns | 1.20 ns | 0.1163 |     976 B |

benchmarks/Sentry.Benchmarks/Extensions.Logging/SentryStructuredLoggerBenchmarks.cs

@@ -0,0 +1,90 @@
+#nullable enable
+
+using BenchmarkDotNet.Attributes;
+using Microsoft.Extensions.Logging;
+using Sentry.Extensibility;
+using Sentry.Extensions.Logging;
+using Sentry.Internal;
+using Sentry.Testing;
+
+namespace Sentry.Benchmarks.Extensions.Logging;
+
+public class SentryStructuredLoggerBenchmarks
+{
+    private Hub _hub = null!;
+    private Sentry.Extensions.Logging.SentryStructuredLogger _logger = null!;
+    private LogRecord _logRecord = null!;
+    private SentryLog? _lastLog;
+
+    [GlobalSetup]
+    public void Setup()
+    {
+        SentryLoggingOptions options = new()
+        {
+            Dsn = DsnSamples.ValidDsn,
+            Experimental =
+            {
+                EnableLogs = true,
+            },
+            ExperimentalLogging =
+            {
+                MinimumLogLevel = LogLevel.Information,
+            }
+        };
+        options.Experimental.SetBeforeSendLog((SentryLog log) =>
+        {
+            _lastLog = log;
+            return null;
+        });
+
+        MockClock clock = new(new DateTimeOffset(2025, 04, 22, 14, 51, 00, 789, TimeSpan.FromHours(2)));
+        SdkVersion sdk = new()
+        {
+            Name = "SDK Name",
+            Version = "SDK Version",
+        };
+
+        _hub = new Hub(options, DisabledHub.Instance);
+        _logger = new Sentry.Extensions.Logging.SentryStructuredLogger("CategoryName", options, _hub, clock, sdk);
+        _logRecord = new LogRecord(LogLevel.Information, new EventId(2025, "EventName"), new InvalidOperationException("exception-message"), "Number={Number}, Text={Text}", 2018, "message");
+    }
+
+    [Benchmark]
+    public void Log()
+    {
+        _logger.Log(_logRecord.LogLevel, _logRecord.EventId, _logRecord.Exception, _logRecord.Message, _logRecord.Args);
+    }
+
+    [GlobalCleanup]
+    public void Cleanup()
+    {
+        _hub.Dispose();
+
+        if (_lastLog is null)
+        {
+            throw new InvalidOperationException("Last Log is null");
+        }
+        if (_lastLog.Message != "Number=2018, Text=message")
+        {
+            throw new InvalidOperationException($"Last Log with Message: '{_lastLog.Message}'");
+        }
+    }
+
+    private sealed class LogRecord
+    {
+        public LogRecord(LogLevel logLevel, EventId eventId, Exception? exception, string? message, params object?[] args)
+        {
+            LogLevel = logLevel;
+            EventId = eventId;
+            Exception = exception;
+            Message = message;
+            Args = args;
+        }
+
+        public LogLevel LogLevel { get; }
+        public EventId EventId { get; }
+        public Exception? Exception { get; }
+        public string? Message { get; }
+        public object?[] Args { get; }
+    }
+}

benchmarks/Sentry.Benchmarks/Sentry.Benchmarks.csproj

@@ -14,6 +14,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\..\src\Sentry\Sentry.csproj" />
+    <ProjectReference Include="..\..\src\Sentry.Extensions.Logging\Sentry.Extensions.Logging.csproj" />
     <ProjectReference Include="..\..\src\Sentry.Profiling\Sentry.Profiling.csproj" />
     <ProjectReference Include="..\..\test\Sentry.Testing\Sentry.Testing.csproj" />
   </ItemGroup>

samples/Sentry.Samples.AspNetCore.Basic/Program.cs

@@ -15,6 +15,9 @@
     // Log debug information about the Sentry SDK
     options.Debug = true;
 #endif
+
+    // This option enables Logs sent to Sentry.
+    options.Experimental.EnableLogs = true;
 });
 
 var app = builder.Build();

samples/Sentry.Samples.ME.Logging/Program.cs

@@ -23,7 +23,17 @@
         // Optionally configure options: The default values are:
         options.MinimumBreadcrumbLevel = LogLevel.Information; // It requires at least this level to store breadcrumb
         options.MinimumEventLevel = LogLevel.Error; // This level or above will result in event sent to Sentry
+        options.ExperimentalLogging.MinimumLogLevel = LogLevel.Trace; // This level or above will result in log sent to Sentry
 
+        // This option enables Logs sent to Sentry.
+        options.Experimental.EnableLogs = true;
+        options.Experimental.SetBeforeSendLog(static log =>
+        {
+            log.SetAttribute("attribute-key", "attribute-value");
+            return log;
+        });
+
+        // TODO: AddLogEntryFilter
         // Don't keep as a breadcrumb or send events for messages of level less than Critical with exception of type DivideByZeroException
         options.AddLogEntryFilter((_, level, _, exception) => level < LogLevel.Critical && exception is DivideByZeroException);
 

samples/Sentry.Samples.Maui/MauiProgram.cs

@@ -33,6 +33,7 @@ public static MauiApp CreateMauiApp()
                 options.AttachScreenshot = true;
 
                 options.Debug = true;
+                options.Experimental.EnableLogs = true;
                 options.SampleRate = 1.0F;
 
                 // The Sentry MVVM Community Toolkit integration automatically creates traces for async relay commands,

src/Sentry.AspNetCore/SentryAspNetCoreStructuredLoggerProvider.cs

@@ -0,0 +1,32 @@
+using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
+using Sentry.Extensions.Logging;
+using Sentry.Infrastructure;
+
+namespace Sentry.AspNetCore;
+
+/// <summary>
+/// Structured Logger Provider for Sentry.
+/// </summary>
+[ProviderAlias("SentryLogs")]
+internal sealed class SentryAspNetCoreStructuredLoggerProvider : SentryStructuredLoggerProvider
+{
+    public SentryAspNetCoreStructuredLoggerProvider(IOptions<SentryAspNetCoreOptions> options, IHub hub)
+        : this(options.Value, hub, SystemClock.Clock, CreateSdkVersion())
+    {
+    }
+
+    internal SentryAspNetCoreStructuredLoggerProvider(SentryAspNetCoreOptions options, IHub hub, ISystemClock clock, SdkVersion sdk)
+        : base(options, hub, clock, sdk)
+    {
+    }
+
+    private static SdkVersion CreateSdkVersion()
+    {
+        return new SdkVersion
+        {
+            Name = Constants.SdkName,
+            Version = SentryMiddleware.NameAndVersion.Version,
+        };
+    }
+}

src/Sentry.AspNetCore/SentryWebHostBuilderExtensions.cs

@@ -93,10 +93,16 @@ public static IWebHostBuilder UseSentry(
             _ = logging.Services
                 .AddSingleton<IConfigureOptions<SentryAspNetCoreOptions>, SentryAspNetCoreOptionsSetup>();
             _ = logging.Services.AddSingleton<ILoggerProvider, SentryAspNetCoreLoggerProvider>();
+            _ = logging.Services.AddSingleton<ILoggerProvider, SentryAspNetCoreStructuredLoggerProvider>();
 
             _ = logging.AddFilter<SentryAspNetCoreLoggerProvider>(
                 "Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware",
                 LogLevel.None);
+            _ = logging.AddFilter<SentryAspNetCoreStructuredLoggerProvider>(static (string? categoryName, LogLevel logLevel) =>
+            {
+                return categoryName is null
+                    || (categoryName != "Sentry.ISentryClient" && categoryName != "Sentry.AspNetCore.SentryMiddleware");
+            });
 
             var sentryBuilder = logging.Services.AddSentry();
             configureSentry?.Invoke(context, sentryBuilder);

src/Sentry.Extensions.Logging/BindableSentryLoggingOptions.cs

@@ -9,11 +9,20 @@ internal class BindableSentryLoggingOptions : BindableSentryOptions
     public LogLevel? MinimumEventLevel { get; set; }
     public bool? InitializeSdk { get; set; }
 
+    public BindableSentryLoggingExperimentalOptions ExperimentalLogging { get; set; } = new();
+
+    internal sealed class BindableSentryLoggingExperimentalOptions
+    {
+        public LogLevel? MinimumLogLevel { get; set; }
+    }
+
     public void ApplyTo(SentryLoggingOptions options)
     {
         base.ApplyTo(options);
         options.MinimumBreadcrumbLevel = MinimumBreadcrumbLevel ?? options.MinimumBreadcrumbLevel;
         options.MinimumEventLevel = MinimumEventLevel ?? options.MinimumEventLevel;
         options.InitializeSdk = InitializeSdk ?? options.InitializeSdk;
+
+        options.ExperimentalLogging.MinimumLogLevel = ExperimentalLogging.MinimumLogLevel ?? options.ExperimentalLogging.MinimumLogLevel;
     }
 }

src/Sentry.Extensions.Logging/LogLevelExtensions.cs

@@ -45,4 +45,19 @@ public static SentryLevel ToSentryLevel(this LogLevel level)
             _ => SentryLevel.Debug
         };
     }
+
+    public static SentryLogLevel ToSentryLogLevel(this LogLevel logLevel)
+    {
+        return logLevel switch
+        {
+            LogLevel.Trace => SentryLogLevel.Trace,
+            LogLevel.Debug => SentryLogLevel.Debug,
+            LogLevel.Information => SentryLogLevel.Info,
+            LogLevel.Warning => SentryLogLevel.Warning,
+            LogLevel.Error => SentryLogLevel.Error,
+            LogLevel.Critical => SentryLogLevel.Fatal,
+            LogLevel.None => default,
+            _ => default,
+        };
+    }
 }

src/Sentry.Extensions.Logging/LoggingBuilderExtensions.cs

@@ -51,13 +51,22 @@ internal static ILoggingBuilder AddSentry<TOptions>(
 
         builder.Services.AddSingleton<IConfigureOptions<TOptions>, SentryLoggingOptionsSetup>();
         builder.Services.AddSingleton<ILoggerProvider, SentryLoggerProvider>();
+        builder.Services.AddSingleton<ILoggerProvider, SentryStructuredLoggerProvider>();
         builder.Services.AddSentry<TOptions>();
 
         // All logs should flow to the SentryLogger, regardless of level.
         // Filtering of events is handled in SentryLogger, using SentryOptions.MinimumEventLevel
         // Filtering of breadcrumbs is handled in SentryLogger, using SentryOptions.MinimumBreadcrumbLevel
         builder.AddFilter<SentryLoggerProvider>(_ => true);
 
+        // Logs from the SentryLogger should not flow to the SentryStructuredLogger as this may cause recursive invocations.
+        // Filtering of logs is handled in SentryStructuredLogger, using SentryOptions.MinimumLogLevel
+        builder.AddFilter<SentryStructuredLoggerProvider>(static (string? categoryName, LogLevel logLevel) =>
+        {
+            return categoryName is null
+                || categoryName != "Sentry.ISentryClient";
+        });
+
         return builder;
     }
 }

src/Sentry.Extensions.Logging/Sentry.Extensions.Logging.csproj

@@ -40,6 +40,7 @@
     <InternalsVisibleTo Include="Sentry.AspNetCore.Grpc.Tests" PublicKey="$(SentryPublicKey)" />
     <InternalsVisibleTo Include="Sentry.Azure.Functions.Worker" PublicKey="$(SentryPublicKey)" />
     <InternalsVisibleTo Include="Sentry.Azure.Functions.Worker.Tests" PublicKey="$(SentryPublicKey)" />
+    <InternalsVisibleTo Include="Sentry.Benchmarks" PublicKey="$(SentryPublicKey)" />
     <InternalsVisibleTo Include="Sentry.DiagnosticSource.IntegrationTests" PublicKey="$(SentryPublicKey)" />
     <InternalsVisibleTo Include="Sentry.Google.Cloud.Functions" PublicKey="$(SentryPublicKey)" />
     <InternalsVisibleTo Include="Sentry.Google.Cloud.Functions.Tests" PublicKey="$(SentryPublicKey)" />

src/Sentry.Extensions.Logging/SentryLoggingOptions.cs

@@ -11,7 +11,9 @@ public class SentryLoggingOptions : SentryOptions
     /// <summary>
     /// Gets or sets the minimum breadcrumb level.
     /// </summary>
-    /// <remarks>Events with this level or higher will be stored as <see cref="Breadcrumb"/></remarks>
+    /// <remarks>
+    /// Events with this level or higher will be stored as <see cref="Breadcrumb"/>.
+    /// </remarks>
     /// <value>
     /// The minimum breadcrumb level.
     /// </value>
@@ -21,7 +23,7 @@ public class SentryLoggingOptions : SentryOptions
     /// Gets or sets the minimum event level.
     /// </summary>
     /// <remarks>
-    /// Events with this level or higher will be sent to Sentry
+    /// Events with this level or higher will be sent to Sentry.
     /// </remarks>
     /// <value>
     /// The minimum event level.
@@ -48,4 +50,39 @@ public class SentryLoggingOptions : SentryOptions
     /// List of callbacks to be invoked when initializing the SDK
     /// </summary>
     internal Action<Scope>[] ConfigureScopeCallbacks { get; set; } = Array.Empty<Action<Scope>>();
+
+    /// <summary>
+    /// Experimental Sentry Logging features.
+    /// </summary>
+    /// <remarks>
+    /// This and related experimental APIs may change in the future.
+    /// </remarks>
+    [Experimental(Infrastructure.DiagnosticId.ExperimentalFeature)]
+    public SentryLoggingExperimentalOptions ExperimentalLogging { get; set; } = new();
+
+    /// <summary>
+    /// Experimental Sentry Logging options.
+    /// </summary>
+    /// <remarks>
+    /// This and related experimental APIs may change in the future.
+    /// </remarks>
+    [Experimental(Infrastructure.DiagnosticId.ExperimentalFeature)]
+    public sealed class SentryLoggingExperimentalOptions
+    {
+        internal SentryLoggingExperimentalOptions()
+        {
+        }
+
+        /// <summary>
+        /// Gets or sets the minimum log level.
+        /// <para>This API is experimental and it may change in the future.</para>
+        /// </summary>
+        /// <remarks>
+        /// Logs with this level or higher will be stored as <see cref="SentryLog"/>.
+        /// </remarks>
+        /// <value>
+        /// The minimum log level.
+        /// </value>
+        public LogLevel MinimumLogLevel { get; set; } = LogLevel.Trace;
+    }
 }