docs(dotnet/logs): add Logs for the .NET SDK

docs/platforms/dotnet/common/logs/index.mdx

@@ -0,0 +1,39 @@
+---
+title: Set Up Logs
+sidebar_title: Logs
+description: "Structured logs allow you to send, view and query logs sent from your applications within Sentry."
+sidebar_order: 5600
+notSupported:
+  - dotnet.google-cloud-functions
+  - dotnet.log4net
+  - dotnet.nlog
+  - dotnet.serilog
+  - dotnet.xamarin
+---
+
+<Include name="feature-stage-beta-logs.mdx" />
+
+With Sentry Structured Logs, you can send text based log information from your applications to Sentry. Once in Sentry, these logs can be viewed alongside relevant errors, searched by text-string, or searched using their individual attributes.
+
+## Requirements
+
+<PlatformContent includePath="logs/requirements" />
+
+## Setup
+
+<PlatformContent includePath="logs/setup" />
+
+## Usage
+
+<PlatformContent includePath="logs/usage" />
+
+## Integrations
+
+<PlatformContent includePath="logs/integrations" />
+
+## Options
+
+<PlatformContent includePath="logs/options" />
+
+
+

docs/product/explore/logs/getting-started/index.mdx

@@ -246,6 +246,14 @@ To set up Sentry Logs, use the links below for supported SDKs. After it's been s
 
 - <LinkWithPlatformIcon platform="rust" label="Rust" url="/platforms/rust/logs/" />
 
+### .NET
+
+- <LinkWithPlatformIcon
+    platform="dotnet"
+    label=".NET"
+    url="/platforms/dotnet/logs/"
+  />
+
 ## Upcoming SDKs
 
 We're actively working on adding Log functionality to additional SDKs. Check out these GitHub issues for the latest updates:
@@ -260,11 +268,6 @@ We're actively working on adding Log functionality to additional SDKs. Check out
     label="Elixir"
     url="https://github.com/getsentry/sentry-elixir/issues/886"
   />
-- <LinkWithPlatformIcon
-    platform="dotnet"
-    label=".NET"
-    url="https://github.com/getsentry/sentry-dotnet/issues/4132"
-  />
 - <LinkWithPlatformIcon
     platform="php.symfony"
     label="Symfony"

platform-includes/logs/integrations/dotnet.mdx

@@ -0,0 +1,6 @@
+Available integrations:
+- [Microsoft.Extensions.Logging](/platforms/dotnet/guides/extensions-logging/logs/)
+- [ASP.NET Core](/platforms/dotnet/guides/aspnetcore/logs/)
+- [.NET Multi-platform App UI (.NET MAUI)](/platforms/dotnet/guides/maui/logs/)
+
+If there's an integration you would like to see, open a [new issue on GitHub](https://github.com/getsentry/sentry-dotnet/issues/new/choose).

platform-includes/logs/options/dotnet.mdx

