docs(dotnet): Use the OTLP exporter in the Azure Functions guide (#19959)

<!-- Keep the urgency section so automation can prioritize this PR. You
may delete other sections you don't need. -->

## DESCRIBE YOUR PR

The Azure Functions (isolated worker) guide sets up tracing with
`TracerProviderBuilder.AddSentry()` and
`SentryOptions.UseOpenTelemetry()` from `Sentry.OpenTelemetry`. Both
have been obsolete since sentry-dotnet 6.12.0, so anyone following the
guide gets obsolete warnings. The guide now uses the OTLP exporter, as
the `Sentry.Samples.OpenTelemetry.AzureFunctions` sample does:

- Install `Sentry.OpenTelemetry.Exporter` instead of
`Sentry.OpenTelemetry`. `OpenTelemetry` is no longer listed because it
comes in transitively. The Package Manager tab now lists the two
OpenTelemetry packages it was missing.
- `AddSentryOtlpExporter(dsn)` and `UseOtlp()` replace `AddSentry()` and
`UseOpenTelemetry()`. The tracing sentence now links to the
OpenTelemetry (OTLP) page.
- The "enabling tracing" link under Features pointed at the generic
tracing concepts page. It now goes to the .NET OpenTelemetry (OTLP) page
too.

Closes getsentry/sentry-dotnet#5715

### Notes for review

- The snippet drops `TracesSampleRate` and
`DisableSentryHttpMessageHandler`, which the sample still sets. Under
`UseOtlp()` Sentry creates no transactions of its own, so
`TracesSampleRate` has no effect, and the OTLP page already says not to
set it. `SentryHttpMessageHandler` already skips span creation under
`UseOtlp()`. Against 6.12.1, an `IHttpClientFactory` request sent with
the handler on still carries a single `sentry-trace` value, and it
matches `traceparent`.
- The snippet's error-monitoring-only variant didn't compile. `using
OpenTelemetry;` and `using Sentry.OpenTelemetry;` sat outside the
performance block, but only the performance option installs those
packages. Neither is needed now: `AddSentryOtlpExporter` lives in
`OpenTelemetry.Trace`, and `UseOtlp` lives in `Sentry`, which the SDK
adds as an implicit using. The snippet now includes `using
Microsoft.Extensions.DependencyInjection;`, which `AddOpenTelemetry()`
needs.
- Both variants of the snippet compile without warnings against Sentry
6.12.1, using the Functions template's `ImplicitUsings`.
- #19925 (merges at 7.0.0 GA) makes the same OTLP
changes on this page, and also moves the options into `SentrySdk.Init`.
When it merges `master` it will conflict in the `logging.AddSentry`
block and on the tracing sentence. That sentence is reworded here into
active voice.

## IS YOUR CHANGE URGENT?

Help us prioritize incoming PRs by letting us know when the change needs
to go live.
Select exactly one option. For deadlines, replace `YYYY-MM-DD` with the
due date. You can update this information later by editing the PR
description.

- [ ] Urgent deadline (GA date, etc.): YYYY-MM-DD
- [ ] Other deadline: YYYY-MM-DD
- [x] No deadline: Not urgent, can wait up to 1 week+

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>

Author: jamescrosswell

docs/platforms/dotnet/guides/azure-functions-worker/index.mdx

@@ -4,11 +4,11 @@ sdk: sentry.dotnet.azure.functions.worker
 description: "Learn about Sentry's .NET integration with Azure Functions."
 ---
 
-Sentry provides an integration with Azure Functions through the [Sentry.Extensions.Logging](https://www.nuget.org/packages/Sentry.Extensions.Logging) and [Sentry.OpenTelemetry](https://www.nuget.org/packages/Sentry.OpenTelemetry) NuGet packages.
+Sentry provides an integration with Azure Functions through the [Sentry.Extensions.Logging](https://www.nuget.org/packages/Sentry.Extensions.Logging) and [Sentry.OpenTelemetry.Exporter](https://www.nuget.org/packages/Sentry.OpenTelemetry.Exporter) NuGet packages.
 
 ## Features
 
-In addition to capturing errors, you can monitor interactions between multiple services or applications by [enabling tracing](/concepts/key-terms/tracing/).
+In addition to capturing errors, you can monitor interactions between multiple services or applications by <PlatformLink to="/tracing/instrumentation/opentelemetry-otlp/">enabling tracing</PlatformLink>.
 
 Select which Sentry features you'd like to install in addition to Error Monitoring to get the corresponding installation and configuration instructions below.
 
@@ -21,8 +21,7 @@ Add the Sentry dependencies to your Azure Functions application:
 ```shell {tabTitle:.NET Core CLI}
 dotnet add package Sentry.Extensions.Logging -v {{@inject packages.version('sentry.dotnet.extensions.logging') }}
 // ___PRODUCT_OPTION_START___ performance
-dotnet add package Sentry.OpenTelemetry -v {{@inject packages.version('sentry.dotnet.opentelemetry') }}
-dotnet add package OpenTelemetry
+dotnet add package Sentry.OpenTelemetry.Exporter -v {{@inject packages.version('sentry.dotnet') }}
 dotnet add package OpenTelemetry.Extensions.Hosting
 dotnet add package OpenTelemetry.Instrumentation.Http
 
@@ -32,7 +31,9 @@ dotnet add package OpenTelemetry.Instrumentation.Http
 ```powershell {tabTitle:Package Manager}
 Install-Package Sentry.Extensions.Logging -Version {{@inject packages.version('sentry.dotnet.extensions.logging') }}
 // ___PRODUCT_OPTION_START___ performance
-Install-Package Sentry.OpenTelemetry -Version {{@inject packages.version('sentry.dotnet.opentelemetry') }}
+Install-Package Sentry.OpenTelemetry.Exporter -Version {{@inject packages.version('sentry.dotnet') }}
+Install-Package OpenTelemetry.Extensions.Hosting
+Install-Package OpenTelemetry.Instrumentation.Http
 // ___PRODUCT_OPTION_END___
 ```
 
@@ -43,19 +44,18 @@ The [Sentry.Extensions.Logging](/platforms/dotnet/guides/extensions-logging/) pa
 The core features of Sentry are enabled by calling `AddSentry` when configuring logging.
 
 <OnboardingOption optionId="performance">
-Performance tracing can be enabled by adding Sentry to the OpenTelemetry `TracerProviderBuilder` and then configuring Sentry itself to use OpenTelemetry.
+To enable tracing, add Sentry's OTLP exporter to the OpenTelemetry `TracerProviderBuilder` and call `UseOtlp()` on the Sentry options. See <PlatformLink to="/tracing/instrumentation/opentelemetry-otlp/">OpenTelemetry (OTLP)</PlatformLink> for sampling and trace propagation.
 </OnboardingOption>
 
 For example:
 
 ```csharp
 using Microsoft.Extensions.Hosting;
 using Microsoft.Extensions.Logging;
-using OpenTelemetry;
 // ___PRODUCT_OPTION_START___ performance
+using Microsoft.Extensions.DependencyInjection;
 using OpenTelemetry.Trace;
 // ___PRODUCT_OPTION_END___
-using Sentry.OpenTelemetry;
 
 var host = new HostBuilder()
     .ConfigureFunctionsWorkerDefaults()
@@ -65,7 +65,7 @@ var host = new HostBuilder()
         services.AddOpenTelemetry().WithTracing(builder =>
         {
             builder
-                .AddSentry() // <-- Configure OpenTelemetry to send traces to Sentry
+                .AddSentryOtlpExporter("___PUBLIC_DSN___") // <-- Send traces to Sentry over OTLP
                 .AddHttpClientInstrumentation(); // From OpenTelemetry.Instrumentation.Http, instruments outgoing HTTP requests
         });
     })
@@ -76,16 +76,13 @@ var host = new HostBuilder()
         {
             options.Dsn = "___PUBLIC_DSN___";
             // ___PRODUCT_OPTION_START___ performance
-            options.TracesSampleRate = 1.0;
-            options.UseOpenTelemetry(); // <-- Configure Sentry to use open telemetry
-            options.DisableSentryHttpMessageHandler = true; // So Sentry doesn't also create spans for outbound HTTP requests
+            options.UseOtlp(); // <-- Configure Sentry to use OpenTelemetry for tracing
             // ___PRODUCT_OPTION_END___
             options.Debug = true;
         });
     })
     .Build();
 
-
 await host.RunAsync();
 ```