feat: Microsoft.Extensions.Logging integration no longer initializes the SDK

Completes the logging-integration part of #5245. The MEL integration now only
wires up the logger providers; Sentry has to be initialized separately.

Unlike Serilog, NLog and log4net, SentryLoggingOptions keeps deriving from
SentryOptions, because SentryAspNetCoreOptions, SentryMauiOptions and
SentryBlazorOptions derive from it and those integrations do initialize the SDK.
InitializeSdk therefore stays as internal plumbing, now defaulting to false and
opted into by the framework integrations that own it.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: jamescrosswell

samples/Sentry.Samples.GenericHost/Program.cs

@@ -7,14 +7,19 @@
 
 builder.Logging.AddConfiguration(builder.Configuration);
 
+// Initialise the Sentry SDK. The logging integration added below only forwards log messages to Sentry.
+using var sentry = SentrySdk.Init(options =>
+{
 #if !SENTRY_DSN_DEFINED_IN_ENV
-// A DSN is required. You can set it here in code, via the SENTRY_DSN environment variable or in your
-// appsettings.json file.
-// See https://docs.sentry.io/platforms/dotnet/guides/aspnetcore/#configure
-builder.Logging.AddSentry(SamplesShared.Dsn);
-#else
-builder.Logging.AddSentry();
+    // A DSN is required. You can set here in code, or you can set it in the SENTRY_DSN environment variable.
+    // See https://docs.sentry.io/product/sentry-basics/dsn-explainer/
+    options.Dsn = SamplesShared.Dsn;
 #endif
+    // Send user name and machine name
+    options.SendDefaultPii = true;
+});
+
+builder.Logging.AddSentry();
 
 builder.Services.AddHostedService<SampleHostedService>();
 

samples/Sentry.Samples.GenericHost/appsettings.json

@@ -10,9 +10,7 @@
     }
   },
   "Sentry": {
-    //"Dsn": "TODO: Configure your DSN here and uncomment this line",
     "MinimumBreadcrumbLevel": "Debug",
-    "MinimumEventLevel": "Warning",
-    "SendDefaultPii": true // Send user name and machine name
+    "MinimumEventLevel": "Warning"
   }
 }

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

@@ -1,35 +1,39 @@
 using Microsoft.Extensions.Logging;
 using Sentry.Extensions.Logging;
 