@@ -0,0 +1,47 @@
+#### Experimental.EnableLogs
+Set to `true` in order to enable the `SentrySdk.Experimental.Logger` APIs, as well as logging integrations via the [ILogger<T>](https://learn.microsoft.com/dotnet/api/microsoft.extensions.logging.ilogger-1) API.
+
+#### Experimental.SetBeforeSendLog(Func<SentryLog, SentryLog?>)
+
+To filter logs, or update them before they are sent to Sentry, you can use the `Experimental.SetBeforeSendLog()` option.
+
+```csharp
+options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+    options.Experimental.EnableLogs = true;
+    // a callback that is invoked before sending a log to Sentry
+    options.Experimental.SetBeforeSendLog(static log =>
+    {
+        // filter out all info logs
+        if (log.Level is SentryLogLevel.Info)
+        {
+            return null;
+        }
+
+        // filter out logs based on some attribute they have
+        if (log.TryGetAttribute("suppress", out var attribute) && attribute is true)
+        {
+            return null;
+        }
+
+        // set a custom attribute for all other logs sent to Sentry
+        log.SetAttribute("my.attribute", "value");
+
+        return log;
+    });
+});
+```
+
+The callback function set via `Experimental.SetBeforeSendLog()` receives a log object, and should return the log object if you want it to be sent to Sentry, or `null` if you want to discard it.
+
+The log object of type `SentryLog` has the following members:
+- `Timestamp` Property: (`DateTimeOffset`) The timestamp of the log.
+- `TraceId` Property: (`SentryId`) The trace id of the log.
+- `Level` Property: (`SentryLogLevel`) The severity level of the log. Either `Trace`, `Debug`, `Info`, `Warning`, `Error`, or `Fatal`.
+- `Message` Property: (`string`) The formatted log message.
+- `Template` Property: (`string?`) The parameterized template string.
+- `Parameters` Property: (`ImmutableArray<KeyValuePair<string, object>>`) The parameters to the template string.
+- `ParentSpanId` Property: (`SpanId?`) The span id of the span that was active when the log was collected.
+- `TryGetAttribute(string key, out object value)` Method: Gets the attribute value associated with the specified key. Returns `true` if the log contains an attribute with the specified key and it's value is not `null`, otherwise `false`.
+- `SetAttribute(string key, object value)` Method: Set a key-value pair of data attached to the log. Supported types are `string`, `bool`, integers up to a size of 64-bit signed, and floating-point numbers up to a size of 64-bit.

platform-includes/logs/requirements/dotnet.mdx

@@ -0,0 +1 @@
+Logs for .NET are supported in Sentry .NET SDK version `5.14.0` and above.

platform-includes/logs/setup/dotnet.mdx

@@ -0,0 +1,53 @@
+To enable logging, you need to initialize the SDK with the `Experimental.EnableLogs` option set to `true`.
+
+<PlatformSection notSupported={["dotnet.aspnetcore"]}>
+
+```csharp
+SentrySdk.Init(options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+    // Enable logs to be sent to Sentry
+    options.Experimental.EnableLogs = true;
+});
+```
+
+</PlatformSection>
+
+<PlatformSection supported={["dotnet.aspnetcore, dotnet.aws-lambda, dotnet.azure-functions-worker, dotnet.blazor-webassembly, dotnet.maui"]}>
+
+```csharp {tabTitle:Builder}
+.UseSentry(options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+    // Enable logs to be sent to Sentry
+    options.Experimental.EnableLogs = true;
+});
+```
+
+</PlatformSection>
+
+<PlatformSection supported={["dotnet.extensions-logging"]}>
+
+```csharp {tabTitle:Factory}
+.AddSentry(options =>
+{
+    options.Dsn = "___PUBLIC_DSN___";
+    // Enable logs to be sent to Sentry
+    options.Experimental.EnableLogs = true;
+});
+```
+
+</PlatformSection>
+
+<PlatformSection supported={["dotnet.aspnetcore, dotnet.extensions-logging"]}>
+
+```json {tabTitle:Configuration} {filename:appsettings.json}
+  "Sentry": {
+    "Dsn": "___PUBLIC_DSN___",
+    "Experimental": {
+      "EnableLogs": true
+    }
+  },
+```
+
+</PlatformSection>

platform-includes/logs/usage/dotnet.mdx

@@ -0,0 +1,63 @@
+Once the feature is enabled on the SDK and the SDK is initialized, you can send logs using the `SentrySdk.Experimental.Logger` APIs.
+
+The `SentrySdk.Experimental.Logger` instance exposes six methods that you can use to log messages at different log levels: `Trace`, `Debug`, `Info`, `Warning`, `Error`, and `Fatal`.
+
+These properties will be sent to Sentry, and can be searched from within the Logs UI, and even added to the Logs views as a dedicated column.
+
+```csharp
+SentrySdk.Experimental.Logger.LogInfo("A simple log message");
+SentrySdk.Experimental.Logger.LogError("A {0} log message", ["formatted"]);
+```
+
+<Alert title="Note">
+During the experimental phase of the feature, we will provide more method overloads for convenient invocation in common scenarios.
+Additionally, we may provide method overloads that are not based on _composite format strings_, but on _interpolated strings_.
+</Alert>
+
+<PlatformSection supported={["dotnet.aspnetcore, dotnet.azure-functions-worker, dotnet.blazor-webassembly, dotnet.extensions-logging, dotnet.maui"]}>
+
+Additionally, when enabled and initialized, the SDK registers a [ILoggerProvider](https://learn.microsoft.com/dotnet/api/microsoft.extensions.logging.iloggerprovider)
+that allows sending logs to Sentry via [ILogger<T>](https://learn.microsoft.com/dotnet/api/microsoft.extensions.logging.ilogger-1) instances resolved through _.NET dependency injection_.
+
+```csharp
+public sealed class MyService(ILogger<MyService> logger)
+{
+    public async Task InvokeAsync(HttpContext context)
+    {
+        logger.LogInformation("A simple log message");
+        await Task.Yield();
+        logger.LogError("A {Parameter} log message", "formatted");
+        await Task.Delay(TimeSpan.FromSeconds(1));
+        logger.LogWarning(new EventId(1, nameof(InvokeAsync)), "Message with EventId");
+    }
+}
+```
+
+The `ILogger<T>`'s _CategoryName_, as well as the `EventId` (if provided), are attached as attributes to the logs.
+
+For more information, see article on [Logging in C# and .NET](https://learn.microsoft.com//dotnet/core/extensions/logging).
+Sentry Structured Logs also work with [High-performance logging in .NET](https://learn.microsoft.com/dotnet/core/extensions/high-performance-logging) and [Compile-time logging source generation](https://learn.microsoft.com/dotnet/core/extensions/logger-message-generator) alike.
+
+</PlatformSection>
+
+The SDK automatically provides a set of default attributes attached to your logs.
+Additionally, you can attach custom attributes via a delegate.
+
+```csharp
+SentrySdk.Experimental.Logger.LogWarning("A log message with additional attributes.", [], static log =>
+{
+    log.SetAttribute("my.attribute", "value");
+});
+```
+
+<Alert title="Note">
+Please note that we will revise the API shape to set custom attributes during the experimental phase of the feature.
+</Alert>
+
+Supported attribute types are:
+- Textual: `string` and `char`
+- Logical: `bool`
+- Integral: `sbyte`, `byte`, `short`, `ushort`, `int`, `uint`, `long` and `nint`
+- Floating-point: `float` and `double`
+
+Unsupported numeric types such as `ulong`, `nuint`, `decimal`, as well as all other types including `object`, are treated as `string` via `ToString`.