fix(logs): minimum Log-Level for Structured Logs

CHANGELOG.md

@@ -2,15 +2,27 @@
 
 ## Unreleased
 
+### BREAKING CHANGES
+
+- Remove `SentryLoggingOptions.ExperimentalLogging.MinimumLogLevel`. _Structured Logs_ can now be configured via the `"Sentry"` logging provider (e.g. in `appsettings.json` and `appsettings.{HostEnvironment}.json`) ([#4700](https://github.com/getsentry/sentry-dotnet/pull/4700))
+- All logging provider types are _internal_ now in order to ensure configuration as intended ([#4700](https://github.com/getsentry/sentry-dotnet/pull/4700))
+
 ### Features
 
 - Added a new SDK `Sentry.Extensions.AI` which allows LLM usage instrumentation via `Microsoft.Extensions.AI` ([#4657](https://github.com/getsentry/sentry-dotnet/pull/4657))
+- Add support for _Structured Logs_ in `Sentry.Google.Cloud.Functions` ([#4700](https://github.com/getsentry/sentry-dotnet/pull/4700))
 
 ### Fixes
 
 - Captured [Http Client Errors](https://docs.sentry.io/platforms/dotnet/guides/aspnet/configuration/http-client-errors/) on .NET 5+ now include a full stack trace in order to improve Issue grouping ([#4724](https://github.com/getsentry/sentry-dotnet/pull/4724))
 - Sentry Tracing middleware crashed ASP.NET Core in .NET 10 in 6.0.0-rc.1 and earlier ([#4747](https://github.com/getsentry/sentry-dotnet/pull/4747))
 - Avoid appending `/NODEFAULTLIB:MSVCRT` to NativeAOT linker arguments on Windows when targetting non-Windows platforms (Android, Browser) ([#4760](https://github.com/getsentry/sentry-dotnet/pull/4760))
+- Minimum Log-Level for _Structured Logs_, _Breadcrumbs_ and _Events_ in all Logging-Integrations ([#4700](https://github.com/getsentry/sentry-dotnet/pull/4700))
+  - for `Sentry.Extensions.Logging`, `Sentry.AspNetCore`, `Sentry.Maui` and `Sentry.Google.Cloud.Functions`
+  - the Logger-Provider for _Breadcrumbs_ and _Events_ ignores Logging-Configuration (e.g. via `appsettings.json`)
+    - use the intended `SentryLoggingOptions.MinimumBreadcrumbLevel`, `SentryLoggingOptions.MinimumEventLevel`, or add filter functions via `SentryLoggingOptionsExtensions.AddLogEntryFilter`
+  - the Logger-Provider for _Structured Logs_ respects Logging-Configuration (e.g. via `appsettings.json`)
+    - when enabled by `SentryOptions.EnableLogs`
 
 ### Dependencies
 

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

@@ -23,10 +23,6 @@ public void Setup()
         {
             Dsn = DsnSamples.ValidDsn,
             EnableLogs = true,
-            ExperimentalLogging =
-            {
-                MinimumLogLevel = LogLevel.Information,
-            }
         };
         options.SetBeforeSendLog((SentryLog log) =>
         {

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

@@ -16,7 +16,12 @@
     options.Debug = true;
 #endif
 
-    // This option enables Logs sent to Sentry.
+    // Configure the minimum Log Level of Breadcrumbs and Events
+    options.MinimumBreadcrumbLevel = LogLevel.Information;
+    options.MinimumEventLevel = LogLevel.Error;
+
+    // This option enables Logs sent to Sentry
+    // Configure the minimum Log Level of Structured-Logs via e.g. "appsettings.json" and "appsettings.{HostEnvironment}.json"
     options.EnableLogs = true;
 });
 

samples/Sentry.Samples.AspNetCore.Basic/appsettings.json

@@ -0,0 +1,14 @@
+{
+  "Logging": {
+    "LogLevel": {
+      "Default": "Information",
+      "Microsoft.AspNetCore": "Warning"
+    },
+    "Sentry": {
+      "LogLevel": {
+        "Default": "Trace"
+      }
+    }
+  },
+  "AllowedHosts": "*"
+}

samples/Sentry.Samples.GenericHost/SampleHostedService.cs

@@ -7,6 +7,8 @@ internal class SampleHostedService(IHub hub, ILogger<SampleHostedService> logger
 {
     public Task StartAsync(CancellationToken cancellationToken)
     {
+        // Configure structured logging via appsettings.json (Logging:Sentry:LogLevel:)
+        logger.LogTrace("LogLevel.Trace is not configured to be sent as structured log");
         // Logging integration by default keeps informational logs as Breadcrumb
         logger.LogInformation("Starting sample hosted service. This goes as a breadcrumb");
         // You can also add breadcrumb directly through Sentry.Hub:

samples/Sentry.Samples.GenericHost/appsettings.json

@@ -2,12 +2,18 @@
   "Logging": {
     "LogLevel": {
       "Default": "Trace"
+    },
+    "Sentry": {
+      "LogLevel": {
+        "Default": "Information" // Configure structured logs
+      }
     }
   },
   "Sentry": {
     //"Dsn": "TODO: Configure your DSN here and uncomment this line",
     "MinimumBreadcrumbLevel": "Debug",
     "MinimumEventLevel": "Warning",
-    "SendDefaultPii": true // Send user name and machine name
+    "SendDefaultPii": true, // Send user name and machine name
+    "EnableLogs": true // Send structured logs
   }
 }

samples/Sentry.Samples.Google.Cloud.Functions/Function.cs

@@ -16,6 +16,7 @@ public class Function : IHttpFunction
 
     public Task HandleAsync(HttpContext context)
     {
+        _logger.LogTrace("LogLevel.Trace is not configured to be sent as structured log");
         _logger.LogInformation("Useful info that is added to the breadcrumb list.");
         throw new Exception("Bad function");
     }

samples/Sentry.Samples.Google.Cloud.Functions/appsettings.json

@@ -1,8 +1,19 @@
 {
+  "Logging": {
+    "LogLevel": {
+      "Default": "Debug"
+    },
+    "Sentry": {
+      "LogLevel": {
+        "Default": "Information"
+      }
+    }
+  },
   "Sentry": {
     //"Dsn": "TODO: Configure your DSN here and uncomment this line",
     "MaxRequestBodySize": "Always",
     "SendDefaultPii": true,
-    "EnableTracing": true
+    "EnableTracing": true,
+    "EnableLogs" : true
   }
 }

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

@@ -23,7 +23,6 @@
         // 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.EnableLogs = true;

src/Sentry.AspNetCore/SentryAspNetCoreLoggerProvider.cs

@@ -1,14 +1,15 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Sentry.Extensions.Logging;
+using Sentry.Infrastructure;
 
 namespace Sentry.AspNetCore;
 
 /// <summary>
-/// Logger provider for Sentry.
+/// Sentry Logger Provider for <see cref="Breadcrumb"/> and <see cref="SentryEvent"/>.
 /// </summary>
 [ProviderAlias("Sentry")]
-public class SentryAspNetCoreLoggerProvider : SentryLoggerProvider
+internal sealed class SentryAspNetCoreLoggerProvider : SentryLoggerProvider
 {
     /// <summary>
     /// Creates a new instance of <see cref="SentryAspNetCoreLoggerProvider"/>
@@ -17,4 +18,9 @@ public SentryAspNetCoreLoggerProvider(IOptions<SentryAspNetCoreOptions> options,
         : base(options, hub)
     {
     }
+
+    internal SentryAspNetCoreLoggerProvider(SentryAspNetCoreOptions options, IHub hub, ISystemClock clock)
+        : base(hub, clock, options)
+    {
+    }
 }

src/Sentry.AspNetCore/SentryAspNetCoreOptionsSetup.cs

@@ -9,7 +9,7 @@ namespace Sentry.AspNetCore;
 /// Sets up ASP.NET Core option for Sentry.
 /// </summary>
 #if NETSTANDARD2_0
-public class SentryAspNetCoreOptionsSetup : ConfigureFromConfigurationOptions<SentryAspNetCoreOptions>
+internal sealed class SentryAspNetCoreOptionsSetup : ConfigureFromConfigurationOptions<SentryAspNetCoreOptions>
 {
     /// <summary>
     /// Creates a new instance of <see cref="SentryAspNetCoreOptionsSetup"/>.
@@ -32,7 +32,7 @@ public override void Configure(SentryAspNetCoreOptions options)
 }
 
 #else
-public class SentryAspNetCoreOptionsSetup : IConfigureOptions<SentryAspNetCoreOptions>
+internal sealed class SentryAspNetCoreOptionsSetup : IConfigureOptions<SentryAspNetCoreOptions>
 {
     private readonly IConfiguration _config;
 

src/Sentry.AspNetCore/SentryAspNetCoreStructuredLoggerProvider.cs

@@ -6,9 +6,9 @@
 namespace Sentry.AspNetCore;
 
 /// <summary>
-/// Structured Logger Provider for Sentry.
+/// Sentry Logger Provider for <see cref="SentryLog"/>.
 /// </summary>
-[ProviderAlias("SentryLogs")]
+[ProviderAlias("Sentry")]
 internal sealed class SentryAspNetCoreStructuredLoggerProvider : SentryStructuredLoggerProvider
 {
     public SentryAspNetCoreStructuredLoggerProvider(IOptions<SentryAspNetCoreOptions> options, IHub hub)

src/Sentry.AspNetCore/SentryWebHostBuilderExtensions.cs

@@ -95,14 +95,15 @@ public static IWebHostBuilder UseSentry(
             _ = 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) =>
+            // Add a delegate rule in order to ignore Configuration like "appsettings.json" and "appsettings.{HostEnvironment}.json"
+            _ = logging.AddFilter<SentryAspNetCoreLoggerProvider>(static (string? categoryName, LogLevel logLevel) =>
             {
                 return categoryName is null
-                    || (categoryName != "Sentry.ISentryClient" && categoryName != "Sentry.AspNetCore.SentryMiddleware");
+                       || categoryName != "Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware";
             });
+            // Add non-delegate rules in order to respect Configuration like "appsettings.json" and "appsettings.{HostEnvironment}.json"
+            _ = logging.AddFilter<SentryAspNetCoreStructuredLoggerProvider>("Sentry.ISentryClient", LogLevel.None);
+            _ = logging.AddFilter<SentryAspNetCoreStructuredLoggerProvider>("Sentry.AspNetCore.SentryMiddleware", LogLevel.None);
 
             var sentryBuilder = logging.Services.AddSentry();
             configureSentry?.Invoke(context, sentryBuilder);

src/Sentry.Extensions.Logging/BindableSentryLoggingOptions.cs

@@ -9,20 +9,11 @@ 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/LoggingBuilderExtensions.cs

@@ -60,12 +60,8 @@ internal static ILoggingBuilder AddSentry<TOptions>(
         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";
-        });
+        // Filtering of structured logs is handled by Microsoft.Extensions.Configuration and Microsoft.Extensions.Options.
+        builder.AddFilter<SentryStructuredLoggerProvider>("Sentry.ISentryClient", LogLevel.None);
 
         return builder;
     }

src/Sentry.Extensions.Logging/SentryLoggerProvider.cs

@@ -6,10 +6,10 @@
 namespace Sentry.Extensions.Logging;
 
 /// <summary>
-/// Sentry Logger Provider.
+/// Sentry Logger Provider for <see cref="Breadcrumb"/> and <see cref="SentryEvent"/>.
 /// </summary>
 [ProviderAlias("Sentry")]
-public class SentryLoggerProvider : ILoggerProvider
+internal class SentryLoggerProvider : ILoggerProvider
 {
     private readonly ISystemClock _clock;
     private readonly SentryLoggingOptions _options;

src/Sentry.Extensions.Logging/SentryLoggingOptions.cs

@@ -50,39 +50,4 @@ 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;
-    }
 }

src/Sentry.Extensions.Logging/SentryLoggingOptionsSetup.cs

@@ -5,7 +5,7 @@
 
 namespace Sentry.Extensions.Logging;
 
-internal class SentryLoggingOptionsSetup : IConfigureOptions<SentryLoggingOptions>
+internal sealed class SentryLoggingOptionsSetup : IConfigureOptions<SentryLoggingOptions>
 {
     private readonly IConfiguration _config;
 
@@ -30,7 +30,7 @@ public void Configure(SentryLoggingOptions options)
 
 namespace Sentry.Extensions.Logging;
 
-internal class SentryLoggingOptionsSetup : ConfigureFromConfigurationOptions<SentryLoggingOptions>
+internal sealed class SentryLoggingOptionsSetup : ConfigureFromConfigurationOptions<SentryLoggingOptions>
 {
     public SentryLoggingOptionsSetup(
         ILoggerProviderConfiguration<SentryLoggerProvider> providerConfiguration)

src/Sentry.Extensions.Logging/SentryStructuredLogger.cs

@@ -30,8 +30,7 @@ public bool IsEnabled(LogLevel logLevel)
     {
         return _hub.IsEnabled
             && _options.EnableLogs
-            && logLevel != LogLevel.None
-            && logLevel >= _options.ExperimentalLogging.MinimumLogLevel;
+            && logLevel != LogLevel.None;
     }
 
     public void Log<TState>(LogLevel logLevel, EventId eventId, TState state, Exception? exception, Func<TState, Exception?, string> formatter)

src/Sentry.Extensions.Logging/SentryStructuredLoggerProvider.cs

@@ -5,9 +5,9 @@
 namespace Sentry.Extensions.Logging;
 
 /// <summary>
-/// Sentry Structured Logger Provider.
+/// Sentry Logger Provider for <see cref="SentryLog"/>.
 /// </summary>
-[ProviderAlias("SentryLogs")]
+[ProviderAlias("Sentry")]
 internal class SentryStructuredLoggerProvider : ILoggerProvider
 {
     private readonly SentryLoggingOptions _options;
@@ -20,6 +20,11 @@ public SentryStructuredLoggerProvider(IOptions<SentryLoggingOptions> options, IH
     {
     }
 
+    internal SentryStructuredLoggerProvider(IHub hub, ISystemClock clock, SentryLoggingOptions options)
+        : this(options, hub, clock, CreateSdkVersion())
+    {
+    }
+
     internal SentryStructuredLoggerProvider(SentryLoggingOptions options, IHub hub, ISystemClock clock, SdkVersion sdk)
     {
         _options = options;

src/Sentry.Google.Cloud.Functions/SentryStartup.cs

@@ -57,10 +57,17 @@ public override void ConfigureLogging(WebHostBuilderContext context, ILoggingBui
 
         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);
+        // Add a delegate rule in order to ignore Configuration like "appsettings.json" and "appsettings.{HostEnvironment}.json"
+        logging.AddFilter<SentryAspNetCoreLoggerProvider>(static (string? categoryName, LogLevel logLevel) =>
+        {
+            return categoryName is null
+                   || categoryName != "Microsoft.AspNetCore.Diagnostics.ExceptionHandlerMiddleware";
+        });
+        // Add non-delegate rules in order to respect Configuration like "appsettings.json" and "appsettings.{HostEnvironment}.json"
+        logging.AddFilter<SentryAspNetCoreStructuredLoggerProvider>("Sentry.ISentryClient", LogLevel.None);
+        logging.AddFilter<SentryAspNetCoreStructuredLoggerProvider>("Sentry.AspNetCore.SentryMiddleware", LogLevel.None);
 
         logging.Services.AddSentry();
     }

src/Sentry.Maui/Internal/SentryMauiLoggerProvider.cs

@@ -1,14 +1,23 @@
 using Microsoft.Extensions.Logging;
 using Microsoft.Extensions.Options;
 using Sentry.Extensions.Logging;
+using Sentry.Infrastructure;
 
 namespace Sentry.Maui.Internal;
 
+/// <summary>
+/// Sentry Logger Provider for <see cref="Breadcrumb"/> and <see cref="SentryEvent"/>.
+/// </summary>
 [ProviderAlias("Sentry")]
-internal class SentryMauiLoggerProvider : SentryLoggerProvider
+internal sealed class SentryMauiLoggerProvider : SentryLoggerProvider
 {
     public SentryMauiLoggerProvider(IOptions<SentryMauiOptions> options, IHub hub)
         : base(options, hub)
     {
     }
+
+    internal SentryMauiLoggerProvider(SentryMauiOptions options, IHub hub, ISystemClock clock)
+        : base(hub, clock, options)
+    {
+    }
 }