@@ -62,9 +62,9 @@ The [Interactive 7.x Migration Guide](./interactive/) lets you check off complet
 
 ## Logs and Metrics
 
-### EnableLogs Moves to Host Options
+### EnableLogs Is Removed from SentryOptions
 
-<Include name="migration/dotnet-v7/enablelogs-moves-to-host-options" />
+<Include name="migration/dotnet-v7/enablelogs-is-removed-from-sentryoptions" />
 
 ### Logging Integrations Send Logs
 
@@ -102,6 +102,12 @@ The [Interactive 7.x Migration Guide](./interactive/) lets you check off complet
 
 <Include name="migration/dotnet-v7/sdk-name-release-and-scope-environment" />
 
+## Requests to Sentry
+
+### DecompressionMethods No Longer Includes Brotli
+
+<Include name="migration/dotnet-v7/decompressionmethods-no-longer-includes-brotli" />
+
 ## Integrations
 
 ### UseSentry Overrides appsettings.json in MAUI
 
@@ -2,6 +2,11 @@
 
 There is no stable 7.0 release of the Sentry SDK for .NET yet. The current release candidate is `7.0.0-rc.2`. Until 7.0.0 ships, use that version wherever this guide says `7.0.0`. The rest of the .NET docs still describe 6.x until then, so where they differ from this guide, follow this guide. If you run into problems, [open an issue on GitHub](https://github.com/getsentry/sentry-dotnet/issues).
 
+On `7.0.0-rc.2`, two things work differently from what this guide describes:
+
+- `Logging.AddSentry()` after `ClearProviders()` doesn't add Sentry's logger providers back. Call `UseSentry` after `ClearProviders()` instead.
+- An ASP.NET Core app that sends `ILogger` entries through NLog crashes with a stack overflow when `Debug` is on. In these apps, leave `Debug` off and check that the test event arrives in Sentry instead.
+
 The release candidate's `net11.0` builds depend on the .NET 11 release candidate versions of `Microsoft.Extensions.Http`, `Microsoft.Extensions.Logging.Configuration` and `Microsoft.Extensions.Configuration.Binder`. A .NET 11 app that references 10.0.x of one of these packages directly fails to restore with error NU1605. Remove that reference, or update it to the same .NET 11 release candidate version.
 
 </Alert>
 
@@ -0,0 +1,26 @@
+---
+id: decompressionmethods-no-longer-includes-brotli
+title: "DecompressionMethods No Longer Includes Brotli"
+phase: verify
+category: behavior
+severity: informational
+frameworks: all
+platformCategory: all
+order: 80
+---
+
+`SentryOptions.DecompressionMethods` now defaults to `GZip | Deflate`. In 6.x, it included every method, so the SDK asked your Sentry server for Brotli-compressed responses and decoded them. Sentry's responses to the SDK are small, so this shouldn't make a visible difference.
+
+The new default keeps the SDK away from the .NET Brotli decoder, which has a security issue in unpatched runtimes. See [CVE-2026-111497](https://github.com/dotnet/announcements/issues/494). This matters most for self-contained, Native AOT and mobile apps, which carry their own runtime.
+
+To accept Brotli-compressed responses again, add it back. `DecompressionMethods.Brotli` is available on .NET Core 3.0 and later:
+
+```csharp {filename:Program.cs}
+using System.Net;
+
+SentrySdk.Init(options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+    options.DecompressionMethods |= DecompressionMethods.Brotli;
+});
+```
@@ -0,0 +1,52 @@
+---
+id: enablelogs-is-removed-from-sentryoptions
+title: "EnableLogs Is Removed from SentryOptions"
+phase: code-changes
+category: removed-api
+severity: action-required
+frameworks: all
+platformCategory: all
+order: 90
+---
+
+Version 7 removes `EnableLogs` from `SentryOptions`, the core options of the SDK, so setting it in `SentrySdk.Init` fails to compile with error CS1061. Remove the line.
+
+Whether logs are on now depends on how your app writes them:
+
+- **Logging integrations.** If you add the Serilog, NLog or log4net integration, or call `Logging.AddSentry()` after `SentrySdk.Init`, logs are on by default. Your logging framework's configuration, such as its minimum level, controls which entries they send. See [Logging Integrations Send Logs](#logging-integrations-send-logs).
+- **Host integrations.** In ASP.NET Core, MAUI, Blazor WebAssembly and generic host apps, `UseSentry` adds an `ILogger` integration. It sends errors and breadcrumbs, but its logs are off by default. To turn them on, set `EnableLogs = true` on the options of `UseSentry`. `EnableLogs` doesn't affect a Serilog, NLog or log4net integration in the same app.
+- **`SentrySdk.Logger`.** It sends logs in every app and needs no option.
+
+In 6.x, `SentrySdk.Init` turned logs on:
+
+```csharp {filename:Program.cs}
+SentrySdk.Init(options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+    options.EnableLogs = true;
+});
+```
+
+In 7.x, remove `EnableLogs`:
+
+```csharp {filename:Program.cs}
+SentrySdk.Init(options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+});
+```
+
+In apps that call `UseSentry`, keep `EnableLogs` on its options to send `ILogger` entries as logs. You can also set it in the `Sentry` section of `appsettings.json`:
+
+```csharp {filename:Program.cs}
+var builder = WebApplication.CreateBuilder(args);
+builder.UseSentry(options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+    options.EnableLogs = true;
+});
+```
+
+A generic host app that set `EnableLogs` on `Logging.AddSentry` in 6.x sets it on `UseSentry` now.
+
+The Serilog sink no longer takes an `enableLogs` argument. NLog's `enableLogs` setting no longer turns logs off, and setting it to `false` writes a warning to standard error. To drop logs and keep errors and breadcrumbs, use `SetBeforeSendLog`, as shown in [Logging Integrations Send Logs](#logging-integrations-send-logs).
@@ -87,8 +87,8 @@ builder.Build().Run();
 
 `UseSentry` also registers `IHub` for dependency injection and sets the environment from the host environment. It works on `IHostApplicationBuilder` types such as `Host.CreateApplicationBuilder` on .NET 8 and later. It also works on `IHostBuilder` types such as `Host.CreateDefaultBuilder` on every target, including .NET Framework.
 
-If the app calls `builder.Logging.ClearProviders()`, call `UseSentry` after it. `ClearProviders` removes every logger provider registered before it, including Sentry's, and the app then sends no errors from `ILogger` without any warning.
+If the app calls `builder.Logging.ClearProviders()`, call `UseSentry` after it. `ClearProviders` removes every logger provider registered before it, including Sentry's, and the app then sends no errors from `ILogger`. If the app has to clear providers after `UseSentry`, call `builder.Logging.AddSentry()` after `ClearProviders` to add Sentry's providers back. Skip that if Serilog, NLog or log4net already sends the app's `ILogger` entries to Sentry, because each entry would then arrive twice.
 
 A helper that takes any `IHostApplicationBuilder` and runs in an ASP.NET Core app, such as the `AddServiceDefaults` method of .NET Aspire, needs a different call. See [Call UseSentry on WebApplicationBuilder](#call-usesentry-on-webapplicationbuilder).
 
-Like ASP.NET Core, `UseSentry` sends `ILogger` entries as logs only when you set `EnableLogs`. See [EnableLogs Moves to Host Options](#enablelogs-moves-to-host-options).
+Like ASP.NET Core, `UseSentry` sends `ILogger` entries as logs only when you set `EnableLogs`. See [EnableLogs Is Removed from SentryOptions](#enablelogs-is-removed-from-sentryoptions).
@@ -24,7 +24,13 @@ Initialize Sentry with the call that matches your app:
 
 `UseSentry` reads its settings from the `Sentry` section of `appsettings.json`. `SentrySdk.Init` only uses the options you set in code and environment variables such as `SENTRY_DSN`.
 
-`UseSentry` also adds Sentry's own `ILogger` integration. If your app sends `ILogger` entries through Serilog, NLog or log4net, set that framework up as shown in Apps That Call UseSentry in the [Serilog](/platforms/dotnet/guides/serilog/#apps-that-call-usesentry), [NLog](/platforms/dotnet/guides/nlog/#apps-that-call-usesentry) or [log4net](/platforms/dotnet/guides/log4net/#apps-that-call-usesentry) guide, so each entry reaches Sentry once instead of twice.
+`UseSentry` also adds Sentry's own `ILogger` integration. If your app sends `ILogger` entries through Serilog, NLog or log4net as well, Sentry receives each entry twice unless only one of them sends it:
+
+- **Serilog.** Add Serilog with `builder.Services.AddSerilog(...)` from `Serilog.Extensions.Hosting`, or with `builder.Host.UseSerilog(...)`. Both replace the app's `ILogger` factory, so each entry reaches Sentry once, through the sink. Don't use `builder.Logging.AddSerilog()` or `writeToProviders: true`.
+- **NLog.** Set `ReplaceLoggerFactory = true` when you add NLog, for example with `builder.Logging.AddNLog(new NLogProviderOptions { ReplaceLoggerFactory = true })`. `UseNLog` in ASP.NET Core takes the same option.
+- **log4net.** `AddLog4Net()` can't replace the factory. Set `MinimumEventLevel` and `MinimumBreadcrumbLevel` to `LogLevel.None` on the options of `UseSentry`, and leave `EnableLogs` off, so each entry reaches Sentry once, through the appender.
+
+The [Serilog](/platforms/dotnet/guides/serilog/#apps-that-call-usesentry), [NLog](/platforms/dotnet/guides/nlog/#apps-that-call-usesentry) and [log4net](/platforms/dotnet/guides/log4net/#apps-that-call-usesentry) guides show the full setup.
 
 A logging integration sends nothing until you initialize Sentry. SDK settings left on the integration fail in different ways:
 
 
@@ -11,7 +11,7 @@ order: 10
 
 The Serilog sink, the NLog target, the log4net appender and `Logging.AddSentry()` after `SentrySdk.Init` send every entry they receive to Sentry as a log. In 6.x, they sent logs only with `EnableLogs` on, so an upgraded app can send many more logs.
 
-Adding one of these integrations is now the opt-in for its logs. This also applies in ASP.NET Core, MAUI, Blazor WebAssembly and generic host apps. There, `EnableLogs` only controls the `ILogger` integration that `UseSentry` adds. A Serilog, NLog or log4net integration in the same app sends logs whether `EnableLogs` is on or off.
+Adding one of these integrations is now the opt-in for its logs, in every kind of app. `EnableLogs` on the options of `UseSentry` doesn't change this. See [EnableLogs Is Removed from SentryOptions](#enablelogs-is-removed-from-sentryoptions).
 
 Each integration sends the entries its logging framework passes to it:
 
 
@@ -9,9 +9,11 @@ platformCategory: all
 order: 50
 ---
 
-In an app that calls `UseSentry`, `Logging.AddSentry()` now does nothing, and options passed to it in code no longer apply. Move those options to `UseSentry` and remove the call. The exception is an app that calls `ClearProviders()` after `UseSentry`, which also removes Sentry's logger providers: keep `Logging.AddSentry()` there to add them back.
+In an app that calls `UseSentry`, `Logging.AddSentry()` now does nothing, and options passed to it in code no longer apply. Move those options to `UseSentry` and remove the call.
 
-In 6.x, an app with both calls captured each error, breadcrumb and log twice. In 7.x, the `ILogger` integration that `UseSentry` adds captures them once, with the options of `UseSentry`. With `Debug` on, the SDK logs a warning that the `Logging.AddSentry()` call can be removed.
+The exception is an app that calls `ClearProviders()` after `UseSentry`, which also removes Sentry's logger providers. Keep `Logging.AddSentry()` there to add them back. It uses the options of `UseSentry`, not the ones passed to it. Leave it out if Serilog, NLog or log4net already sends the app's `ILogger` entries to Sentry, because each entry would then arrive twice.
+
+In 6.x, an app with both calls captured each error, breadcrumb and log twice. In 7.x, the `ILogger` integration that `UseSentry` adds captures them once, with the options of `UseSentry`. With `Debug` on, the SDK logs a warning about the redundant call.
 
 In 6.x, the app passed the logging options to `Logging.AddSentry`: