Added guidance on capturing exceptions via OTel in .NET (#14343)

## DESCRIBE YOUR PR

Resolves getsentry/sentry-dotnet#2520 and
getsentry/sentry-dotnet#2519:
- getsentry/sentry-dotnet#2520
- getsentry/sentry-dotnet#2519

## IS YOUR CHANGE URGENT?  

- [x] None: Not urgent, can wait up to 1 week+

## SLA

- Teamwork makes the dream work, so please add a reviewer to your PRs.

CC: @Flash0ver 

## PRE-MERGE CHECKLIST

*Make sure you've checked the following before merging your changes:*

- [ ] Checked Vercel preview for correctness, including links
- [ ] PR was reviewed and approved by any necessary SMEs (subject matter
experts)
- [ ] PR was reviewed and approved by a member of the [Sentry docs
team](https://github.com/orgs/getsentry/teams/docs)

---------

Co-authored-by: Stefan Pölz <[email protected]>

Author: jamescrosswell

docs/platforms/dotnet/common/tracing/instrumentation/opentelemetry.mdx

@@ -18,6 +18,12 @@ You can configure your [OpenTelemetry SDK](https://opentelemetry.io/) to send tr
 
 With Sentry’s OpenTelemetry SDK, an OpenTelemetry `Span` becomes a Sentry `Transaction` or `Span`. The first `Span` sent through the Sentry `SpanProcessor` is a `Transaction`, and any child `Span` gets attached to the first `Transaction` upon checking the parent `Span` context. This is true for the OpenTelemetry root `Span` and any top level `Span` in the system. For example, a request sent from frontend to backend will create an OpenTelemetry root `Span` with a corresponding Sentry `Transaction`. The backend request will create a new Sentry `Transaction` for the OpenTelemetry `Span`. The Sentry `Transaction` and `Span` are linked as a trace for navigation and error tracking purposes.
 
+### Capturing exceptions
+
+OpenTelemetry in .NET is implemented via the System.Diagnostics.Activity namespace. However, not all of the functionality in that namespace is supported by OpenTelemetry. In particular, it is [not recommended](https://github.com/open-telemetry/opentelemetry-specification/pull/4333) that you use the `Activity.RecordException` or `Activity.AddException` methods. Using either of these methods will result in valuable **information being removed from exceptions** before these get captured by Sentry.
+
+Instead you should either log the exceptions (using `ILogger`) or capture the exceptions directly using `SentrySdk.CaptureException`.
+
 ## Additional Configuration
 
 If you need more fine grained control over Sentry, take a look at the <PlatformLink to="/configuration/">Configuration page</PlatformLink>. In case you'd like to filter out transactions before sending them to Sentry (to get rid of health checks, for example), you may find the <PlatformLink to="/configuration/filtering/#filtering-transaction-events">Filtering page</PlatformLink> helpful.

platform-includes/performance/opentelemetry-setup/dotnet.aspnet.mdx

@@ -0,0 +1,25 @@
+To start tracing in an ASP.NET application, you'll need to create a tracer provider.
+
+```csharp
+var builder = Sdk.CreateTracerProviderBuilder()
+    .AddAspNetInstrumentation(); // <-- Adds ASP.NET telemetry sources
+```
+
+Next, initialize Sentry and opt into the use of OpenTelemetry. Provide the SDK with the builder for OpenTelemetry's tracer provider to allow sending spans to Sentry.
+
+```csharp
+_sentry = SentrySdk.Init(options =>
+{
+    //options.Dsn = "...Your DSN...";
+    //options.SendDefaultPii = true;
+    options.TracesSampleRate = 1.0;
+    options.AddAspNet(RequestSize.Always);
+    options.UseOpenTelemetry(builder);
+});
+```
+
+Lastly, build the tracer provider.
+
+```csharp
+_tracerProvider = builder.Build();
+```

platform-includes/performance/opentelemetry-setup/dotnet.aspnetcore.mdx

@@ -0,0 +1,25 @@
+To start tracing in an ASP.NET Core app, add OpenTelemetry with tracing and add Sentry to the tracer provider.
+
+```csharp
+var builder = WebApplication.CreateBuilder(args);
+
+builder.Services.AddOpenTelemetry()
+    .WithTracing(tracerProviderBuilder =>
+        tracerProviderBuilder
+            .AddAspNetCoreInstrumentation() // <-- Adds ASP.NET Core telemetry sources
+            .AddHttpClientInstrumentation() // <-- Adds HttpClient telemetry sources
+            .AddSentry() // <-- Configure OpenTelemetry to send trace information to Sentry
+    );
+```
+
+Next, initialize Sentry and opt into the use of OpenTelemetry. This allows the SDK to send OpenTelemetry spans to Sentry.
+
+```csharp
+builder.WebHost.UseSentry(options =>
+{
+    options.Dsn = "...Your DSN...";
+    options.SendDefaultPii = true;
+    options.TracesSampleRate = 1.0;
+    options.UseOpenTelemetry(); // <-- Configure Sentry to use OpenTelemetry trace information
+});
+```

platform-includes/performance/opentelemetry-setup/dotnet.mdx

@@ -1,8 +1,4 @@
-To learn how to start tracing based on your application kind, read the instructions below.
-
-### Console Applications
-
-To start tracing in a console application, you'll need to add Sentry to the tracer provider. This will make it possible for OpenTelemetry spans to be captured by Sentry.
+To start tracing, you'll need to add Sentry to the tracer provider. This will make it possible for OpenTelemetry spans to be captured by Sentry.
 
 ```csharp
 using var tracerProvider = Sdk.CreateTracerProviderBuilder()
@@ -22,59 +18,3 @@ SentrySdk.Init(options =>
     options.UseOpenTelemetry(); // <-- Configure Sentry to use OpenTelemetry trace information
 });
 ```
-
-### ASP.NET Core Applications
-
-To start tracing in an ASP.NET Core app, add OpenTelemetry with tracing and add Sentry to the tracer provider.
-
-```csharp
-var builder = WebApplication.CreateBuilder(args);
-
-builder.Services.AddOpenTelemetry()
-    .WithTracing(tracerProviderBuilder =>
-        tracerProviderBuilder
-            .AddAspNetCoreInstrumentation() // <-- Adds ASP.NET Core telemetry sources
-            .AddHttpClientInstrumentation() // <-- Adds HttpClient telemetry sources
-            .AddSentry() // <-- Configure OpenTelemetry to send trace information to Sentry
-    );
-```
-
-Next, initialize Sentry and opt into the use of OpenTelemetry. This allows the SDK to send OpenTelemetry spans to Sentry.
-
-```csharp
-builder.WebHost.UseSentry(options =>
-{
-    options.Dsn = "...Your DSN...";
-    options.SendDefaultPii = true;
-    options.TracesSampleRate = 1.0;
-    options.UseOpenTelemetry(); // <-- Configure Sentry to use OpenTelemetry trace information
-});
-```
-
-### ASP.NET Applications
-
-To start tracing in an ASP.NET application, you'll need to create a tracer provider.
-
-```csharp
-var builder = Sdk.CreateTracerProviderBuilder()
-    .AddAspNetInstrumentation(); // <-- Adds ASP.NET telemetry sources
-```
-
-Next, initialize Sentry and opt into the use of OpenTelemetry. Provide the SDK with the builder for OpenTelemetry's tracer provider to allow sending spans to Sentry.
-
-```csharp
-_sentry = SentrySdk.Init(options =>
-{
-    //options.Dsn = "...Your DSN...";
-    //options.SendDefaultPii = true;
-    options.TracesSampleRate = 1.0;
-    options.AddAspNet(RequestSize.Always);
-    options.UseOpenTelemetry(builder);
-});
-```
-
-Lastly, build the tracer provider.
-
-```csharp
-_tracerProvider = builder.Build();
-```