-using var loggerFactory = LoggerFactory.Create(builder =>
+// Initialise the Sentry SDK. The logging integration added below only forwards log messages to Sentry.
+using var sentry = SentrySdk.Init(options =>
 {
-    builder.AddConsole();
-    builder.AddSentry(options =>
-    {
 #if !SENTRY_DSN_DEFINED_IN_ENV
-        // A DSN is required. You can set here in code, or you can set it in the SENTRY_DSN environment variable.
-        // See https://docs.sentry.io/product/sentry-basics/dsn-explainer/
-        options.Dsn = SamplesShared.Dsn;
+    // A DSN is required. You can set here in code, or you can set it in the SENTRY_DSN environment variable.
+    // See https://docs.sentry.io/product/sentry-basics/dsn-explainer/
+    options.Dsn = SamplesShared.Dsn;
 #endif
 
-        // Set to true to SDK debugging to see the internal messages through the logging library.
-        options.Debug = false;
-        // Configure the level of Sentry internal logging
-        options.DiagnosticLevel = SentryLevel.Debug;
+    // Set to true to SDK debugging to see the internal messages through the logging library.
+    options.Debug = false;
+    // Configure the level of Sentry internal logging
+    options.DiagnosticLevel = SentryLevel.Debug;
 
-        options.MaxBreadcrumbs = 150; // Increasing from default 100
-        options.Release = "e386dfd"; // If not set here, SDK looks for it on main assembly's AssemblyInformationalVersion and AssemblyVersion
+    options.MaxBreadcrumbs = 150; // Increasing from default 100
+    options.Release = "e386dfd"; // If not set here, SDK looks for it on main assembly's AssemblyInformationalVersion and AssemblyVersion
+
+    options.SetBeforeSendLog(static log =>
+    {
+        log.SetAttribute("attribute-key", "attribute-value");
+        return log;
+    });
+});
 
+using var loggerFactory = LoggerFactory.Create(builder =>
+{
+    builder.AddConsole();
+    builder.AddSentry(options =>
+    {
         // 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.SetBeforeSendLog(static log =>
-        {
-            log.SetAttribute("attribute-key", "attribute-value");
-            return log;
-        });
-
         // 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);
 
@@ -86,8 +90,6 @@
     Dependency.Work("8 - This unhandled exception is captured and includes Scope (A, B) and crumbs: (2, 4, 5) and event (3) ");
 }
 
-// Disposing the LoggerFactory will close the SDK since it was initialized through
-// the integration while calling .Init()
 
 internal static class Dependency
 {

samples/Sentry.Samples.OpenTelemetry.AzureFunctions/Program.cs

@@ -14,6 +14,16 @@
 var dsn = SamplesShared.Dsn;
 #endif
 
+// Initialise the Sentry SDK. The logging integration added below only forwards log messages to Sentry.
+using var sentry = SentrySdk.Init(options =>
+{
+    options.Dsn = dsn;
+    options.TracesSampleRate = 1.0;
+    options.UseOtlp(); // <-- Configure Sentry to use open telemetry
+    options.DisableSentryHttpMessageHandler = true; // So Sentry doesn't also create spans for outbound HTTP requests
+    options.Debug = true;
+});
+
 var host = new HostBuilder()
     .ConfigureFunctionsWorkerDefaults()
     .ConfigureServices(services =>
@@ -25,17 +35,7 @@
                 .AddHttpClientInstrumentation(); // From OpenTelemetry.Instrumentation.Http... adds automatic tracing for outgoing HTTP requests
         });
     })
-    .ConfigureLogging(logging =>
-    {
-        logging.AddSentry(options =>
-        {
-            options.Dsn = dsn;
-            options.TracesSampleRate = 1.0;
-            options.UseOtlp(); // <-- Configure Sentry to use open telemetry
-            options.DisableSentryHttpMessageHandler = true; // So Sentry doesn't also create spans for outbound HTTP requests
-            options.Debug = true;
-        });
-    })
+    .ConfigureLogging(logging => logging.AddSentry())
     .Build();
 
 await host.RunAsync();

src/Sentry.AspNetCore.Blazor.WebAssembly/WebAssemblyHostBuilderExtensions.cs

@@ -46,5 +46,10 @@ public static WebAssemblyHostBuilder UseSentry(this WebAssemblyHostBuilder build
 /// </summary>
 public class SentryBlazorOptions : SentryLoggingOptions
 {
+    /// <summary>
+    /// Creates a new instance of <see cref="SentryBlazorOptions"/>.
+    /// </summary>
+    public SentryBlazorOptions() => InitializeSdk = true;
+
     // Awesome Blazor specific options go here
 }

src/Sentry.AspNetCore/SentryAspNetCoreOptions.cs

@@ -108,6 +108,8 @@ public SentryAspNetCoreOptions()
     {
         // Don't report Environment.UserName as the user.
         IsEnvironmentUser = false;
+
+        InitializeSdk = true;
     }
 
     internal void SetEnvironment(IWebHostEnvironment hostingEnvironment)

src/Sentry.Extensions.Logging/BindableSentryLoggingOptions.cs

@@ -7,13 +7,11 @@ internal class BindableSentryLoggingOptions : BindableSentryOptions
 {
     public LogLevel? MinimumBreadcrumbLevel { get; set; }
     public LogLevel? MinimumEventLevel { get; set; }
-    public bool? InitializeSdk { 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;
     }
 }

src/Sentry.Extensions.Logging/LoggingBuilderExtensions.cs

@@ -21,14 +21,6 @@ public static class LoggingBuilderExtensions
     public static ILoggingBuilder AddSentry(this ILoggingBuilder builder)
         => builder.AddSentry((Action<SentryLoggingOptions>?)null);
 
-    /// <summary>
-    /// Adds the Sentry logging integration.
-    /// </summary>
-    /// <param name="builder">The builder.</param>
-    /// <param name="dsn">The DSN.</param>
-    public static ILoggingBuilder AddSentry(this ILoggingBuilder builder, string dsn)
-        => builder.AddSentry(o => o.Dsn = dsn);
-
     /// <summary>
     /// Adds the Sentry logging integration.
     /// </summary>

src/Sentry.Extensions.Logging/SentryLoggerFactoryExtensions.cs

@@ -17,8 +17,8 @@ public static class SentryLoggerFactoryExtensions
     /// Adds the Sentry logging integration.
     /// </summary>
     /// <remarks>
-    /// This method does not need to be called when calling `UseSentry` with ASP.NET Core
-    /// since that integrates with the logging framework automatically.
+    /// This method does not initialize Sentry. Initialize it separately, with <see cref="SentrySdk.Init(Action{SentryOptions})"/>
+    /// or a framework integration such as <c>UseSentry</c>.
     /// </remarks>
     /// <param name="factory">The factory.</param>
     /// <param name="optionsConfiguration">The options configuration.</param>
@@ -30,34 +30,7 @@ public static ILoggerFactory AddSentry(
 
         optionsConfiguration?.Invoke(options);
 
-        if (options.DiagnosticLogger == null)
-        {
-            var logger = factory.CreateLogger<ISentryClient>();
-            options.DiagnosticLogger = new MelDiagnosticLogger(logger, options.DiagnosticLevel);
-        }
-
-        IHub hub;
-        if (options.InitializeSdk)
-        {
-            if (SentrySdk.IsEnabled && options.Dsn is null)
-            {
-                options.LogWarning("Not calling Init from {0} because SDK is already enabled and no DSN was provided to the integration", nameof(SentryLoggerFactoryExtensions));
-                hub = HubAdapter.Instance;
-            }
-            else
-            {
-                options.LogDebug("Initializing from {0} and swapping current Hub.", nameof(SentryLoggerFactoryExtensions));
-                hub = SentrySdk.InitHub(options);
-                SentrySdk.UseHub(hub);
-            }
-        }
-        else
-        {
-            // Access to whatever the SentrySdk points to (disabled or initialized via SentrySdk.Init)
-            hub = HubAdapter.Instance;
-        }
-
-        factory.AddProvider(new SentryLoggerProvider(hub, SystemClock.Clock, options));
+        factory.AddProvider(new SentryLoggerProvider(HubAdapter.Instance, SystemClock.Clock, options));
         return factory;
     }
 }

src/Sentry.Extensions.Logging/SentryLoggingOptions.cs

@@ -30,17 +30,17 @@ public class SentryLoggingOptions : SentryOptions
     /// </value>
     public LogLevel MinimumEventLevel { get; set; } = LogLevel.Error;
 
-    /// <summary>
-    /// Whether to initialize this SDK through this integration
-    /// </summary>
-    public bool InitializeSdk { get; set; } = true;
-
     /// <summary>
     /// Add a callback to configure the scope upon SDK initialization
     /// </summary>
     /// <param name="action">The function to invoke when initializing the SDK</param>
     public void ConfigureScope(Action<Scope> action) => ConfigureScopeCallbacks = ConfigureScopeCallbacks.Concat(new[] { action }).ToArray();
 
+    /// <summary>
+    /// Whether the integration owning these options initializes the SDK
+    /// </summary>
+    internal bool InitializeSdk { get; set; }
+
     /// <summary>
     /// Log entry filters
     /// </summary>